Leistung Ihrer HTML5-App verbessern

Einführung

HTML5 bietet hervorragende Tools, um die visuelle Darstellung von Webanwendungen zu verbessern. Das gilt insbesondere für Animationen. Diese neuen Möglichkeiten bringen jedoch auch neue Herausforderungen mit sich. Tatsächlich sind diese Herausforderungen gar nicht so neu und es kann manchmal sinnvoll sein, die Flash-Programmiererin am Nachbarschreibtisch zu fragen, wie sie ähnliche Probleme in der Vergangenheit gelöst hat.

Wenn Sie mit Animationen arbeiten, ist es jedenfalls sehr wichtig, dass Nutzer diese Animationen als flüssig wahrnehmen. Wir müssen uns darüber im Klaren sein, dass flüssige Animationen nicht einfach dadurch entstehen, dass die Bilder pro Sekunde über einen kognitiven Schwellenwert hinaus erhöht werden. Unser Gehirn ist leider schlauer. Sie werden feststellen, dass echte 30 Bilder pro Sekunde (fps) viel besser sind als 60 fps, bei denen zwischendurch einige Frames verloren gehen. Menschen hassen Zacken.

In diesem Artikel werden Tools und Techniken vorgestellt, mit denen Sie die Nutzerfreundlichkeit Ihrer eigenen Anwendung verbessern können.

Die Strategie

Wir möchten Sie keinesfalls davon abhalten, mit HTML5 tolle, visuell beeindruckende Apps zu entwickeln.

Wenn Sie dann feststellen, dass die Leistung etwas besser sein könnte, können Sie hier nachlesen, wie Sie die Elemente Ihrer Anwendung verbessern können. Natürlich kann es hilfreich sein, einige Dinge von Anfang an richtig zu machen, aber lassen Sie sich dadurch nicht von Ihrer Produktivität abhalten.

Visuelle Wiedergabetreue++ mit HTML5

Hardwarebeschleunigung

Die Hardwarebeschleunigung ist ein wichtiger Meilenstein für die allgemeine Renderingleistung im Browser. Das allgemeine Schema besteht darin, Aufgaben, die sonst von der Haupt-CPU berechnet würden, auf den Grafikprozessor (GPU) im Grafikadapter Ihres Computers zu übertragen. Dies kann zu massiven Leistungssteigerungen führen und auch den Ressourcenverbrauch auf Mobilgeräten reduzieren.

Diese Aspekte Ihres Dokuments können durch die GPU beschleunigt werden

  • Allgemeines Layout-Compositing
  • CSS3-Übergänge
  • CSS3-3D-Transformationen
  • Canvas-Zeichnung
  • WebGL-3D-Zeichnung

Die Beschleunigung von Canvas und WebGL sind spezielle Funktionen, die für Ihre Anwendung möglicherweise nicht relevant sind. Die ersten drei Aspekte können jedoch dazu beitragen, dass so gut wie jede App schneller wird.

Was kann beschleunigt werden?

Bei der GPU-Beschleunigung werden klar definierte und spezifische Aufgaben auf spezielle Hardware ausgelagert. Das allgemeine Schema besteht darin, dass Ihr Dokument in mehrere „Ebenen“ unterteilt wird, die von den beschleunigten Aspekten Ihrer Seite nicht beeinflusst werden. Diese Ebenen werden mit der herkömmlichen Render-Pipeline gerendert. Die GPU wird dann verwendet, um die Ebenen auf einer einzelnen Seite zusammenzusetzen und die „Effekte“ anzuwenden, die im laufenden Betrieb beschleunigt werden können. Ein mögliches Ergebnis ist, dass ein Objekt, das auf dem Bildschirm animiert wird, während der Animation kein einziges „Relayout“ der Seite erfordert.

Wichtig ist, dass Sie es der Rendering-Engine leicht machen, zu erkennen, wann sie die GPU-Beschleunigung anwenden kann. Dazu ein Beispiel:

Das funktioniert zwar, aber der Browser weiß nicht, dass Sie etwas ausführen, das von einem Menschen als flüssige Animation wahrgenommen werden soll. Sehen wir uns an, was passiert, wenn Sie stattdessen CSS3-Übergänge verwenden, um dasselbe visuelle Erscheinungsbild zu erzielen:

