621 Stimmen

jQuery.click() vs onClick

Ich habe eine riesige jQuery-Anwendung, und ich bin mit den unten zwei Methoden für Klick-Ereignisse.

Erste Methode

HTML

<div id="myDiv">Some Content</div>

jQuery

$('#myDiv').click(function(){
    //Some code
});

Zweite Methode

HTML

<div id="myDiv" onClick="divFunction()">Some Content</div>

JavaScript-Funktionsaufruf

function divFunction(){
    //Some code
}

Ich verwende in meiner Bewerbung entweder die erste oder die zweite Methode. Welche Methode ist besser? Besser für die Leistung? Und Standard?

5voto

Kamil Kiełczewski Punkte 69048

Leistung

Es gibt hier bereits viele gute Antworten, aber die Autoren erwähnen manchmal die Leistung, aber eigentlich hat sie noch niemand untersucht - deshalb werde ich mich hier auf diesen Aspekt konzentrieren. Heute führe ich Tests mit Chrome 83.0, Safari 13.1 und Firefox 77.0 für die in der Frage erwähnten Lösungen und zusätzlich einige alternative Lösungen durch (einige von ihnen wurden in anderen Antworten erwähnt).

Ergebnisse

Ich vergleiche hier die Lösungen A-H, weil sie mit Elementen arbeiten id . Ich zeige auch Ergebnisse für Lösungen, die Folgendes verwenden class (I,J,K) als Referenz.

  • die Lösung auf der Grundlage der HTML-Inline-Handler-Bindung (B) ist schnell und am schnellsten für Chrome und am schnellsten für eine kleine Anzahl von Elementen
  • Lösungen basierend auf getElementById (C,D) sind schnell, und für eine große Anzahl von Elementen am schnellsten auf Safari und Firefox
  • referenzierte Lösungen auf Basis von I,J sind am schnellsten für eine große Anzahl von Elementen, so dass es sich lohnt, die Verwendung von class stattdessen id Ansatz in diesem Fall
  • die auf jQuery.click basierende Lösung (A) ist am langsamsten

enter image description here

Einzelheiten

Eigentlich war es nicht einfach, einen Leistungstest für diese Frage zu entwickeln. Ich stelle fest, dass bei allen getesteten Lösungen die Leistung beim Auslösen von Ereignissen für 10K div-s schnell war und ich manuell keine Unterschiede zwischen ihnen feststellen konnte (Sie können das unten stehende Snippet ausführen, um es selbst zu überprüfen). Daher konzentriere ich mich auf die Messung der Ausführungszeit der Generierung von HTML- und Bind-Event-Handlern für zwei Fälle

  • 10 div s - Sie können einen Test durchführen HIER
  • 1000 div s - Sie können einen Test durchführen HIER

    // https://stackoverflow.com/questions/12627443/jquery-click-vs-onclick let a= [...Array(10000)];

    function clean() { test.innerHTML = ''; console.clear() }

    function divFunction(el) { console.log(clicked on: ${el.id}); }

    function initA() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; a.map((x,i)=> $(#myDiv${i}`).click(e=> divFunction(e.target))); }

    function initB() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box" onclick="divFunction(this)">${i}</div>).join``; }

    function initC() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; a.map((x,i)=> document.getElementById(myDiv${i}`).onclick = e=> divFunction(e.target) ); }

    function initD() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; a.map((x,i)=> document.getElementById(myDiv${i}`).addEventListener('click', e=> divFunction(e.target) )); }

    function initE() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; a.map((x,i)=> document.querySelector(#myDiv${i}`).onclick = e=> divFunction(e.target) ); }

    function initF() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; a.map((x,i)=> document.querySelector(#myDiv${i}`).addEventListener('click', e=> divFunction(e.target) )); }

    function initG() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; a.map((x,i)=> window[myDiv${i}`].onclick = e=> divFunction(e.target) ); }

    function initH() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; a.map((x,i)=> window[myDiv${i}`].addEventListener('click',e=> divFunction(e.target))); }

    function initI() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; [...document.querySelectorAll(.box`)].map(el => el.onclick = e=> divFunction(e.target)); }

    function initJ() { test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; [...document.querySelectorAll(.box`)].map(el => el.addEventListener('click', e=> divFunction(e.target))); }

    function initK() {
    test.innerHTML = a.map((x,i)=> <div id="myDiv${i}" class="box">${i}</div>).join`; $(.box`).click(e=> divFunction(e.target)); }

    function measure(f) {
    console.time("measure "+f.name); f(); console.timeEnd("measure "+f.name) }

    test {

    display: flex; flex-wrap: wrap; }

    .box { margin: 1px; height: 10px; background: red; font-size: 10px; cursor: pointer; }

    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script> <div>This snippet only presents used solutions. Click to solution button and then click on any red box to trigger its handler</div> <button onclick="measure(initA)">A</button> <button onclick="measure(initB)">B</button> <button onclick="measure(initC)">C</button> <button onclick="measure(initD)">D</button> <button onclick="measure(initE)">E</button> <button onclick="measure(initF)">F</button> <button onclick="measure(initG)">G</button> <button onclick="measure(initH)">H</button> <button onclick="measure(initI)">I</button> <button onclick="measure(initJ)">J</button> <button onclick="measure(initK)">K</button> <button onclick="clean()">Clean</button>

    <div id="test"></div>

Hier ein Beispieltest für Chrome

enter image description here

4voto

Explosion Pills Punkte 182627

Keines von beiden ist besser da sie für unterschiedliche Zwecke verwendet werden können. onClick (sollte eigentlich lauten onclick ) ist nur geringfügig besser, aber ich bezweifle sehr, dass Sie einen Unterschied bemerken werden.

Es ist erwähnenswert, dass sie unterschiedliche Dinge tun: .click kann an jede jQuery-Sammlung gebunden werden, während onclick muss inline auf den Elementen verwendet werden, an die es gebunden werden soll. Sie können auch nur ein Ereignis binden, indem Sie onclick in der Erwägung, dass .click können Sie weiterhin Ereignisse binden.

Meiner Meinung nach würde ich konsequent sein und einfach die .click überall und halten tous meines JavaScript-Codes zusammen und getrennt vom HTML-Code.

Verwenden Sie nicht onclick . Es gibt keinen Grund, sie zu verwenden, es sei denn, Sie wissen, was Sie tun, und das tun Sie wahrscheinlich nicht.

4voto

Love Kumar Punkte 920

Onclick-Funktion Jquery

$('#selector').click(function(){ //Your Functionality });

3voto

supernova Punkte 3784

Nun, einer der Hauptgedanken hinter jQuery ist die Trennung von JavaScript und dem unangenehmen HTML Code. Die erste Methode ist der richtige Weg.

3voto

Adil Punkte 143047

Die meiste Zeit sind native JavaScript-Methoden die bessere Wahl als jQuery, wenn die Leistung das einzige Kriterium ist, aber jQuery nutzt JavaScript und macht die Entwicklung einfach. Sie können jQuery verwenden, da es die Leistung nicht zu sehr beeinträchtigt. In Ihrem speziellen Fall ist der Leistungsunterschied unbedeutend.

CodeJaeger.com

CodeJaeger ist eine Gemeinschaft für Programmierer, die täglich Hilfe erhalten..
Wir haben viele Inhalte, und Sie können auch Ihre eigenen Fragen stellen oder die Fragen anderer Leute lösen.

Powered by:

X