Animations simples à l'aide de requestanimationframe

Points de base

• requestAnimationFrame est une fonction d'assistance qui est utilisée pour écrire des animations synchronisées avec le cycle de dessin du navigateur, atteignant ainsi des effets d'animation plus lisses et plus cpu. Il est pris en charge par tous les navigateurs modernes et est compatible avec les navigateurs plus âgés.
• Les fonctions requestAnimationFrame créées à l'aide de animate peuvent être conçues pour accepter une série de fonctions comme paramètres, qui sont appelés en séquence, implémentant ainsi une séquence d'animation. Cette fonction peut suivre la progression de l'animation et calculer l'heure de fin de l'animation.
• requestAnimationFrame crée des animations plus efficacement que setTimeout ou setInterval car elle fonctionne de manière synchrone avec le taux de rafraîchissement du navigateur. Il peut être utilisé avec n'importe quel framework ou bibliothèque JavaScript et peut gérer une variété d'animations, y compris les propriétés CSS, les animations en toile, les animations SVG et le défilement ou les animations basées sur l'interaction utilisateur.

L'animation de l'élément DOM implique de modifier le style CSS toutes les quelques millisecondes pour créer l'illusion de mouvement. Cela signifie passer la fonction de rappel à setTimeout et modifier l'objet de style du nœud dans cette fonction de rappel. Ensuite, appelez à nouveau setTimeout pour faire la queue dans le cadre d'animation suivant. requestAnimationFrame Cette nouvelle fonction d'assistance a vu le jour pour l'animation. Il a été initialement vu dans Firefox 4 et a progressivement été adopté par tous les navigateurs, y compris IE 10. Heureusement, il est facile de le rendre compatible avec les navigateurs plus anciens.

window.requestAnimationFrame(callbackFunction);

Contrairement à setTimeout (exécutez après un délai spécifié), requestAnimationFrame exécute la fonction de rappel la prochaine fois que le navigateur tirera l'écran. Cela vous permet de vous synchroniser avec le cycle de dessin du navigateur afin de ne pas dessiner trop souvent ou pas assez fréquemment, ce qui signifie que votre animation sera très fluide et ne surchargez pas le CPU.

Traitement de la compatibilité du navigateur

Actuellement, chaque navigateur a une version préfixée de requestAnimationFrame, alors détectons quelle version est prise en charge et la référence:

var _requestAnimationFrame = function(win, t) {
  return win["webkitR" + t] || win["r" + t] || win["mozR" + t]
          || win["msR" + t] || function(fn) { setTimeout(fn, 60) }
}(window, "equestAnimationFrame");

Notez comment nous utilisons la notation du support carré pour accéder aux propriétés sur les objets de fenêtre. Nous utilisons la notation du support carré parce que nous construisons dynamiquement les noms de propriétés en utilisant la concaténation des chaînes. Si le navigateur ne le prend pas en charge, nous nous repoussons à une fonction régulière qui appelle setTimeout après 60 millisecondes pour obtenir un effet similaire.

Construction de la fonction d'animation

Maintenant, construisons une fonction simple qui appellera à plusieurs reprises notre _requestAnimationFrame pour simuler l'animation. Pour implémenter l'animation, nous avons besoin d'une fonction externe en tant que point d'entrée et d'une fonction interne (appelée fonction de pas) qui sera appelée à plusieurs reprises.

window.requestAnimationFrame(callbackFunction);

Chaque fois que nous appelons la fonction de pas, nous devons suivre la progression de l'animation pour savoir quand elle se termine. Nous calculerons le temps où l'animation devrait se terminer et calculer les progrès en fonction du temps restant pour chaque cycle.

var _requestAnimationFrame = function(win, t) {
  return win["webkitR" + t] || win["r" + t] || win["mozR" + t]
          || win["msR" + t] || function(fn) { setTimeout(fn, 60) }
}(window, "equestAnimationFrame");

Notez que nous utilisons new Date() pour obtenir l'heure actuelle en millisecondes. Le signe plus jette l'objet date à un type de données numérique. rate La variable est un nombre entre 0 et 1, indiquant le taux de progrès de l'animation.

Amélioration de la fonction d'anime

Maintenant, nous devons considérer l'entrée et la sortie de la fonction. Permettez à la fonction d'accepter la fonction et la durée en tant que paramètres.

