JavaScript-Variablenobjekt Teil 2: VO in verschiedenen Ausführungskontexten

Variablenobjekte in verschiedenen Ausführungskontexten

Einige Vorgänge (z. B. Variableninitialisierung) und Verhaltensweisen von Variablenobjekten sind allen Arten von Ausführungskontexten gemeinsam. Aus dieser Perspektive ist es einfacher, variable Objekte als abstrakte Grunddinge zu verstehen. Zusätzliche Inhalte im Zusammenhang mit variablen Objekten werden ebenfalls im Funktionskontext definiert.

抽象变量对象VO (变量初始化过程的一般行为)
  ║
  ╠══> 全局上下文变量对象GlobalContextVO
  ║        (VO === this === global)
  ║
  ╚══> 函数上下文变量对象FunctionContextVO
           (VO === AO, 并且添加了<arguments>和<formal parameters>)

Lassen Sie uns einen genaueren Blick darauf werfen:

Variablenobjekte im globalen Kontext

Zuerst müssen wir dem globalen Objekt eine klare Definition geben:

Globales Objekt (Globalobjekt) ist ein Objekt, das erstellt wurde, bevor es in einen Ausführungskontext eintritt. Es gibt nur eine Kopie dieses Objekts und auf seine Eigenschaften kann überall im Programm zugegriffen werden. Der Lebenszyklus des globalen Objekts endet, sobald das Programm beendet wird.

In der anfänglichen Erstellungsphase des globalen Objekts werden Math, String, Date, parseInt als eigene Attribute verwendet und andere Attribute werden initialisiert. Es können auch andere zusätzlich erstellte Objekte als Attribute vorhanden sein (die zeigen können). zum globalen Objekt selbst). Beispielsweise kann im DOM die Fenstereigenschaft des globalen Objekts auf das globale Objekt selbst verweisen (natürlich sind nicht alle spezifischen Implementierungen so):

global = {
  Math: <...>,
  String: <...>
  ...
  ...
  window: global //引用自身
};

Es wird normalerweise beim Zugriff auf ignoriert Eigenschaften des globalen Objekts Entfernen Sie das Präfix, da auf globale Objekte nicht direkt über den Namen zugegriffen werden kann. Über diesen globalen Kontext können wir jedoch weiterhin auf das globale Objekt zugreifen und auch rekursiv auf sich selbst verweisen. Beispiel: Fenster im DOM. Zusammenfassend kann der Code wie folgt gekürzt werden:

String(10); // 就是global.String(10);
  
// 带有前缀
window.a = 10; // === global.window.a = 10 === global.a = 10;
this.b = 20; // global.b = 20;

Also zurück zum variablen Objekt im globalen Kontext – hier ist das variable Objekt das globale Objekt selbst:

VO(globalContext) === global;

Es ist sehr wichtig, die obige Schlussfolgerung zu verstehen. Basierend auf diesem Prinzip können wir nur dann indirekt über die Eigenschaften darauf zugreifen, wenn die Korrespondenz im globalen Kontext deklariert wird globales Objekt (z. B. ohne vorher den Variablennamen zu kennen).

var a = new String('test');
  
alert(a); // 直接访问，在VO(globalContext)里找到："test"
  
alert(window['a']); // 间接通过global访问：global === VO(globalContext): "test"
alert(a === this.a); // true
  
var aKey = 'a';
alert(window[aKey]); // 间接通过动态属性名称访问："test"

Variablenobjekte im Funktionskontext

Im Funktionsausführungskontext kann auf VO nicht direkt zugegriffen werden. Zu diesem Zeitpunkt spielt das Aktivierungsobjekt (abgekürzt als AO) die Rolle der VO-Rolle.

VO(functionContext) === AO;

Das aktive Objekt wird beim Betreten des Funktionskontexts erstellt und über das Arguments-Attribut der Funktion initialisiert. Der Wert des Arguments-Attributs ist das Arguments-Objekt:

AO = {
  arguments: <ArgO>
};

Das Arguments-Objekt ist ein Attribut des aktiven Objekts, das die folgenden Attribute enthält:

callee – eine Referenz auf das aktuelle Funktion

Länge – Die Anzahl der tatsächlich übergebenen Parameter

properties-indexes (Ganzzahl vom String-Typ) Der Wert der Eigenschaft ist der Parameterwert der Funktion (von links nach rechts angeordnet). Parameterliste). Die Anzahl der Elemente innerhalb von Properties-Indexes ist gleich arguments.length. Der Wert von Properties-Indexes wird mit den tatsächlich übergebenen Parametern geteilt.

Zum Beispiel:

function foo(x, y, z) {
  
  // 声明的函数参数数量arguments (x, y, z)
  alert(foo.length); // 3
  
  // 真正传进来的参数个数(only x, y)
  alert(arguments.length); // 2
  
  // 参数的callee是函数自身
  alert(arguments.callee === foo); // true
  
  // 参数共享
  alert(x === arguments[0]); // true
  alert(x); // 10
  
  arguments[0] = 20;
  alert(x); // 20
  
  x = 30;
  alert(arguments[0]); // 30
  
  // 不过，没有传进来的参数z，和参数的第3个索引值是不共享的
  z = 40;
  alert(arguments[2]); // undefined
  
  arguments[2] = 50;
  alert(z); // 40
}
  
foo(10, 20);

Der Code für dieses Beispiel weist einen Fehler in der aktuellen Version von Google Chrome auf – selbst wenn der Parameter z nicht übergeben wird, sind es z und arguments[2]. immer noch geteilt von.