Javascript Pointer / Verrücktheit der Referenz. Kann jemand das erklären?

Javascript übergibt Objekte by reference. Das macht auch Sinn. Aber sobald Sie anfangen, die Manipulation dieser Objekte, alles wirkt in einer Weise, die scheinen unintuitiv. Lassen Sie mich ein Beispiel geben:

var a, b;

a = {}
b = a;
a['one'] = {};

console.log( JSON.stringify(a) );
//outputs: {"one":{}}

console.log( JSON.stringify(b) );
//outputs: {"one":{}}

Das ist ja alles schön und gut, weil jetzt b hat einen Zeiger auf a es ist also zu erwarten, dass die Zuordnung von Sachen zu a wird auch Auswirkungen auf b.

Aber dann, wenn ich dies tun:

a = a['one'];

console.log( JSON.stringify(a) );
//outputs: {}

console.log( JSON.stringify(b) );
//outputs: {"one":{}}

Dies ist für mich überraschend. Ich würde erwarten, dass a und b noch die gleichen (und werden {} seit a['one'] vorher festgelegt wurde, um {} und a war a['one']).

Aber das ist nicht der Fall. Es scheint, dass a verliert seine Referenz zu b wenn es zugeordnet ist, etwas neues, aber b behält den Wert, der a festgelegt wurde vor a verlieren Ihren Bezug zu b.

Aber dann, wenn ich dies tun:

a['two'] = 2;

console.log( JSON.stringify(a) );
//outputs: {"two":2}

console.log( JSON.stringify(b) );
//outputs: {"one":{"two":2}}

Was? a hat klar verloren Verweis auf b, aber b scheint, haben noch einige Verweis auf a.

Nicht das leere Objekt {} Punkt an eine andere Stelle im Speicher, so dass jede variable, die darauf verweisen, zeigt jetzt auf den gleichen Platz?

Kann jemand mit einem festen Griff auf das, erklär es mir?

Kommentar zu dem Problem - Öffnen

Siehe stackoverflow.com/questions/518000/... Kommentarautor: Crescent Fresh

"jetzt b ist ein Zeiger auf a" ist, wo die Unwahrheit beginnt. "jetzt b Punkte auf derselben Stelle wie a" ist der fix. Kommentarautor:

"Javascript übergibt Objekte per Referenz" - Nein, das geht nicht. Es geht durch den Wert aber in dem Fall von Objekten, die übergebene Wert ist eine Referenz auf das Objekt und keine Kopie des Objekts selbst. Dies ist eine wichtige Unterscheidung. Es macht nicht wirklich Sinn machen, darüber reden, die "Weitergabe" von Werten oder Referenzen, wenn Sie reden nicht über die Parameter der Funktion, aber trotzdem: wenn es per Referenz übergeben, dann könnte man ändern, was für ein Objekt die ursprünglichen Variablen a zeigt an, indem Sie das verändert, was die zweite variable b zeigt auf - was Sie definitiv nicht tun (ob in einer Funktion oder nicht). Kommentarautor: nnnnnn

@Seth Carnegie: "Pass by reference" ist ein standard-nicht-Sprache-Programmierung, Begriff, der eine Reihe von Sprachen unterstützt, ohne dass der Programmierer Zeiger, aber JavaScript tut dies nicht. Was Sie gesagt haben, richtig ist: "passing a reference by value" ist, was passiert mit JavaScript-Objekten. Ich entschuldige mich, dass ich es nicht geschafft zu sagen, dass zuvor. Ich denke, wir haben im Kreise herum durch die Terminologie, sorry. Kommentarautor: nnnnnn

Danke @nnnnnn das macht eine Menge von Terminologie-Fragen, die ich hatte. Kommentarautor: Philip Walton

InformationsquelleAutor der Frage Philip Walton | 2011-11-29

194

Folgenden deinem Beispiel Zeile für Zeile:
```
a = {}
```
a jetzt verweist das neue Objekt.
```
b = a;
```
b jetzt verweist auf das gleiche Objekt, dass a Referenzen. Beachten Sie, dass es nicht auf a.
```
a['one'] = {};
```
Das neue Objekt hat nun einen index 'one', das auf ein anderes neues Objekt.

Wenn Sie
```
a = a['one'];
```
Sind Sie a zu finden a['one'], die das neue Objekt, das Sie erstellt, wenn Sie haben a['one'] = {}. b noch Referenzen das Objekt, das Sie erstellt mit a = {}.

Du verwechselst das Problem, wenn Sie sagen "a verloren hat, seine Referenz zu b", weil a bezieht sich nicht auf b , noch Umgekehrt. a und b siehe Objekte, und Sie können gemacht werden, um beziehen sich auf andere Objekte. Wie diese:

Mit a = {}; b = a erhalten Sie
```
a
 \
  \
   { }
  /
 /
b
```
Dann mit a['one'] = {} erhalten Sie
```
a
 \
  \
   { one: { } }
  /
 /
b
```
Dann mit a = a['one'] erhalten Sie
```
a - - - - 
          \
   { one: { } }
  /
 /
b
```
InformationsquelleAutor der Antwort Seth Carnegie

😛 Du bist Abstieg in die knitty gritty details und ich bin froh, dass Sie gefragt, wie Sie wird klüger sein, bis Ende.

Schauen Sie nicht in Bezug auf die Zeiger, da ich denke, dass ist immer, wo Sie verwirrt. Denke, dass es eher in Bezug auf den heap (oder einfach nur "Speicher", wenn man so will) und die symbol-Tabelle.