Wie der Browser diese Animation implementiert, ist für den Entwickler völlig verborgen. Das bedeutet wiederum, dass der Browser Tricks wie die GPU-Beschleunigung anwenden kann, um das definierte Ziel zu erreichen.

Es gibt zwei nützliche Befehlszeilen-Flags für Chrome, die beim Debuggen der GPU-Beschleunigung helfen:

  1. --show-composited-layer-borders zeigt einen roten Rahmen um Elemente, die auf GPU-Ebene manipuliert werden. Gut, um zu bestätigen, dass Ihre Manipulationen innerhalb der GPU-Ebene erfolgen.
  2. --show-paint-rects werden alle Änderungen, die nicht die GPU betreffen, dargestellt und es wird ein dünner Rahmen um alle Bereiche gezeichnet, die neu dargestellt werden. Sie können sehen, wie der Browser die Zeichenbereiche optimiert.

Safari hat ähnliche Laufzeit-Flags, die hier beschrieben werden.

CSS3-Übergänge

CSS-Übergänge machen die Stilanimation für alle einfach, sind aber auch eine intelligente Leistungsfunktion. Da ein CSS-Übergang vom Browser verwaltet wird, kann die Wiedergabetreue der Animation erheblich verbessert und in vielen Fällen hardwarebeschleunigt werden. Derzeit verfügen WebKit (Chrome, Safari, iOS) über hardwarebeschleunigte CSS-Transformationen, aber andere Browser und Plattformen werden bald folgen.

Sie können transitionEnd-Ereignisse verwenden, um dies in leistungsstarken Kombinationen zu skripten. in Echtzeit müssen Sie jedoch webkitTransitionEnd transitionend oTransitionEnd beobachten, um alle unterstützten Übergangsendereignisse zu erfassen.

Viele Bibliotheken haben jetzt Animations-APIs eingeführt, die Übergänge nutzen, falls vorhanden, und andernfalls auf Standard-DOM-Animationen zurückgreifen. scripty2, YUI-Übergang, jQuery animate enhanced.

CSS3-Übersetzung

Sicherlich haben Sie schon einmal die x/y-Position eines Elements auf der Seite animiert. Sie haben wahrscheinlich die Eigenschaften „left“ und „top“ des Inline-Stils manipuliert. Bei 2D-Transformationen können wir die translate()-Funktion verwenden, um dieses Verhalten zu replizieren.

Wir können dies mit der DOM-Animation kombinieren, um die bestmögliche Option zu nutzen,

<div style="position:relative; height:120px;" class="hwaccel">

  <div style="padding:5px; width:100px; height:100px; background:papayaWhip;
              position:absolute;" id="box">
  </div>
</div>

<script>
document.querySelector('#box').addEventListener('click', moveIt, false);

function moveIt(evt) {
  var elem = evt.target;

  if (Modernizr.csstransforms && Modernizr.csstransitions) {
    // vendor prefixes omitted here for brevity
    elem.style.transition = 'all 3s ease-out';
    elem.style.transform = 'translateX(600px)';

  } else {
    // if an older browser, fall back to jQuery animate
    jQuery(elem).animate({ 'left': '600px'}, 3000);
  }
}
</script>

Wir verwenden Modernizr, um die Unterstützung von CSS-2D-Transformationen und CSS-Übergängen zu testen. Wenn diese unterstützt werden, verwenden wir „translate“, um die Position zu verschieben. Wenn dies mit einem Übergang animiert wird, ist die Wahrscheinlichkeit groß, dass der Browser die Hardwarebeschleunigung nutzen kann. Um dem Browser einen weiteren Schubs in die richtige Richtung zu geben, verwenden wir die oben genannte „magische CSS-Kugel“.

Wenn unser Browser weniger leistungsfähig ist, greifen wir auf jQuery zurück, um das Element zu verschieben. Sie können das jQuery Transform Polyfill-Plug-in von Louis-Remi Babe verwenden, um diesen Vorgang zu automatisieren.

window.requestAnimationFrame

