Améliorer les performances de votre application HTML5

Introduction

HTML5 nous fournit d'excellents outils pour améliorer l'apparence visuelle des applications Web. Cela est particulièrement vrai dans le domaine des animations. Toutefois, cette nouvelle puissance s'accompagne également de nouveaux défis. En réalité, ces défis ne sont pas vraiment nouveaux, et il peut parfois être judicieux de demander à votre sympathique collègue, la programmeuse Flash, comment elle a surmonté des problèmes similaires par le passé.

Quoi qu'il en soit, lorsque vous travaillez sur des animations, il est extrêmement important que les utilisateurs les perçoivent comme fluides. Il faut comprendre que la fluidité des animations ne peut pas être créée simplement en augmentant le nombre d'images par seconde au-delà d'un certain seuil cognitif. Malheureusement, notre cerveau est plus intelligent que cela. Vous apprendrez qu'une animation à 30 images par seconde (FPS) est bien meilleure qu'une animation à 60 FPS avec quelques images perdues au milieu. Les gens détestent les irrégularités.

Cet article vous présente les outils et techniques permettant d'améliorer l'expérience de votre propre application.

La stratégie

Nous ne voulons en aucun cas vous décourager de créer des applications HTML5 visuellement époustouflantes.

Ensuite, lorsque vous remarquerez que les performances pourraient être un peu meilleures, revenez ici et lisez comment vous pouvez améliorer les éléments de votre application. Bien sûr, cela peut vous aider à faire certaines choses correctement dès le départ, mais ne laissez jamais cela vous empêcher d'être productif.

Fidélité visuelle améliorée avec HTML5

Accélération matérielle

L'accélération matérielle est une étape importante pour les performances globales de rendu dans le navigateur. Le principe général consiste à décharger le processeur principal (CPU) des tâches qui seraient normalement calculées par celui-ci, en les confiant au processeur graphique (GPU) de la carte graphique de votre ordinateur. Cela peut améliorer considérablement les performances et réduire la consommation de ressources sur les appareils mobiles.

Ces aspects de votre document peuvent être accélérés par le GPU

  • Composition de la mise en page générale
  • Transitions CSS3
  • Transformations 3D CSS3
  • Dessin sur canevas
  • Dessin 3D WebGL

Bien que l'accélération de Canvas et de WebGL soient des fonctionnalités spécifiques qui ne s'appliquent pas forcément à votre application, les trois premiers aspects peuvent aider pratiquement toutes les applications à devenir plus rapides.

Qu'est-ce qui peut être accéléré ?

L'accélération GPU consiste à décharger des tâches bien définies et spécifiques sur du matériel dédié. Le principe général est que votre document est divisé en plusieurs "couches" qui sont invariantes par rapport aux aspects de votre page qui sont accélérés. Ces couches sont affichées à l'aide du pipeline de rendu traditionnel. Le GPU est ensuite utilisé pour composer les couches sur une seule page en appliquant les "effets" qui peuvent être accélérés à la volée. Il est possible qu'un objet animé à l'écran ne nécessite pas une seule "réorganisation" de la page pendant l'animation.

Ce que vous devez retenir, c'est que vous devez permettre au moteur de rendu d'identifier facilement quand il peut appliquer l'accélération GPU. Prenons l'exemple suivant :

Bien que cela fonctionne, le navigateur ne sait pas vraiment que vous effectuez une opération censée être perçue comme une animation fluide par un être humain. Voyons ce qui se passe lorsque vous obtenez la même apparence visuelle en utilisant des transitions CSS3 :

La façon dont le navigateur implémente cette animation est complètement masquée pour le développeur. Cela signifie que le navigateur peut appliquer des astuces telles que l'accélération GPU pour atteindre l'objectif défini.

Deux flags de ligne de commande sont utiles pour déboguer l'accélération GPU dans Chrome :

  1. --show-composited-layer-borders affiche une bordure rouge autour des éléments manipulés au niveau du GPU. Idéal pour confirmer que vos manipulations se produisent dans la couche GPU.
  2. --show-paint-rects : toutes les modifications non liées au GPU sont peintes, ce qui ajoute une bordure claire autour de toutes les zones repeintes. Vous pouvez voir le navigateur optimiser les zones de peinture en action.

Safari dispose d'options d'exécution similaires décrites ici.

Transitions CSS3

