Las animaciones de JavaScript pueden manejar cosas que CSS no puede.
Por ejemplo, moverse a lo largo de una ruta compleja, con una función de sincronización diferente a las curvas de Bézier, o una animación en un canvas.
Usando setInterval
Una animación se puede implementar como una secuencia de frames, generalmente pequeños cambios en las propiedades de HTML/CSS.
Por ejemplo, cambiar style.left de 0px a 100px mueve el elemento. Y si lo aumentamos en setInterval, cambiando en 2px con un pequeño retraso, como 50 veces por segundo, entonces se ve suave. Ese es el mismo principio que en el cine: 24 frames por segundo son suficientes para que se vea suave.
El pseudocódigo puede verse así:
let timer = setInterval(function() {
if (animation complete) clearInterval(timer);
else increase style.left by 2px
}, 20); // cambiar en 2px cada 20ms, aproximadamente 50 frames por segundo
Ejemplo más completo de la animación:
let start = Date.now(); // recordar la hora de inicio
let timer = setInterval(function() {
// ¿Cuánto tiempo pasó desde el principio?
let timePassed = Date.now() - start;
if (timePassed >= 2000) {
clearInterval(timer); // terminar la animación después de 2 segundos
return;
}
// dibujar la animación en el momento timePassed
draw(timePassed);
}, 20);
// mientras timePassed va de 0 a 2000
// left obtiene valores de 0px a 400px
function draw(timePassed) {
train.style.left = timePassed / 5 + 'px';
}
Haz clic para ver la demostración:
<!DOCTYPE HTML>
<html>
<head>
<style>
#train {
position: relative;
cursor: pointer;
}
</style>
</head>
<body>
<img id="train" src="https://js.cx/clipart/train.gif">
<script>
train.onclick = function() {
let start = Date.now();
let timer = setInterval(function() {
let timePassed = Date.now() - start;
train.style.left = timePassed / 5 + 'px';
if (timePassed > 2000) clearInterval(timer);
}, 20);
}
</script>
</body>
</html>Usando requestAnimationFrame
Imaginemos que tenemos varias animaciones ejecutándose simultáneamente.
Si las ejecutamos por separado, aunque cada una tenga setInterval (..., 20), el navegador tendría que volver a pintar con mucha más frecuencia que cada 20ms.
Eso es porque tienen un tiempo de inicio diferente, por lo que “cada 20ms” difiere entre las diferentes animaciones. Los intervalos no están alineados. Así que tendremos varias ejecuciones independientes dentro de 20ms.
En otras palabras, esto:
setInterval(function() {
animate1();
animate2();
animate3();
}, 20)
…Es más ligero que tres llamadas independientes:
setInterval(animate1, 20); // animaciones independientes
setInterval(animate2, 20); // en diferentes lugares del script
setInterval(animate3, 20);
Estos varios redibujos independientes deben agruparse para facilitar el redibujado al navegador y, por lo tanto, cargar menos CPU y verse más fluido.
Hay una cosa más a tener en cuenta. A veces, cuando el CPU está sobrecargado, o hay otras razones para volver a dibujar con menos frecuencia (como cuando la pestaña del navegador está oculta), no deberíamos ejecutarlo cada 20ms.
Pero, ¿cómo sabemos eso en JavaScript? Hay una especificación Sincronización de animación que proporciona la función requestAnimationFrame. Aborda todos estos problemas y aún más.
La sintaxis:
let requestId = requestAnimationFrame(callback)
Eso programa la función callback para que se ejecute en el tiempo más cercano cuando el navegador quiera hacer una animación.
Si hacemos cambios en los elementos dentro de callback, entonces se agruparán con otros callbacks de requestAnimationFrame y con animaciones CSS. Así que habrá un recálculo y repintado de geometría en lugar de muchos.
El valor devuelto requestId se puede utilizar para cancelar la llamada:
// cancelar la ejecución programada del callback
cancelAnimationFrame(requestId);
El callback obtiene un argumento: el tiempo transcurrido desde el inicio de la carga de la página en microsegundos. Este tiempo también se puede obtener llamando a performance.now().
Por lo general, el callback se ejecuta muy pronto, a menos que el CPU esté sobrecargado o la batería de la laptop esté casi descargada, o haya otra razón.
El siguiente código muestra el tiempo entre las primeras 10 ejecuciones de requestAnimationFrame. Por lo general, son 10-20ms:
<script>
let prev = performance.now();
let times = 0;
requestAnimationFrame(function measure(time) {
document.body.insertAdjacentHTML("beforeEnd", Math.floor(time - prev) + " ");
prev = time;
if (times++ < 10) requestAnimationFrame(measure);
})
</script>
Animación estructurada
Ahora podemos hacer una función de animación más universal basada en requestAnimationFrame:
function animate({timing, draw, duration}) {
let start = performance.now();
requestAnimationFrame(function animate(time) {
// timeFraction va de 0 a 1
let timeFraction = (time - start) / duration;
if (timeFraction > 1) timeFraction = 1;
// calcular el estado actual de la animación
let progress = timing(timeFraction)
draw(progress); // dibujar
if (timeFraction < 1) {
requestAnimationFrame(animate);
}
});
}
La función animate acepta 3 parámetros que básicamente describen la animación:
duration-
Tiempo total de animación. Como:
1000. timing(timeFraction)-
Función de sincronización, como la propiedad CSS
transition-timing-functionque obtiene la fracción de tiempo que pasó (0al inicio,1al final) y devuelve la finalización de la animación (comoyen la curva de Bézier).Por ejemplo, una función lineal significa que la animación continúa uniformemente con la misma velocidad:
function linear(timeFraction) { return timeFraction; }Su gráfico:
Eso es como
transition-timing-function: linear. A continuación se muestran variantes más interesantes. draw(progress)-
La función que toma el estado de finalización de la animación y la dibuja. El valor
progress=0denota el estado inicial de la animación yprogress=1– el estado final.Esta es la función que realmente dibuja la animación.
Puede mover el elemento:
function draw(progress) { train.style.left = progress + 'px'; }…O hacer cualquier otra cosa, podemos animar cualquier cosa, de cualquier forma.
Vamos a animar el elemento width de 0 a 100% usando nuestra función.
Haz clic en el elemento de la demostración:
function animate({duration, draw, timing}) {
let start = performance.now();
requestAnimationFrame(function animate(time) {
let timeFraction = (time - start) / duration;
if (timeFraction > 1) timeFraction = 1;
let progress = timing(timeFraction)
draw(progress);
if (timeFraction < 1) {
requestAnimationFrame(animate);
}
});
}<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
<style>
progress {
width: 5%;
}
</style>
<script src="animate.js"></script>
</head>
<body>
<progress id="elem"></progress>
<script>
elem.onclick = function() {
animate({
duration: 1000,
timing: function(timeFraction) {
return timeFraction;
},
draw: function(progress) {
elem.style.width = progress * 100 + '%';
}
});
};
</script>
</body>
</html>