Introduzione
HTML5 ci offre ottimi strumenti per migliorare l'aspetto visivo delle applicazioni web. Questo è particolarmente vero nel campo delle animazioni. Tuttavia, questo nuovo potere comporta anche nuove sfide. In realtà, queste sfide non sono poi così nuove e a volte potrebbe avere senso chiedere al tuo vicino di scrivania, il programmatore Flash, come ha superato problemi simili in passato.
In ogni caso, quando lavori con le animazioni, è estremamente importante che gli utenti le percepiscano come fluide. Dobbiamo renderci conto che la fluidità delle animazioni non può essere creata semplicemente aumentando i frame al secondo oltre qualsiasi soglia cognitiva. Il nostro cervello è, purtroppo, più intelligente di così. Scoprirai che un'animazione a 30 fotogrammi al secondo (fps) reali è molto meglio di una a 60 fps con alcuni fotogrammi persi nel mezzo. Le persone odiano le irregolarità.
Questo articolo cercherà di fornirti gli strumenti e le tecniche per migliorare l'esperienza della tua applicazione.
La strategia
Non vogliamo assolutamente scoraggiarti dal creare app straordinarie e visivamente sbalorditive con HTML5.
Quando noti che il rendimento potrebbe essere un po' migliore, torna qui e scopri come migliorare gli elementi della tua applicazione. Naturalmente, può essere utile fare alcune cose nel modo giusto fin dall'inizio, ma non lasciare mai che questo ostacoli la tua produttività.
Fedeltà visiva++ con HTML5
Accelerazione hardware
L'accelerazione hardware è un traguardo importante per le prestazioni di rendering complessive nel browser. Lo schema generale consiste nell'esternalizzare le attività che altrimenti verrebbero calcolate dalla CPU principale all'unità di elaborazione grafica (GPU) nell'adattatore grafico del computer. Ciò può portare a enormi miglioramenti delle prestazioni e può anche ridurre il consumo di risorse sui dispositivi mobili.
Questi aspetti del documento possono essere accelerati dalla GPU
- Composizione del layout generale
- Transizioni CSS3
- Trasformazioni 3D CSS3
- Disegno su tela
- Disegno 3D WebGL
Sebbene l'accelerazione di canvas e WebGL siano funzionalità per scopi speciali che potrebbero non essere applicabili alla tua applicazione specifica, i primi tre aspetti possono aiutare quasi tutte le app a diventare più veloci.
Cosa si può accelerare?
L'accelerazione GPU funziona trasferendo attività ben definite e specifiche a un hardware per scopi speciali. Lo schema generale prevede che il documento venga suddiviso in più "livelli" che non variano in base agli aspetti della pagina che vengono accelerati. Il rendering di questi livelli viene eseguito utilizzando la pipeline di rendering tradizionale. La GPU viene quindi utilizzata per comporre i livelli in un'unica pagina applicando gli "effetti" che possono essere accelerati al momento. Un possibile risultato è che un oggetto animato sullo schermo non richieda un singolo "relayout" della pagina durante l'animazione.
Ciò che devi ricordare è che devi semplificare l'identificazione del momento in cui il motore di rendering può applicare la sua magia di accelerazione GPU. Considera l'esempio seguente:
Sebbene questo metodo funzioni, il browser non sa davvero che stai eseguendo un'operazione che dovrebbe essere percepita come un'animazione fluida da un essere umano. Considera cosa succede quando ottieni lo stesso aspetto visivo utilizzando le transizioni CSS3:
Il modo in cui il browser implementa questa animazione è completamente nascosto allo sviluppatore. Ciò significa che il browser è in grado di applicare trucchi come l'accelerazione GPU per raggiungere l'obiettivo definito.
Esistono due utili flag della riga di comando per Chrome che aiutano a eseguire il debug dell'accelerazione GPU:
--show-composited-layer-bordersmostra un bordo rosso attorno agli elementi che vengono manipolati a livello di GPU. Utile per verificare che le manipolazioni avvengano all'interno del livello GPU.--show-paint-rectstutte le modifiche non GPU vengono visualizzate e viene mostrato un bordo chiaro intorno a tutte le aree che vengono ridisegnate. Puoi vedere il browser che ottimizza le aree di visualizzazione in azione.
Safari ha flag di runtime simili descritti qui.
Transizioni CSS3
Le transizioni CSS rendono l'animazione degli stili un gioco da ragazzi per tutti, ma sono anche una funzionalità intelligente per le prestazioni. Poiché una transizione CSS è gestita dal browser, la fedeltà della sua animazione può essere notevolmente migliorata e, in molti casi, accelerata dall'hardware. Al momento, WebKit (Chrome, Safari, iOS) dispone di trasformazioni CSS con accelerazione hardware, ma questa funzionalità sarà presto disponibile anche per altri browser e piattaforme.
Puoi utilizzare gli eventi transitionEnd per creare script con combinazioni efficaci, anche se al momento l'acquisizione di tutti gli eventi di fine transizione supportati significa osservare webkitTransitionEnd transitionend oTransitionEnd.
Molte librerie hanno ora introdotto API di animazione che sfruttano le transizioni, se presenti, e tornano all'animazione standard in stile DOM in caso contrario. scripty2, YUI transition, jQuery animate enhanced.
CSS3 translate
Sono sicuro che ti è già capitato di animare la posizione x/y di un elemento nella pagina. Probabilmente hai manipolato le proprietà left e top dello stile incorporato. Con le trasformazioni 2D, possiamo utilizzare la funzionalità translate() per replicare questo comportamento.
Possiamo combinarlo con l'animazione DOM per utilizzare la soluzione migliore possibile
<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>
Utilizziamo Modernizr per testare le funzionalità delle trasformazioni 2D CSS e delle transizioni CSS. Se sono supportate, utilizzeremo translate per spostare la posizione. Se l'animazione viene eseguita utilizzando una transizione, è molto probabile che il browser possa accelerarla tramite hardware. Per dare al browser un'altra spinta nella giusta direzione, utilizzeremo il "proiettile magico CSS" di cui sopra.
Se il nostro browser è meno potente, utilizzeremo jQuery per spostare l'elemento. Puoi utilizzare il plug-in polyfill jQuery Transform di Louis-Remi Babe per automatizzare l'intero processo.
window.requestAnimationFrame
requestAnimationFrame è stato introdotto da Mozilla e ripetuto da WebKit con l'obiettivo di fornirti un'API nativa per l'esecuzione di animazioni, basate su DOM/CSS o su <canvas> o WebGL. Il browser può ottimizzare le animazioni simultanee in un unico ciclo di ridisposizione e ridisegno, con un'animazione di fedeltà superiore. Ad esempio, animazioni basate su JS sincronizzate con transizioni CSS o SVG SMIL. Inoltre, se esegui il loop di animazione in una scheda non visibile, il browser non lo manterrà in esecuzione, il che significa un minore utilizzo di CPU, GPU e memoria utilizzata, con una durata della batteria molto più lunga.
Per ulteriori dettagli su come e perché utilizzare requestAnimationFrame, consulta l'articolo di Paul Irish requestAnimationFrame per un'animazione intelligente.
Profilazione
Quando scopri che la velocità della tua applicazione può essere migliorata, è il momento di approfondire la profilazione per scoprire dove le ottimizzazioni potrebbero produrre il massimo vantaggio. Le ottimizzazioni spesso hanno un impatto negativo sulla manutenibilità del codice sorgente e, pertanto, devono essere applicate solo se necessario. La profilazione ti indica quali parti del codice trarrebbero i maggiori vantaggi dal miglioramento delle prestazioni.
Profilazione JavaScript
I profiler JavaScript offrono una panoramica del rendimento della tua applicazione a livello di funzione JavaScript misurando il tempo necessario per eseguire ogni singola funzione dall'inizio alla fine.
Il tempo di esecuzione lordo di una funzione è il tempo complessivo necessario per eseguirla dall'inizio alla fine. Il tempo di esecuzione netto è il tempo di esecuzione lordo meno il tempo impiegato per eseguire le funzioni chiamate dalla funzione.
Alcune funzioni vengono chiamate più spesso di altre. I profiler di solito forniscono il tempo impiegato per l'esecuzione di tutte le chiamate, nonché il tempo di esecuzione medio, minimo e massimo.
Per maggiori dettagli, consulta la documentazione di Chrome DevTools sulla profilazione.
Il DOM
Le prestazioni di JavaScript hanno una forte influenza sulla fluidità e sulla reattività della tua applicazione. È importante capire che, sebbene i profiler JavaScript misurino il tempo di esecuzione del codice JavaScript, misurano anche indirettamente il tempo impiegato per eseguire le operazioni DOM. Queste operazioni DOM sono spesso alla base dei problemi di prestazioni.
function drawArray(array) {
for(var i = 0; i < array.length; i++) {
document.getElementById('test').innerHTML += array[i]; // No good :(
}
}
Ad esempio, nel codice riportato sopra, non viene impiegato quasi alcun tempo per l'esecuzione del codice JavaScript effettivo. È comunque molto probabile che la funzione drawArray venga visualizzata nei tuoi profili perché interagisce con il DOM in modo molto inefficiente.
Suggerimenti utili
Funzioni anonime
Le funzioni anonime non sono facili da profilare perché, per loro natura, non hanno un nome con cui potrebbero essere visualizzate nel profiler. Esistono due modi per ovviare a questo problema:
$('.stuff').each(function() { ... });
riscrivi in:
$('.stuff').each(function workOnStuff() { ... });
Non è comunemente noto che JavaScript supporta le espressioni di funzione con nome. In questo modo, verranno visualizzati perfettamente nel profiler. C'è un problema con questa soluzione: l'espressione con nome inserisce effettivamente il nome della funzione nell'ambito lessicale corrente. Questo potrebbe sovrascrivere altri simboli, quindi fai attenzione.
Profilazione di funzioni lunghe
Immagina di avere una funzione lunga e di sospettare che una piccola parte di questa possa essere la causa dei problemi di prestazioni. Esistono due modi per scoprire quale parte causa il problema:
- Il metodo corretto: rifattorizza il codice in modo da non includere funzioni lunghe.
- Il metodo malvagio per portare a termine le cose: aggiungi istruzioni sotto forma di funzioni con nome che si richiamano da sole al tuo codice. Se presti un po' di attenzione, questo non cambia la semantica e fa sì che parti della tua funzione vengano visualizzate come funzioni individuali nel profiler:
js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... }Non dimenticare di rimuovere queste funzioni aggiuntive al termine della profilazione o di utilizzarle come punto di partenza per rifattorizzare il codice.
Profilazione DOM
Gli strumenti per sviluppatori di Chrome Web Inspector più recenti contengono la nuova "Visualizzazione cronologica", che mostra una cronologia delle azioni di basso livello eseguite dal browser. Puoi utilizzare queste informazioni per ottimizzare le operazioni DOM. Dovresti cercare di ridurre il numero di "azioni" che il browser deve eseguire durante l'esecuzione del codice.
La visualizzazione cronologica può generare un'enorme quantità di informazioni. Pertanto, dovresti provare a creare scenari di test minimi che puoi eseguire in modo indipendente.
L'immagine sopra mostra l'output della visualizzazione cronologica per uno script molto semplice. Il riquadro a sinistra mostra le operazioni eseguite dal browser in ordine cronologico, mentre la sequenza temporale nel riquadro a destra mostra il tempo effettivo impiegato da una singola operazione.
Scopri di più sulla visualizzazione cronologica. Uno strumento alternativo per la profilazione in Internet Explorer è DynaTrace Ajax Edition.
Strategie di profilazione
Isola gli aspetti
Quando vuoi profilare la tua applicazione, cerca di individuare gli aspetti della sua funzionalità che potrebbero causare rallentamenti il più vicino possibile. Quindi, prova a eseguire un'esecuzione del profilo che esegua solo le parti del codice pertinenti a questi aspetti della tua applicazione. In questo modo, i dati di profilazione saranno più facili da interpretare perché non sono mescolati con percorsi del codice non correlati al problema effettivo. Ecco alcuni esempi di aspetti individuali della tua applicazione:
- Tempo di avvio (attivazione del profiler, ricaricamento dell'applicazione, attesa del completamento dell'inizializzazione, arresto del profiler).
- Fai clic su un pulsante e sull'animazione successiva (avvia il profiler, fai clic sul pulsante, attendi il completamento dell'animazione, arresta il profiler).
Profilazione della GUI
Eseguire solo la parte corretta dell'applicazione può essere più difficile in un programma GUI rispetto a quando ottimizzi, ad esempio, il ray tracer del tuo motore 3D. Ad esempio, se vuoi profilare ciò che accade quando fai clic su un pulsante, potresti attivare eventi mouseover non correlati lungo il percorso che rendono i risultati meno conclusivi. Cerca di evitarlo :)
Interfaccia programmatica
Esiste anche un'interfaccia programmatica per attivare il debugger. In questo modo, puoi controllare con precisione quando inizia e quando termina la profilazione.
Avvia una profilazione con:
console.profile()
Interrompi la profilazione con:
console.profileEnd()
Ripetibilità
Quando esegui la profilazione, assicurati di poter effettivamente riprodurre i risultati. Solo così potrai capire se le tue ottimizzazioni hanno effettivamente migliorato la situazione. Inoltre, la profilazione a livello di funzione viene eseguita nel contesto dell'intero computer. Non è una scienza esatta. Le singole esecuzioni del profilo potrebbero essere influenzate da molti altri fattori che si verificano sul computer:
- Un timer non correlato nella tua applicazione che si attiva mentre misuri qualcos'altro.
- Il garbage collector che esegue il suo lavoro.
- Un'altra scheda del browser sta eseguendo un'operazione complessa nello stesso thread operativo.
- Un altro programma sul computer sta utilizzando la CPU, rallentando l'applicazione.
- Cambiamenti improvvisi nel campo gravitazionale della Terra.
Inoltre, è opportuno eseguire lo stesso percorso del codice più volte in una sessione di profilazione. In questo modo, riduci l'influenza dei fattori sopra indicati e le parti lente potrebbero risaltare ancora più chiaramente.
Misura, migliora, misura
Quando identifichi un punto lento nel tuo programma, prova a pensare a come migliorare il comportamento di esecuzione. Dopo aver modificato il codice, esegui di nuovo la profilazione. Se il risultato ti soddisfa, vai avanti; se non vedi un miglioramento, probabilmente dovresti eseguire il rollback della modifica e non lasciarla "perché non può far male".
Strategie di ottimizzazione
Riduci al minimo l'interazione con il DOM
Un tema comune per migliorare la velocità delle applicazioni client web è ridurre al minimo l'interazione con il DOM. Sebbene la velocità dei motori JavaScript sia aumentata di un ordine di grandezza, l'accesso al DOM non è diventato più veloce allo stesso ritmo. Anche per motivi molto pratici, questo non accadrà mai (operazioni come il layout e il disegno di elementi su uno schermo richiedono tempo).
Memorizza nella cache i nodi DOM
Ogni volta che recuperi un nodo o un elenco di nodi dal DOM, prova a pensare se potresti riutilizzarli in un calcolo successivo (o anche solo nell'iterazione del loop successiva). Questo è spesso il caso, a meno che tu non aggiunga o elimini effettivamente nodi nell'area pertinente.
Prima:
function getElements() {
return $('.my-class');
}
Dopo:
var cachedElements;
function getElements() {
if (cachedElements) {
return cachedElements;
}
cachedElements = $('.my-class');
return cachedElements;
}
Valori degli attributi della cache
Allo stesso modo in cui puoi memorizzare nella cache i nodi DOM, puoi anche memorizzare nella cache i valori degli attributi. Immagina di animare un attributo dello stile di un nodo. Se sai che tu (ovvero quella parte del codice) sei l'unica persona che toccherà quell'attributo, puoi memorizzare nella cache l'ultimo valore di ogni iterazione, in modo da non doverlo leggere ripetutamente.
Prima:
setInterval(function() {
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
ele.css('left', (left + 5) + 'px');
}, 1000 / 30);
Dopo:
js
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
setInterval(function() {
left += 5;
ele.css('left', left + 'px');
}, 1000 / 30);
Sposta la manipolazione del DOM fuori dai loop
I loop sono spesso punti caldi per l'ottimizzazione. Prova a pensare a modi per disaccoppiare l'elaborazione effettiva dei numeri dall'utilizzo del DOM. Spesso è possibile eseguire un calcolo e poi, una volta terminato, applicare tutti i risultati in un'unica soluzione.
Prima:
document.getElementById('target').innerHTML = '';
for(var i = 0; i < array.length; i++) {
var val = doSomething(array[i]);
document.getElementById('target').innerHTML += val;
}
Dopo:
var stringBuilder = [];
for(var i = 0; i < array.length; i++) {
var val = doSomething(array[i]);
stringBuilder.push(val);
}
document.getElementById('target').innerHTML = stringBuilder.join('');
Ridisegni e ridisposizioni
Come accennato in precedenza, l'accesso al DOM è relativamente lento. Diventa molto lento quando il codice legge un valore che deve essere ricalcolato perché il codice ha modificato di recente un elemento correlato nel DOM. Pertanto, è consigliabile evitare di combinare l'accesso in lettura e scrittura al DOM. In teoria, il codice dovrebbe essere sempre raggruppato in due fasi:
- Fase 1: leggi i valori DOM necessari per il tuo codice
- Fase 2: modifica del DOM
Cerca di non programmare un pattern come:
- Fase 1: lettura dei valori DOM
- Fase 2: modifica del DOM
- Fase 3: leggi di più
- Fase 4: modifica il DOM altrove.
Prima:
function paintSlow() {
var left1 = $('#thing1').css('left');
$('#otherThing1').css('left', left);
var left2 = $('#thing2').css('left');
$('#otherThing2').css('left', left);
}
Dopo:
function paintFast() {
var left1 = $('#thing1').css('left');
var left2 = $('#thing2').css('left');
$('#otherThing1').css('left', left);
$('#otherThing2').css('left', left);
}
Questo consiglio deve essere preso in considerazione per le azioni che si verificano all'interno di un contesto di esecuzione JavaScript. (ad es. all'interno di un gestore di eventi, all'interno di un gestore di intervalli o durante la gestione di una risposta ajax).
L'esecuzione della funzione paintSlow() riportata sopra crea questa immagine:
Il passaggio all'implementazione più rapida produce questa immagine:
Queste immagini mostrano che riordinare il modo in cui il codice accede al DOM può migliorare notevolmente le prestazioni di rendering. In questo caso, il codice originale deve ricalcolare gli stili e il layout della pagina due volte per creare lo stesso risultato. Un'ottimizzazione simile può essere applicata praticamente a tutto il codice "reale" e produrre risultati davvero notevoli.
Scopri di più: Rendering: repaint, reflow/relayout, restyle di Stoyan Stefanov
Ridisegni e loop di eventi
L'esecuzione di JavaScript nel browser segue un modello "loop di eventi". Per impostazione predefinita, il browser è in stato "Inattivo". Questo stato può essere interrotto da eventi derivanti dalle interazioni degli utenti o da elementi come timer JavaScript o callback Ajax. Ogni volta che un frammento di JavaScript viene eseguito in un punto di interruzione di questo tipo, il browser di solito attende che termini prima di ridisegnare lo schermo (potrebbero esserci eccezioni per JavaScript con tempi di esecuzione estremamente lunghi o in casi come le finestre di avviso che interrompono effettivamente l'esecuzione di JavaScript).
Conseguenze
- Se i cicli di animazione JavaScript richiedono più di 1/30 di secondo per l'esecuzione, non potrai creare animazioni fluide perché il browser non eseguirà il repaint durante l'esecuzione di JS. Quando prevedi di gestire anche gli eventi utente, devi essere molto più veloce.
- A volte è utile ritardare leggermente alcune azioni JavaScript.
Ad esempio:
setTimeout(function() { ... }, 0)In questo modo, il browser viene istruito a eseguire il callback non appena il loop di eventi è di nuovo inattivo (in pratica, alcuni browser attendono almeno 10 ms). Tieni presente che verranno creati due cicli di esecuzione di JavaScript molto vicini nel tempo. Entrambi potrebbero attivare un ridisegno dello schermo, il che potrebbe raddoppiare il tempo complessivo impiegato per la pittura. L'attivazione effettiva di due paint dipende dalle euristiche nel browser.
Versione normale:
function paintFast() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
$('#otherThing2').css('height', '20px');
}
Aggiungiamo un po' di ritardo:
function paintALittleLater() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
setTimeout(function() {
$('#otherThing2').css('height', '20px');
}, 10)
}
La versione ritardata mostra che il browser esegue il painting due volte, anche se le due modifiche alla pagina sono separate da un centesimo di secondo.
Inizializzazione lazy
Gli utenti vogliono app web che si carichino velocemente e siano reattive. Tuttavia, gli utenti hanno soglie diverse per ciò che percepiscono come lento a seconda dell'azione che eseguono. Ad esempio, un'app non dovrebbe mai eseguire molti calcoli su un evento mouseover perché ciò potrebbe creare un'esperienza utente negativa mentre l'utente continua a muovere il mouse. Tuttavia, gli utenti sono abituati ad accettare un piccolo ritardo dopo aver fatto clic su un pulsante.
Pertanto, potrebbe avere senso spostare il codice di inizializzazione in modo che venga eseguito il più tardi possibile (ad esempio quando l'utente fa clic su un pulsante che attiva un componente specifico dell'applicazione).
Prima:
js
var things = $('.ele > .other * div.className');
$('#button').click(function() { things.show() });
Dopo:
js
$('#button').click(function() { $('.ele > .other * div.className').show() });
Delega degli eventi
La distribuzione dei gestori di eventi su una pagina potrebbe richiedere un tempo relativamente lungo e può anche essere noiosa una volta che gli elementi vengono sostituiti dinamicamente, il che richiede poi di ricollegare i gestori di eventi ai nuovi elementi.
La soluzione in questo caso è utilizzare una tecnica chiamata delega degli eventi. Anziché collegare singoli gestori di eventi agli elementi, la natura di bubbling di molti eventi del browser viene utilizzata collegando effettivamente il gestore di eventi a un nodo principale e controllando il nodo di destinazione dell'evento per verificare se l'evento è di interesse.
In jQuery, questo può essere facilmente espresso come:
$('#parentNode').delegate('.button', 'click', function() { ... });
Quando non utilizzare la delega degli eventi
A volte può essere vero il contrario: utilizzi la delega degli eventi e hai un problema di prestazioni. In sostanza, la delega degli eventi consente un tempo di inizializzazione a complessità costante. Tuttavia, il prezzo per verificare se un evento è di interesse deve essere pagato per ogni chiamata di quell'evento. Questo potrebbe essere costoso, soprattutto per gli eventi che si verificano di frequente, come "mouseover" o persino "mousemove".
Problemi e soluzioni tipici
Le attività che svolgo in $(document).ready richiedono molto tempo
Il consiglio personale di Malte: non fare mai nulla in $(document).ready. Cerca di fornire il documento nella sua forma finale. Ok, puoi registrare i listener di eventi, ma solo utilizzando il selettore ID e/o la delega degli eventi. Per gli eventi costosi come "mousemove", ritarda la registrazione fino a quando non sono necessari (evento mouseover sull'elemento pertinente).
Se devi davvero eseguire operazioni, come effettuare una richiesta Ajax per ottenere dati effettivi, mostra una bella animazione; potresti includere l'animazione come URI di dati se si tratta di una GIF animata o simile.
Da quando ho aggiunto un filmato Flash alla pagina, tutto è molto lento
L'aggiunta di Flash a una pagina rallenta sempre un po' il rendering perché il layout finale della finestra deve essere "negoziato" tra il browser e il plug-in Flash. Se non puoi evitare completamente di inserire Flash nelle tue pagine, assicurati di impostare il parametro Flash "wmode" sul valore "window" (che è l'impostazione predefinita). In questo modo, non sarà possibile combinare elementi HTML e Flash (non potrai vedere un elemento HTML che si trova sopra il filmato Flash e il filmato Flash non potrà essere trasparente). Questo potrebbe essere un inconveniente, ma migliorerà notevolmente il rendimento. Ad esempio, guarda come youtube.com evita accuratamente di posizionare livelli sopra il video player principale.
Sto salvando elementi in localStorage, ora la mia applicazione si blocca
La scrittura su localStorage è un'operazione sincrona che comporta l'avvio del disco rigido. Non eseguire mai operazioni sincrone "a lunga esecuzione" durante le animazioni. Sposta l'accesso a localStorage in un punto del codice in cui hai la certezza che l'utente sia inattivo e che non siano in corso animazioni.
La profilazione indica che un selettore jQuery è molto lento
Innanzitutto, assicurati che il selettore possa essere eseguito tramite document.querySelectorAll. Puoi verificarlo nella console JavaScript. In caso di eccezione, riscrivi il selettore in modo da non utilizzare alcuna estensione speciale del framework JavaScript. In questo modo, il selettore sarà molto più veloce nei browser moderni.
Se questo non aiuta o se vuoi anche essere veloce nei browser moderni, segui queste linee guida:
- Sii il più specifico possibile sul lato destro del selettore.
- Utilizza un nome di tag che non usi spesso come parte del selettore più a destra.
- Se non funziona nulla, valuta la possibilità di riscrivere gli elementi in modo da poter utilizzare un selettore ID
Tutte queste manipolazioni del DOM richiedono molto tempo
Un gruppo di inserimenti, rimozioni e aggiornamenti di nodi DOM può essere molto lento. In genere, questo problema può essere ottimizzato generando una stringa di HTML di grandi dimensioni e utilizzando domNode.innerHTML = newHTML per sostituire i contenuti precedenti. Tieni presente che questo potrebbe essere molto dannoso per la manutenibilità e potrebbe creare link di memoria in IE, quindi fai attenzione.
Un altro problema comune è che il codice di inizializzazione potrebbe creare molto codice HTML. Ad esempio, un plug-in jQuery che trasforma una casella di selezione in un gruppo di div perché è ciò che volevano i designer, ignorando le best practice per la UX. Se vuoi davvero che la tua pagina sia veloce, non farlo mai. Invece, fornisci tutto il markup dal lato server nella sua forma finale. Anche questo approccio presenta molti problemi, quindi valuta attentamente se la velocità vale il compromesso.
Strumenti
- JSPerf - Benchmark little snippets of JavaScript
- Firebug - Per la profilazione in Firefox
- Strumenti per sviluppatori di Google Chrome (disponibili come WebInspector in Safari)
- DOM Monster: per ottimizzare le prestazioni del DOM
- DynaTrace Ajax Edition: per la profilazione e le ottimizzazioni della visualizzazione in Internet Explorer