Les transitions CSS facilitent l'animation des styles pour tous, mais elles constituent également une fonctionnalité de performances intelligente. Comme une transition CSS est gérée par le navigateur, la fidélité de son animation peut être considérablement améliorée et, dans de nombreux cas, accélérée par le matériel. Actuellement, WebKit (Chrome, Safari, iOS) propose des transformations CSS avec accélération matérielle, mais cette fonctionnalité sera bientôt disponible sur d'autres navigateurs et plates-formes.

Vous pouvez utiliser les événements transitionEnd pour créer des scripts de combinaisons puissantes. Toutefois, pour le moment, capturer tous les événements de fin de transition compatibles signifie surveiller webkitTransitionEnd transitionend oTransitionEnd.

De nombreuses bibliothèques ont désormais introduit des API d'animation qui exploitent les transitions si elles sont présentes et reviennent à l'animation de style DOM standard dans le cas contraire. scripty2, YUI transition, jQuery animate enhanced.

CSS3 translate

Vous avez probablement déjà animé la position X/Y d'un élément sur une page. Vous avez probablement manipulé les propriétés "left" et "top" du style intégré. Avec les transformations 2D, nous pouvons utiliser la fonctionnalité translate() pour reproduire ce comportement.

Nous pouvons combiner cela avec l'animation DOM pour utiliser la meilleure option possible

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

Nous utilisons Modernizr pour tester les transformations 2D CSS et les transitions CSS. Si elles sont disponibles, nous utilisons la propriété "translate" pour décaler la position. Si l'animation est réalisée à l'aide d'une transition, il est fort probable que le navigateur puisse l'accélérer de manière matérielle. Pour donner un coup de pouce au navigateur, nous allons utiliser la "solution miracle CSS" ci-dessus.

Si notre navigateur est moins performant, nous utiliserons jQuery pour déplacer notre élément. Vous pouvez utiliser le plug-in polyfill jQuery Transform de Louis-Remi Babe pour automatiser l'ensemble du processus.

window.requestAnimationFrame

requestAnimationFrame a été introduit par Mozilla et repris par WebKit dans le but de vous fournir une API native pour exécuter des animations, qu'elles soient basées sur DOM/CSS, ou sur <canvas> ou WebGL. Le navigateur peut optimiser les animations simultanées en un seul cycle de redistribution et de repeinture, ce qui permet d'obtenir une animation de haute fidélité. Par exemple, des animations basées sur JS synchronisées avec des transitions CSS ou SVG SMIL. De plus, si vous exécutez la boucle d'animation dans un onglet qui n'est pas visible, le navigateur ne la maintiendra pas en cours d'exécution, ce qui signifie une utilisation moindre du processeur, du GPU et de la mémoire, et donc une autonomie de la batterie beaucoup plus longue.

Pour en savoir plus sur l'utilisation de requestAnimationFrame et ses avantages, consultez l'article de Paul Irish requestAnimationFrame for smart animating.

Profilage

Lorsque vous découvrez que la vitesse de votre application peut être améliorée, il est temps de vous pencher sur le profilage pour identifier les optimisations qui pourraient s'avérer les plus bénéfiques. Les optimisations ont souvent un impact négatif sur la facilité de maintenance de votre code source. Elles ne doivent donc être appliquées que si nécessaire. Le profilage vous indique quelles parties de votre code bénéficieraient le plus d'une amélioration de leurs performances.

Profilage JavaScript

Les profileurs JavaScript vous donnent un aperçu des performances de votre application au niveau des fonctions JavaScript en mesurant le temps nécessaire à l'exécution de chaque fonction, du début à la fin.

Le temps d'exécution brut d'une fonction correspond au temps total nécessaire pour l'exécuter de haut en bas. Le temps d'exécution net correspond au temps d'exécution brut moins le temps nécessaire à l'exécution des fonctions appelées à partir de la fonction.

Certaines fonctions sont appelées plus souvent que d'autres. Les profileurs vous indiquent généralement le temps nécessaire à l'exécution de toutes les appels, ainsi que le temps d'exécution moyen, minimal et maximal.

Pour en savoir plus, consultez la documentation des outils pour les développeurs Chrome sur le profilage.

Le DOM

Les performances de JavaScript ont une forte influence sur la fluidité et la réactivité de votre application. Il est important de comprendre que, même si les profileurs JavaScript mesurent le temps d'exécution de votre code JavaScript, ils mesurent également indirectement le temps passé à effectuer des opérations DOM. Ces opérations DOM sont souvent au cœur de vos problèmes de performances.

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

