Introducción
HTML5 nos brinda excelentes herramientas para mejorar la apariencia visual de las aplicaciones web. Esto es especialmente cierto en el ámbito de las animaciones. Sin embargo, este nuevo poder también trae consigo nuevos desafíos. En realidad, estos desafíos no son tan nuevos y, a veces, puede ser útil preguntarle a tu vecino de escritorio, el programador de Flash, cómo superó problemas similares en el pasado.
De todos modos, cuando trabajas en animaciones, es muy importante que los usuarios las perciban como fluidas. Debemos darnos cuenta de que la fluidez en las animaciones no se puede crear simplemente aumentando los fotogramas por segundo más allá de cualquier umbral cognitivo. Lamentablemente, nuestro cerebro es más inteligente que eso. Aprenderás que una animación de 30 fotogramas por segundo (fps) reales es mucho mejor que una de 60 fps con solo unos pocos fotogramas perdidos en el medio. A las personas no les gustan las irregularidades.
En este artículo, se intentará brindarte las herramientas y técnicas para trabajar en la mejora de la experiencia de tu propia aplicación.
La estrategia
De ninguna manera queremos desalentarte para que no crees apps increíbles y visualmente impactantes con HTML5.
Luego, cuando notes que el rendimiento podría ser un poco mejor, vuelve aquí y lee cómo puedes mejorar los elementos de tu aplicación. Por supuesto, puede ayudar a hacer algunas cosas bien en primer lugar, pero nunca dejes que eso se interponga en tu productividad.
Fidelidad visual mejorada con HTML5
Aceleración de hardware
La aceleración de hardware es un hito importante para el rendimiento general de la renderización en el navegador. El esquema general consiste en descargar las tareas que, de lo contrario, calcularía la CPU principal en la unidad de procesamiento gráfico (GPU) del adaptador de gráficos de tu computadora. Esto puede generar grandes mejoras en el rendimiento y también reducir el consumo de recursos en dispositivos móviles.
La GPU puede acelerar estos aspectos de tu documento
- Composición de diseño general
- Transiciones de CSS3
- Transformaciones en 3D de CSS3
- Dibujo en lienzo
- Dibujo en 3D con WebGL
Si bien la aceleración de canvas y WebGL son funciones de propósito especial que podrían no aplicarse a tu aplicación específica, los primeros tres aspectos pueden ayudar a que casi todas las apps sean más rápidas.
¿Qué se puede acelerar?
La aceleración de GPU funciona descargando tareas específicas y bien definidas en hardware de propósito especial. El esquema general es que tu documento se divide en varias "capas" que son invariables para los aspectos de tu página que se aceleran. Estas capas se renderizan con la canalización de renderización tradicional. Luego, la GPU se usa para componer las capas en una sola página y aplicar los "efectos" que se pueden acelerar sobre la marcha. Un resultado posible es que un objeto que se anima en la pantalla no requiera un solo "rediseño" de la página mientras se produce la animación.
Lo que debes tener en cuenta es que debes facilitar que el motor de renderización identifique cuándo puede aplicar su magia de aceleración de GPU. Consulta el siguiente ejemplo:
Si bien esto funciona, el navegador no sabe realmente que estás realizando algo que un ser humano debería percibir como una animación fluida. Considera lo que sucede cuando logras la misma apariencia visual con transiciones de CSS3:
La forma en que el navegador implementa esta animación está completamente oculta para el desarrollador. Esto, a su vez, significa que el navegador puede aplicar trucos, como la aceleración de GPU, para lograr el objetivo definido.
Existen dos funciones experimentales de línea de comandos útiles para Chrome que ayudan a depurar la aceleración de GPU:
--show-composited-layer-bordersmuestra un borde rojo alrededor de los elementos que se manipulan a nivel de la GPU. Es útil para confirmar que tus manipulaciones se produzcan dentro de la capa de GPU.--show-paint-rects: Se pintan todos los cambios que no son de GPU y se agrega un borde claro alrededor de todas las áreas que se vuelven a pintar. Puedes ver cómo el navegador optimiza las áreas de pintura en acción.
Safari tiene marcas de tiempo de ejecución similares que se describen aquí.
Transiciones de CSS3
Las transiciones de CSS hacen que la animación de estilo sea trivial para todos, pero también son una función de rendimiento inteligente. Debido a que el navegador administra una transición de CSS, la fidelidad de su animación se puede mejorar en gran medida y, en muchos casos, se puede acelerar el hardware. Actualmente, WebKit (Chrome, Safari, iOS) tiene transformaciones de CSS con aceleración de hardware, pero pronto llegará a otros navegadores y plataformas.
Puedes usar los eventos transitionEnd para crear secuencias de comandos con combinaciones potentes, aunque, en este momento, capturar todos los eventos de finalización de transición admitidos significa observar webkitTransitionEnd transitionend oTransitionEnd.
Muchas bibliotecas ahora introdujeron APIs de animación que aprovechan las transiciones si están presentes y, de lo contrario, recurren a la animación de estilo DOM estándar. scripty2, YUI transition, jQuery animate enhanced.
Traducción de CSS3
Seguro que ya has animado la posición x/y de un elemento en la página antes. Es probable que hayas manipulado las propiedades left y top del estilo intercalado. Con las transformaciones en 2D, podemos usar la funcionalidad translate() para replicar este comportamiento.
Podemos combinar esto con la animación del DOM para usar la mejor opción posible
<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>
Usamos Modernizr para probar las transformaciones 2D y las transiciones de CSS. Si es así, usaremos translate para cambiar la posición. Si se anima con una transición, es muy probable que el navegador pueda acelerarla por hardware. Para darle al navegador otro empujón en la dirección correcta, usaremos la "fórmula mágica de CSS" que vimos anteriormente.
Si nuestro navegador es menos capaz, recurriremos a jQuery para mover nuestro elemento. Puedes usar el complemento de polyfill de transformación de jQuery de Louis-Remi Babe para que todo esto sea automático.
window.requestAnimationFrame
Mozilla introdujo requestAnimationFrame y WebKit lo iteró con el objetivo de proporcionarte una API nativa para ejecutar animaciones, ya sea que se basen en DOM/CSS o en <canvas> o WebGL. El navegador puede optimizar las animaciones simultáneas en un solo ciclo de redistribución y repintado, lo que genera una animación de mayor calidad. Por ejemplo, animaciones basadas en JS sincronizadas con transiciones de CSS o SMIL de SVG. Además, si ejecutas el bucle de animación en una pestaña que no está visible, el navegador no lo mantendrá en ejecución, lo que significa un menor uso de CPU, GPU y memoria, lo que genera una duración de batería mucho mayor.
Para obtener más detalles sobre cómo y por qué usar requestAnimationFrame, consulta el artículo de Paul Irish requestAnimationFrame para animaciones inteligentes.
Generación de perfiles
Cuando descubres que se puede mejorar la velocidad de tu aplicación, es momento de profundizar en la generación de perfiles para descubrir dónde las optimizaciones podrían generar el mayor beneficio. Las optimizaciones suelen tener un impacto negativo en la capacidad de mantenimiento de tu código fuente y, por lo tanto, solo deben aplicarse si es necesario. La generación de perfiles te indica qué partes de tu código generarían los mayores beneficios si se mejorara su rendimiento.
Generación de perfiles de JavaScript
Los generadores de perfiles de JavaScript te brindan una descripción general del rendimiento de tu aplicación a nivel de la función de JavaScript, ya que miden el tiempo que tarda en ejecutarse cada función individual desde su inicio hasta su finalización.
El tiempo de ejecución bruto de una función es el tiempo total que se tarda en ejecutarla de principio a fin. El tiempo de ejecución neto es el tiempo de ejecución bruto menos el tiempo que tardaron en ejecutarse las llamadas a funciones desde la función.
Algunas funciones se llaman con más frecuencia que otras. Por lo general, los generadores de perfiles te indican el tiempo que tardaron en ejecutarse todas las invocaciones, así como el tiempo de ejecución promedio, mínimo y máximo.
Para obtener más detalles, consulta los documentos de Herramientas para desarrolladores de Chrome sobre la generación de perfiles.
El DOM
El rendimiento de JavaScript tiene una gran influencia en la fluidez y la capacidad de respuesta de tu aplicación. Es importante comprender que, si bien los generadores de perfiles de JavaScript miden el tiempo de ejecución de tu JavaScript, también miden de forma indirecta el tiempo que se dedica a realizar operaciones del DOM. Estas operaciones del DOM suelen ser la causa principal de los problemas de rendimiento.
function drawArray(array) {
for(var i = 0; i < array.length; i++) {
document.getElementById('test').innerHTML += array[i]; // No good :(
}
}
Por ejemplo, en el código anterior, casi no se dedica tiempo a ejecutar JavaScript real. Es muy probable que la función drawArray siga apareciendo en tus perfiles porque interactúa con el DOM de una manera muy ineficiente.
Sugerencias y trucos
Funciones anónimas
No es fácil generar perfiles de funciones anónimas porque, por naturaleza, no tienen un nombre con el que puedan aparecer en el generador de perfiles. Existen dos maneras de solucionar este problema:
$('.stuff').each(function() { ... });
reescribir a:
$('.stuff').each(function workOnStuff() { ... });
No es muy conocido que JavaScript admita expresiones de funciones con nombre. De esta manera, se mostrarán perfectamente en el generador de perfiles. Hay un problema con esta solución: la expresión con nombre en realidad coloca el nombre de la función en el ámbito léxico actual. Esto podría afectar a otros símbolos, así que ten cuidado.
Genera perfiles de funciones largas
Imagina que tienes una función larga y sospechas que una pequeña parte de ella podría ser la causa de tus problemas de rendimiento. Existen dos maneras de averiguar qué parte es la que tiene el problema:
- El método correcto: Refactoriza tu código para que no incluya funciones largas.
- El método malvado para hacer las cosas: agrega declaraciones en forma de funciones de autollamada con nombre a tu código. Si tienes un poco de cuidado, esto no cambia la semántica y hace que partes de tu función aparezcan como funciones individuales en el generador de perfiles:
js function myLongFunction() { ... (function doAPartOfTheWork() { ... })(); ... }No olvides quitar estas funciones adicionales después de que se complete la generación de perfiles o incluso usarlas como punto de partida para refactorizar tu código.
Generación de perfiles del DOM
Las herramientas para desarrolladores más recientes de Inspector web de Chrome contienen la nueva "Vista de línea de tiempo", que muestra una línea de tiempo de las acciones de bajo nivel que realiza el navegador. Puedes usar esta información para optimizar tus operaciones del DOM. Debes intentar reducir la cantidad de "acciones" que el navegador debe realizar mientras se ejecuta tu código.
La vista de línea de tiempo puede crear una gran cantidad de información. Por lo tanto, debes intentar crear casos de prueba mínimos que puedas ejecutar de forma independiente.
En la imagen anterior, se muestra el resultado de la vista de línea de tiempo de una secuencia de comandos muy simple. En el panel izquierdo, se muestran las operaciones que realizó el navegador en orden cronológico, mientras que en la línea de tiempo del panel derecho, se muestra el tiempo real que consumió una operación individual.
Obtén más información sobre la vista de línea de tiempo. Una herramienta alternativa para generar perfiles en Internet Explorer es DynaTrace Ajax Edition.
Estrategias de generación de perfiles
Destaca aspectos
Cuando quieras generar un perfil de tu aplicación, intenta identificar los aspectos de su funcionalidad que podrían provocar lentitud lo más cerca posible. Luego, intenta realizar una ejecución de perfil que solo ejecute partes de tu código que sean relevantes para estos aspectos de tu aplicación. Esto facilitará la interpretación de los datos de generación de perfiles, ya que no se mezclarán con instrucciones de código que no estén relacionadas con el problema real. Estos son algunos buenos ejemplos para aspectos individuales de tu aplicación:
- Tiempo de inicio (activa el generador de perfiles, vuelve a cargar la aplicación, espera hasta que se complete la inicialización y detén el generador de perfiles).
- Haz clic en un botón y en la animación posterior (inicia el generador de perfiles, haz clic en el botón, espera hasta que se complete la animación y detén el generador de perfiles).
Generación de perfiles de GUI
Ejecutar solo la parte correcta de tu aplicación puede ser más difícil en un programa de GUI que cuando optimizas, por ejemplo, el trazador de rayos de tu motor 3D. Por ejemplo, cuando quieres generar un perfil de lo que sucede cuando haces clic en un botón, puedes activar eventos de mouseover no relacionados que hagan que tus resultados sean menos concluyentes. Intenta evitarlo :)
Interfaz programática
También hay una interfaz programática para activar el depurador. Esto permite un control preciso sobre cuándo se inicia y cuándo finaliza la generación de perfiles.
Inicia una generación de perfiles con lo siguiente:
console.profile()
Detén la generación de perfiles con lo siguiente:
console.profileEnd()
Repetibilidad
Cuando realices la generación de perfiles, asegúrate de que puedas reproducir tus resultados. Solo entonces podrás saber si tus optimizaciones realmente mejoraron las cosas. Además, la generación de perfiles a nivel de la función se realiza en el contexto de toda la computadora. No es una ciencia exacta. Las ejecuciones de perfiles individuales pueden verse influenciadas por muchos otros factores que ocurren en tu computadora:
- Un temporizador no relacionado en tu propia aplicación que se activa mientras mides otra cosa
- El recolector de elementos no utilizados haciendo su trabajo.
- Otra pestaña en tu navegador que realiza un trabajo pesado en el mismo subproceso operativo.
- Otro programa en tu computadora está usando la CPU, lo que hace que tu aplicación sea más lenta.
- Cambios repentinos en el campo gravitacional de la Tierra
También tiene sentido ejecutar la misma ruta de código varias veces en una sesión de generación de perfiles. De esta manera, disminuyes la influencia de los factores anteriores y las partes lentas pueden destacarse aún más claramente.
Medir, mejorar, medir
Cuando identifiques un punto lento en tu programa, intenta pensar en formas de mejorar el comportamiento de ejecución. Después de cambiar el código, vuelve a generar el perfil. Si estás conforme con el resultado, continúa. Si no ves una mejora, probablemente debas revertir el cambio y no dejarlo "porque no puede hacer daño".
Estrategias de optimización
Minimiza la interacción con el DOM
Un tema común para mejorar la velocidad de las aplicaciones cliente web es minimizar la interacción con el DOM. Si bien la velocidad de los motores de JavaScript aumentó en un orden de magnitud, el acceso al DOM no se aceleró al mismo ritmo. Por razones muy prácticas, esto nunca sucederá (las tareas como diseñar y dibujar elementos en una pantalla llevan tiempo).
Almacena en caché los nodos del DOM
Cada vez que recuperes un nodo o una lista de nodos del DOM, intenta pensar si podrías reutilizarlos en un cálculo posterior (o incluso en la siguiente iteración del bucle). Siempre que no agregues ni borres nodos en el área relevante, este suele ser el caso.
Antes:
function getElements() {
return $('.my-class');
}
Después:
var cachedElements;
function getElements() {
if (cachedElements) {
return cachedElements;
}
cachedElements = $('.my-class');
return cachedElements;
}
Valores de atributos de caché
De la misma manera que puedes almacenar en caché los nodos del DOM, también puedes almacenar en caché los valores de los atributos. Imagina que estás animando un atributo del estilo de un nodo. Si sabes que tú (como esa parte del código) eres el único que tocará ese atributo, puedes almacenar en caché el último valor en cada iteración para no tener que leerlo repetidamente.
Antes:
setInterval(function() {
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
ele.css('left', (left + 5) + 'px');
}, 1000 / 30);
Después:
js
var ele = $('#element');
var left = parseInt(ele.css('left'), 10);
setInterval(function() {
left += 5;
ele.css('left', left + 'px');
}, 1000 / 30);
Mueve la manipulación del DOM fuera de los bucles
Los bucles suelen ser puntos críticos para la optimización. Intenta pensar en formas de desvincular el procesamiento de números real del trabajo con el DOM. A menudo, es posible realizar un cálculo y, luego, aplicar todos los resultados de una sola vez.
Antes:
document.getElementById('target').innerHTML = '';
for(var i = 0; i < array.length; i++) {
var val = doSomething(array[i]);
document.getElementById('target').innerHTML += val;
}
Despué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('');
Redibujados y redistribuciones
Como se mencionó antes, acceder al DOM es relativamente lento. Se vuelve muy lento cuando tu código lee un valor que se debe volver a calcular porque tu código modificó recientemente algo relacionado en el DOM. Por lo tanto, se debe evitar mezclar el acceso de lectura y escritura al DOM. Idealmente, tu código siempre debería agruparse en dos fases:
- Fase 1: Lee los valores del DOM necesarios para tu código
- Fase 2: Modifica el DOM
Intenta no programar un patrón como el siguiente:
- Fase 1: Lee los valores del DOM
- Fase 2: Modifica el DOM
- Fase 3: Lee un poco más
- Fase 4: Modifica el DOM en otro lugar.
Antes:
function paintSlow() {
var left1 = $('#thing1').css('left');
$('#otherThing1').css('left', left);
var left2 = $('#thing2').css('left');
$('#otherThing2').css('left', left);
}
Después:
function paintFast() {
var left1 = $('#thing1').css('left');
var left2 = $('#thing2').css('left');
$('#otherThing1').css('left', left);
$('#otherThing2').css('left', left);
}
Este consejo se debe tener en cuenta para las acciones que se realizan dentro de un contexto de ejecución de JavaScript. (p.ej., dentro de un controlador de eventos, dentro de un controlador de intervalos o cuando se controla una respuesta de Ajax).
Cuando se ejecuta la función paintSlow() anterior, se crea esta imagen:
Si cambias a la implementación más rápida, se genera esta imagen:
Estas imágenes muestran que reordenar la forma en que tu código accede al DOM puede mejorar en gran medida el rendimiento de la renderización. En este caso, el código original tiene que volver a calcular los estilos y diseñar la página dos veces para crear el mismo resultado. Se puede aplicar una optimización similar a básicamente todo el código del "mundo real" y obtener resultados realmente espectaculares.
Más información: Rendering: repaint, reflow/relayout, restyle de Stoyan Stefanov
Redibujados y el bucle de eventos
La ejecución de JavaScript en el navegador sigue un modelo de "bucle de eventos". De forma predeterminada, el navegador se encuentra en un estado "inactivo". Este estado se puede interrumpir por eventos de interacciones del usuario o elementos como temporizadores de JavaScript o devoluciones de llamada de Ajax. Cada vez que se ejecuta un fragmento de JavaScript en un punto de interrupción de este tipo, el navegador suele esperar a que finalice hasta que vuelve a pintar la pantalla (puede haber excepciones para JavaScripts de ejecución extremadamente larga o en casos como cuadros de alerta que interrumpen de forma efectiva la ejecución de JavaScript).
Consecuencias
- Si los ciclos de animación de JavaScript tardan más de 1/30 de segundo en ejecutarse, no podrás crear animaciones fluidas porque el navegador no volverá a pintar durante la ejecución de JS. Cuando esperas controlar también los eventos de usuario, debes ser mucho más rápido.
- A veces, resulta útil retrasar algunas acciones de JavaScript hasta un poco más tarde.
P.ej.,
setTimeout(function() { ... }, 0)Esto le indica al navegador que ejecute la devolución de llamada en cuanto el bucle de eventos vuelva a estar inactivo (en efecto, algunos navegadores esperarán al menos 10 ms). Debes tener en cuenta que esto creará dos ciclos de ejecución de JavaScript que están muy cerca en el tiempo. Ambos podrían activar un nuevo dibujo de la pantalla, lo que podría duplicar el tiempo total dedicado a dibujar. El hecho de que esto realmente active dos pinturas depende de la heurística del navegador.
Versión normal:
function paintFast() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
$('#otherThing2').css('height', '20px');
}
Agreguemos un poco de retraso:
function paintALittleLater() {
var height1 = $('#thing1').css('height');
var height2 = $('#thing2').css('height');
$('#otherThing1').css('height', '20px');
setTimeout(function() {
$('#otherThing2').css('height', '20px');
}, 10)
}
La versión retrasada muestra que el navegador pinta dos veces, aunque los dos cambios en la página solo tienen una diferencia de 1/100 de segundo.
Inicialización diferida
Los usuarios quieren apps web que se carguen rápido y sean responsivas. Sin embargo, los usuarios tienen diferentes umbrales para lo que perciben como lento según la acción que realizan. Por ejemplo, una app nunca debería realizar muchos cálculos en un evento de mouseover, ya que esto podría crear una mala experiencia del usuario mientras este sigue moviendo el mouse. Sin embargo, los usuarios están acostumbrados a aceptar un pequeño retraso después de hacer clic en un botón.
Por lo tanto, podría ser conveniente mover el código de inicialización para que se ejecute lo más tarde posible (p.ej., cuando el usuario hace clic en un botón que activa un componente específico de tu aplicación).
Antes:
js
var things = $('.ele > .other * div.className');
$('#button').click(function() { things.show() });
Después:
js
$('#button').click(function() { $('.ele > .other * div.className').show() });
Delegación de eventos
Distribuir controladores de eventos en una página puede llevar un tiempo relativamente largo y también puede ser tedioso una vez que los elementos se reemplazan de forma dinámica, lo que requiere volver a adjuntar controladores de eventos a los elementos nuevos.
La solución en este caso es usar una técnica llamada delegación de eventos. En lugar de adjuntar controladores de eventos individuales a los elementos, se usa la naturaleza de propagación de muchos eventos del navegador adjuntando el controlador de eventos a un nodo superior y verificando el nodo de destino del evento para ver si es de interés.
En jQuery, esto se puede expresar fácilmente de la siguiente manera:
$('#parentNode').delegate('.button', 'click', function() { ... });
Cuándo no usar la delegación de eventos
A veces, puede ocurrir lo contrario: estás usando la delegación de eventos y tienes un problema de rendimiento. Básicamente, la delegación de eventos permite un tiempo de inicialización de complejidad constante. Sin embargo, el precio de verificar si un evento es de interés se debe pagar por cada invocación de ese evento. Esto puede resultar costoso, especialmente para los eventos que ocurren con frecuencia, como "mouseover" o incluso "mousemove".
Problemas y soluciones típicos
Las tareas que realizo en $(document).ready toman mucho tiempo
Consejo personal de Malte: Nunca hagas nada en $(document).ready. Intenta entregar el documento en su forma final. OK, puedes registrar objetos de escucha de eventos, pero solo con el selector de ID o la delegación de eventos. En el caso de los eventos costosos, como "mousemove", retrasa el registro hasta que sea necesario (evento de mouseover en el elemento correspondiente).
Y si realmente necesitas hacer cosas, como realizar una solicitud Ajax para obtener datos reales, muestra una animación agradable. Es posible que quieras incluir la animación como un URI de datos si es un GIF animado o algo similar.
Desde que agregué una película Flash a la página, todo es muy lento
Agregar Flash a una página siempre ralentizará un poco la renderización, ya que el diseño final de la ventana se debe "negociar" entre el navegador y el complemento de Flash. Si no puedes evitar por completo incluir Flash en tus páginas, asegúrate de establecer el parámetro de Flash "wmode" en el valor "window" (que es el predeterminado). Esto inhabilitará la capacidad de componer elementos HTML y Flash (no podrás ver un elemento HTML que se encuentre por encima de la película Flash, y esta no podrá ser transparente). Esto puede ser un inconveniente, pero mejorará drásticamente tu rendimiento. Por ejemplo, observa cómo youtube.com evita cuidadosamente colocar capas sobre el reproductor de películas principal.
Guardo elementos en localStorage y ahora mi aplicación se traba
La escritura en localStorage es una operación síncrona que implica poner en marcha el disco duro. Nunca debes realizar operaciones síncronas de "larga duración" mientras se ejecutan animaciones. Mueve el acceso a localStorage a un lugar de tu código en el que estés seguro de que el usuario está inactivo y no se están ejecutando animaciones.
La generación de perfiles indica que un selector de jQuery es muy lento
Primero, asegúrate de que tu selector se pueda ejecutar a través de document.querySelectorAll. Puedes probarlo en la consola de JavaScript. Si hay una excepción, vuelve a escribir el selector para que no use ninguna extensión especial de tu framework de JavaScript. Esto acelerará tu selector en los navegadores modernos en un orden de magnitud.
Si esto no ayuda o si también quieres que la carga sea rápida en los navegadores actualizados, sigue estos lineamientos:
- Sé lo más específico posible en el lado derecho del selector.
- Usa un nombre de etiqueta que no uses con frecuencia como la parte del selector que se encuentra más a la derecha.
- Si nada funciona, considera reescribir el código para poder usar un selector de ID.
Todas estas manipulaciones del DOM llevan mucho tiempo.
Un montón de inserciones, eliminaciones y actualizaciones de nodos del DOM puede ser muy lento. Por lo general, esto se puede optimizar generando una cadena grande de HTML y usando domNode.innerHTML = newHTML para reemplazar el contenido anterior. Ten en cuenta que esto podría ser muy malo para la capacidad de mantenimiento y podría crear vínculos de memoria en IE, así que ten cuidado.
Otro problema común es que tu código de inicialización puede crear mucho código HTML. Por ejemplo, un complemento de jQuery que transforma un cuadro de selección en un grupo de divs porque eso es lo que querían los diseñadores, que ignoraban las prácticas recomendadas de UX. Si realmente quieres que tu página sea rápida, nunca hagas eso. En su lugar, entrega todo el lenguaje de marcado desde el servidor en su forma final. Esto también tiene muchos problemas, por lo que debes pensar bien si la velocidad vale la pena.
Herramientas
- JSPerf: Realiza comparativas de pequeños fragmentos de JavaScript
- Firebug: Para generar perfiles en Firefox
- Herramientas para desarrolladores de Chrome (disponibles como WebInspector en Safari)
- DOM Monster: Para optimizar el rendimiento del DOM
- DynaTrace Ajax Edition: Para generar perfiles y optimizar la renderización en Internet Explorer