Zwiększanie skuteczności aplikacji HTML5

Wprowadzenie

HTML5 daje nam świetne narzędzia do ulepszania wyglądu aplikacji internetowych. Dotyczy to zwłaszcza animacji. Jednak te nowe możliwości wiążą się też z nowymi wyzwaniami. W rzeczywistości te wyzwania nie są nowe i czasami warto zapytać programistę Flasha, jak radził sobie z podobnymi problemami w przeszłości.

W każdym razie, gdy pracujesz nad animacją, bardzo ważne jest, aby użytkownicy postrzegali ją jako płynną. Musimy zdać sobie sprawę, że płynności animacji nie da się uzyskać przez zwykłe zwiększenie liczby klatek na sekundę powyżej progu percepcji. Nasz mózg jest niestety mądrzejszy. Dowiesz się, że prawdziwe 30 klatek animacji na sekundę (kl./s) jest znacznie lepsze niż 60 kl./s z kilkoma pominiętymi klatkami w środku. Ludzie nie lubią poszarpanych krawędzi.

W tym artykule znajdziesz narzędzia i techniki, które pomogą Ci poprawić wrażenia użytkowników Twojej aplikacji.

Strategia

W żadnym wypadku nie chcemy zniechęcać Cię do tworzenia niesamowitych, atrakcyjnych wizualnie aplikacji w HTML5.

Jeśli zauważysz, że skuteczność mogłaby być nieco lepsza, wróć tutaj i dowiedz się, jak możesz ulepszyć elementy aplikacji. Oczywiście może to pomóc w prawidłowym wykonaniu niektórych czynności, ale nie pozwól, aby przeszkodziło Ci to w produktywności.

Wierność wizualna++ dzięki HTML5

Akceleracja sprzętowa

Akceleracja sprzętowa to ważny krok w kierunku poprawy ogólnej wydajności renderowania w przeglądarce. Ogólny schemat polega na przeniesieniu zadań, które w przeciwnym razie byłyby obliczane przez główny procesor, do procesora graficznego (GPU) w karcie graficznej komputera. Może to przynieść ogromne korzyści pod względem wydajności, a także zmniejszyć zużycie zasobów na urządzeniach mobilnych.

Te aspekty dokumentu mogą być przyspieszane przez GPU

  • Komponowanie ogólnego układu
  • Przejścia CSS3
  • Przekształcenia 3D w CSS3
  • Rysunek na obszarze roboczym
  • Rysowanie 3D w WebGL

Akceleracja Canvas i WebGL to funkcje specjalne, które mogą nie mieć zastosowania w przypadku Twojej aplikacji, ale pierwsze 3 aspekty mogą pomóc przyspieszyć działanie niemal każdej aplikacji.

Co można przyspieszyć?

Akceleracja GPU polega na przenoszeniu dobrze zdefiniowanych i konkretnych zadań na sprzęt specjalnego przeznaczenia. Ogólny schemat polega na tym, że dokument jest podzielony na wiele „warstw”, które są niezmienne w odniesieniu do aspektów strony, które są przyspieszane. Te warstwy są renderowane przy użyciu tradycyjnego potoku renderowania. Następnie GPU jest używany do scalania warstw w jedną stronę z zastosowaniem „efektów”, które można przyspieszyć na bieżąco. Możliwy wynik jest taki, że obiekt animowany na ekranie nie wymaga pojedynczego „ponownego układu” strony podczas animacji.

Wniosek jest taki, że musisz ułatwić silnikowi renderowania rozpoznanie, kiedy może zastosować akcelerację GPU. Przyjrzyj się temu przykładowi:

To działa, ale przeglądarka nie wie, że wykonujesz coś, co ma być postrzegane przez człowieka jako płynna animacja. Zastanów się, co się stanie, gdy uzyskasz ten sam efekt wizualny za pomocą przejść CSS3:

Sposób, w jaki przeglądarka implementuje tę animację, jest całkowicie ukryty przed deweloperem. Oznacza to, że przeglądarka może stosować różne sztuczki, takie jak akceleracja GPU, aby osiągnąć określony cel.