requestAnimationFrame wurde von Mozilla eingeführt und von WebKit weiterentwickelt, um Ihnen eine native API zum Ausführen von Animationen bereitzustellen, unabhängig davon, ob sie DOM-/CSS-basiert sind oder auf <canvas> oder WebGL basieren. Der Browser kann gleichzeitige Animationen in einem einzigen Reflow- und Repaint-Zyklus optimieren, was zu einer höheren Qualität der Animation führt. Beispielsweise JS-basierte Animationen, die mit CSS-Übergängen oder SVG SMIL synchronisiert sind. Außerdem wird die Animationsschleife nicht weiter ausgeführt, wenn sie sich in einem Tab befindet, der nicht sichtbar ist. Das bedeutet, dass weniger CPU, GPU und Arbeitsspeichernutzung verwendet werden, was zu einer viel längeren Akkulaufzeit führt.

Weitere Informationen dazu, wie und warum requestAnimationFrame verwendet werden sollte, finden Sie im Artikel requestAnimationFrame for smart animating von Paul Irish.

Profilerstellung

Wenn Sie feststellen, dass die Geschwindigkeit Ihrer Anwendung verbessert werden kann, sollten Sie sich mit der Profilerstellung befassen, um herauszufinden, wo Optimierungen den größten Nutzen bringen könnten. Optimierungen wirken sich oft negativ auf die Wartbarkeit Ihres Quellcodes aus und sollten daher nur bei Bedarf angewendet werden. Anhand der Profilerstellung können Sie erkennen, welche Teile Ihres Codes die größten Vorteile bringen würden, wenn ihre Leistung verbessert würde.

JavaScript-Profiling

JavaScript-Profiler bieten einen Überblick über die Leistung Ihrer Anwendung auf der Ebene der JavaScript-Funktionen. Dazu wird die Zeit gemessen, die für die Ausführung jeder einzelnen Funktion von Anfang bis Ende benötigt wird.

Die Bruttoausführungszeit einer Funktion ist die Gesamtzeit, die für die Ausführung von oben nach unten benötigt wird. Die Nettoausführungszeit ist die Bruttoausführungszeit abzüglich der Zeit, die für die Ausführung von Funktionen benötigt wurde, die von der Funktion aufgerufen wurden.

Einige Funktionen werden häufiger aufgerufen als andere. Profiler geben in der Regel die Zeit an, die für die Ausführung aller Aufrufe benötigt wurde, sowie die durchschnittliche, minimale und maximale Ausführungszeit.

Weitere Informationen finden Sie in der Dokumentation zu den Chrome-Entwicklertools zur Profilerstellung.

Das DOM

Die Leistung von JavaScript hat einen starken Einfluss darauf, wie flüssig und responsiv sich Ihre Anwendung anfühlt. Es ist wichtig zu wissen, dass JavaScript-Profiler zwar die Ausführungszeit Ihres JavaScripts messen, aber auch indirekt die Zeit, die für DOM-Vorgänge aufgewendet wird. Diese DOM-Vorgänge sind oft die Ursache für Leistungsprobleme.

function drawArray(array) {
  for(var i = 0; i < array.length; i++) {
    document.getElementById('test').innerHTML += array[i]; // No good :(
  }
}

Im obigen Code wird beispielsweise fast keine Zeit für die Ausführung von JavaScript aufgewendet. Es ist immer noch sehr wahrscheinlich, dass die Funktion „drawArray“ in Ihren Profilen angezeigt wird, da sie auf sehr ineffiziente Weise mit dem DOM interagiert.

Tipps und Tricks

Anonyme Funktionen

Anonyme Funktionen sind nicht einfach zu profilieren, da sie von Natur aus keinen Namen haben, unter dem sie im Profiler angezeigt werden könnten. Es gibt zwei Möglichkeiten, dieses Problem zu umgehen:

$('.stuff').each(function() { ... });

umschreiben in:

$('.stuff').each(function workOnStuff() { ... });

Es ist nicht allgemein bekannt, dass JavaScript die Benennung von Funktionsausdrücken unterstützt. Dadurch werden sie im Profiler korrekt angezeigt. Diese Lösung hat ein Problem: Der benannte Ausdruck fügt den Funktionsnamen tatsächlich in den aktuellen lexikalischen Bereich ein. Dies kann andere Symbole überschreiben, seien Sie also vorsichtig.

Lange Funktionen profilieren

