


Partager des informations utiles : vous permet d'apprendre les fermetures javascript en quelques minutes_javascript skills
La fermeture est un concept important en JavaScript. Pour les débutants, la fermeture est un concept très abstrait, notamment la définition donnée par la spécification ECMA, il vous est difficile de la comprendre. Cet article ne décrira donc pas longuement le concept de fermeture, mais passera directement aux informations pratiques pour que vous puissiez apprendre la fermeture en quelques minutes !
1. Clôture - la première expérience de l'amour
Quand j'entre en contact avec une nouvelle technologie, la première chose que je fais est de chercher son code démo. Pour les codeurs, le code peut parfois mieux comprendre quelque chose que le langage naturel. En fait, les fermetures sont partout. Par exemple, les principaux codes de jQuery et de zepto sont tous inclus dans une grande fermeture. J'écrirai donc ci-dessous la démo de fermeture la plus simple et la plus primitive pour vous aider à générer des fermetures dans votre cerveau :
function A(){ function B(){ console.log("Hello Closure!"); } return B; } var c = A(); c();//Hello Closure!
C'est la fermeture la plus simple de l'histoire. Cela ne peut pas être plus simple. Aussi simple soit-elle, ce n'est plus une fermeture !
Le code ci-dessus est traduit en langage naturel comme suit :
- (1) définit une fonction ordinaire A
- (2) Une fonction ordinaire B est définie dans A
- (3) Retourner B dans A (pour être précis, renvoyer une référence à B dans A)
- (4) Exécuter A() et attribuer le résultat de retour de A à la variable c
- (5)Exécuter c()
La fonction interne B de la fonction A est référencée par une variable c extérieure à la fonction A
Retraitez ces bêtises et cela devient la définition de la clôture :
Lorsqu'une fonction interne est référencée par une variable extérieure à sa fonction externe, une fermeture est formée.
N'essayez pas de vous souvenir de cette définition. Le but de vous donner cette définition est de vous faire comprendre que les 5 étapes ci-dessus visent à élaborer la définition de la fermeture.
Par conséquent, lorsque vous effectuez les 5 étapes ci-dessus, vous avez déjà défini une fermeture !
C'est la clôture.
2. Le rôle de la fermeture
Avant de comprendre le rôle de la fermeture, comprenons d'abord le mécanisme GC en JavaScript : En JavaScript, si un objet n'est plus référencé, alors l'objet sera recyclé par GC, sinon l'objet sera toujours stocké en mémoire au milieu. .Dans l'exemple ci-dessus, B est défini dans A, donc B dépend de A, et la variable externe c fait référence à B, donc A est indirectement référencé par c En d'autres termes, A ne sera pas recyclé par GC et le sera. toujours être Enregistré en mémoire. Pour prouver notre raisonnement, l'exemple ci-dessus est légèrement amélioré :
function A(){ var count = 0; function B(){ count ++; console.log(count); } return B; } var c = A(); c();// 1 c();// 2 c();// 3
C'est le rôle de la fermeture. Parfois, nous avons besoin de définir une telle variable dans un module : nous voulons que cette variable soit conservée en mémoire mais ne "pollue" pas la variable globale. Dans ce cas, nous pouvons utiliser la fermeture pour définir. ce module.
3. Écriture haut de gamme
La méthode d'écriture ci-dessus est en fait la méthode d'écriture la plus simple et la plus primitive, mais dans les applications réelles, personne ne le fait de cette façon, en particulier dans certains grands frameworks JS. La raison pour laquelle je vous parle de cette façon d’écrire est que moins il y a de distractions, plus il est facile de se concentrer sur une chose. Ci-dessous, j'utilise des méthodes d'écriture couramment utilisées pour écrire un composant de démonstration simple :
(function(document){ var viewport; var obj = { init:function(id){ viewport = document.querySelector("#"+id); }, addChild:function(child){ viewport.appendChild(child); }, removeChild:function(child){ viewport.removeChild(child); } } window.jView = obj; })(document);
La fonction de ce composant est d'initialiser un conteneur, puis d'ajouter des sous-conteneurs au conteneur, ou de supprimer un conteneur. La fonction est très simple, mais un autre concept entre ici en jeu : exécuter la fonction immédiatement. Comprenez-le simplement brièvement. L'essentiel est de comprendre comment cette méthode d'écriture implémente la fonction de fermeture.
Le processus d'exécution de ce code peut donc être décomposé comme suit :
var f = function(document){ var viewport; var obj = { init:function(id){ viewport = document.querySelector("#"+id); }, addChild:function(child){ viewport.appendChild(child); }, removeChild:function(child){ viewport.removeChild(child); } } window.jView = obj; }; f(document);
이 코드에는 클로저의 그림자가 보이는 것 같지만 f에는 반환 값이 없습니다. 클로저 조건을 충족하지 않는 것 같습니다.
window.jView = obj;
obj는 f에 정의된 객체이고 이 객체에는 일련의 메소드가 정의되어 있습니다. window.jView = obj를 실행한다는 것은 윈도우 전역 객체에 jView 변수를 정의하고 이 변수를 obj 객체, 즉 전역 객체를 가리키는 것을 의미합니다. 변수 jView는 obj를 참조합니다. obj 객체의 함수는 f의 변수 viewport를 참조하므로 f의 뷰포트는 GC에 의해 재활용되지 않고 메모리에 저장되므로 이 쓰기 방법은 클로저 조건을 충족합니다.
4. 간단 요약
이것은 클로저에 대한 가장 간단한 이해입니다. 물론 클로저는 더 깊은 이해를 갖고 있으며, 이는 훨씬 더 복잡합니다. JS 실행 컨텍스트(실행 컨텍스트), 활성 객체(호출 객체) 및 작동 메커니즘을 이해해야 합니다. 범위 및 범위 체인. 하지만 초보자로서 지금 당장은 이러한 내용을 이해할 필요는 없습니다. 간단한 이해를 한 후에는 실제 프로젝트에서 사용하면 자연스럽게 클로저에 대한 더 깊은 이해를 갖게 됩니다.
위 내용은 이 글의 전체 내용입니다. 모든 분들의 공부에 도움이 되었으면 좋겠습니다.

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é,

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.

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.

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.

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.