W Chrome dostępne są 2 przydatne flagi wiersza poleceń, które pomagają w debugowaniu akceleracji GPU:

  1. --show-composited-layer-borders wyświetla czerwone obramowanie wokół elementów, które są przetwarzane na poziomie GPU. Przydaje się do potwierdzania, że manipulacje występują w warstwie GPU.
  2. --show-paint-rects wszystkie zmiany niezwiązane z GPU są renderowane, a wokół wszystkich ponownie renderowanych obszarów pojawia się jasna ramka. Możesz zobaczyć, jak przeglądarka optymalizuje obszary renderowania.

Safari ma podobne flagi środowiska wykonawczego, które są opisane tutaj.

Przejścia CSS3

Przejścia CSS sprawiają, że animacja stylu jest banalna dla wszystkich, ale są też inteligentną funkcją zwiększającą wydajność. Ponieważ przejście CSS jest zarządzane przez przeglądarkę, wierność animacji może być znacznie lepsza, a w wielu przypadkach przyspieszona sprzętowo. Obecnie WebKit (Chrome, Safari, iOS) ma przekształcenia CSS z akceleracją sprzętową, ale wkrótce będą one dostępne w innych przeglądarkach i na innych platformach.

Możesz używać zdarzeń transitionEnd, aby tworzyć skrypty z zaawansowanymi kombinacjami, ale obecnie przechwytywanie wszystkich obsługiwanych zdarzeń zakończenia przejścia oznacza obserwowanie webkitTransitionEnd transitionend oTransitionEnd.

Wiele bibliotek wprowadziło już interfejsy API animacji, które wykorzystują przejścia, jeśli są dostępne, a w przeciwnym razie korzystają ze standardowej animacji w stylu DOM. scripty2, YUI transition, jQuery animate enhanced.

CSS3 translate

Prawdopodobnie zdarzyło Ci się już animować pozycję x/y elementu na stronie. Prawdopodobnie zmodyfikowano właściwości left i top stylu wbudowanego. W przypadku przekształceń 2D możemy użyć funkcji translate(), aby odtworzyć to zachowanie.

Możemy połączyć to z animacją DOM, aby uzyskać najlepszy możliwy efekt.

<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>

Używamy Modernizra do testowania funkcji przekształceń i przejść CSS 2D. Jeśli są dostępne, użyjemy translacji do zmiany pozycji. Jeśli jest animowany za pomocą przejścia, istnieje duża szansa, że przeglądarka może go przyspieszyć sprzętowo. Aby dodatkowo pomóc przeglądarce, użyjemy wspomnianego wyżej „magicznego pocisku CSS”.

Jeśli nasza przeglądarka ma mniejsze możliwości, do przeniesienia elementu użyjemy jQuery. Możesz skorzystać z wtyczki polyfill jQuery Transform autorstwa Louisa-Remiego Babe, aby zautomatyzować cały proces.

window.requestAnimationFrame

Metoda requestAnimationFrame została wprowadzona przez Mozillę i ulepszona przez WebKit, aby zapewnić natywny interfejs API do uruchamiania animacji, niezależnie od tego, czy są one oparte na DOM/CSS, czy na <canvas> lub WebGL. Przeglądarka może optymalizować jednoczesne animacje w ramach jednego cyklu ponownego przepływu i ponownego renderowania, co pozwala uzyskać animację o wyższej jakości. Na przykład animacje oparte na JS zsynchronizowane z przejściami CSS lub SVG SMIL. Ponadto jeśli pętla animacji jest uruchomiona na karcie, która nie jest widoczna, przeglądarka nie będzie jej odtwarzać, co oznacza mniejsze wykorzystanie procesora, GPU i wykorzystanie pamięci, a w rezultacie znacznie dłuższą żywotność baterii.

Więcej informacji o tym, jak i dlaczego warto używać requestAnimationFrame, znajdziesz w artykule Paula Irisha requestAnimationFrame for smart animating (requestAnimationFrame do inteligentnej animacji).

Profilowanie

