像字符串和数字这样的基本类型变量总是按值传递。 数组和对象通过引用或基于以下条件的值传递:

如果你正在设置一个对象或数组的值，它是通过值传递。 Object1 = {prop: "car"}; Array1 = [1,2,3]; 如果你正在改变一个对象或数组的属性值，那么它是引用传递。 中的object1。道具= "汽车"; Array1 [0] = 9;

Code

函数passVar(obj1, obj2, num) { 其中obj1。道具= "笔记本电脑";//将改变原来的 Obj2 ={道具:"电脑"};//不影响原 Num = Num + 1;//不影响原 ｝ Var object1 = { 道具:“车” }; Var object2 = { 道具:“自行车” }; Var number1 = 10; passVar(object1, object2, number1); console.log(中的object1);//输出:对象{道具:"笔记本电脑"} console.log (object2);//输出:Object {prop: "bike"} console.log (number1);//输出:10

像字符串和数字这样的基本类型变量总是按值传递。 数组和对象通过引用或基于以下条件的值传递:

如果你正在设置一个对象或数组的值，它是通过值传递。 Object1 = {prop: "car"}; Array1 = [1,2,3]; 如果你正在改变一个对象或数组的属性值，那么它是引用传递。 中的object1。道具= "汽车"; Array1 [0] = 9;

Code

函数passVar(obj1, obj2, num) { 其中obj1。道具= "笔记本电脑";//将改变原来的 Obj2 ={道具:"电脑"};//不影响原 Num = Num + 1;//不影响原 ｝ Var object1 = { 道具:“车” }; Var object2 = { 道具:“自行车” }; Var number1 = 10; passVar(object1, object2, number1); console.log(中的object1);//输出:对象{道具:"笔记本电脑"} console.log (object2);//输出:Object {prop: "bike"} console.log (number1);//输出:10

JavaScript中没有“引用传递”。你可以传递一个对象(也就是说，你可以按值传递一个对象的引用)，然后让一个函数修改对象的内容:

function alterObject(obj) {
  obj.foo = "goodbye";
}

var myObj = { foo: "hello world" };

alterObject(myObj);

alert(myObj.foo); // "goodbye" instead of "hello world"

如果需要，可以使用数值索引遍历数组的属性，并修改数组的每个单元格。

var arr = [1, 2, 3];

for (var i = 0; i < arr.length; i++) { 
    arr[i] = arr[i] + 1; 
}

需要注意的是，“引用传递”是一个非常具体的术语。这并不仅仅意味着可以将引用传递给一个可修改的对象。相反，这意味着可以通过允许函数在调用上下文中修改该值的方式传递简单变量。所以:

 function swap(a, b) {
   var tmp = a;
   a = b;
   b = tmp; //assign tmp to b
 }

 var x = 1, y = 2;
 swap(x, y);

 alert("x is " + x + ", y is " + y); // "x is 1, y is 2"

在c++这样的语言中，这样做是可能的，因为该语言确实(在某种程度上)具有引用传递。

edit — this recently (March 2015) blew up on Reddit again over a blog post similar to mine mentioned below, though in this case about Java. It occurred to me while reading the back-and-forth in the Reddit comments that a big part of the confusion stems from the unfortunate collision involving the word "reference". The terminology "pass by reference" and "pass by value" predates the concept of having "objects" to work with in programming languages. It's really not about objects at all; it's about function parameters, and specifically how function parameters are "connected" (or not) to the calling environment. In particular, note that in a true pass-by-reference language — one that does involve objects — one would still have the ability to modify object contents, and it would look pretty much exactly like it does in JavaScript. However, one would also be able to modify the object reference in the calling environment, and that's the key thing that you can't do in JavaScript. A pass-by-reference language would pass not the reference itself, but a reference to the reference.

编辑-这里有一篇关于这个主题的博客文章。(注意那篇文章的注释，解释了c++并没有真正的引用传递。这是真的。然而，c++所拥有的是创建对普通变量的引用的能力，可以在函数调用时显式地创建指针，也可以在调用其参数类型签名要求这样做的函数时隐式地创建指针。这些都是JavaScript不支持的关键。)

我个人不喜欢各种编程语言提供的“引用传递”功能。也许这是因为我刚刚发现函数式编程的概念，但是当我看到函数会产生副作用(比如通过引用来操纵参数)时，我总是起鸡皮疙瘩。我个人强烈拥护“单一责任”原则。

恕我直言，函数应该使用return关键字只返回一个结果/值。我不修改参数/实参，而是返回修改后的参数/实参值，并将任何所需的重赋留给调用代码。

但有时(希望很少)，需要从同一个函数返回两个或多个结果值。在这种情况下，我会选择将所有这些结果值包含在单个结构或对象中。同样，处理任何重分配都应该由调用代码来决定。

例子:

假设通过在参数列表中使用'ref'这样的特殊关键字来支持传递参数。我的代码可能是这样的:

//The Function
function doSomething(ref value) {
    value = "Bar";
}

//The Calling Code
var value = "Foo";
doSomething(value);
console.log(value); //Bar

相反，我更喜欢这样做:

//The Function
function doSomething(value) {
    value = "Bar";
    return value;
}

//The Calling Code:
var value = "Foo";
value = doSomething(value); //Reassignment
console.log(value); //Bar

当我需要编写一个返回多个值的函数时，我也不会使用引用传递的参数。所以我会避免这样的代码:

//The Function
function doSomething(ref value) {
    value = "Bar";

    //Do other work
    var otherValue = "Something else";

    return otherValue;
}

//The Calling Code
var value = "Foo";
var otherValue = doSomething(value);
console.log(value); //Bar
console.log(otherValue); //Something else

相反，我实际上更喜欢在对象中返回两个新值，就像这样:

//The Function
function doSomething(value) {
    value = "Bar";

    //Do more work
    var otherValue = "Something else";

    return {
        value: value,
        otherValue: otherValue
    };
}

//The Calling Code:
var value = "Foo";
var result = doSomething(value);
value = result.value; //Reassignment
console.log(value); //Bar
console.log(result.otherValue);

这些代码示例非常简化，但它大致演示了我个人如何处理这些东西。它帮助我把各种责任放在正确的位置。

快乐的编码。：）

我完全明白你的意思。同样的事情在Swift中是没有问题的。底线是使用let，而不是var。

原语是按值传递的，但在迭代时var i的值没有复制到匿名函数中，这一点至少令人惊讶。

for (let i = 0; i < boxArray.length; i++) {
  boxArray[i].onclick = function() { console.log(i) }; // Correctly prints the index
}

由于我们没有javascript的引用传递功能，唯一的方法是让函数返回值，并让调用者分配它:

So

"makePretty(myArray[x]);"

应该是

"myArray[x] = makePretty(myArray[x]);"

这是在函数内部需要赋值的情况下，如果只需要突变，那么传递对象并突变它就足够了