Une brève discussion à ce sujet en javascript

Qu'est-ce que c'est en js ? Concernant cette chose, il y a trop d'explications dans le parc des blogs. Cependant, après l'avoir lu, j'ai l'impression que l'explication est un peu compliquée, donc je vais en donner une définition simple et facile à comprendre.

c'est en fait un objet de js. Quant à de quel objet il s'agit ? C'est très simple, Cet objet est : celui qui l'appelle désigne celui qui l'appelle.

Sur ce point, en effet, les articles du Blog Park ont ​​déjà beaucoup expliqué, et certains articles sont également allés à l'essentiel cependant, leurs explications sont encore un peu vagues. Je vais vous l'expliquer sur la base des résultats de quelques expériences contrôlées simples, tout le monde devrait être très clair.

J'espère que vous pourrez répéter l'expérience ci-dessous en fonction de mon code.

Tout d'abord, examinons le code suivant :

//创建一个局部对象a
var a = {
 user:'小东',
 getName:function(){
  return this.user;//返回当前对象的user属性值
 }
}
//调用a的getName方法
alert(a.getName());

Que produira le code ci-dessus ? Oui, l'alerte ici est... Xiaodong... C'est très simple. Cela s'appelle ceci à l'intérieur de l'objet a. Ce doit être l'objet qui appelle ceci, donc selon...・・Celui qui appelle cela pointera vers le. définition・・・・・・・・・・・, alors ceci pointe ici vers un objet.

Ensuite, nous ajoutons une autre ligne au code ci-dessus :

//创建一个局部对象a
var a = {
 user:'小东',
 getName:function(){
  return this.user;//返回当前对象的user属性值
 }
}
//调用a的getName方法
alert(a.getName());
//把局部对象的属性函数赋值给外面的变量out
var out = a.getName;
//调用out函数
alert(out());

D'après les résultats expérimentaux ci-dessus, nous savons que l'appel direct a La sortie de .getName est Xiaodong, n'est-ce pas ? Ainsi, après avoir attribué la fonction d'attribut a.getName à la variable out, que sera le résultat lorsque nous appellerons à nouveau ? Le résultat est : indéfini. Pourquoi n'est-il pas défini ? S'il vous plaît, réfléchissez-y un instant. Si vous comprenez pourquoi le résultat ici n'est pas défini, alors je pense que vous le comprenez clairement. Cependant, si cet article vous intéresse, vous pouvez toujours continuer à lire.

Ici, je n'expliquerai pas pourquoi la fonction getName qui fait référence à un objet à l'extérieur de ne peut pas obtenir la valeur à l'intérieur d'un objet. Parlons-en de manière détournée. code suivant (En fait, il est similaire au code ci-dessus, haha) :

//创建一个局部对象a
var a = {
 user:'小东',
 getName:function(){
 return 1;//这里我们不返回this，而是返回1
}
}
//调用a的getName方法
alert(a.getName());
//把局部对象的属性函数赋值给外面的变量out
var out = a.getName;
//调用out函数
alert(out());

Le code ci-dessus est très simple, non ? ne sont pas dans la fonction d'attribut getName de l'objet a. Il renvoie l'objet a au lieu de ・・・1・・・・ Donc, si vous appelez à nouveau la fonction out à ce moment, que pensez-vous qui sera affiché ? C'est vrai, ce que vous obtenez n'est plus... indéfini・・・・, mais un nombre réel・・・・1・・・・・. C'est bizarre, n'est-ce pas ? Lorsque la fonction a.getName renvoie l'attribut utilisateur dans l'objet a, lorsque nous utilisons out pour faire référence à la fonction a.getName, nous obtenons un résultat non défini, et lorsque la fonction a.getName renvoie 1, nous utilisons alors la référence Can out la fonction a.getName mais obtenir le contenu de a.getName ? Que se passe-t-il?

La raison est très simple. Lorsque nous appelons la variable globale externe, cela pointe vers l'objet qui devrait être sorti, pas l'objet a, et qui est l'objet de out ? Il faut savoir que l'objet de la variable déclarée par js globalement est un objet fenêtre. Puisque lors de l'appel, cela pointe vers window, alors nous devrions écrire window.user pour this.user dans function out=a.getName=function(){return this.user;}, n'est-ce pas ? Mais à ce moment, y a-t-il une valeur d'attribut window.user dans la variable globale ? Non? Puisqu'il n'y a pas de valeur d'attribut de window.user, alors notre alerte (window.user) doit être indéfinie. Pour le prouver, faisons l'expérience suivante :

//创建一个局部对象a
var a = {
 user:'小东',
 getName:function(){
  return this.user;//返回当前对象的user属性值
 }
}
//调用a的getName方法
alert(a.getName());
//把局部对象的属性函数赋值给外面的变量out
var out = a.getName;
//我们增加一个window.user的全局属性，看看再次调用out函数会输出什么
var window.user='window"s username';
//调用out函数
alert(out());

À ce moment, lorsque vous exécutez à nouveau le code ci-dessus, vous constaterez que la fonction out La sortie n'est plus indéfinie, mais le nom d'utilisateur de la fenêtre. Qu'est-ce que cela prouve ? Cela prouve que lorsque out appelle ceci, cela pointe vers la fenêtre. Cela prouve également que cela pointe vers celui qui l'appelle.

Si vous ne comprenez pas les variables globales de js, alors nous pouvons remplacer le code ci-dessus par le code suivant puis appeler, et vous comprendrez mieux :

//创建一个局部对象a
var a = {
 user:'小东',
 getName:function(){
  return this.user;//返回当前对象的user属性值
 }
}
//调用a的getName方法
alert(a.getName());
//把局部对象的属性函数赋值给外面的变量out
var out = a.getName;
//此刻，我们增加一个user的变量，看看再次调用out函数会输出什么
var user='window"s username';
//调用out函数
alert(out());

Ici, nous n'activons plus l'objet window. Pour les propriétés et fonctions externes, nous utilisons toujours var pour les déclarer Puisqu'elles sont toutes déclarées avec var, elles doivent toutes pointer vers la même. objet. ? À ce moment, si vous exécutez à nouveau le code ci-dessus, c'est-à-dire exécutez la fonction out, vous pouvez toujours alerter le nom d'utilisateur de la fenêtre. À ce stade de la rédaction, la définition de ceci est on ne peut plus claire : celui qui l’appelle désigne celui qui l’appelle.

Ce n'est pas difficile à comprendre. Ce qui est difficile à comprendre, c'est que vous devez trouver l'objet qui l'appelle. Ce n'est que lorsque vous trouvez l'objet qui l'appelle que vous pouvez connaître la fin de cela. à, parce que : la définition de ceci est : celui qui l'appelle le désigne.

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!