


Une analyse approfondie du mécanisme de fermeture de JavaScript_Connaissances de base
Les variables JavaScript peuvent être des variables locales ou des variables globales.
Les fermetures peuvent être utilisées pour les variables privées.
Variables globales
Les fonctions peuvent accéder aux variables définies dans la fonction, telles que :
Exemple
function myFunction() { var a = 4; return a * a; }
Les fonctions peuvent également accéder à des variables définies en dehors de la fonction, telles que :
Exemple
var a = 4; function myFunction() { return a * a; }
Dans ce dernier exemple, a est une variable globale.
Les variables globales dans les pages Web appartiennent à l'objet window.
Les variables globales s'appliquent à tous les scripts de la page.
Dans le premier cas, a est une variable locale.
Les variables locales ne peuvent être utilisées que dans la fonction dans laquelle elles sont définies. Non disponible pour d'autres fonctions ou codes de script.
Même si les variables globales et locales portent le même nom, ce sont deux variables différentes. Modifier l’un d’eux n’affectera pas la valeur de l’autre.
Remarque
Si une variable est déclarée sans le mot-clé var, c'est une variable globale, même si elle est définie au sein d'une fonction.
Cycle de vie variable
La portée des variables globales est globale, c'est-à-dire que les variables globales sont partout dans l'ensemble du programme JavaScript.
Les variables déclarées dans une fonction ne fonctionnent qu'à l'intérieur de la fonction. Ces variables sont des variables locales et leur portée est locale ; les paramètres de la fonction sont également locaux et ne fonctionnent qu'à l'intérieur de la fonction.
Contre-dilemme
Imaginez que vous souhaitiez compter certaines valeurs et que le compteur est disponible dans toutes les fonctions.
Vous pouvez utiliser des variables globales, des fonctions pour régler le compteur pour qu'il incrémente :
Exemple
var counter = 0; function add() { counter += 1; } add(); add(); add(); // 计数器现在为 3
La valeur du compteur change lorsque la fonction add() est exécutée.
Mais voici le problème, n'importe quel script sur la page peut modifier le compteur, même si la fonction add() n'est pas appelée.
Si je déclare un compteur à l'intérieur d'une fonction, la valeur du compteur ne peut pas être modifiée sans appeler la fonction :
Exemple
function add() { var counter = 0; counter += 1; } add(); add(); add(); // 本意是想输出 3, 但事与愿违,输出的都是 1 !
Le code ci-dessus ne s'affichera pas correctement, chaque fois que j'appelle la fonction add(), le compteur sera mis à 1.
Les fonctions JavaScript en ligne peuvent résoudre ce problème.
Fonctions intégrées JavaScript
Toutes les fonctions ont accès aux variables globales.
En fait, en JavaScript, toutes les fonctions ont accès à la portée située au-dessus d'elles.
JavaScript prend en charge les fonctions imbriquées. Les fonctions imbriquées peuvent accéder aux variables de fonction du niveau supérieur.
Dans cet exemple, la fonction inline plus() peut accéder à la variable compteur de la fonction parent :
Exemple
function add() { var counter = 0; function plus() {counter += 1;} plus(); return counter; }
Si nous pouvions accéder à la fonction plus() en externe, cela résoudrait le dilemme du compteur.
Nous devons également nous assurer que counter = 0 n'est exécuté qu'une seule fois.
Nous avons besoin de fermetures.
Fermeture JavaScript
Vous vous souvenez de la fonction qui s'appelle ? A quoi sert cette fonction ?
Exemple
var add = (function () { var counter = 0; return function () {return counter += 1;} })(); add(); add(); add(); // 计数器为 3
Exemple d'analyse
La variable add spécifie la valeur du mot de retour de la fonction qui s'appelle elle-même.
Les fonctions d'appel automatique ne sont exécutées qu'une seule fois. Mettez le compteur à 0. et renvoie l'expression de la fonction.
La variable add peut être utilisée comme fonction. Ce qui est cool, c'est qu'il donne accès aux compteurs depuis la portée située au-dessus de la fonction.
C'est ce qu'on appelle une fermeture JavaScript. Cela permet aux fonctions d'avoir des variables privées.
Le compteur est protégé par la portée de la fonction anonyme et ne peut être modifié que via la méthode add.
Remarque
Une fermeture est une fonction qui peut accéder aux variables dans la portée de la fonction précédente, même si la fonction précédente a été fermée.

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

