Il s'agit d'un objet spécial à l'intérieur de la fonction. Cela fait référence à l'objet environnemental en fonction de laquelle la fonction est exécutée (nous ferons des explications supplémentaires à la fin de l'article). La valeur de ceci n'est pas certaine avant d'appeler la fonction. Différentes méthodes d'appel entraîneront le changement de cette valeur.
window.num = 22; var o = {num: 11}; function sayNnum () {alert (this.num)} saynum (); // 22o.saynum = saynum; o.saynum (); // 11N'oubliez pas: le nom de la fonction n'est qu'une variable contenant un pointeur. Par conséquent, même s'il est exécuté dans différents environnements, la fonction globale Saynum () est toujours la même fonction que O.Saynum ().
1. Lorsque vous appelez une fonction dans la portée globale
Appelé dans la portée globale, cet objet fait référence à la fenêtre
L'exécution des fonctions anonymes est globale, donc son objet pointe généralement vers la fenêtre.
fonction fn1 () {console.log (this);} fn1 ();2. Appelé via le nouvel opérateur
Cela fait référence à un objet d'instance
fonction personne (name) {this.name = name;} personne.prototype.printname = function () {alert (this.name); // byron}; var p1 = new personne ('byron');3. Méthode appelle comme objets
Cela fait référence à l'objet
var obj1 = {name: 'byron', fn: function () {console.log (this); }}; obj1.fn ();4. Appel indirect
appeler et postuler
Chaque fonction contient deux méthodes non héritées: call () et appliquer (). Le but de ces deux méthodes est d'appeler des fonctions dans une portée spécifique, ce qui équivaut en fait à la définition de la valeur de cet objet dans le corps de la fonction. En d'autres termes, la fonction est appelée directement et l'environnement d'exécution est spécifié lors de l'appel
window.color = 'red'; var o = {couleur: 'bleu'}; fonction sayColor () {alert (this.color);} sayColor.call (this); // redsayColor.call (window); // redsayColor.call (o); // bleu (fenêtre); // redsayColor.call (o); // Blue(1) Appliquer la méthode
Recevez deux paramètres, l'un est la portée de la fonction exécutée dans la fonction, et l'autre est le tableau des paramètres.
(2) Méthode d'appel
La méthode d'appel est la même que la méthode d'application, la différence est que la méthode de réception des paramètres est différente. Pour la méthode d'appel, le premier paramètre est que cette valeur n'a pas changé, et le changement est que les autres paramètres sont directement transmis à la fonction.
fonction fn () {console.log (this) // fonction windwow innerfn () {console.log (this)} innerfn.call (this) // window} fn (); fonction fn0 () {console.log (this) // fenêtre} fonction fn1 () {fn0.call (this); console.log (this); // fenêtre} fn1 (); fonction fn0 () {console.log (this) // objet} var o = {fn1: fonction fn1 () {fn0.call (this); console.log (this); // objet}} o.fn1 ();5. Méthode Bind
Cette méthode crée une instance de la fonction dont la valeur est liée à la valeur transmise à la fonction bind (). C'est-à-dire qu'une nouvelle fonction sera retournée et que dans la fonction sera le premier paramètre passé.
window.color = 'red'; var o = {couleur: 'blue'}; function sayColor () {alert (this.color)} var objectSayColor = sayColor.bind (o); objectSayColor (); // BlueRemarque supplémentaire: Exécuter la définition de l'environnement
Définit des variables ou d'autres données qui ont la permission d'accès. Chaque environnement d'exécution a un objet variable qui lui est associé. Toutes les variables et fonctions définies dans l'environnement sont stockées dans cet objet. Le code que nous écrivons ne peut pas accéder à cet objet, mais l'analyseur l'utilisera dans l'arrière-plan lors du traitement des données.
1. Création d'un environnement d'exécution:
1. Environnement d'exécution mondiale
Dans un navigateur Web, l'environnement d'exécution globale est considéré comme un objet de fenêtre, de sorte que toutes les variables et fonctions globales sont créées en tant que propriétés et méthodes de l'objet Window. Lorsque le code est chargé dans le navigateur, l'environnement d'exécution globale est créé (l'environnement d'exécution globale n'est détruit que lorsque nous fermons la page Web ou le navigateur).
2. Environnement d'exécution locale
Chaque fonction a son propre environnement d'exécution, donc l'environnement d'exécution locale est un objet de fonction. Lorsqu'une fonction est appelée, l'environnement local de la fonction est créé (après l'exécution du code de la fonction, l'environnement est détruit et que toutes les variables et définitions de fonction stockées dedans sont également détruites).
Cet environnement d'exécution et les objets variables connexes sont un concept abstrait, expliqué comme suit
var a = 1; fonction fn (num1, num2) {var b = 2; fonction fninner () {var c = 3; alerte (a + b + c); } fninner (); // Création de l'environnement d'exécution local lorsque Fninner est appelé} fn (4,5); // Création de l'environnement d'exécution local lorsque FN est appelé2. Chaîne de portée
L'exécution des fonctions JavaScript utilise une chaîne de portée. Cette chaîne de portée est créée lorsque la fonction est définie. Lorsqu'une fonction est définie, elle économise en fait une chaîne de portée. Lorsque cette fonction est appelée, il crée un nouvel objet pour stocker ses variables locales et ajoute cet objet à la chaîne de portée enregistrée. L'extrémité avant de la chaîne de portée est toujours un objet variable dans l'environnement où se trouve le code actuellement exécuté. La fin de la chaîne de portée est toujours un objet variable de l'environnement d'exécution global. Le but de la chaîne de portée est de s'assurer que toutes les variables et fonctions qui ont la permission d'accéder à l'environnement d'exécution sont autorisées à accéder.
var scope = 'Global Scope'; fonction chèquescope () {var scope = 'Local Scope'; fonction f () {return scope}; retour f;} Checkscope () (); // portée localeCompréhension: Lorsque Checkcope est appelé, la fonction F est définie et liée à la chaîne de portée de la gpe de contrôle en tant que variable locale. Par conséquent, peu importe où la fonction F est appelée, cette liaison est toujours valide, donc la valeur de retour est la portée locale.
var num1 = 1; fonction outer () {var num2 = 2; console.log (num1 + num2); // 3 fonction inner () {// vous pouvez accéder à num3, num2, num1 var num3 = 3; console.log (num1 + num2 + num3); // 6} // ici vous pouvez accéder à num2, inner (), num1 mais pas num3 inner ();} exter (); console.log (num1); // 1, environnement d'exécution // ici vous ne pouvez accéder qu'à NUM1Chaîne de portée (recherche): L'environnement interne peut accéder à tous les environnements externes via la chaîne de portée, mais l'environnement externe ne peut accéder à aucune variable et fonctions dans l'environnement interne.
var name = 'byron'; fonction fn () {var name = 'csper'; console.log (name); // casper} fn ();Plus l'environnement est interne, plus le poids variable est élevé.
Remarque: les variables qui ne sont pas directement déclarées avec le mot clé VAR sont des variables globales. Par exemple, si a = 1 est déclaré directement, A est une variable globale pour le moment.
Lorsque le moteur Javscript entre dans la portée, il traitera le code en deux tours. Le premier tour, initialisez les variables. Le deuxième tour, exécutez le code
var a = 1; fonction de la prison (a) {console.log (a); // 1 var a; console.log (a); // 1} prison (1);3. Exécution de la fonction
Lorsqu'un appel de fonction entre dans l'environnement d'exécution, les arguments du premier processus, initialisent les paramètres formels (la valeur par défaut n'est pas définie), puis initialise la déclaration de fonction dans la fonction. Lorsque le code est exécuté étape par étape, la déclaration de variable dans la fonction est initialisée (lorsque le code n'est pas exécuté après la saisie de l'environnement, la valeur n'est pas définie). Par conséquent, l'ordre d'initialisation dans la fonction est des paramètres formels, des déclarations de fonction et des déclarations variables. Il peut être vu sur l'image ci-dessus. Permettez-moi de vous donner un exemple (l'environnement global est également une fonction).
alerte (typeof fn); // fonction, déclaration de fonction alerte à l'avance (typeof fn0); // non défini, déclaration variable à l'avance mais non attribuée fn () {// Fonction Expression} var fn0 = fonction () {// définition de fonction} alerte (typeof fn0); // fonction, à ce moment la variable a été attribuée