Résumé de la façon d'utiliser ce mot-clé dans les conseils JavaScript_javascript

En JavaScript, cela ne se trouve pas nécessairement uniquement dans le contexte des méthodes objets. Il existe également cette référence dans les appels de fonctions globales et dans plusieurs autres contextes différents.
Il peut s'agir de l'objet global, de l'objet actuel ou de n'importe quel objet, tout dépend de la manière dont la fonction est appelée. Il existe plusieurs manières d'appeler des fonctions en JavaScript : en tant que méthode objet, en tant que fonction, en tant que constructeur et en utilisant apply ou call.

1. Appeler en tant que méthode objet

En JavaScript, les fonctions sont également des objets, les fonctions peuvent donc être utilisées comme attributs d'un objet. À ce stade, la fonction est appelée une méthode de l'objet. Lorsque vous utilisez cette méthode d'appel, elle est naturellement liée à l'objet.

Copier le code Le code est le suivant :

varpoint = {
x : 0,
y : 0,
moveTo : function(x, y) {
Ceci.x = ceci.x x;
Ceci.y = ceci.y y
}
};
point.moveTo(1, 1)//this est lié à l'objet actuel, c'est-à-dire l'objet point

2. Appel en fonction

La fonction peut également être appelée directement, auquel cas elle est liée à l'objet global. Dans le navigateur, window est l'objet global. Par exemple, dans l'exemple suivant : lorsque la fonction est appelée, celle-ci est liée à l'objet global, puis l'instruction d'affectation est exécutée, ce qui équivaut à déclarer implicitement une variable globale, ce qui n'est évidemment pas ce que souhaite l'appelant.

Copier le code Le code est le suivant :

function makeNoSense(x) {
ceci.x = x;
}
makeNoSense(5);
x;// x est devenu une variable globale de valeur 5

Pour les fonctions internes, c'est-à-dire les fonctions déclarées dans un autre corps de fonction, cette méthode de liaison à l'objet global posera un autre problème. Nous prenons toujours l'objet point mentionné précédemment comme exemple. Cette fois, nous espérons définir deux fonctions dans la méthode moveTo pour traduire respectivement les coordonnées x et y. Le résultat peut être inattendu. Non seulement l’objet ponctuel ne bouge pas, mais il existe deux autres variables globales x et y.

Copier le code Le code est le suivant :

varpoint = {
x : 0,
y : 0,
moveTo : function(x, y) {
// Fonction interne
var moveX = fonction(x) {
This.x = x;//Où est-ce lié ?
};
// Fonction interne
var moveY = fonction(y) {
This.y = y;//Où est-ce lié ?
};

déplacerX(x);
déplacerY(y);
}
};
point.moveTo(1, 1);
point.x; //==>0
point.y; //==>0
x; //==>1
y; //==>1

Il s'agit d'un défaut de conception en JavaScript. La méthode de conception correcte est que celle-ci de la fonction interne doit être liée à l'objet correspondant à sa fonction externe. Afin d'éviter ce défaut de conception, les programmeurs JavaScript intelligents ont proposé une substitution de variable. . Méthode, par convention, la variable est généralement nommée ainsi.

Copier le code Le code est le suivant :

varpoint = {
x : 0,
y : 0,
moveTo : function(x, y) {
var ça = ceci
// Fonction interne
var moveX = fonction(x) {
Cela.x = x;
};
// Fonction interne
var moveY = fonction(y) {
C'est.y = y;
}  
DéplacerX(x);
DéplacerY(y);
}  
};
point.moveTo(1, 1);
point.x; //==>1
point.y; //==>1

Appeler en tant que constructeur

JavaScript prend en charge la programmation orientée objet. Contrairement aux langages de programmation orientés objet traditionnels, JavaScript n'a pas le concept de classes, mais utilise l'héritage basé sur des prototypes. En conséquence, le constructeur en JavaScript est également très spécial s'il n'est pas appelé avec new, c'est la même chose qu'une fonction ordinaire. Autre convention, les constructeurs commencent par une lettre majuscule pour rappeler aux appelants de les appeler de la bonne manière. S'il est appelé correctement, ceci est lié à l'objet nouvellement créé.

Copier le code Le code est le suivant :

fonction Point(x, y){
Ceci.x = x;
Ceci.y = y;
}

Utilisez postuler ou appeler pour appeler

Rappelons encore qu'en JavaScript, les fonctions sont aussi des objets, et les objets ont des méthodes apply et call sont des méthodes d'objets fonction. Ces deux méthodes sont extrêmement puissantes. Elles permettent de changer le contexte dans lequel la fonction est exécutée, c'est-à-dire l'objet auquel elle est liée. De nombreuses techniques et bibliothèques en JavaScript utilisent cette méthode. Regardons un exemple concret :

Copier le code Le code est le suivant :

fonction Point(x, y){
Ceci.x = x;
Ceci.y = y;
This.moveTo = function(x, y){
Ceci.x = x;
Ceci.y = y;
}
>

var p1 = nouveau Point(0, 0);
var p2 = {x : 0, y : 0} ;
p1.moveTo(1, 1);
p1.moveTo.apply(p2, [10, 10]);

Dans l'exemple ci-dessus, nous utilisons le constructeur pour générer un objet p1, qui a également une méthode moveTo ; nous utilisons des littéraux d'objet pour créer un autre objet p2, et nous voyons que l'utilisation de apply peut appliquer la méthode de p1 à p2 sur , cette fois, c'est également lié à l'objet p2. Un autre appel de méthode a également la même fonction, mais la différence est que le dernier paramètre n'est pas transmis uniformément sous forme de tableau, mais séparément.

Copier le code Le code est le suivant :

fonction Foo(){
//1.Le constructeur référencé par this est l'objet référencé par argument.callee
//La description est le constructeur exécuté via l'opérateur new
if(this.constructor==arguments.callee){
alert('Objet créé');
>
//2.c'est une fenêtre, alors c'est un appel global
si(this==fenêtre){
alert('appel normal');
>
else{//3. Sinon, il est appelé comme méthode d'autres objets
alert('appelé par ' this.constructor);
>
>
Foo();//Appel de fonction global
Foo.call(new Object());//Appeler en tant que méthode membre d'un objet objet
new Foo();//Appelé par le nouvel opérateur pour effectuer la construction d'un objet