¿Por qué este objeto no se pasa por referencia al asignarle algo más?

Question

sé que en JS, los objetos se pasan por referencia, por ejemplo:

function test(obj) { 
    obj.name = 'new name'; 
} 

var my_obj = { name: 'foo' }; 
test(my_obj); 
alert(my_obj.name); // new name 

Pero ¿por qué no el siguiente trabajo:

function test(obj) { 
    obj = {}; 
} 

var my_obj = { name: 'foo' }; 
test(my_obj); 
alert(my_obj.name); // foo 

que han establecido el objeto a {} (vacío) pero todavía dice foo.

¿Alguien puede explicar la lógica detrás de esto?

Answer 1

Si está familiarizado con los punteros, esa es una analogía que puede tomar. De hecho, está pasando un puntero, por lo que obj.someProperty haría referencia a esa propiedad y, de hecho, anulará eso, mientras que simplemente anular obj matará al puntero y no sobrescribirá el objeto.

Answer 2

Porque JavaScript pasa objetos por pass-by-copia -reference.

Cuando se pasa my_obj en su función test, una copia de una referencia a ese objeto se pasa en. Como resultado, cuando se vuelva a asignar el objeto en test, estás realmente sólo re-asignación de una copia de una referencia al objeto original; su my_obj original permanece sin cambios.

Answer 3

Porque está sobreescribiendo la referencia, no el objeto.

// Create a new object and assign a reference to it 
// to the variable my_obj 
var my_obj = { name: 'foo' }; 

// Pass the reference to the test function 
test(my_obj); 

// Assign the reference to a variable called obj 
// (since that is the first argument) 
function test(obj) { 
// Create a new (empty) object and assign a reference to it to obj 
// This replaces the existing REFERENCE 
    obj = {}; 
} 
// my_obj still has a reference to the original object, 
// because my_obj wasn't overwritten 
alert(my_obj.name); // foo 

Answer 4

Javascript carece de soporte para pasar por referencia (aunque los objetos se pasan por referencia y la referencia se mantiene siempre que no se sobreescrito con asignación por ejemplo. Usando =), pero se puede imitar ref palabra clave de C# utilizando la siguiente técnica:

function test(obj) { 
    obj.Value = {}; 
    //obj.Value = {name:"changed"}; 
} 

var my_obj = { name: 'foo' }; 

(function() 
{ 
    my_obj = {Value: my_obj}; 
    var $return = test(my_obj); 
    my_obj = my_obj.Value; 
    return $return; 
}).call(this); 

alert(my_obj.name); // undefined, as expected 
        // In the question this returns "foo" because 
        // assignment causes dereference 

por supuesto, puede utilizar variables globales y la función de llamada sin argumentos, en cuyo caso las referencias no se pierden de esta manera:

var obj = { name: 'foo' }; 
function test() { 
    obj = {}; 
} 
test(); 
alert(obj.name); // undefined 

Si usted tiene todo el código en el cierre, entonces las cosas son más simples y por encima como variables globales no contamina espacio de nombres global:

(function(){ 
    var obj = { name: 'foo' }; 
    function test() { 
     obj = {}; 
    } 
    test(); 
    alert(obj.name); // undefined 
}).call(this); 

Las variables globales "en el interior de cierre" por encima -technique es agradable si tiene al puerto Javascript algún código de C# que tiene ref argumentos. P.ej. El siguiente código C#:

void MainLoop() 
{ 
    // ... 
    MyStruct pt1 = CreateMyStruct(1); 
    MyStruct pt2 = CreateMyStruct(2); 
    SwapPoints(ref pt1, ref pt2); 
    // ... 
} 
void SwapPoints(ref MyStruct pt1, ref MyStruct pt2) 
{ 
    MyStruct tmp = pt1; 
    pt1 = pt2; 
    pt2 = tmp; 
} 

podría ser portado a Javascript usando algo como:

(function(){ 
    var pt1, pt2; 
    function CreateMyStruct(myvar) 
    { 
     return {"myvar":myvar} 
    } 
    function MainLoop() 
    { 
     // ... 
     pt1 = CreateMyStruct(1); 
     pt2 = CreateMyStruct(2); 
     console.log("ORIG:",pt1,pt2); 
     SwapPoints(); 
     console.log("SWAPPED:",pt1,pt2); 
     // ... 
    } 
    function SwapPoints() 
    { 
     var tmp = pt1; 
     pt1 = pt2; 
     pt2 = tmp; 
    } 
    MainLoop(); 

}).call(this); 

o si es imprescindible el uso de variables y parámetros de una función local, entonces la solución se puede basar en el primer ejemplo de mi respuesta como esta:

(function(){ 
    function CreateMyStruct(myvar) 
    { 
     return {"myvar":myvar} 
    } 
    function MainLoop() 
    { 
     // ... 
     var pt1 = CreateMyStruct(1); 
     var pt2 = CreateMyStruct(2); 
     console.log("ORIG:",pt1,pt2); 

     (function() 
     { 
     pt1 = {Value: pt1}; 
     pt2 = {Value: pt2}; 
     var $return = SwapPoints(pt1, pt2); 
     pt1 = pt1.Value; 
     pt2 = pt2.Value; 
     return $return; 
     }).call(this); 

     console.log("SWAPPED:",pt1,pt2); 
     // ... 
    } 
    function SwapPoints(pt1, pt2) 
    { 
     var tmp = pt1.Value; 
     pt1.Value = pt2.Value; 
     pt2.Value = tmp; 
    } 
    MainLoop(); 
}).call(this); 

realmente tiene que decir que carece de Javascript mucho cuando se tiene no es nativo ref! El código sería mucho más simple.