Explication détaillée des exemples d'utilisation de la méthode statique object.extend en Javascript

Puisqu'il s'agit d'une classe, il existe des classes abstraites, des classes concrètes et des héritages de classes. En même temps, les membres d'une classe peuvent avoir des membres d'instance et des membres statiques.

Regardez d'abord le code suivant dans le prototype :

var Abstract = new Object(); 
Object.extend = function(destination, source) { 
for (property in source) { 
destination[property] = source[property]; 
} 
return destination; 
} 
Object.prototype.extend = function(object) { 
return Object.extend.apply(this, [this, object]); 
}

Le premier déclare un objet Abstract. L'objet est en fait une fonction. Il n'a donc aucun membre. c'est une classe vide, donc Abstract n'a aucun membre. N’en parlons pas pour l’instant. Nous verrons plus tard que c’est la base des classes abstraites. Expliquons d'abord la syntaxe suivante :

function.member=function(){}

Dans ce cas, la fonction a généralement été définie. La fonction de cette instruction est d'ajouter un membre statique à la fonction. C'est après le signe égal. Par exemple, le deuxième code ci-dessus, Object.extend=..., ajoute une extension de méthode statique à la classe Object. ok, nous savons comment définir des membres statiques pour une classe, alors vous devez vouloir savoir comment définir des membres d'instance. C'est très simple, ajoutez un prototype entre le nom de la classe et le nom du membre :

function.prototype.member=function(){}

.

Le prototype peut non seulement être utilisé comme ceci, mais aussi :

function.prototype={ 
member1:function(){……}, 
member2:"abc", 
member3:function(){……} 
}

C'est ainsi que la définition des membres de l'instance est implémentée. Mais que signifie prototype ? Dans le premier article, j'ai dit qu'il était directement entouré de {} pour représenter un objet. Par exemple, Prototype et Class sont des objets globaux définis de cette manière. En regardant l'utilisation suivante, le prototype est suivi d'une structure {}. Est-ce aussi un objet ? Oui, c’est vrai, le prototype est en réalité un objet ! En JavaScript, on peut ajouter arbitrairement des membres à un objet, en utilisant la syntaxe suivante :
object.member=function(){...};
Tant qu'il est défini de cette manière, un objet peut immédiatement avoir des membres. Cette méthode! JavaScript est tellement magique !
D'accord, nous savons maintenant que le prototype est un objet et que la fonction est une fonction ou une classe, nous pouvons alors considérer le prototype comme un membre statique retenu en interne par n'importe quelle classe (fonction). Sa fonction est de stocker tous les pointeurs membres de cette classe, mais ces membres ne sont que des prototypes et n'ont pas été initialisés, ce qui est également conforme au sens original de prototype. Vous pouvez étendre les membres à tout moment via l'objet prototype. Lors de la création d'une classe, les membres du prototype sont initialisés puis affectés à l'objet instancié.
Le troisième morceau de code ci-dessus, Object.prototype.extend=..., ajoute une extension de méthode d'instance à Object. Dans la méthode d'instance, vous pouvez référencer ce pointeur, qui pointe vers l'objet lui-même instancié par cette classe. Bien entendu, cet objet a une extension de membre.
Avant de continuer, veuillez comprendre deux phrases :

for(var p in object){} 
method.apply(object,arguments);

La première phrase : Liste tous les membres d'une variable, si c'est une fonction, puis tous les membres statiques si c'est un objet ; , c'est-à-dire tous les membres de l'instance, le type de p est une chaîne. Indique le nom du membre. Non seulement vous pouvez utiliser variabel.member pour référencer un membre, vous pouvez également utiliser variabel["member"]. Il en va de même pour l’affectation. Cela apporte une grande commodité à l’énumération des membres d’une variable.
La deuxième instruction : appliquez la méthode à l'objet pour l'exécution, et le paramètre est le tableau d'arguments. Remarque : la méthode n'est pas membre de l'objet. Cependant, on peut penser que l'exécution de cette instruction signifie : object.method(arguments). Il s’agit d’une méthode très importante qui sera fréquemment utilisée par la suite et avec laquelle vous vous familiariserez progressivement.
Continuons avec extend. C'est une méthode très importante. Vous pouvez voir que c'est à la fois un membre statique et un membre d'instance de la classe Object. Jetons un coup d'oeil : il reçoit deux paramètres, destination et source. Si destination et source sont toutes deux des classes, alors sa fonction est de copier tous les membres statiques de la classe source vers la classe destination. Si la destination et la source sont toutes deux des objets, alors tous les membres de l'instance. sont copiés. À ce moment-là, s'il existe déjà un membre portant le même nom dans la destination, ce membre sera écrasé. C'est-à-dire que destination ait tous les membres de source, et la fonction renvoie cette destination. Regardons extend en tant que membre d'instance d'Object :

Object.prototype.extend = function(object) { 
return Object.extend.apply(this, [this, object]); 
}

Je suis un peu étourdi au début, mais ne vous inquiétez pas, vous pouvez toujours la comprendre. La syntaxe d'application vient d'être terminée. expliqué, et son appelant est une méthode, et Object.extend est une méthode statique, qui est appliquée à this, qui est une instance de Object, en supposant qu'il s'agit d'un obj. Les crochets suivants sont un tableau comprenant deux membres, this et. objet. Ce tableau est en fait le paramètre arguments de l’extension du membre statique Object. Ensuite, cette instruction équivaut à exécuter
obj.extend(this, object);
this n'est pas expliqué, il se représente. Qu'est-ce qu'un objet ? Les paramètres, eh bien, ce sont des paramètres passés par la méthode d'instance extend, ne vous y trompez pas. Et si on prolongeait ? obj ne définit pas le membre de l'instance extend, mais via apply, il peut utiliser le membre statique extend de Object. Jetons un coup d'œil au corps de la fonction extend :

.

Object.extend = function(destination, source) { 
for (property in source) { 
destination[property] = source[property]; 
} 
return destination; 
}

因为obj是对象，object也是对象，即destination和source都是对象，于是函数的作用就是使obj具有object的所有成员。并且会返回obj。听起来有点拗口，但逻辑很简单：让obj“继承于”object！很好，我们看到了继承，但你肯定会问，对象的继承，第一次听说啊，我们讲继承都是讲的类的继承。没错，现在的确还没有看到真正的类继承，但已经近在眼前了：类不就是有个prototype吗，而prototype是对象！
好，想到这一点，类的继承语法看似很简单了：

b.prototype.extend(a.prototype);

让b继承a。
可是事实却没那么简单：prototype是存放方法原型指针，extend方法没有初始化，不能使用！要使用extend，就必须实例化一个对象。还是看看prototype是怎么做的吧：

b.prototype=(new a()).extend(b.prototype);

很高明的办法！充分说明了函数其实也是一个变量的道理。先实例化a对象，然后在它基础上调用extend，将所有的成员b.prototype的成员覆盖到a的对象，然后把这个a对象再赋值给b.prototype。完成了b从a继承的工作。在实际使用中，一般的用法都是：

b.prototype=(new a()).extend({});

因为让一个b继承自a，通常b之前都是一个未定义的类，所以后面的{}中其实就可以定义类成员。当然，你也可以先定义，再继承，只是和传统概念有所区别了。 

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!