Gdy odkryjesz, że szybkość aplikacji można poprawić, czas zagłębić się w profilowanie, aby dowiedzieć się, gdzie optymalizacja może przynieść największe korzyści. Optymalizacje często mają negatywny wpływ na łatwość utrzymania kodu źródłowego, dlatego należy je stosować tylko wtedy, gdy jest to konieczne. Profilowanie wskazuje, które części kodu przyniosą największe korzyści, gdy ich wydajność zostanie poprawiona.

Profilowanie JavaScriptu

Profilery JavaScriptu dają ogólny obraz wydajności aplikacji na poziomie funkcji JavaScriptu, mierząc czas potrzebny na wykonanie każdej funkcji od początku do końca.

Czas wykonania brutto funkcji to łączny czas potrzebny na jej wykonanie od początku do końca. Czas wykonywania netto to czas wykonywania brutto pomniejszony o czas potrzebny na wykonanie funkcji wywołanych z funkcji.

Niektóre funkcje są wywoływane częściej niż inne. Profilery zwykle podają czas potrzebny na wykonanie wszystkich wywołań, a także średni, minimalny i maksymalny czas wykonywania.

Więcej informacji znajdziesz w dokumentacji Narzędzi deweloperskich w Chrome dotyczącej profilowania.

DOM

Wydajność kodu JavaScript ma duży wpływ na płynność i szybkość działania aplikacji. Warto pamiętać, że chociaż profilery JavaScriptu mierzą czas wykonywania kodu JavaScript, pośrednio mierzą też czas wykonywania operacji DOM. Te operacje DOM są często przyczyną problemów z wydajnością.

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

Na przykład w powyższym kodzie prawie nie ma czasu na wykonanie rzeczywistego kodu JavaScript. Jest bardzo prawdopodobne, że funkcja drawArray będzie widoczna w profilach, ponieważ wchodzi w interakcję z modelem DOM w bardzo nieefektywny sposób.

Porady i wskazówki

Funkcje anonimowe

Funkcje anonimowe nie są łatwe do profilowania, ponieważ nie mają nazwy, pod którą mogłyby się pojawić w profilerze. Możesz to obejść na 2 sposoby:

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

przeredaguj na:

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

Nie jest powszechnie wiadomo, że JavaScript obsługuje nazywanie wyrażeń funkcji. Dzięki temu będą one prawidłowo wyświetlane w profilerze. To rozwiązanie ma jedną wadę: wyrażenie nazwane faktycznie umieszcza nazwę funkcji w bieżącym zakresie leksykalnym. Może to spowodować nadpisanie innych symboli, więc zachowaj ostrożność.

Profilowanie długich funkcji

Wyobraź sobie, że masz długą funkcję i podejrzewasz, że jej niewielka część może być przyczyną problemów z wydajnością. Aby dowiedzieć się, która część jest uszkodzona, możesz:

  1. Prawidłowa metoda: refaktoryzuj kod, aby nie zawierał długich funkcji.
  2. Zła metoda na osiągnięcie celu: dodaj do kodu instrukcje w postaci nazwanych funkcji wywołujących same siebie. Jeśli zachowasz ostrożność, nie zmieni to semantyki, a części funkcji będą wyświetlane w profilerze jako osobne funkcje: js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... } Po zakończeniu profilowania nie zapomnij usunąć tych dodatkowych funkcji. Możesz też użyć ich jako punktu wyjścia do refaktoryzacji kodu.

Profilowanie DOM

Najnowsze narzędzia dla programistów Chrome Web Inspector zawierają nowy „Widok osi czasu”, który pokazuje oś czasu działań niskiego poziomu wykonywanych przez przeglądarkę. Możesz użyć tych informacji do optymalizacji operacji DOM. Staraj się zmniejszyć liczbę „działań”, które przeglądarka musi wykonać podczas wykonywania kodu.

Widok osi czasu może zawierać ogromną ilość informacji. Dlatego staraj się tworzyć minimalne elementy testowania, które można wykonywać niezależnie.

Profilowanie DOM

Obraz powyżej pokazuje dane wyjściowe widoku osi czasu dla bardzo prostego skryptu. W lewym panelu wyświetlane są operacje wykonywane przez przeglądarkę w porządku chronologicznym, a na osi czasu w prawym panelu widać rzeczywisty czas trwania poszczególnych operacji.

