¿Por qué el operador de asignación devuelve un valor y no una referencia?

Question

Vi el ejemplo a continuación explicado en este site y pensé que ambas respuestas serían 20 y no las 10 que se devuelven. Escribió que tanto la coma como la asignación devuelven un valor, no una referencia. No entiendo muy bien lo que eso significa.

Lo entiendo en relación con pasar variables a funciones o métodos, es decir, los tipos primitivos se pasan por valor y objetos por referencia, pero no estoy seguro de cómo se aplica en este caso.

También entiendo el contexto y el valor de 'esto' (después de la ayuda de stackoverflow) pero pensé que en ambos casos seguiría invocando como método, foo.bar() lo que significaría que foo es el contexto pero parece que ambos dan como resultado una función llamada barra().

¿Por qué es eso y qué significa todo esto?

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

No tiene que ver con los valores frente a las referencias, tiene que ver con los valores this (a medida que se sospecha). En JavaScript, this se establece por completo por cómo se llama una función, no donde se define. Establece el valor this en una de tres maneras:

1. Llame a la función a través de una propiedad de objeto usando la notación de acceso de propiedad, ya sea separada por puntos (obj.foo()) o notación entre corchetes (obj["foo"]()).
2. Llame a la función a través de una propiedad de objeto utilizando una sentencia with (en realidad una variante del # 1, pero vale la pena llamar a cabo por separado, especialmente en lo que no es obvio a partir del código fuente)
3. Uso los apply o call características de la instancia de función.

En los ejemplos anteriores, usted no está haciendo ninguna de ellas, por lo que terminan llamando a la función con el valor por defecto this, el objeto global, y así x proviene de allí más que de su objeto foo. Aquí hay otra manera de pensar acerca de lo que el código está haciendo:

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

Si no utilizan directamente una propiedad para hacer realidad la llamada (en lugar de recuperar el valor de la propiedad y luego hacer la llamada con ese), el manejo this no entra en acción.

Answer 2

Lo está entendiendo mal.

Ambos ejemplos devuelven window 's x propiedad, ya que no se invocan directamente en foo.

El valor de la palabra clave this dentro de una función depende del contexto en el que se llamó a la función.

En una llamada a función normal (por ejemplo, myFunc()), this será el objeto global, que generalmente es window.
En una llamada a un método de objeto (por ejemplo, foo.bar()), this será el objeto sobre el que se invocó la función. (en este caso, foo)

Puede establecer el contexto explícitamente llamando al myFunc.call(context, arg1, arg2) o myFunc.apply(context, argArray).

Ambos ejemplos son invocaciones normales de una expresión que evalúa a foo.bar.
Por lo tanto, this es el window.

Ellos son equivalentes a

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

Answer 3

Debe comprender cómo funciona el Reference Type interno.

_{Nota: Este no es un tipo de datos de idioma, es un mecanismo interno para manejar las referencias.}

Una referencia se compone de dos elementos, el objeto base de y un nombre propiedad.

En su ejemplo, la referencia foo.bar tiene este aspecto.

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

Tanto el comma operator y una simple assignment, se basan en conseguir el valor del nombre de la propiedad, que hace que el objeto base que se ha perdido, ya que se devuelve un solo valor (esto se hace a través de la operación interna GetValue) .

Esta es la forma en que funciona el GetValue funcionamiento 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]; 

Como se ve, un valor se devuelve, por lo que se pierde la referencia original.

Editar: La clave para entender por qué (foo.bar = foo.bar)(); no es equivalente a foo.bar(); se basa en el Simple Assignment operador, vamos a ver el 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). 

Básicamente cuando usted hace (foo.bar = foo.bar) la asignación real (Paso 4.) no tiene ningún efecto porque PutValue solo obtendrá el valor de la referencia y lo colocará de nuevo, con el mismo objeto base.

La clave es que los rendimientos operador de asignación (Paso 5) el valor obtenido en la Paso 3 y como he dicho antes en la pseudo-código GetValue, este método interno devuelve un valorque doesn' t realmente tiene un objeto base .

Answer 4

Puede ser útil pensar que el operador punto se comporta de manera similar a una instrucción with.Cuando se ejecuta foo.bar(), el resultado es el mismo que si se ejecutó:

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

Esto ejecutará su función bar con foo superpuesta en la parte superior del objeto global, lo que le permite encontrar el x en foo y por lo tanto el retorno 20.

Si usted no llama bar de inmediato, sin embargo, como en (foo.bar = foo.bar), en su lugar se obtiene:

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

El resultado se pasa del paréntesis, produciendo una instrucción intermedia como <reference to bar>(), que no tiene operador de punto, por lo que no hay instrucción with, por lo que no hay acceso a foo, solo al valor global de x.

(El operador punto no lo hace realidad convertido a una declaración with, por supuesto, pero el comportamiento es similar.)