Stellen Sie sich vor, Sie haben eine lange Funktion und vermuten, dass ein kleiner Teil davon die Ursache für Ihre Leistungsprobleme ist. Es gibt zwei Möglichkeiten, um herauszufinden, welches Teil das Problem verursacht:

  1. Die richtige Methode: Refaktorieren Sie Ihren Code, sodass er keine langen Funktionen enthält.
  2. Die böse Methode, um Dinge zu erledigen: Fügen Sie Ihrem Code Anweisungen in Form von benannten, sich selbst aufrufenden Funktionen hinzu. Wenn Sie vorsichtig sind, ändert dies die Semantik nicht und Teile Ihrer Funktion werden im Profiler als einzelne Funktionen angezeigt: js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... } Vergessen Sie nicht, diese zusätzlichen Funktionen nach Abschluss des Profilings zu entfernen oder sie sogar als Ausgangspunkt für die Refaktorierung Ihres Codes zu verwenden.

DOM-Profilerstellung

Die neuesten Chrome Web Inspector-Entwicklertools enthalten die neue „Zeitachsenansicht“, die eine Zeitachse der vom Browser ausgeführten Low-Level-Aktionen zeigt. Anhand dieser Informationen können Sie Ihre DOM-Vorgänge optimieren. Sie sollten versuchen, die Anzahl der „Aktionen“ zu reduzieren, die der Browser während der Ausführung Ihres Codes ausführen muss.

In der Zeitachsenansicht können sehr viele Informationen angezeigt werden. Sie sollten daher versuchen, minimale Testläufe zu erstellen, die Sie unabhängig voneinander ausführen können.

DOM-Profilerstellung

Die Abbildung oben zeigt die Ausgabe der Zeitachsenansicht für ein sehr einfaches Skript. Im linken Bereich werden die vom Browser ausgeführten Vorgänge in chronologischer Reihenfolge angezeigt. Die Zeitachse im rechten Bereich zeigt die tatsächliche Zeit, die für einen einzelnen Vorgang benötigt wurde.

Weitere Informationen zur Zeitachsenansicht Ein alternatives Tool für die Profilerstellung im Internet Explorer ist die DynaTrace Ajax Edition.

Profiling-Strategien

Aspekte herausgreifen

Wenn Sie ein Profil Ihrer Anwendung erstellen möchten, versuchen Sie, die Aspekte der Funktionalität, die zu einer Verlangsamung führen könnten, so genau wie möglich zu identifizieren. Führen Sie dann einen Profiler-Lauf aus, bei dem nur die Teile Ihres Codes ausgeführt werden, die für diese Aspekte Ihrer Anwendung relevant sind. Dadurch lassen sich die Profildaten leichter interpretieren, da sie nicht mit Codepfaden vermischt sind, die nichts mit dem eigentlichen Problem zu tun haben. Gute Beispiele für einzelne Aspekte Ihrer Bewerbung könnten sein:

  1. Startzeit (Profiler aktivieren, Anwendung neu laden, warten, bis die Initialisierung abgeschlossen ist, Profiler beenden.
  2. Klicken Sie auf eine Schaltfläche und die nachfolgende Animation (Profiler starten, auf Schaltfläche klicken, warten, bis die Animation abgeschlossen ist, Profiler beenden).
GUI-Profilerstellung

Es kann schwieriger sein, nur den richtigen Teil Ihrer Anwendung in einem GUI-Programm auszuführen, als beispielsweise den Raytracer Ihrer 3D-Engine zu optimieren. Wenn Sie beispielsweise die Vorgänge beim Klicken auf eine Schaltfläche analysieren möchten, können Sie dabei nicht relevante Mouseover-Ereignisse auslösen, die die Ergebnisse weniger aussagekräftig machen. Versuche, das zu vermeiden :)

Programmatische Schnittstelle

Es gibt auch eine programmatische Schnittstelle zum Aktivieren des Debuggers. So können Sie genau steuern, wann die Profilerstellung beginnt und wann sie endet.

Starten Sie eine Profilerstellung mit:

console.profile()

Profilerstellung beenden mit:

console.profileEnd()

Wiederholbarkeit