Więcej informacji o widoku osi czasu Alternatywnym narzędziem do profilowania w Internet Explorerze jest DynaTrace Ajax Edition.

Strategie profilowania

Wyróżnianie aspektów

Jeśli chcesz utworzyć profil aplikacji, spróbuj jak najdokładniej wyodrębnić aspekty jej funkcjonalności, które mogą powodować spowolnienie. Następnie spróbuj przeprowadzić profilowanie, które wykonuje tylko te części kodu, które są istotne dla tych aspektów aplikacji. Ułatwi to interpretację danych profilowania, ponieważ nie będą one wymieszane ze ścieżkami kodu, które nie są związane z Twoim problemem. Dobre przykłady poszczególnych aspektów aplikacji:

  1. Czas uruchamiania (aktywuj profiler, ponownie załaduj aplikację, poczekaj na zakończenie inicjowania, zatrzymaj profiler).
  2. Kliknij przycisk i poczekaj na zakończenie animacji (uruchom profiler, kliknij przycisk, poczekaj na zakończenie animacji, zatrzymaj profiler).
Profilowanie GUI

W programie z interfejsem GUI wykonanie tylko odpowiedniej części aplikacji może być trudniejsze niż w przypadku optymalizacji np. ray tracera silnika 3D. Jeśli na przykład chcesz profilować to, co dzieje się po kliknięciu przycisku, możesz po drodze wywołać niepowiązane zdarzenia najechania kursorem myszy, co sprawi, że wyniki będą mniej jednoznaczne. Staraj się tego unikać :)

Interfejs automatyzacji

Dostępny jest też interfejs programistyczny do aktywowania debugera. Umożliwia to precyzyjną kontrolę nad tym, kiedy profilowanie się rozpoczyna i kończy.

Rozpocznij profilowanie za pomocą:

console.profile()

Zatrzymaj profilowanie za pomocą:

console.profileEnd()

Powtarzalność

Podczas profilowania upewnij się, że możesz odtworzyć wyniki. Dopiero wtedy będziesz w stanie stwierdzić, czy optymalizacje rzeczywiście przyniosły poprawę. Profilowanie na poziomie funkcji jest też wykonywane w kontekście całego komputera. Nie jest to nauka ścisła. Na poszczególne uruchomienia profilu może wpływać wiele innych czynników na komputerze:

  1. Niezwiązany z pomiarem timer w Twojej aplikacji, który uruchamia się podczas pomiaru czegoś innego.
  2. Odśmiecanie pamięci.
  3. inna karta w przeglądarce wykonuje intensywne zadania w tym samym wątku operacyjnym;
  4. Inny program na komputerze zużywa moc procesora, co spowalnia działanie aplikacji.
  5. Nagłe zmiany pola grawitacyjnego Ziemi.

Warto też wykonać tę samą ścieżkę kodu kilka razy w jednej sesji profilowania. W ten sposób zmniejszysz wpływ powyższych czynników, a powolne fragmenty mogą być jeszcze bardziej widoczne.

Mierzenie, ulepszanie, mierzenie

Gdy znajdziesz w programie wolne miejsce, zastanów się, jak możesz poprawić jego działanie. Po zmianie kodu ponownie przeprowadź profilowanie. Jeśli wynik Cię zadowala, przejdź dalej. Jeśli nie widzisz poprawy, prawdopodobnie warto cofnąć zmianę, a nie zostawiać ją, „bo nie zaszkodzi”.

Strategie optymalizacji

Minimalizowanie interakcji z DOM

Częstym sposobem na zwiększenie szybkości aplikacji klienckich w internecie jest minimalizowanie interakcji z DOM. Chociaż szybkość silników JavaScriptu wzrosła o rząd wielkości, dostęp do DOM nie przyspieszył w tym samym stopniu. Z bardzo praktycznych powodów nigdy się to nie stanie (takie czynności jak układanie i rysowanie elementów na ekranie po prostu wymagają czasu).

Zapisywanie węzłów DOM w pamięci podręcznej