Par exemple, dans le code ci-dessus, l'exécution du code JavaScript réel ne prend presque pas de temps. Il est toujours très probable que la fonction drawArray apparaisse dans vos profils, car elle interagit avec le DOM de manière très inefficace.

Conseils et astuces

Fonctions anonymes

Les fonctions anonymes ne sont pas faciles à profiler, car elles n'ont pas de nom sous lequel elles pourraient apparaître dans le profileur. Il existe deux façons de contourner ce problème :

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

réécrire :

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

On ne sait pas toujours que JavaScript permet de nommer les expressions de fonction. Cela permettra de les afficher parfaitement dans le profileur. Cette solution présente un problème : l'expression nommée place en fait le nom de la fonction dans le champ d'application lexical actuel. Cela peut écraser d'autres symboles, alors soyez prudent.

Profiler des fonctions longues

Imaginons que vous ayez une fonction longue et que vous soupçonniez qu'une petite partie de celle-ci soit à l'origine de vos problèmes de performances. Il existe deux façons de déterminer quelle partie est à l'origine du problème :

  1. La bonne méthode : refactorisez votre code pour ne pas inclure de fonctions longues.
  2. La méthode diabolique pour faire avancer les choses : ajoutez des instructions sous la forme de fonctions auto-appelantes nommées à votre code. Si vous faites attention, cela ne modifie pas la sémantique et permet d'afficher des parties de votre fonction en tant que fonctions individuelles dans le profileur : js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... } N'oubliez pas de supprimer ces fonctions supplémentaires une fois le profilage terminé, ou même de les utiliser comme point de départ pour refactoriser votre code.

Profilage DOM

Les derniers outils pour les développeurs de l'inspecteur Web de Chrome contiennent la nouvelle "vue chronologique", qui affiche une chronologie des actions de bas niveau effectuées par le navigateur. Vous pouvez utiliser ces informations pour optimiser vos opérations DOM. Vous devez vous efforcer de réduire le nombre d'actions que le navigateur doit effectuer pendant l'exécution de votre code.

La vue chronologique peut générer une quantité immense d'informations. Vous devez donc essayer de créer des scénarios de test minimaux que vous pouvez exécuter indépendamment.

Profilage DOM

L'image ci-dessus montre le résultat de la vue chronologique pour un script très simple. Le volet de gauche affiche les opérations effectuées par le navigateur dans l'ordre chronologique, tandis que la chronologie du volet de droite indique le temps réel consommé par une opération individuelle.

En savoir plus sur la vue chronologique DynaTrace Ajax Edition est un autre outil de profilage pour Internet Explorer.

Stratégies de profilage

Isoler des aspects

Lorsque vous souhaitez profiler votre application, essayez d'isoler au mieux les aspects de ses fonctionnalités susceptibles de ralentir l'application. Ensuite, essayez d'exécuter un profil qui n'exécute que les parties de votre code pertinentes pour ces aspects de votre application. Cela facilitera l'interprétation des données de profilage, car elles ne seront pas mélangées à des chemins de code qui ne sont pas liés à votre problème réel. Voici quelques exemples d'aspects individuels de votre application :

  1. Temps de démarrage (activer le profileur, actualiser l'application, attendre la fin de l'initialisation, arrêter le profileur).
  2. Cliquez sur un bouton et sur l'animation suivante (démarrez le profileur, cliquez sur le bouton, attendez que l'animation soit terminée, arrêtez le profileur).
Profilage de l'IUG

Il peut être plus difficile de n'exécuter que la partie appropriée de votre application dans un programme d'IUG que lorsque vous optimisez, par exemple, le ray tracer de votre moteur 3D. Par exemple, si vous souhaitez profiler ce qui se passe lorsque vous cliquez sur un bouton, vous pouvez déclencher des événements de survol sans rapport qui rendent vos résultats moins concluants. Essayez d'éviter cela :)

Interface programmatique

Il existe également une interface programmatique pour activer le débogueur. Cela permet de contrôler précisément le début et la fin du profilage.

Démarrer un profilage avec :

console.profile()

Arrêter le profilage avec :

console.profileEnd()

Reproductibilité

