Une brève analyse des compétences expressions_javascript de la fonction javascript

Commencez à apprendre les expressions de fonctions javascript et lisez attentivement ce qui suit.

1. Dans la forme générale de création d'une fonction, la déclaration de fonction sera lue avant d'exécuter le code, la déclaration de fonction peut donc être écrite sous l'appel de fonction :

 sayHi();
 function sayHi(){
     alert("Hi!");
}

2. Utilisez des expressions de fonction pour créer des fonctions, auxquelles une valeur doit être attribuée avant d'être appelée :

 sayHi(); //错误！！函数不存在
 var sayHi=function(){
     alert("Hi!");
}

3. Récursion

Récursion générale

function factorial(num){
        if (num <= 1){
          return 1;
        } else {
          return num * factorial(num-1);
        }
      }

arguments.callee est un pointeur vers la fonction en cours d'exécution, qui peut être utilisé pour implémenter la récursivité :

function factorial(num){
        if (num <= 1){
          return 1;
        } else {
          return num * arguments.callee(num-1);
        }
      }

4. Fermeture ( La fermeture fait référence à une fonction qui peut accéder à des variables dans une autre portée ).
Une manière courante de créer des fermetures consiste à créer une fonction à l’intérieur d’une autre fonction. Lorsqu'une fonction est exécutée, un environnement d'exécution et une chaîne de portée correspondante sont créés. Une fermeture ne peut prendre que la dernière valeur de n'importe quelle variable dans la fonction contenant :

function createFunctions(){
        var result = new Array();
        
        for (var i=0; i < 10; i++){
          result[i] = function(){
            return i;
          };
        }
        
        return result;
      }
      
      var funcs = createFunctions();
      
      //every function outputs 10
      for (var i=0; i < funcs.length; i++){
        document.write(funcs[i]() + "<br />");
      }

Le code ci-dessus affiche les 10. En effet : chaque fonction funcs enregistre l'objet actif createFunctions() (qui est une fonction, un objet et un type de fonction de type référence), et l'objet actif createFunctions() a une variable i, donc chaque fonction aura ceci variable i, et lorsque la fonction createFunctions() renvoie le résultat, i est devenu 10. Ainsi, chaque valeur du tableau funcs est 10.

Peut être transformé comme suit :

function createFunctions(){
        var result = new Array();
        
        for (var i=0; i < 10; i++){
          result[i] = function(num){
            return function(){
              return num;
            };
          }(i);
        }
        
        return result;
      }

Lorsque chaque fonction anonyme est appelée, la valeur actuelle de i est donnée à num, et à l'intérieur de la fonction anonyme, une fermeture de num est créée et renvoyée. De cette façon, chaque fonction qui renvoie un tableau possède sa propre copie de la variable num. (Ce paragraphe n'est pas expliqué clairement, les lecteurs peuvent le découvrir par eux-mêmes. S'il existe une meilleure façon de le décrire, veuillez commenter sous l'article, merci)

5. cet objet

• Dans les fonctions globales, cela équivaut à window.
  
• Lorsqu'une fonction est appelée en tant que méthode, cela équivaut à cet objet.
  
• Lorsque chaque fonction est appelée, cette fonction obtiendra automatiquement deux variables spéciales : this et arguments. Lorsque la fonction interne recherche ces deux variables, elle recherche uniquement jusqu'à l'objet actif.
  

6. Imiter la portée au niveau du bloc (portée privée)
Comme suit :

function outputNumbers(count){
        for (var i=0; i < count; i++){
          alert(i);
        }
      
        alert(i);  //count
      }

      outputNumbers(5);

Dans des langages tels que Java, la variable i pour est détruite lorsqu'elle est utilisée. En JavaScript, un objet actif est généré lorsque outputNumbers est appelé, et ce i appartient à cet objet actif, donc puisqu'il est défini, il est accessible n'importe où dans la fonction et il est partagé au sein de l'objet actif.

Syntaxe des fonctions anonymes (création de portée privée) :

(function(){
 //这里是块级作用域
})();

La déclaration de fonction est placée entre parenthèses, indiquant qu'il s'agit d'une expression, et l'ajout de parenthèses après peut l'appeler immédiatement.

Si vous avez besoin temporairement de certaines variables, vous pouvez utiliser la portée privée :

function outputNumbers(count){
      
        (function () {
          for (var i=0; i < count; i++){
            alert(i);
          }
        })();
        
        alert(i);  //causes an error
      }

Dans le code ci-dessus, i est privé et une erreur sera signalée lors d'un accès à i en dehors de la fonction anonyme (domaine privé), bien que l'alerte soit toujours dans l'objet actif.

7.Variables privées
Les paramètres, variables locales et autres fonctions définies à l'intérieur de la fonction sont toutes des variables privées de la fonction. Par exemple :

function add(num1,num2){
  var sum = num1 + num2;
  return sum; 
}

Il existe 3 variables privées : num1, num2, sum. Ils sont accessibles à l’intérieur de la fonction, mais pas à l’extérieur.

Les méthodes privilégiées peuvent accéder à des variables privées : en termes simples, utilisez une expression pour lui donner une fermeture et accédez à d'autres fonctions à l'intérieur de la fermeture :

 function Person(name){

        var a=0;
      
        this.getName = function(){
          return name + a;
        };
      
        this.setName = function (value) {
          name = value;
        };
      }

This.getName et this.setName sont des méthodes d'expression. Après avoir créé une instance Person, le nom et les attributs ne sont accessibles que via getName ou setName.

Ce qui précède représente l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'étude de chacun.