Dans Javascritp, ce n'est pas nécessairement le seul contexte de la méthode d'objet. Ceci est également mentionné dans les appels de fonction globaux et plusieurs autres contextes différents.
Il peut s'agir d'un objet global, d'un objet actuel ou de n'importe quel objet, en fonction entièrement de la façon dont la fonction est appelée. Il existe plusieurs façons d'appeler des fonctions dans JavaScript: comme les appels de la méthode d'objet, comme appelle les appels, comme appels de constructeur, et l'utilisation d'appels d'application ou d'appel.
1. Appelez la méthode d'objet
Dans JavaScript, les fonctions sont également des objets, donc les fonctions peuvent être utilisées comme attributs d'un objet. À l'heure actuelle, la fonction est appelée méthode de l'objet. Lorsque vous utilisez cette méthode d'appel, cela est naturellement lié à l'objet.
La copie de code est la suivante:
var point = {
x: 0,
Y: 0,
MOVETO: fonction (x, y) {
this.x = this.x + x;
this.y = this.y + y;
}
};
Point.moveto (1, 1) // Ceci se lie à l'objet actuel, c'est-à-dire l'objet Point
2. En fonction d'un appel
La fonction peut également être appelée directement, et cela est lié à l'objet global. Dans le navigateur, Window est l'objet global. Par exemple, l'exemple suivant: Lorsqu'une fonction est appelée, ceci est lié à l'objet global, et l'instruction d'affectation est exécutée ensuite, ce qui équivaut à déclarer implicitement une variable globale, ce qui n'est évidemment pas ce que l'appelant veut.
La copie de code est la suivante:
fonction MakenoSense (x) {
this.x = x;
}
Makenosense (5);
x; // x est devenu une variable globale avec une valeur de 5
Pour les fonctions internes, c'est-à-dire que les fonctions déclarées dans le corps d'une autre fonction, cette façon de se lier à un objet global créera un autre problème. Nous continuerons à utiliser l'objet Point mentionné précédemment comme exemple. Cette fois, nous espérons définir deux fonctions dans la méthode MoveTo et traduire respectivement les coordonnées x et y. Le résultat peut être inattendu. Non seulement l'objet Point ne bouge pas, mais il existe deux variables globales supplémentaires x et y.
La copie de code est la suivante:
var point = {
x: 0,
Y: 0,
MOVETO: fonction (x, y) {
// fonctions internes
var movex = fonction (x) {
This.x = x; // où est-ce lié?
};
// fonctions internes
var movey = fonction (y) {
this.y = y; // où est-ce lié?
};
movex (x);
Movey (y);
}
};
point.moveto (1, 1);
Point.x; // ==> 0
point.y; // ==> 0
x; // ==> 1
y; // ==> 1
Ceci est un défaut de conception de JavaScript. La méthode de conception correcte est que celle de la fonction interne doit être liée à l'objet correspondant à sa fonction extérieure. Afin d'éviter ce défaut de conception, le programmeur JavaScript intelligent a proposé une méthode pour remplacer les variables, qui est conventionnellement nommée cela.
La copie de code est la suivante:
var point = {
x: 0,
Y: 0,
MOVETO: fonction (x, y) {
var that = this;
// fonctions internes
var movex = fonction (x) {
that.x = x;
};
// fonctions internes
var movey = fonction (y) {
que.y = y;
}
movex (x);
Movey (y);
}
};
point.moveto (1, 1);
Point.x; // ==> 1
point.y; // ==> 1
Appelé constructeur
JavaScript prend en charge la programmation orientée objet. Contrairement aux langages de programmation orientés objet grand public, JavaScript n'a pas le concept de classe, mais utilise une méthode d'héritage basée sur un prototype. En conséquence, les constructeurs de JavaScript sont également très spéciaux. Si vous n'utilisez pas de nouveaux appels, c'est la même chose que les fonctions ordinaires. En tant qu'une autre règle conventionnelle, le constructeur commence par des majuscules pour rappeler à l'appelant d'appeler de la bonne manière. Si l'appel est correct, cela est lié à l'objet nouvellement créé.
La copie de code est la suivante:
Point de fonction (x, y) {
this.x = x;
this.y = y;
}
Appelé à l'aide d'appliquer ou d'appeler
Réitérons que dans les fonctions JavaScript sont également des objets, les objets ont des méthodes et appliquer et les appels sont des méthodes d'objets de fonction. Ces deux méthodes sont extrêmement puissantes et permettent de changer le contexte de l'exécution de la fonction, c'est-à-dire l'objet lié à cela. Cette méthode est utilisée dans de nombreuses techniques JavaScript et bibliothèques de classe. Regardons un exemple spécifique:
La copie de code est la suivante:
Point de fonction (x, y) {
this.x = x;
this.y = y;
this.moveto = fonction (x, y) {
this.x = x;
this.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; Utilisez l'objet littéral pour créer un autre objet P2, et nous voyons que l'utilisation d'appliquer, la méthode de P1 peut être appliquée à P2, et cela est également lié à l'objet P2. Un autre appel de méthode a également la même fonction, la différence est que le dernier paramètre n'est pas passé en uniforme en tant que tableau, mais qu'il est passé séparément.
La copie de code est la suivante:
fonction foo () {
//1. Ce constructeur référencé est un objet référencé par Argument.Callee
// Les instructions sont des constructeurs exécutés via le nouvel opérateur
if (this.constructor == arguments.callee) {
alert ('objet créé');
}
//2.C'est une fenêtre, alors c'est un appel global
if (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 globale
Foo.call (nouvel objet ()); // appelle une méthode membre d'un objet objet
Nouveau foo (); // appelé par le nouvel opérateur pour exécuter la construction d'objets