Eine kurze Diskussion dazu in Javascript

Was ist das in js? Zu dieser Sache gibt es im Blog-Park zu viele Erklärungen. Nach dem Lesen finde ich die Erklärung jedoch etwas kompliziert, daher werde ich eine einfache und leicht verständliche Definition geben.

Dies ist tatsächlich ein Objekt von js. Was ist das für ein Objekt? Es ist ganz einfach. Dieses Objekt ist: Wer es ruft, zeigt auf denjenigen, der es ruft.

Zu diesem Punkt haben die Artikel im Blog Park tatsächlich schon viel erklärt, und einige Artikel kommen auch auf den Punkt. Allerdings sind ihre Erklärungen hier noch etwas vage Ich werde es Ihnen anhand der Ergebnisse einiger einfacher kontrollierter Experimente erklären.

Ich hoffe, Sie können das Experiment unten basierend auf meinem Code wiederholen.

Schauen wir uns zunächst den folgenden Code an:

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

Was wird der obige Code ausgeben? Ja, die Warnung hier ist ... Xiaodong ... Es ist sehr einfach, dies innerhalb des Objekts a zu nennen. Es muss das Objekt a sein, das dies aufruft Definition・・・・・・・・・・・, dann zeigt dies hier auf das a-Objekt.

Als nächstes fügen wir dem obigen Code eine weitere Zeile hinzu:

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

Gemäß den obigen experimentellen Ergebnissen wissen wir, dass direkt aufgerufen wird a Die Ausgabe von .getName ist Xiaodong, oder? Was wird also ausgegeben, wenn wir out erneut aufrufen, nachdem wir der Out-Variablen die Attributfunktion a.getName zugewiesen haben? Das Ergebnis ist: undefiniert. Warum ist es undefiniert? Bitte denken Sie einen Moment darüber nach. Wenn Sie verstehen, warum die Ausgabe hier undefiniert ist, dann haben Sie meiner Meinung nach ein klares Verständnis davon. Wenn Sie jedoch an diesem Artikel interessiert sind, können Sie trotzdem weiterlesen.

Hier werde ich nicht erklären, warum die getName-Funktion, die sich auf ein Objekt außerhalb von bezieht, den Wert innerhalb eines Objekts nicht abrufen kann. Schauen wir uns bitte das an Folgender Code (Tatsächlich ist er fast derselbe wie der obige Code, haha):

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

Der obige Code ist sehr einfach, oder? , wir befinden uns nicht in der getName-Attributfunktion des a-Objekts. Sie gibt das Objekt a statt ・・・1・・ zurück. Wenn Sie also in diesem Moment die Out-Funktion erneut aufrufen, was wird Ihrer Meinung nach ausgegeben? Das ist richtig, was Sie erhalten, ist nicht mehr ... undefiniert ..., sondern eine reelle Zahl ... 1 ... Das ist seltsam, nicht wahr? Wenn die Funktion a.getName das Benutzerattribut im a-Objekt zurückgibt, erhalten wir ein undefiniertes Ergebnis, wenn wir out verwenden, um auf die Funktion a.getName zu verweisen, und wenn die Funktion a.getName 1 zurückgibt, verwenden wir Can out reference the a.getName-Funktion, aber den Inhalt von a.getName abrufen? Was ist los?

Der Grund ist ganz einfach: Wenn wir die externe globale Variable out aufrufen, verweist dies auf das Objekt, das out sein sollte, und nicht auf das a-Objekt, und wer ist das Objekt von out? Wir sollten wissen, dass das Objekt der von js global deklarierten Variablen Fensterobjekt ist. Da dies beim Aufruf auf window verweist, sollten wir window.user für this.user in die Funktion out=a.getName=function(){return this.user;} schreiben, oder? Aber gibt es in diesem Moment einen Attributwert von window.user in der globalen Variablen? NEIN? Da es keinen Attributwert von window.user gibt, muss unsere Warnung (window.user) undefiniert sein. Um dies zu beweisen, führen wir das folgende Experiment durch:

//创建一个局部对象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());

Wenn Sie in diesem Moment den obigen Code erneut ausführen, werden Sie feststellen, dass die Out-Funktion funktioniert Die Ausgabe ist nicht mehr undefiniert, sondern der Benutzername des Fensters. Was beweist das? Es beweist, dass, wenn out dies aufruft, dies auf das Fenster verweist. Es beweist auch, dass dies auf denjenigen verweist, der es aufruft.

Wenn Sie die globalen Variablen von js nicht verstehen, können wir den obigen Code durch den folgenden Code ersetzen und dann aufrufen, und Sie werden es besser verstehen:

//创建一个局部对象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());

Hier aktivieren wir das Fensterobjekt nicht mehr, sondern verwenden immer var, um sie zu deklarieren. Da sie alle mit var deklariert sind, sollten sie alle auf dasselbe verweisen Objekt. Wenn Sie zu diesem Zeitpunkt den obigen Code erneut ausführen, dh die Out-Funktion ausführen, können Sie weiterhin den Benutzernamen des Fensters benachrichtigen. An diesem Punkt des Schreibens kann die Definition nicht klarer sein: Wer es nennt, zeigt auf jeden, der es nennt.

Das ist nicht schwer zu verstehen, aber nur wenn man das Objekt findet, das es aufruft, kann man das Ende erkennen zu, denn: Die Definition davon lautet: Wer es nennt, zeigt darauf.

Das obige ist der detaillierte Inhalt vonEine kurze Diskussion dazu in Javascript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!