Za każdym razem, gdy pobierasz węzeł lub listę węzłów z DOM, zastanów się, czy możesz ich użyć ponownie w późniejszych obliczeniach (lub nawet w następnej iteracji pętli). Jeśli nie dodasz ani nie usuniesz węzłów w odpowiednim obszarze, często tak się dzieje.

Przed:

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

Po:

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

Wartości atrybutów pamięci podręcznej

W ten sam sposób, w jaki buforujesz węzły DOM, możesz też buforować wartości atrybutów. Wyobraź sobie, że animujesz atrybut stylu węzła. Jeśli wiesz, że Ty (jako ta część kodu) jesteś jedyną osobą, która kiedykolwiek będzie korzystać z tego atrybutu, możesz zapisać w pamięci podręcznej ostatnią wartość w każdej iteracji, aby nie trzeba było jej wielokrotnie odczytywać.

Przed:

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

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

Przenoszenie manipulacji DOM poza pętle

Pętle są często kluczowymi punktami optymalizacji. Spróbuj znaleźć sposoby na oddzielenie rzeczywistego przetwarzania liczb od pracy z DOM. Często można wykonać obliczenia, a następnie zastosować wszystkie wyniki jednocześnie.

Przed:

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

Po:

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

Ponowne rysowanie i ponowne rozmieszczanie

Jak wspomnieliśmy wcześniej, dostęp do modelu DOM jest stosunkowo powolny. Działanie staje się bardzo powolne, gdy kod odczytuje wartość, którą trzeba ponownie obliczyć, ponieważ kod niedawno zmodyfikował coś powiązanego w DOM. Dlatego należy unikać jednoczesnego odczytu i zapisu w DOM. Najlepiej, aby kod był zawsze pogrupowany w 2 fazach:

  • Faza 1. Odczytaj wartości DOM niezbędne dla kodu.
  • Etap 2. Modyfikowanie modelu DOM

Staraj się nie programować wzorców takich jak:

  • Faza 1. Odczyt wartości DOM
  • Etap 2. Modyfikowanie modelu DOM
  • Etap 3. Czytaj dalej
  • Etap 4. Zmodyfikuj DOM w innym miejscu.

Przed:

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

Po:

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

Te wskazówki dotyczą działań wykonywanych w ramach jednego kontekstu wykonywania JavaScriptu. (np. w module obsługi zdarzeń, w module obsługi interwałów lub podczas obsługi odpowiedzi AJAX).

Wykonanie funkcji paintSlow() z powyższego przykładu spowoduje utworzenie tego obrazu:

paintSlow()

Przejście na szybszą implementację daje ten obraz:

Szybsze wdrażanie

Te obrazy pokazują, że zmiana kolejności, w jakiej kod uzyskuje dostęp do modelu DOM, może znacznie zwiększyć wydajność renderowania. W tym przypadku pierwotny kod musi dwukrotnie przeliczyć style i układ strony, aby uzyskać ten sam wynik. Podobną optymalizację można zastosować do praktycznie każdego kodu „z prawdziwego świata” i uzyskać naprawdę spektakularne wyniki.

Więcej informacji: Rendering: repaint, reflow/relayout, restyle, autor: Stoyan Stefanov

Ponowne rysowanie i pętla zdarzeń

Wykonywanie kodu JavaScript w przeglądarce odbywa się zgodnie z modelem „pętli zdarzeń”. Domyślnie przeglądarka jest w stanie „bezwynikowym”. Ten stan może zostać przerwany przez zdarzenia wynikające z interakcji użytkownika lub takie elementy jak liczniki czasu JavaScriptu czy wywołania zwrotne Ajax. Gdy w takim punkcie przerwania zostanie uruchomiony fragment kodu JavaScript, przeglądarka zwykle czeka na jego zakończenie, zanim ponownie wyrenderuje ekran (mogą wystąpić wyjątki w przypadku bardzo długo działających skryptów JavaScript lub w przypadkach takich jak okna alertów, które skutecznie przerywają wykonywanie kodu JavaScript).