Achten Sie beim Profiling darauf, dass Sie Ihre Ergebnisse tatsächlich reproduzieren können. Nur so können Sie feststellen, ob Ihre Optimierungen tatsächlich zu Verbesserungen geführt haben. Außerdem wird die Profilerstellung auf Funktionsebene im Kontext des gesamten Computers durchgeführt. Es ist keine exakte Wissenschaft. Einzelne Profilausführungen können durch viele andere Vorgänge auf Ihrem Computer beeinflusst werden:

  1. Ein nicht zusammenhängender Timer in Ihrer eigenen Anwendung, der ausgelöst wird, während Sie etwas anderes messen.
  2. Die Speicherbereinigung erledigt ihre Arbeit.
  3. Ein anderer Tab in Ihrem Browser, der im selben Betriebsthread viel Arbeit erledigt.
  4. Ein anderes Programm auf Ihrem Computer beansprucht die CPU, wodurch Ihre Anwendung langsamer wird.
  5. Plötzliche Änderungen im Gravitationsfeld der Erde.

Es ist auch sinnvoll, denselben Codepfad mehrmals in einer Profilerstellungssitzung auszuführen. So verringern Sie den Einfluss der oben genannten Faktoren und die langsamen Teile fallen möglicherweise noch deutlicher auf.

Messen, verbessern, messen

Wenn Sie eine langsame Stelle in Ihrem Programm gefunden haben, überlegen Sie, wie Sie das Ausführungsverhalten verbessern können. Nachdem Sie den Code geändert haben, erstellen Sie ein neues Profil. Wenn Sie mit dem Ergebnis zufrieden sind, können Sie fortfahren. Wenn Sie keine Verbesserung feststellen, sollten Sie die Änderung wahrscheinlich rückgängig machen und sie nicht beibehalten, „weil sie nicht schaden kann“.

Optimierungsstrategien

DOM-Interaktion minimieren

Ein gängiges Thema zur Verbesserung der Geschwindigkeit von Webclient-Anwendungen ist die Minimierung der DOM-Interaktion. Die Geschwindigkeit von JavaScript-Engines hat sich zwar um eine Größenordnung erhöht, der Zugriff auf das DOM ist jedoch nicht im gleichen Maße schneller geworden. Das wird auch aus sehr praktischen Gründen nie passieren (Dinge wie das Layouten und Zeichnen von Elementen auf einem Bildschirm brauchen einfach Zeit).

DOM-Knoten im Cache speichern

Wenn Sie einen Knoten oder eine Liste von Knoten aus dem DOM abrufen, sollten Sie sich überlegen, ob Sie sie in einer späteren Berechnung (oder auch nur in der nächsten Schleifeniteration) wiederverwenden können. Solange Sie im relevanten Bereich keine Knoten hinzufügen oder löschen, ist dies häufig der Fall.

Vorher:

function getElements() {
  return $('.my-class');
}

Nachher:

var cachedElements;
function getElements() {
  if (cachedElements) {
    return cachedElements;
  }
  cachedElements = $('.my-class');
  return cachedElements;
}

Attributwerte im Cache speichern

Genauso wie DOM-Knoten können Sie auch die Werte von Attributen im Cache speichern. Stellen Sie sich vor, Sie animieren ein Attribut des Stils eines Knotens. Wenn Sie wissen, dass Sie (also dieser Teil des Codes) der Einzige sind, der dieses Attribut jemals berührt, können Sie den letzten Wert bei jeder Iteration im Cache speichern, sodass Sie ihn nicht wiederholt lesen müssen.

Vorher:

setInterval(function() {
  var ele = $('#element');
  var left = parseInt(ele.css('left'), 10);
  ele.css('left', (left + 5) + 'px');
}, 1000 / 30);

Nachher: js var ele = $('#element'); var left = parseInt(ele.css('left'), 10); setInterval(function() { left += 5; ele.css('left', left + 'px'); }, 1000 / 30);

DOM-Manipulationen aus Schleifen entfernen

Schleifen sind oft wichtige Punkte für die Optimierung. Überlegen Sie, wie Sie die eigentliche Datenverarbeitung von der Arbeit mit dem DOM entkoppeln können. Oft ist es möglich, eine Berechnung durchzuführen und dann alle Ergebnisse auf einmal anzuwenden.

Vorher:

document.getElementById('target').innerHTML = '';
for(var i = 0; i < array.length; i++) {
  var val = doSomething(array[i]);
  document.getElementById('target').innerHTML += val;
}

Nachher:

var stringBuilder = [];
for(var i = 0; i < array.length; i++) {
  var val = doSomething(array[i]);
  stringBuilder.push(val);
}
document.getElementById('target').innerHTML = stringBuilder.join('');

Neuzeichnen und Umfließen

Wie bereits erwähnt, ist der Zugriff auf das DOM relativ langsam. Es wird sehr langsam, wenn Ihr Code einen Wert liest, der neu berechnet werden muss, weil Ihr Code vor Kurzem etwas im DOM geändert hat. Daher sollte vermieden werden, Lese- und Schreibzugriffe auf das DOM zu vermischen. Idealerweise sollte Ihr Code immer in zwei Phasen gruppiert sein:

  • Phase 1: Für den Code erforderliche DOM-Werte lesen
  • Phase 2: DOM ändern

Vermeiden Sie Muster wie:

  • Phase 1: DOM-Werte lesen
  • Phase 2: DOM ändern
  • Phase 3: Weiterlesen
  • Phase 4: DOM an anderer Stelle ändern.

Vorher:

function paintSlow() {
  var left1 = $('#thing1').css('left');
  $('#otherThing1').css('left', left);
  var left2 = $('#thing2').css('left');
  $('#otherThing2').css('left', left);
}

Nachher:

function paintFast() {
  var left1 = $('#thing1').css('left');
  var left2 = $('#thing2').css('left');
  $('#otherThing1').css('left', left);
  $('#otherThing2').css('left', left);
}

Diese Empfehlung gilt für Aktionen, die innerhalb eines JavaScript-Ausführungskontexts stattfinden. (z.B. innerhalb eines Event-Handlers, innerhalb eines Intervall-Handlers oder bei der Verarbeitung einer AJAX-Antwort).

Wenn Sie die Funktion paintSlow() von oben ausführen, wird dieses Bild erstellt:

paintSlow()

Wenn Sie zur schnelleren Implementierung wechseln, erhalten Sie dieses Bild:

Schnellere Implementierung

Diese Bilder zeigen, dass die Renderleistung erheblich verbessert werden kann, wenn Sie die Art und Weise, wie Ihr Code auf das DOM zugreift, neu anordnen. In diesem Fall muss der ursprüngliche Code die Stile neu berechnen und die Seite zweimal layouten, um dasselbe Ergebnis zu erzielen. Eine ähnliche Optimierung kann auf praktisch jeden „realen“ Code angewendet werden und zu wirklich beeindruckenden Ergebnissen führen.

Weitere Informationen: Rendering: repaint, reflow/relayout, restyle von Stoyan Stefanov

Neuzeichnen und die Ereignisschleife

Die JavaScript-Ausführung im Browser folgt einem „Ereignisschleife“-Modell. Standardmäßig befindet sich der Browser im Status „Inaktiv“. Dieser Status kann durch Ereignisse aus Nutzerinteraktionen oder durch JavaScript-Timer oder Ajax-Callbacks unterbrochen werden. Wenn ein JavaScript-Code an einem solchen Unterbrechungspunkt ausgeführt wird, wartet der Browser in der Regel, bis er fertig ist, bevor er den Bildschirm neu zeichnet. Es kann Ausnahmen für extrem lange laufende JavaScript-Codes oder in Fällen wie Warnfeldern geben, die die JavaScript-Ausführung effektiv unterbrechen.

Folgen

  1. Wenn die Ausführung Ihrer JavaScript-Animationszyklen länger als 1/30 Sekunde dauert, können Sie keine flüssigen Animationen erstellen, da der Browser während der JS-Ausführung nicht neu zeichnet. Wenn Sie auch Nutzerereignisse verarbeiten möchten, müssen Sie viel schneller sein.
  2. Manchmal ist es praktisch, einige JavaScript-Aktionen etwas später auszuführen. Beispiel: setTimeout(function() { ... }, 0) Damit wird der Browser angewiesen, den Callback auszuführen, sobald die Ereignisschleife wieder inaktiv ist. Einige Browser warten mindestens 10 ms. Beachten Sie, dass dadurch zwei JavaScript-Ausführungszyklen erstellt werden, die zeitlich sehr nah beieinander liegen. Beide können ein erneutes Zeichnen des Bildschirms auslösen, was die Gesamtzeit für das Zeichnen verdoppeln kann. Ob dadurch tatsächlich zwei Paint-Vorgänge ausgelöst werden, hängt von der Heuristik im Browser ab.

