为什么在向该对象分配其他内容时不通过引用传递该对象？

Question

我知道在 JS 中，对象是通过引用传递的，例如：

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

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

但是为什么下面的不起作用：

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

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

我已将对象设置为 {} （空），但它仍然显示 foo。

谁能解释一下这背后的逻辑吗？

Answer 1

如果您熟悉指针，您就可以进行类比。您实际上传递了一个指针，因此 obj.someProperty 会取消对该属性的引用并实际上覆盖它，而仅仅覆盖 obj 会杀死指针而不覆盖对象。

Answer 2

因为 JavaScript 实际上是通过复制引用传递对象的。

当您将 my_obj 传递到 test 函数时，会传入对该对象的引用的副本。因此，当您重新在 test 中分配对象，实际上只是重新分配对原始对象的引用的副本；您原来的 my_obj 保持不变。

Answer 3

因为您正在覆盖引用，而不是对象。

// 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 缺乏对按引用传递的支持（尽管对象是按引用传递的，并且只要不被赋值覆盖，引用就会被维护，例如使用 =），但是您可以模仿 ref<使用以下技术的 C# 的 /code> 关键字：

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

当然，您可以使用全局变量并调用不带参数的函数，在这种情况下，不会像这样错过引用：

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

如果您将所有代码都放在闭包中，那么事情会更简单，就像上面这样globals 不会污染全局命名空间：

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

如果您必须将一些带有 ref 参数的 C# 代码移植到 Javascript，那么上面的“闭包内的全局变量”技术就很好。例如。以下 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;
}

可以使用类似以下内容移植到 Javascript：

(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);

或者如果必须使用局部变量和函数参数，那么解决方案可以基于我的答案的第一个示例，如下所示：

(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);

真的不得不说 Javascript 缺乏很多它没有本机ref！代码会简单得多。