Lorsque vous effectuez un profilage, assurez-vous de pouvoir reproduire vos résultats. Vous pourrez alors déterminer si vos optimisations ont réellement amélioré les choses. De plus, le profilage au niveau des fonctions est effectué dans le contexte de l'ensemble de votre ordinateur. Il ne s'agit pas d'une science exacte. Les exécutions de profils individuels peuvent être influencées par de nombreux autres événements sur votre ordinateur :

  1. Un minuteur non lié dans votre propre application qui se déclenche pendant que vous mesurez autre chose.
  2. Le récupérateur de mémoire fait son travail.
  3. Un autre onglet de votre navigateur effectue un travail intensif dans le même thread d'exploitation.
  4. Un autre programme sur votre ordinateur utilise le processeur, ce qui ralentit votre application.
  5. Changements soudains dans le champ gravitationnel de la Terre.

Il est également judicieux d'exécuter le même chemin de code plusieurs fois au cours d'une même session de profilage. De cette façon, vous réduisez l'influence des facteurs ci-dessus et les parties lentes peuvent ressortir encore plus clairement.

Mesurer, améliorer, mesurer

Lorsque vous identifiez un point lent dans votre programme, essayez de trouver des moyens d'améliorer le comportement d'exécution. Après avoir modifié votre code, profilez-le à nouveau. Si vous êtes satisfait du résultat, passez à l'étape suivante. Si vous ne constatez aucune amélioration, vous devriez probablement annuler votre modification et ne pas la laisser en place "parce que ça ne peut pas faire de mal".

Stratégies d'optimisation

Réduire l'interaction avec le DOM

Pour améliorer la vitesse des applications clientes Web, il est courant de réduire l'interaction avec le DOM. Bien que la vitesse des moteurs JavaScript ait augmenté d'un ordre de grandeur, l'accès au DOM n'a pas augmenté au même rythme. Pour des raisons très pratiques, cela n'arrivera jamais (des opérations comme la mise en page et le dessin d'éléments sur un écran prennent du temps).

Mettre en cache les nœuds DOM

Chaque fois que vous récupérez un nœud ou une liste de nœuds à partir du DOM, essayez de réfléchir à la possibilité de les réutiliser dans un calcul ultérieur (ou même simplement lors de la prochaine itération de la boucle). C'est souvent le cas tant que vous n'ajoutez ni ne supprimez de nœuds dans la zone concernée.

Avant :

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

Après :

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

Valeurs d'attribut de cache

De la même manière que vous pouvez mettre en cache des nœuds DOM, vous pouvez également mettre en cache les valeurs des attributs. Imaginons que vous animez un attribut du style d'un nœud. Si vous savez que vous (c'est-à-dire cette partie du code) êtes le seul à toucher à cet attribut, vous pouvez mettre en cache la dernière valeur à chaque itération afin de ne pas avoir à la lire de manière répétée.

Avant :

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

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

Déplacer la manipulation du DOM en dehors des boucles

Les boucles sont souvent des points chauds pour l'optimisation. Essayez de trouver des moyens de dissocier le traitement des données de l'utilisation du DOM. Il est souvent possible d'effectuer un calcul, puis d'appliquer tous les résultats en une seule fois.

Avant :

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

Après :

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

Nouveaux dessins et redistributions

Comme indiqué précédemment, l'accès au DOM est relativement lent. Il devient très lent lorsque votre code lit une valeur qui doit être recalculée, car votre code a récemment modifié un élément associé dans le DOM. Il convient donc d'éviter de mélanger les accès en lecture et en écriture au DOM. Idéalement, votre code doit toujours être regroupé en deux phases :

  • Phase 1 : Lire les valeurs DOM nécessaires pour votre code
  • Phase 2 : Modifier le DOM

Essayez de ne pas programmer un schéma tel que :

  • Phase 1 : Lire les valeurs DOM
  • Phase 2 : Modifier le DOM
  • Phase 3 : Lire un peu plus
  • Phase 4 : Modifier le DOM ailleurs.

Avant :

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

Après :

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

Ce conseil doit être pris en compte pour les actions qui se produisent dans un contexte d'exécution JavaScript. (par exemple, dans un gestionnaire d'événements, dans un gestionnaire d'intervalles ou lors du traitement d'une réponse AJAX).

L'exécution de la fonction paintSlow() ci-dessus crée l'image suivante :

paintSlow()

Le passage à l'implémentation plus rapide donne l'image suivante :

Implémentation plus rapide