Konsekwencje

  1. Jeśli cykle animacji JavaScriptu trwają dłużej niż 1/30 sekundy, nie uda Ci się utworzyć płynnych animacji, ponieważ przeglądarka nie będzie odświeżać obrazu podczas wykonywania kodu JS. Jeśli chcesz obsługiwać też zdarzenia użytkownika, musisz działać znacznie szybciej.
  2. Czasami przydaje się opóźnienie niektórych działań JavaScriptu. Na przykład: setTimeout(function() { ... }, 0) To skutecznie informuje przeglądarkę, aby wykonała wywołanie zwrotne, gdy tylko pętla zdarzeń znów będzie bezczynna (niektóre przeglądarki będą czekać co najmniej 10 ms). Pamiętaj, że spowoduje to utworzenie 2 cykli wykonywania kodu JavaScript, które będą bardzo blisko siebie w czasie. Oba te zdarzenia mogą spowodować ponowne renderowanie ekranu, co może podwoić łączny czas renderowania. To, czy faktycznie spowoduje to 2 renderowania, zależy od heurystyki przeglądarki.

Wersja zwykła:

function paintFast() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  $('#otherThing2').css('height', '20px');
}
Ponowne rysowanie i pętla zdarzeń

Dodajmy opóźnienie:

function paintALittleLater() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  setTimeout(function() {
    $('#otherThing2').css('height', '20px');
  }, 10)
}
Opóźnienie

Wersja z opóźnieniem pokazuje, że przeglądarka renderuje stronę dwukrotnie, mimo że te 2 zmiany na stronie dzieli tylko 1/100 sekundy.

Leniwa inicjalizacja

Użytkownicy chcą, aby aplikacje internetowe szybko się wczytywały i działały sprawnie. Jednak użytkownicy mają różne progi tego, co postrzegają jako powolne, w zależności od wykonywanej czynności. Na przykład aplikacja nie powinna wykonywać wielu obliczeń po najechaniu kursorem myszy, ponieważ może to pogorszyć wrażenia użytkownika, gdy ten nadal porusza myszą. Użytkownicy są jednak przyzwyczajeni do niewielkiego opóźnienia po kliknięciu przycisku.

Dlatego warto przenieść kod inicjowania, aby był wykonywany jak najpóźniej (np. gdy użytkownik kliknie przycisk, który aktywuje określony komponent aplikacji).

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

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

Przekazywanie zdarzeń

Rozmieszczanie modułów obsługi zdarzeń na stronie może zająć stosunkowo dużo czasu i być uciążliwe, gdy elementy są dynamicznie zastępowane, co wymaga ponownego dołączania modułów obsługi zdarzeń do nowych elementów.

Rozwiązaniem w tym przypadku jest użycie techniki zwanej delegowaniem zdarzeń. Zamiast dołączać poszczególne moduły obsługi zdarzeń do elementów, wykorzystuje się bąbelkowy charakter wielu zdarzeń przeglądarki, dołączając moduł obsługi zdarzeń do węzła nadrzędnego i sprawdzając węzeł docelowy zdarzenia, aby zobaczyć, czy zdarzenie jest interesujące.

W jQuery można to łatwo wyrazić w ten sposób:

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

Kiedy nie używać przekazywania zdarzeń

Czasami może być odwrotnie: używasz delegowania zdarzeń i masz problem z wydajnością. Zasadniczo delegowanie zdarzeń umożliwia stałą złożoność czasu inicjowania. Jednak koszt sprawdzenia, czy zdarzenie jest interesujące, musi zostać poniesiony przy każdym wywołaniu tego zdarzenia. Może to być kosztowne, zwłaszcza w przypadku zdarzeń, które występują często, takich jak „mouseover” czy „mousemove”.

Typowe problemy i rozwiązania

Czynności, które wykonuję w aplikacji $(document).ready, zajmują dużo czasu

Osobista rada Malte: nigdy nie rób niczego w $(document).ready. Postaraj się przesłać dokument w ostatecznej formie. OK, możesz rejestrować detektory zdarzeń, ale tylko za pomocą selektora identyfikatora lub delegowania zdarzeń. W przypadku kosztownych zdarzeń, takich jak „mousemove”, opóźnij rejestrację, dopóki nie będą potrzebne (zdarzenie mouseover na odpowiednim elemencie).

