Warum tun diese snippets von JavaScript Verhalten sich anders, obwohl Sie beide einen Fehler?

JS:

var a = {}
var b = {}

try{
  a.x.y = b.e = 1 //Uncaught TypeError: Cannot set property 'y' of undefined
} catch(err) {
  console.error(err);
}
console.log(b.e) //1

JS:

var a = {}
var b = {}

try {
  a.x.y.z = b.e = 1 //Uncaught TypeError: Cannot read property 'y' of undefined
} catch(err) {
  console.error(err);
}

console.log(b.e) //undefined

Ich verstehe es nicht. Es gibt keine syntax-Fehler; ich würde also davon ausgehen, dass b.z = 1 und b.e = 1 zuerst ausgeführt (gegebenen rechts-Assoziativität auf =), dann a.x.y.z = ... führen und scheitern; warum b Zuordnung pass in einem Fall und im anderen nicht?
Wir sind damit einverstanden, dass das Eigentum y existiert nicht auf a.x; aber das gilt in beiden Fällen. Warum muss es verhindern, dass der right-hand-side-Zuordnung im zweiten Fall aber nicht der erste? Was ist anders in der Reihenfolge der Ausführung? (Ich erwähnte Syntax-error, da das timing auf der syntax-Fehler ist sehr Verschieden von der ein runtime error.)
nach dem ausführen von code erhalten Sie Fehler, und als Verwendung als Typ-variable name wieder zu sehen Wert
Fand diese beschreiben, wie Javascript gehen Zuweisungsoperator ecma-international.org/ecma-262/5.1/#sec-11.13
Was denkst du, was der Unterschied ist? Haben Sie versucht, auf Grund dieses heraus, bevor Sie Fragen? Was hat Ihre Forschung auftauchen? In anderen Worten, haben Sie Ihre Hausaufgaben machen, bevor Sie Fragen?
Es ist interessant, aus einer theoretischen Perspektive, aber das fällt definitiv unter die "dies ist der Grund, warum Sie nicht den code schreiben, wie, dass" die Kategorie des unerwarteten Verhalten.

InformationsquelleAutor Kevin Askin | 2019-02-12

151

Eigentlich, wenn du die Fehlermeldung Lesen richtig, Fall 1 und Fall 2 werfen unterschiedliche Fehler.

Fall a.x.y:

Nicht set Eigenschaft 'y' undefined

Fall a.x.y.z:

Nicht Lesen Eigenschaft 'y' undefined

Ich denke, es ist am besten, um es zu beschreiben von Schritt-für-Schritt-Ausführung in einfachem Englisch.

Fall 1

JS:

//1. Declare variable `a`
//2. Define variable `a` as {}
var a = {}

//1. Declare variable `b`
//2. Define variable `b` as {}
var b = {}

try {

  /**
   *  1. Read `a`, gets {}
   *  2. Read `a.x`, gets undefined
   *  3. Read `b`, gets {}
   *  4. Set `b.z` to 1, returns 1
   *  5. Set `a.x.y` to return value of `b.z = 1`
   *  6. Throws "Cannot **set** property 'y' of undefined"
   */
  a.x.y = b.z = 1
  
} catch(e){
  console.error(e.message)
} finally {
  console.log(b.z)
}

Fall 2

JS:

//1. Declare variable `a`
//2. Define variable `a` as {}
var a = {}

//1. Declare variable `b`
//2. Define variable `b` as {}
var b = {}

try {

  /**
   *  1. Read `a`, gets {}
   *  2. Read `a.x`, gets undefined
   *  3. Read `a.x.y`, throws "Cannot **read** property 'y' of undefined".
   */
  a.x.y.z = b.z = 1
  
} catch(e){
  console.error(e.message)
} finally {
  console.log(b.z)
}

In den Kommentaren, Solomon Tam gefunden diese ECMA-Dokumentation über die Zuordnung Betrieb.

InformationsquelleAutor Yong Quan

56

Wird die Reihenfolge der Vorgänge wird deutlicher, wenn man Sie nutzen den Komma-operator innerhalb Klammer-notation, um zu sehen, welche Teile ausgeführt werden, wenn:

JS:
```
var a = {}
var b = {}

try{
 //Uncaught TypeError: Cannot set property 'y' of undefined
  a
    [console.log('x'), 'x']
    [console.log('y'), 'y']
    = (console.log('right hand side'), b.e = 1);
} catch(err) {
  console.error(err);
}
console.log(b.e) //1
```
JS:
```
var a = {}
var b = {}

try {
  //Uncaught TypeError: Cannot read property 'y' of undefined
  a
    [console.log('x'), 'x']
    [console.log('y'), 'y']
    [console.log('z'), 'z']
    = (console.log('right hand side'), b.e = 1);
} catch(err) {
  console.error(err);
}

console.log(b.e) //undefined
```
Blick auf die spec:
Die Produktion AssignmentExpression : LeftHandSideExpression = AssignmentExpression wird wie folgt bewertet:
1. Lassen lref werden das Ergebnis der Auswertung LeftHandSideExpression.
2. Lassen rref sein, das Ergebnis der Auswertung AssignmentExpression.
3. Lassen rval werden GetValue(rref).
4. Werfen eine SyntaxError-exception aus, wenn... (irrelevant)
5. Call PutValue(lref, rval).
PutValue ist, was wirft die TypeError:
1. Lassen O sein ToObject(base).
2. Wenn das Ergebnis des Aufrufs der [[CanPut]] interne Methode von O, mit dem argument P ist falsch, dann
  
  ein. Wenn Werfen, wahr ist, dann werfen Sie einen TypeError-Ausnahme.
Nichts zugewiesen werden kann, eine Eigenschaft von undefined - die [[CanPut]] interne Methode der undefined immer wieder false.

In anderen Worten: der interpreter parst die linke Seite, dann analysiert der rechten Seite, dann wirft einen Fehler, wenn die Eigenschaft auf der linken Seite kann nichts zugewiesen werden.

Wenn Sie
```
a.x.y = b.e = 1
```
Der linken Seite ist erfolgreich analysiert bis PutValue genannt wird; die Tatsache, dass die .x - Eigenschaft ausgewertet wird undefined ist nicht berücksichtigt, bis die Rechte Seite geparst wird. Der Dolmetscher sieht es als "Weisen Sie einen Wert für die Eigenschaft "y" undefined", und die Zuweisung an eine Eigenschaft von undefined nur wirft innerhalb PutValue.

Im Gegensatz:
```
a.x.y.z = b.e = 1
```
Den interpreter wird nie zu dem Punkt, wo es versucht zu ordnen, um die z Eigenschaft, weil Sie zuerst lösen müssen a.x.y auf einen Wert. Wenn a.x.y aufgelöst Wert (auch zu undefined), wäre es OK - würde ein Fehler geworfen werden innerhalb PutValue wie oben. Aber Zugriff auf a.x.y wirft einen Fehler, weil Eigentum y kann nicht zugegriffen werden auf undefined.
- Schön, Komma-operator trick--nie gedacht, dass es auf diese Weise benutzen (nur zum debugging, natürlich)!
- s/analysieren/bewerten/
InformationsquelleAutor CertainPerformance
3

Betrachten Sie den folgenden code:

JS:
```
var a = {};
a.x.y = console.log("evaluating right hand side"), 1;
```
Die grobe Gliederung der Schritte, die erforderlich sind, um den code auszuführen, ist wie folgt ^ref:
1. Auswerten der linken Seite. Zwei Dinge zu beachten:
  - Auswerten eines Ausdrucks ist nicht das gleiche wie der Wert von Ausdruck.
  - Bewertung eines property-accessor ^ref z.B. a.x.y gibt einen Verweis ^ref, bestehend aus Basis Wert a.x (undefiniert) und referenzierten Namen (y).
2. Auswerten der rechten Seite.
3. Um den Wert des Ergebnisses in Schritt 2 abgerufen.
4. Setzen Sie den Wert der Referenz, die in Schritt 1 auf den Wert in Schritt 3 d.h. Eigenschaft y undefined dem Wert. Dies soll zu werfen, eine TypeError-Ausnahme ^ref.
InformationsquelleAutor Salman A

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.