Ces images montrent que la réorganisation de la façon dont votre code accède au DOM peut considérablement améliorer les performances de rendu. Dans ce cas, le code d'origine doit recalculer les styles et mettre en page la page deux fois pour obtenir le même résultat. Une optimisation similaire peut être appliquée à pratiquement tout code "réel" et donner des résultats spectaculaires.

En savoir plus : Rendering: repaint, reflow/relayout, restyle par Stoyan Stefanov

Nouveaux dessins et boucle d'événements

L'exécution de JavaScript dans le navigateur suit un modèle de "boucle d'événements". Par défaut, le navigateur est à l'état "inactif". Cet état peut être interrompu par des événements issus d'interactions utilisateur ou d'éléments tels que des minuteurs JavaScript ou des rappels Ajax. Chaque fois qu'un morceau de code JavaScript s'exécute à un tel point d'interruption, le navigateur attend généralement qu'il se termine avant de repeindre l'écran (il peut y avoir des exceptions pour les codes JavaScript extrêmement longs ou dans des cas tels que les boîtes d'alerte qui interrompent l'exécution du code JavaScript).

Conséquences

  1. Si les cycles d'animation JavaScript prennent plus de 1/30 seconde à s'exécuter, vous ne pourrez pas créer d'animations fluides, car le navigateur ne repeindra pas pendant l'exécution du code JS. Si vous prévoyez de gérer également les événements utilisateur, vous devez être beaucoup plus rapide.
  2. Il est parfois utile de retarder légèrement certaines actions JavaScript. Ex. : setTimeout(function() { ... }, 0) Cela indique au navigateur d'exécuter le rappel dès que la boucle d'événements est à nouveau inactive (en pratique, certains navigateurs attendent au moins 10 ms). Sachez que cela créera deux cycles d'exécution JavaScript très rapprochés dans le temps. Les deux peuvent déclencher un nouveau rendu de l'écran, ce qui peut doubler le temps total consacré au rendu. Le fait que cela déclenche réellement deux peintures dépend des heuristiques du navigateur.

Version standard :

function paintFast() {
  var height1 = $('#thing1').css('height');
  var height2 = $('#thing2').css('height');
  $('#otherThing1').css('height', '20px');
  $('#otherThing2').css('height', '20px');
}
Nouveaux dessins et boucle d'événements

Ajoutons un délai :

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

La version différée montre que le navigateur peint deux fois, même si les deux modifications apportées à la page ne sont espacées que d'un centième de seconde.

Initialisation différée

Les utilisateurs veulent des applications Web qui se chargent rapidement et qui sont réactives. Cependant, les utilisateurs ont des seuils différents pour ce qu'ils perçoivent comme lent en fonction de l'action qu'ils effectuent. Par exemple, une application ne doit jamais effectuer beaucoup de calculs lors d'un événement de survol avec la souris, car cela peut créer une mauvaise expérience utilisateur pendant que l'utilisateur continue de déplacer sa souris. Cependant, les utilisateurs sont habitués à un léger délai après avoir cliqué sur un bouton.