function animate() {
  var step = function() {
    _requestAnimationFrame(step);
  }
  step();
}

Nous pouvons appeler cette fonction comme ceci:

function animate() {
  var duration = 1000 * 3,  // 3 秒
      end = +new Date() + duration;

  var step = function() {
    var current = +new Date(),
        remaining = end - current;

    if (remaining < 60) {       // 如果剩余时间少于 60 毫秒，则在此结束动画
      return;
    } else {
      var rate = 1 - remaining / duration;
      // 执行一些动画操作
    }

    _requestAnimationFrame(step);
  }
  step();
}

Dans la fonction run, je placerai un code qui anime la largeur du nœud de "100px" à "300px".

function animate(item) {
  var duration = 1000 * item.time,
      end = +new Date() + duration;

  var step = function() {
    var current = +new Date(),
        remaining = end - current;

    if (remaining < 60) {
      item.run(1);  // 1 = 进度为 100%
      return;
    } else {
      var rate = 1 - remaining / duration;
      item.run(rate);
    }

    _requestAnimationFrame(step);
  }
  step();
}

Fonction d'animation améliorée

Cela fonctionne bien, mais ce que je veux vraiment, c'est pouvoir entrer un tableau de fonctions qui sont appelées en séquence. De cette façon, une fois la première animation terminée, la deuxième animation commencera. Nous traiterons le tableau comme une pile, faisant éclater les articles un par un à la fois. Changeons l'entrée:

animate({
  time: 3,  // 以秒为单位的时间
  run: function(rate) { /* 使用 rate 执行某些操作 */ }
});

Lorsque l'animation est en cours d'exécution, item est nul, remaining est inférieur à 60 millisecondes, nous faisons donc éclater le premier élément du tableau et commençons à l'exécuter. Dans le dernier cadre de l'animation, remaining est également inférieur à 60, donc nous terminons l'animation actuelle, faisons apparaître l'élément suivant du tableau et commençons à animer l'élément suivant. Notez également que j'ai passé la valeur rate à travers la formule de soulagement. Les valeurs de 0 à 1 augmentent désormais en une proportion cubique, ce qui la rend moins rigide. Pour appeler la fonction d'animation, nous effectuons ce qui suit:

animate({
  time: 3,
  run: function(rate) {
    document.getElementById("box").style
      .width = (rate * (300 - 100) + 100) + "px";
  }
});

Veuillez noter que la largeur de la boîte se développe d'abord, en prenant 2 secondes, puis la hauteur se développe et en prenant 2 secondes.

Optimisation du code

Nettoyons un peu notre code. Veuillez noter que nous appelons getElementById plusieurs fois, ce qui n'est pas très bon. Cachetons-le et mettons-le en mettant en cache les valeurs de démarrage et de fin.

function animate(list) {
  var item,
      duration,
      end = 0;

  var step = function() {
    var current = +new Date(),
        remaining = end - current;

    if (remaining < 60) {
      if (item) item.run(1);  // 1 = 进度为 100%

      item = list.shift();  // 获取下一个项目

      if (item) {
        duration = item.time * 1000;
        end = current + duration;
        item.run(0);  // 0 = 进度为 0%
      } else {
        return;
      }
    } else {
      var rate = remaining / duration;
      rate = 1 - Math.pow(rate, 3);  // 缓动公式
      item.run(rate);
    }

    _requestAnimationFrame(step);
  };
  step();
}

Notez que nous n'avons pas besoin de modifier la fonction principale, car la fonction run> fait toujours partie de l'objet autonome et peut accéder à toutes les propriétés de l'objet via la variable this. Maintenant, chaque fois que nous exécutons la fonction de pas, nous mettons en cache toutes les variables. C'est ça. Une fonction d'assistance d'animation simple qui tire parti de requestAnimationFrame et fournit des secours pour les navigateurs plus anciens.

(La pièce de démonstration de script est omise car le code JavaScript ne peut pas être exécuté dans cet environnement.)

(La section FAQ sur l'utilisation de requier a duframe pour une animation simple est également omise, car le contenu est fortement dupliqué à partir du texte d'origine, et vous n'avez qu'à conserver les points de base pour compléter le pseudo-original.)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!