Reguläre Version:

function paintFast() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  $('#otherThing2').css('height', '20px');
}
Neuzeichnen und die Ereignisschleife

Fügen wir eine Verzögerung hinzu:

function paintALittleLater() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  setTimeout(function() {
    $('#otherThing2').css('height', '20px');
  }, 10)
}
Verzögerung

In der verzögerten Version wird gezeigt, dass der Browser zweimal rendert, obwohl die beiden Änderungen an der Seite nur 1/100 Sekunde auseinanderliegen.

Verzögerte Initialisierung

Nutzer wünschen sich Web-Apps, die schnell geladen werden und responsiv sind. Nutzer haben jedoch je nach Aktion unterschiedliche Schwellenwerte für das, was sie als langsam empfinden. Beispielsweise sollte eine App bei einem Mouseover-Ereignis nie viele Berechnungen durchführen, da dies die Nutzerfreundlichkeit beeinträchtigen könnte, während der Nutzer die Maus weiter bewegt. Nutzer sind es jedoch gewohnt, dass es nach dem Klicken auf eine Schaltfläche zu einer kleinen Verzögerung kommt.

Daher kann es sinnvoll sein, den Initialisierungscode so spät wie möglich auszuführen, z.B. wenn der Nutzer auf eine Schaltfläche klickt, die eine bestimmte Komponente Ihrer Anwendung aktiviert.

Vorher: js var things = $('.ele > .other * div.className'); $('#button').click(function() { things.show() });

Nachher: js $('#button').click(function() { $('.ele > .other * div.className').show() });

Ereignisdelegation

Das Verteilen von Event-Handlern auf einer Seite kann relativ lange dauern und auch mühsam sein, wenn Elemente dynamisch ersetzt werden. Dann müssen Event-Handler nämlich neu an die neuen Elemente angehängt werden.

Die Lösung in diesem Fall ist die Verwendung einer Technik namens Ereignisdelegation. Anstatt einzelne Event-Handler an Elemente anzuhängen, wird die Bubbling-Natur vieler Browser-Ereignisse genutzt, indem der Event-Handler an einen übergeordneten Knoten angehängt und der Zielknoten des Ereignisses überprüft wird, um festzustellen, ob das Ereignis von Interesse ist.

In jQuery kann dies so ausgedrückt werden:

$('#parentNode').delegate('.button', 'click', function() { ... });

Wann die Ereignisdelegierung nicht verwendet werden sollte

Manchmal kann auch das Gegenteil der Fall sein: Sie verwenden die Ereignisdelegation und haben ein Leistungsproblem. Im Grunde ermöglicht die Ereignisdelegierung eine Initialisierungszeit mit konstanter Komplexität. Die Kosten für die Prüfung, ob ein Ereignis von Interesse ist, müssen jedoch für jeden Aufruf dieses Ereignisses bezahlt werden. Das kann teuer werden, insbesondere bei häufig auftretenden Ereignissen wie „mouseover“ oder „mousemove“.

Typische Probleme und Lösungen

Die Dinge, die ich in $(document).ready mache, dauern lange

Maltes persönlicher Rat: Mach nie etwas in $(document).ready. Versuchen Sie, Ihr Dokument in der endgültigen Form zu liefern. OK, Sie dürfen Ereignis-Listener registrieren, aber nur mit ID-Selektor und/oder Ereignisdelegation. Bei aufwendigen Ereignissen wie „mousemove“ sollten Sie die Registrierung verzögern, bis sie benötigt werden (Mouseover-Ereignis für das entsprechende Element).

Wenn ihr wirklich etwas tun müsst, z. B. eine Ajax-Anfrage stellen, um tatsächliche Daten abzurufen, dann zeigt eine schöne Animation an. Ihr könnt die Animation als Daten-URI einfügen, wenn es sich um ein animiertes GIF oder Ähnliches handelt.