Il peut donc être judicieux de déplacer votre code d'initialisation pour qu'il soit exécuté le plus tard possible (par exemple, lorsque l'utilisateur clique sur un bouton qui active un composant particulier de votre application).

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

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

Délégation d'événements

La répartition des gestionnaires d'événements sur une page peut prendre un certain temps et s'avérer fastidieuse une fois que les éléments sont remplacés de manière dynamique, ce qui nécessite de rattacher les gestionnaires d'événements aux nouveaux éléments.

Dans ce cas, la solution consiste à utiliser une technique appelée "délégation d'événements". Au lieu d'associer des gestionnaires d'événements individuels à des éléments, la nature de propagation de nombreux événements de navigateur est utilisée en associant le gestionnaire d'événements à un nœud parent et en vérifiant le nœud cible de l'événement pour voir s'il est pertinent.

En jQuery, cela peut être facilement exprimé comme suit :

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

Quand ne pas utiliser la délégation d'événements

Parfois, l'inverse peut être vrai : vous utilisez la délégation d'événements et vous rencontrez un problème de performances. En gros, la délégation d'événements permet d'obtenir un temps d'initialisation à complexité constante. Cependant, le coût de la vérification de l'intérêt d'un événement doit être payé pour chaque appel de cet événement. Cela peut s'avérer coûteux, en particulier pour les événements qui se produisent fréquemment, comme "mouseover" ou même "mousemove".

Problèmes courants et solutions

Ce que je fais dans $(document).ready prend beaucoup de temps

Conseil personnel de Malte : ne faites jamais rien dans $(document).ready. Essayez de livrer votre document dans sa forme finale. OK, vous êtes autorisé à enregistrer des écouteurs d'événements, mais uniquement à l'aide d'un sélecteur d'ID et/ou de la délégation d'événements. Pour les événements coûteux tels que "mousemove", retardez l'enregistrement jusqu'à ce qu'ils soient nécessaires (événement de survol avec la souris sur l'élément concerné).

Et si vous devez vraiment effectuer des opérations, comme envoyer une requête Ajax pour obtenir des données réelles, puis afficher une belle animation, vous pouvez inclure l'animation en tant qu'URI de données s'il s'agit d'un GIF animé ou d'un élément similaire.

Depuis que j'ai ajouté une vidéo Flash à la page, tout est très lent.

L'ajout de Flash à une page ralentit toujours un peu l'affichage, car la mise en page finale de la fenêtre doit être "négociée" entre le navigateur et le plug-in Flash. Si vous ne pouvez pas éviter d'insérer du contenu Flash sur vos pages, veillez à définir le paramètre Flash "wmode" sur la valeur "window" (valeur par défaut). Cette action désactive la possibilité de combiner des éléments HTML et Flash (vous ne pourrez pas voir un élément HTML situé au-dessus de l'animation Flash, et votre animation Flash ne pourra pas être transparente). Cela peut être un inconvénient, mais cela améliorera considérablement vos performances. Par exemple, observez la façon dont youtube.com évite soigneusement de placer des calques au-dessus du lecteur vidéo principal.

J'enregistre des éléments dans localStorage, mais mon application est maintenant saccadée

L'écriture dans localStorage est une opération synchrone qui implique de faire tourner votre disque dur. Vous ne devez jamais effectuer d'opérations synchrones de longue durée pendant les animations. Déplacez l'accès à localStorage vers un endroit de votre code où vous êtes sûr que l'utilisateur est inactif et qu'aucune animation n'est en cours.

Le profilage indique qu'un sélecteur jQuery est très lent

Tout d'abord, vous devez vous assurer que votre sélecteur peut être exécuté via document.querySelectorAll. Vous pouvez tester cela dans la console JavaScript. Si une exception se produit, réécrivez votre sélecteur pour ne pas utiliser d'extension spéciale de votre framework JavaScript. Cela accélérera considérablement votre sélecteur dans les navigateurs récents.

Si cela ne vous aide pas ou si vous souhaitez également être rapide dans les navigateurs récents, suivez ces consignes :

  • Soyez aussi précis que possible sur le côté droit de votre sélecteur.
  • Utilisez un nom de balise que vous n'utilisez pas souvent comme partie de sélecteur la plus à droite.
  • Si rien ne fonctionne, envisagez de réécrire le code pour pouvoir utiliser un sélecteur d'ID.

Toutes ces manipulations du DOM prennent beaucoup de temps.

L'insertion, la suppression et la mise à jour d'un grand nombre de nœuds DOM peuvent être très lentes. En général, vous pouvez optimiser ce processus en générant une longue chaîne de code HTML et en utilisant domNode.innerHTML = newHTML pour remplacer l'ancien contenu. Notez que cela peut être très mauvais pour la maintenabilité et peut créer des liens de mémoire dans IE, alors soyez prudent.

Un autre problème courant est que votre code d'initialisation peut créer beaucoup de code HTML. Par exemple, un plug-in jQuery qui transforme une zone de sélection en un ensemble de divs, car c'est ce que les concepteurs voulaient, sans tenir compte des bonnes pratiques d'UX. Si vous voulez vraiment que votre page soit rapide, ne faites jamais cela. Fournissez plutôt tout le balisage côté serveur dans sa forme finale. Cette approche présente également de nombreux problèmes. Réfléchissez donc bien pour déterminer si la vitesse vaut le compromis.

Outils

  1. JSPerf : évaluez de petits extraits de code JavaScript
  2. Firebug : pour le profilage dans Firefox
  3. Outils pour les développeurs Google Chrome (disponibles sous le nom de WebInspector dans Safari)
  4. DOM Monster : pour optimiser les performances du DOM
  5. DynaTrace Ajax Edition : pour le profilage et l'optimisation de l'affichage dans Internet Explorer

Documentation complémentaire

  1. Google Speed
  2. Paul Irish sur les performances de jQuery
  3. Performances JavaScript extrêmes (présentation)