Jeśli musisz wykonać jakieś czynności, np. wysłać żądanie Ajax, aby uzyskać rzeczywiste dane, wyświetl ładną animację. Możesz ją dołączyć jako identyfikator URI danych, jeśli jest to animowany GIF lub coś podobnego.

Po dodaniu filmu Flash do strony wszystko działa bardzo wolno

Dodanie Flasha do strony zawsze nieco spowalnia renderowanie, ponieważ ostateczny układ okna musi zostać „uzgodniony” między przeglądarką a wtyczką Flash. Jeśli nie możesz całkowicie uniknąć umieszczania Flasha na swoich stronach, ustaw parametr „wmode” na wartość „window” (jest to wartość domyślna). Spowoduje to wyłączenie możliwości łączenia elementów HTML i Flash (nie będzie można zobaczyć elementu HTML, który znajduje się nad filmem Flash, a film Flash nie będzie mógł być przezroczysty). Może to być uciążliwe, ale znacznie poprawi wydajność. Zobacz na przykład, jak na stronie youtube.com unika się umieszczania warstw nad głównym odtwarzaczem filmów.

Zapisuję dane w localStorage, a moja aplikacja się zacina

Zapisywanie w localStorage to operacja synchroniczna, która wymaga uruchomienia dysku twardego. Podczas animacji nie należy wykonywać „długotrwałych” operacji synchronicznych. Przenieś dostęp do localStorage do miejsca w kodzie, w którym masz pewność, że użytkownik jest nieaktywny i nie są wyświetlane żadne animacje.

Profilowanie wskazuje, że selektor jQuery jest bardzo powolny.

Najpierw upewnij się, że selektor może zostać uruchomiony za pomocą document.querySelectorAll. Możesz to sprawdzić w konsoli JavaScript. Jeśli wystąpi wyjątek, zmień selektor tak, aby nie używał żadnego specjalnego rozszerzenia platformy JavaScript. Dzięki temu selektor będzie działać w nowoczesnych przeglądarkach o rząd wielkości szybciej.

Jeśli to nie pomoże lub jeśli chcesz, aby Twoja witryna działała szybko również w nowoczesnych przeglądarkach, postępuj zgodnie z tymi wskazówkami:

  • Po prawej stronie selektora podaj jak najwięcej szczegółów.
  • Jako selektora najbardziej po prawej stronie użyj nazwy tagu, którego nie używasz często.
  • Jeśli nic nie pomaga, rozważ przepisanie kodu, aby użyć selektora identyfikatora.

Wszystkie te operacje na DOM zajmują dużo czasu,

Wstawianie, usuwanie i aktualizowanie wielu węzłów DOM może być bardzo powolne. Zwykle można to zoptymalizować, generując duży ciąg znaków HTML i używając domNode.innerHTML = newHTML do zastąpienia starej treści. Pamiętaj, że może to być bardzo niekorzystne dla łatwości konserwacji i może powodować wycieki pamięci w IE, więc zachowaj ostrożność.

Innym częstym problemem jest to, że kod inicjujący może tworzyć dużo kodu HTML. Na przykład wtyczka jQuery, która przekształca pole wyboru w grupę elementów div, ponieważ tego chcieli projektanci, którzy nie znali sprawdzonych metod dotyczących UX. Jeśli naprawdę chcesz, aby Twoja strona była szybka, nigdy tego nie rób. Zamiast tego dostarczaj wszystkie znaczniki po stronie serwera w ich ostatecznej formie. To rozwiązanie również ma wiele wad, więc zastanów się, czy szybkość jest warta kompromisu.

Narzędzia

  1. JSPerf – testy porównawcze krótkich fragmentów kodu JavaScript
  2. Firebug – do profilowania w Firefoksie
  3. Narzędzia deweloperskie w Google Chrome (dostępne jako WebInspector w Safari)
  4. DOM Monster – do optymalizacji wydajności DOM
  5. DynaTrace Ajax Edition – do profilowania i optymalizacji renderowania w Internet Explorerze

Więcej informacji

  1. Szybkość Google
  2. Paul Irish o wydajności jQuery
  3. Extreme JavaScript Performance (prezentacja)