Seit ich der Seite einen Flash-Film hinzugefügt habe, ist alles sehr langsam.

Wenn Sie einer Seite Flash hinzufügen, wird das Rendering immer etwas verlangsamt, da das endgültige Layout des Fensters zwischen dem Browser und dem Flash-Plug-in „ausgehandelt“ werden muss. Wenn Sie Flash auf Ihren Seiten nicht vollständig vermeiden können, legen Sie den Flash-Parameter „wmode“ auf den Wert „window“ fest (Standardeinstellung). Dadurch wird die Möglichkeit deaktiviert, HTML- und Flash-Elemente zu kombinieren. Sie können dann kein HTML-Element sehen, das sich über dem Flash-Film befindet, und der Flash-Film kann nicht transparent sein. Das ist zwar etwas umständlich, verbessert aber die Leistung erheblich. Auf youtube.com wird beispielsweise sorgfältig darauf geachtet, dass keine Ebenen über dem Hauptvideoplayer platziert werden.

Ich speichere Dinge in localStorage und jetzt ruckelt meine Anwendung

Das Schreiben in localStorage ist ein synchroner Vorgang, bei dem die Festplatte hochgefahren wird. Sie sollten während Animationen keine synchronen Vorgänge mit langer Ausführungszeit ausführen. Verschieben Sie den Zugriff auf localStorage an eine Stelle im Code, an der Sie sicher sind, dass der Nutzer inaktiv ist und keine Animationen ausgeführt werden.

Profiling weist auf einen sehr langsamen jQuery-Selektor hin

Zuerst müssen Sie sicherstellen, dass Ihr Selektor über document.querySelectorAll ausgeführt werden kann. Sie können das in der JavaScript-Konsole testen. Wenn eine Ausnahme vorliegt, schreiben Sie den Selektor so um, dass keine spezielle Erweiterung Ihres JavaScript-Frameworks verwendet wird. Dadurch wird der Selektor in modernen Browsern um eine Größenordnung beschleunigt.

Wenn das nicht hilft oder Sie auch in modernen Browsern schnell sein möchten, beachten Sie die folgenden Richtlinien:

  • Seien Sie auf der rechten Seite des Selektors so spezifisch wie möglich.
  • Verwenden Sie als Selektorteil ganz rechts einen Tag-Namen, den Sie nicht oft verwenden.
  • Wenn nichts hilft, sollten Sie den Code so umschreiben, dass Sie einen ID-Selektor verwenden können.

Alle diese DOM-Manipulationen nehmen viel Zeit in Anspruch,

Eine Reihe von DOM-Knoteneinfügungen, -entfernungen und -aktualisierungen kann sehr langsam sein. Dies kann im Allgemeinen optimiert werden, indem ein großer HTML-String generiert und der alte Inhalt mit domNode.innerHTML = newHTML ersetzt wird. Beachten Sie, dass dies die Wartbarkeit beeinträchtigen und in IE zu Speicherlecks führen kann. Seien Sie also vorsichtig.

Ein weiteres häufiges Problem ist, dass durch den Initialisierungscode möglicherweise viel HTML erstellt wird. Beispiel: Ein jQuery-Plug-in, das ein Auswahlfeld in eine Reihe von Divs umwandelt, weil die Designer das so wollten, ohne die Best Practices für die UX zu kennen. Wenn Sie wirklich möchten, dass Ihre Seite schnell ist, sollten Sie das niemals tun. Stattdessen sollte das gesamte Markup serverseitig in seiner endgültigen Form bereitgestellt werden. Auch das hat viele Probleme. Überlegen Sie sich also gut, ob die Geschwindigkeit den Kompromiss wert ist.

Tools

  1. JSPerf – Benchmark little snippets of JavaScript
  2. Firebug – für die Profilerstellung in Firefox
  3. Google Chrome-Entwicklertools (in Safari als WebInspector verfügbar)
  4. DOM Monster – zur Optimierung der DOM-Leistung
  5. DynaTrace Ajax Edition – für Profilerstellung und Optimierung des Rendering in Internet Explorer

Weitere Informationen

  1. Google Speed
  2. Paul Irish zur jQuery-Leistung
  3. Extreme JavaScript Performance (Präsentation)