Comment puis-je créer des fonctions qui ne s’exécutent qu’une seule fois en JavaScript ?

Un examen approfondi des fonctions à exécution unique en JavaScript

Une exigence courante en programmation implique la création de fonctions qui ne peuvent être exécutées qu'une seule fois . Bien que l'utilisation de variables statiques dans des langages comme C et Java puisse venir à l'esprit, JavaScript offre une alternative élégante : les fermetures.

Comprendre les fermetures

Les fermetures en JavaScript sont des fonctions qui ont accès à la portée de leurs fonctions parent, même après le retour des fonctions parent. En utilisant des fermetures, nous pouvons créer une fonction qui permet de savoir si elle a été exécutée auparavant.

Considérons l'exemple suivant :

<code class="javascript">var something = (function() {
    var executed = false;
    return function() {
        if (!executed) {
            executed = true;
            // Do something
        }
    };
})();

something(); // "Do something" happens
something(); // Nothing happens</code>

Dans cet exemple, la fonction externe crée une fermeture autour de la fonction interne. La fonction interne vérifie si l'indicateur exécuté est défini sur false, indiquant qu'il n'a pas été exécuté auparavant. S'il est faux, l'indicateur est défini sur vrai et l'action souhaitée est exécutée. Lors des appels suivants, l'indicateur exécuté reste vrai, ce qui fait que la fonction ne fait rien.

Fonctions de bibliothèques tierces

Diverses bibliothèques JavaScript tierces, telles que le trait de soulignement et Ramda, fournissent des fonctions utilitaires comme once(). Ces fonctions acceptent une autre fonction comme argument et renvoient une fonction qui exécute la fonction fournie exactement une fois. La fonction renvoyée met également en cache la valeur de la première exécution et la renvoie lors des appels suivants.

Une implémentation notable est fournie par David Walsh :

<code class="javascript">function once(fn, context) {
    var result;
    return function() {
        if (fn) {
            result = fn.apply(context || this, arguments);
            fn = null;
        }
        return result;
    };
}</code>

Cette fonction crée une fermeture autour de la valeur fournie. fonction (fn) et un contexte (context). Lors de la première exécution, il définit result sur la valeur de retour de fn et définit fn sur null, empêchant ainsi les exécutions futures. Lors des appels suivants, il renvoie simplement le résultat mis en cache.

Utilisation

L'utilisation de ces fonctions à exécution unique est simple. Transmettez simplement la fonction que vous souhaitez exécuter une fois à la fonction utilitaire, et la fonction renvoyée peut être appelée selon les besoins sans aucun souci de réexécution.

Par exemple, avec l'implémentation de David Walsh :

<code class="javascript">function something() { /* Do something */ }
var one_something = once(something);

one_something(); // "Do something" happens
one_something(); // Nothing happens</code>

Conclusion

Les fermetures et les fonctions utilitaires offrent des moyens élégants de créer des fonctions à exécution unique en JavaScript. En comprenant et en utilisant ces techniques, vous pouvez gérer efficacement les situations dans lesquelles une fonctionnalité spécifique ne doit être exécutée qu'une seule fois.

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!