Können beginnen, indem Sie die ersten paar Zeilen von deinem code:

var a, b;

a = {}
b = a;

Was Sie getan haben, ist hier ein Objekt auf dem heap, und zwei Symbole auf das symbol Tabelle. Es sieht wie folgt aus:

Symbol Tabelle:

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|      a |        0x400000 |
+--------+-----------------+
|      b |        0x400000 |
+--------+-----------------+

Heap:

+----------+-----------------+
| Location | Value           |
+----------+-----------------+
| 0x400000 | <object val 1>  |
+----------+-----------------+

Hier ist, wo die Dinge interessant: Objekte haben Ihre eigenen "symbol-Tabellen" (in der Regel sind diese nur hash-Tabellen, aber nannte es ein symbol-Tabelle kann deutlicher machen).

Nun, nach deiner nächsten Anweisung, haben Sie 3 Dinge zu berücksichtigen: Die Globale Symboltabelle <object val 1>'s symbol-Tabelle und der heap.

Ausführen die folgende Zeile ein:

a['one'] = {}

Und Dinge die nun wie folgt Aussehen:

Globalen Symboltabelle:

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|      a |        0x400000 |
+--------+-----------------+
|      b |        0x400000 |
+--------+-----------------+

<object val 1>'s Symbol-Tabelle

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|    one |        0x400004 |
+--------+-----------------+

Heap:

+----------+-----------------+
| Location | Value           |
+----------+-----------------+
| 0x400000 | <object val 1>  |
+----------+-----------------+
| 0x400004 | <object val 2>  |     <---we created a new object on the heap
+----------+-----------------+

Nun lief man den folgenden code:

a = a['one'];

Diese sollte hoffentlich scheint eine triviale änderung. Das Ergebnis ist:

Globalen Symboltabelle:

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|      a |        0x400004 |
+--------+-----------------+
|      b |        0x400000 |
+--------+-----------------+

<object val 1>'s Symbol-Tabelle

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|    one |        0x400004 |
+--------+-----------------+

Heap:

+----------+-----------------+
| Location | Value           |
+----------+-----------------+
| 0x400000 | <object val 1>  |
+----------+-----------------+
| 0x400004 | <object val 2>  | 
+----------+-----------------+

Folgenden Speicherplatz auf dem heap sollte hoffentlich klar machen, warum du die Ausgabe, die du hast.

Nun werden die Dinge sogar noch interessanter, weil Sie jetzt tun:

a['two'] = 2;

Ok, so lassen Sie uns dies Schritt für Schritt.

a Punkte auf Speicherbereich 0x400004 enthält <object val 2>
<object val 2> ist ein leeres Objekt, also dessen symbol-Tabelle beginnt leer
Durch ausführen dieser Zeile fügen wir die variable 'zwei' zu <object val 2>'s symbol-Tabelle.

Wenn Sie nicht müde der Blick auf diese Diagramme noch nicht, werden Sie. Dinge, die nun wie folgt Aussehen:

Globalen Symboltabelle:

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|      a |        0x400004 |
+--------+-----------------+
|      b |        0x400000 |
+--------+-----------------+

<object val 1>'s Symbol-Tabelle

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|    one |        0x400004 |
+--------+-----------------+

<object val 2>'s Symbol-Tabelle

+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
|    two |        0x400008 |
+--------+-----------------+

Heap:

+----------+-----------------+
| Location | Value           |
+----------+-----------------+
| 0x400000 | <object val 1>  |
+----------+-----------------+
| 0x400004 | <object val 2>  | 
+----------+-----------------+
| 0x400008 | 2 (literal val) |    <-- yes, even integers are stored on the heap
+----------+-----------------+        in JavaScript.

Wenn Ihr fleißig die Zeit zu nehmen, befolgen Sie die memory locations, Sie werden sehen, dass Ihre browser angezeigt, die richtige Ausgabe.

InformationsquelleAutor der Antwort riwalk

8

Denke, dass der anonyme Objekt als sich selbst mit einem Namen:
```
a = {}; //The variable "a" now points to (holds) an anonymous object.
b = a; //"b" points to the same anonymous object held by "a".
a = 123; //"a" now holds some other value.
b; //"b" still holds the anonymous object.
```
Der Schlüssel ist, sich daran zu erinnern, dass Variablen, die Verweise auf Objekte, keine Referenzen auf andere Variablen. Und das selbe Objekt bezeichnet werden kann von einer beliebigen Anzahl von Variablen.

InformationsquelleAutor der Antwort maerics
6

Objekte in Javascript bestehen kann durch sich selbst ohne einen Namen. Zum Beispiel:
```
{}
```
wird eine neue Instanz des dictionary-Objekts.
```
a = {};
```
erstellt ein neues dictionary-Objekt und macht a beziehen. Jetzt
```
b = a;
```
macht b beziehen sich auf dasselbe zugrunde liegende Objekt. Sie können dann a Punkt woanders:
```
a = "hi";
```
sowie b noch Punkte, um den gleichen dictionary-Objekt vor. Das Verhalten von b ist nicht, wie Sie ändern, was a Punkte zu.

InformationsquelleAutor der Antwort Greg Hewgill
0

Soweit ich weiß ist Sie überschrieben eine also ich denke, die engine speichert es in einen anderen Speicherplatz, in der Erwägung, dass b noch auf die alte eine's Speicher-Adresse (die irgendwie nicht zerstört).

InformationsquelleAutor der Antwort R01010010

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.