En C++, une fermeture est une expression lambda qui peut accéder à des variables externes. Pour créer une fermeture, capturez la variable externe dans l'expression lambda. Les fermetures offrent des avantages tels que la réutilisabilité, la dissimulation des informations et une évaluation paresseuse. Ils sont utiles dans des situations réelles telles que les gestionnaires d'événements, où la fermeture peut toujours accéder aux variables externes même si elles sont détruites.

Les expressions C++ Lambda prennent en charge les fermetures, qui enregistrent les variables de portée de fonction et les rendent accessibles aux fonctions. La syntaxe est [capture-list](parameters)->return-type{function-body}. capture-list définit les variables à capturer. Vous pouvez utiliser [=] pour capturer toutes les variables locales par valeur, [&] pour capturer toutes les variables locales par référence, ou [variable1, variable2,...] pour capturer des variables spécifiques. Les expressions Lambda ne peuvent accéder qu'aux variables capturées mais ne peuvent pas modifier la valeur d'origine.

Une fermeture est une fonction imbriquée qui peut accéder aux variables dans la portée de la fonction externe. Ses avantages incluent l'encapsulation des données, la conservation de l'état et la flexibilité. Les inconvénients incluent la consommation de mémoire, l’impact sur les performances et la complexité du débogage. De plus, les fermetures peuvent créer des fonctions anonymes et les transmettre à d'autres fonctions sous forme de rappels ou d'arguments.

Titre : Fuites de mémoire causées par les fermetures et solutions Introduction : Les fermetures sont un concept très courant en JavaScript, qui permettent aux fonctions internes d'accéder aux variables des fonctions externes. Cependant, les fermetures peuvent provoquer des fuites de mémoire si elles ne sont pas utilisées correctement. Cet article explorera le problème de fuite de mémoire provoqué par les fermetures et fournira des solutions et des exemples de code spécifiques. 1. Fuites de mémoire causées par les fermetures La caractéristique des fermetures est que les fonctions internes peuvent accéder aux variables des fonctions externes, ce qui signifie que les variables référencées dans les fermetures ne seront pas récupérées. S'il est mal utilisé,

Les fermetures de fonctions du langage Go jouent un rôle essentiel dans les tests unitaires : Capture de valeurs : les fermetures peuvent accéder aux variables dans la portée externe, permettant ainsi de capturer et de réutiliser les paramètres de test dans des fonctions imbriquées. Simplifiez le code de test : en capturant les valeurs, les fermetures simplifient le code de test en éliminant le besoin de définir des paramètres à plusieurs reprises pour chaque boucle. Améliorez la lisibilité : utilisez des fermetures pour organiser la logique de test, rendant ainsi le code de test plus clair et plus facile à lire.

Oui, la simplicité et la lisibilité du code peuvent être optimisées grâce à des appels et des fermetures enchaînés : les appels en chaîne lient les appels de fonction dans une interface fluide. Les fermetures créent des blocs de code réutilisables et accèdent à des variables en dehors des fonctions.

L'impact des pointeurs de fonction et des fermetures sur les performances de Go est le suivant : Pointeurs de fonction : légèrement plus lents que les appels directs, mais améliorent la lisibilité et la réutilisabilité. Fermetures : généralement plus lentes, mais encapsulent les données et le comportement. Cas pratique : les pointeurs de fonction peuvent optimiser les algorithmes de tri et les fermetures peuvent créer des gestionnaires d'événements, mais ils entraîneront des pertes de performances.

Les fermetures en Java permettent aux fonctions internes d'accéder aux variables de portée externe même si la fonction externe est terminée. Implémentée via des classes internes anonymes, la classe interne contient une référence à la classe externe et maintient les variables externes actives. Les fermetures augmentent la flexibilité du code, mais vous devez être conscient du risque de fuite de mémoire, car les références à des variables externes par des classes internes anonymes maintiennent ces variables en vie.
