Perché l'operatore di assegnazione restituisce un valore e non un riferimento?

Question

Ho visto l'esempio di seguito spiegato su questo site e ho pensato che entrambe le risposte sarebbero 20 e non il 10 che viene restituito. Ha scritto che sia la virgola che l'assegnazione restituiscono un valore, non un riferimento. Non capisco cosa significhi.

Lo capisco in relazione al passaggio di variabili in funzioni o metodi in cui i tipi primitivi vengono passati per valore e oggetti per riferimento, ma non sono sicuro di come si applica in questo caso.

Capisco anche il contesto e il valore di "this" (dopo l'aiuto di stackoverflow) ma ho pensato che in entrambi i casi lo avrei ancora invocato come metodo, foo.bar() che vorrebbe dire foo è il contesto ma sembra che entrambi risultino in una funzione call bar().

Perché è questo e cosa significa tutto questo?

var x = 10; 
var foo = { 
    x: 20, 
    bar: function() {return this.x;} 
}; 

(foo.bar = foo.bar)();//returns 10 
(foo.bar, foo.bar)();//returns 10 

Answer 1

Non ha a che fare con i valori vs. riferimenti, ha a che fare con i valori this (come si sospetta). In JavaScript, this è impostato interamente in base a come viene chiamata una funzione, non dove è definita. Si imposta il valore this in uno dei tre modi:

1. Chiamare la funzione tramite proprietà di un oggetto utilizzando la proprietà di accesso notazione, sia notazione con punti (obj.foo()) o la notazione tra parentesi (obj["foo"]()).
2. Chiamare la funzione tramite proprietà di un oggetto utilizzando un with dichiarazione (in realtà solo una variante di # 1, ma vale la pena chiamare separatamente, in particolare in quanto non è evidente dal codice sorgente)
3. Utilizzare i apply o call caratteristiche del istanza di funzione.

Nei tuoi esempi di cui sopra, non stai facendo una di queste, così si finisce per chiamare la funzione con il valore predefinito this, l'oggetto globale, e così x viene da lì piuttosto che dal vostro foo oggetto. Ecco un altro modo di pensare a quello che il codice sta facendo:

var f = foo.bar; // Not calling it, getting a reference to it 
f();    // Calls the function with `this` referencing the global object 

Se non si utilizza direttamente una proprietà di fare effettivamente la chiamata (invece recuperare il valore della proprietà e quindi effettuare la chiamata con quella), la gestione di this non dà il via.

Answer 2

Lo stai fraintendendo.

Entrambi gli esempi stanno tornando x proprietà s' il window, dal momento che non vengono direttamente invocati su foo.

Il valore della parola chiave this all'interno di una funzione dipende dal contesto in cui è stata richiamata la funzione.

In una normale chiamata di funzione (ad esempio, myFunc()), this sarà l'oggetto globale, che di solito è window.
In una chiamata al metodo oggetto (ad esempio, foo.bar()), this sarà l'oggetto su cui è stata richiamata la funzione. (in questo caso, foo)

È possibile impostare il contesto in modo esplicito chiamando myFunc.call(context, arg1, arg2) o myFunc.apply(context, argArray).

Entrambi gli esempi sono invocazioni normali di un'espressione che restituisce foo.bar.
Pertanto, this è il window.

sono equivalenti a

var func = (some expression); 
func(); 

Answer 3

Dovresti capire come funziona l'interno Reference Type.

_{Nota: Questo non è un tipo di dati di lingua, è un meccanismo interno per gestire i riferimenti.}

Un riferimento è composto da due elementi, l'oggetto di base e un nome struttura.

Nell'esempio, il riferimento foo.bar si presenta così.

// pseudo-code 
foo.bar = { 
    baseObject: foo, 
    propertyName: 'bar' 
} 

Sia la comma operator e simple assignment, si basano su come ottenere il valore del nome della proprietà, che causa l'oggetto base da perdere, poiché un singolo valore viene restituito (questo avviene attraverso il GetValue funzionamento interno) .

Questo è come funziona il GetValue funzionamento interno:

// pseudo-code 
GetValue(V) : 
    if (Type(V) != Reference) return V; 

    baseObject = GetBase(V); // in your example foo 
    if (baseObject === null) throw ReferenceError; 

    return baseObject.[[Get]](GetPropertyName(V)); 
    // equivalent to baseObject[v.PropertyName]; 

Come si vede, un valoreviene restituito, così si perde il riferimento originale.

Edit: la chiave per comprendere il motivo per cui (foo.bar = foo.bar)(); non è equivalente alla foo.bar(); si basa nel Simple Assignment operatore, vediamo l'algoritmo:

 
11.13.1 Simple Assignment (`=`) 
The production `AssignmentExpression` : 
       `LeftHandSideExpression` = `AssignmentExpression` 

is evaluated as follows: 

1. Evaluate LeftHandSideExpression. 

2. Evaluate AssignmentExpression. 

3.Call GetValue(Result(2)). 

4.Call PutValue(Result(1), Result(3)). 

5.Return Result(3). 

In pratica quando si effettua (foo.bar = foo.bar) l'assegnazione effettiva (Fase 4.) non ha effetto perché PutValue otterrà solo il valore del riferimento e lo riposizionerà, con lo stesso oggetto base.

La chiave è che l'operatore di assegnazione restituisce (Fase 5) il valore ottenuto nella Passaggio 3 e come detto prima in pseudo-codice GetValue, questo metodo interno restituisce un valoreche doesn' t avere un oggetto di base.

Answer 4

Può essere utile pensare all'operatore punto come comportandosi in modo simile a un'istruzione with.Quando si esegue foo.bar(), il risultato è più o meno lo stesso come se è stato eseguito:

with (foo) { 
    bar(); // returns 20 
} 

Questo farà eseguire la funzione bar con foo sovrapposto sopra l'oggetto globale, permettendo così di trovare il x in foo e quindi di ritorno 20.

Se non si chiama bar immediatamente, anche se, come in (foo.bar = foo.bar), voi invece ottiene:

with (foo) { 
    bar; // returns "bar" itself 
} 

Il risultato è quindi passato fuori dalle parentesi, producendo una istruzione intermedia come <reference to bar>(), che non ha un operatore punto, quindi nessuna istruzione with, quindi nessun accesso a foo, solo al valore globale di x.

(L'operatore punto non lo fa in realtà convertito ad una dichiarazione with, naturalmente, ma il comportamento è simile.)