在JavaScript中向函数传递参数类似于传递参数（按C中的指针值）：

/*
The following C program demonstrates how arguments
to JavaScript functions are passed in a way analogous
to pass-by-pointer-value in C. The original JavaScript
test case by @Shog9 follows with the translation of
the code into C. This should make things clear to
those transitioning from C to JavaScript.

function changeStuff(num, obj1, obj2)
{
    num = num * 10;
    obj1.item = "changed";
    obj2 = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};
changeStuff(num, obj1, obj2);
console.log(num);
console.log(obj1.item);    
console.log(obj2.item);

This produces the output:

10
changed
unchanged
*/

#include <stdio.h>
#include <stdlib.h>

struct obj {
    char *item;
};

void changeStuff(int *num, struct obj *obj1, struct obj *obj2)
{
    // make pointer point to a new memory location
    // holding the new integer value
    int *old_num = num;
    num = malloc(sizeof(int));
    *num = *old_num * 10;
    // make property of structure pointed to by pointer
    // point to the new value
    obj1->item = "changed";
    // make pointer point to a new memory location
    // holding the new structure value
    obj2 = malloc(sizeof(struct obj));
    obj2->item = "changed";
    free(num); // end of scope
    free(obj2); // end of scope
}

int num = 10;
struct obj obj1 = { "unchanged" };
struct obj obj2 = { "unchanged" };

int main()
{
    // pass pointers by value: the pointers
    // will be copied into the argument list
    // of the called function and the copied
    // pointers will point to the same values
    // as the original pointers
    changeStuff(&num, &obj1, &obj2);
    printf("%d\n", num);
    puts(obj1.item);
    puts(obj2.item);
    return 0;
}

我的两分钱。。。这是我理解它的方式。（如果我错了，请随时纠正我）

是时候抛弃你所知道的关于传递值/引用的一切了。

因为在JavaScript中，它是通过值传递还是通过引用传递都不重要。重要的是变异与传递给函数的参数赋值。

好吧，让我尽力解释一下我的意思。假设您有几个对象。

var object1 = {};
var object2 = {};

我们所做的是“任务”。。。我们为变量“object1”和“object2”分配了两个单独的空对象。

现在，假设我们更喜欢对象1。。。因此，我们“分配”一个新变量。

var favoriteObject = object1;

接下来，无论出于什么原因，我们决定更喜欢对象2。所以，我们做了一点重新分配。

favoriteObject = object2;

对象1或对象2未发生任何情况。我们根本没有改变任何数据。我们所做的只是重新分配我们最喜欢的对象。重要的是要知道object2和favoriteObject都分配给了同一个对象。我们可以通过这些变量中的任何一个来改变这个对象。

object2.name = 'Fred';
console.log(favoriteObject.name) // Logs Fred
favoriteObject.name = 'Joe';
console.log(object2.name); // Logs Joe

好了，现在让我们看一下像字符串这样的原语

var string1 = 'Hello world';
var string2 = 'Goodbye world';

再次，我们选择一个最喜欢的。

var favoriteString = string1;

我们的favoriteString和string1变量都分配给“Helloworld”。现在，如果我们想更改我们的收藏夹字符串？？？会发生什么？？？

favoriteString = 'Hello everyone';
console.log(favoriteString); // Logs 'Hello everyone'
console.log(string1); // Logs 'Hello world'

噢。。。。发生了什么。我们无法通过更改收藏夹字符串来更改字符串1。。。为什么？因为我们没有更改字符串对象。我们所做的只是将favoriteString变量“RE ASSIGN”为一个新字符串。这实际上将其与字符串1断开。在前面的示例中，当我们重命名对象时，我们没有分配任何内容。（好吧，不是变量本身，……但是，我们确实将name属性分配给了一个新字符串。）相反，我们对保持2个变量和基础对象之间连接的对象进行了变异。（即使我们想修改或变异字符串对象本身，我们也不能这样做，因为字符串在JavaScript中实际上是不可变的。）

现在，转到函数和传递参数。。。。当你调用一个函数并传递一个参数时，你所做的基本上是对一个新变量的“赋值”，它的工作方式与你使用等号（=）赋值的方式完全相同。

举这些例子。

var myString = 'hello';

// Assign to a new variable (just like when you pass to a function)
var param1 = myString;
param1 = 'world'; // Re assignment

console.log(myString); // Logs 'hello'
console.log(param1);   // Logs 'world'

现在，同样的事情，但有一个函数

function myFunc(param1) {
    param1 = 'world';

    console.log(param1);   // Logs 'world'
}

var myString = 'hello';
// Calls myFunc and assigns param1 to myString just like param1 = myString
myFunc(myString);

console.log(myString); // logs 'hello'

好的，现在让我们举几个使用对象的例子。。。首先，没有函数。

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Assign to a new variable (just like when you pass to a function)
var otherObj = myObject;

// Let's mutate our object
otherObj.firstName = 'Sue'; // I guess Joe decided to be a girl

console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Sue'

// Now, let's reassign the variable
otherObj = {
    firstName: 'Jack',
    lastName: 'Frost'
};

// Now, otherObj and myObject are assigned to 2 very different objects
// And mutating one object has no influence on the other
console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Jack';

现在，同样的事情，但有一个函数调用

function myFunc(otherObj) {

    // Let's mutate our object
    otherObj.firstName = 'Sue';
    console.log(otherObj.firstName); // Logs 'Sue'

    // Now let's re-assign
    otherObj = {
        firstName: 'Jack',
        lastName: 'Frost'
    };
    console.log(otherObj.firstName); // Logs 'Jack'

    // Again, otherObj and myObject are assigned to 2 very different objects
    // And mutating one object doesn't magically mutate the other
}

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Calls myFunc and assigns otherObj to myObject just like otherObj = myObject
myFunc(myObject);

console.log(myObject.firstName); // Logs 'Sue', just like before

好的，如果你通读了这篇文章，也许你现在对JavaScript中函数调用的工作方式有了更好的理解。不管什么是通过引用还是通过值传递。。。重要的是赋值与变异。

每次将变量传递给函数时，都会“赋值”参数变量的名称，就像使用等号（=）一样。

始终记住等号（=）表示赋值。始终记住，在JavaScript中向函数传递参数也意味着赋值。它们是相同的，并且这两个变量以完全相同的方式连接（也就是说它们不是，除非你认为它们被分配给了同一个对象）。

“修改变量”影响不同变量的唯一时间是基础对象发生变化时（在这种情况下，您没有修改变量，而是修改对象本身）。

区分对象和基元是没有意义的，因为它的工作方式与没有函数的情况完全相同，只是使用等号分配给一个新变量。

唯一的错误是当传递到函数中的变量的名称与函数参数的名称相同时。当发生这种情况时，您必须将函数内的参数视为该函数专用的一个全新变量（因为它是）

function myFunc(myString) {
    // myString is private and does not affect the outer variable
    myString = 'hello';
}

var myString = 'test';
myString = myString; // Does nothing, myString is still 'test';

myFunc(myString);
console.log(myString); // Logs 'test'

我已经多次阅读了这些答案，但直到我了解了Barbara Liskov所称的“通过共享呼叫”的技术定义，我才真正理解

通过共享调用的语义与通过引用调用的语义不同，因为对函数内函数参数的赋值对调用方不可见（与引用语义不同）[需要引用]，因此例如，如果传递了变量，则无法在调用方的范围内模拟对该变量的赋值。然而，由于函数可以访问与调用方相同的对象（不进行复制），因此如果对象是可变的，则调用方可以看到函数中这些对象的突变，这可能与逐值调用语义不同。调用方可以看到函数中可变对象的变体，因为该对象未被复制或克隆，而是共享的。

也就是说，如果您访问参数值本身，参数引用是可变的。另一方面，对参数的赋值将在求值后消失，函数调用方无法访问。

这里有一些关于JavaScript中使用术语“通过引用传递”的讨论，但要回答您的问题：

对象通过引用自动传递，无需特别声明

（摘自上述文章。）

这些短语/概念最初是在JS创建之前很久定义的，它们没有准确描述javascript的语义。我认为尝试将它们应用于JS会导致更多的困惑。

所以不要被“通过引用/值传递”挂断。

考虑以下事项：

变量是指向值的指针。重新分配变量只会将指针指向新值。重新分配变量不会影响指向同一对象的其他变量，因为每个变量都有自己的指针。

所以如果我必须给它起个名字，我会说“passbypointer”——我们不处理JS中的指针，但底层引擎会处理。

// code
var obj = {
    name: 'Fred',
    num: 1
};

// illustration
               'Fred'
              /
             /
(obj) ---- {}
             \
              \
               1

// code
obj.name = 'George';


// illustration
                 'Fred'


(obj) ---- {} ----- 'George'
             \
              \
               1

// code
obj = {};

// illustration
                 'Fred'


(obj)      {} ----- 'George'
  |          \
  |           \
 { }            1

// code
var obj = {
    text: 'Hello world!'
};

/* function parameters get their own pointer to 
 * the arguments that are passed in, just like any other variable */
someFunc(obj);


// illustration
(caller scope)        (someFunc scope)
           \             /
            \           /
             \         /
              \       /
               \     /
                 { }
                  |
                  |
                  |
            'Hello world'

一些最终意见：

短语“传递值/引用”仅用于描述语言的行为，不一定是实际的底层实现。由于这种抽象，对于正确解释至关重要的关键细节丢失了，这不可避免地导致了当前的情况，在没有额外信息的情况下，单个术语无法充分描述实际行为。人们很容易认为原语是由特殊规则强制执行的，而对象不是，但原语只是指针链的末端。作为最后一个示例，请考虑为什么清除数组的常见尝试不能按预期工作。

变量a=[1，2]；变量b=a；a=[]；console.log（b）；//[1,2]//不起作用，因为“b”仍指向原始数组

字符串、数字等基本类型变量始终作为传递按价值计算。基于这两个条件，数组和对象作为引用传递或值传递。如果要使用新的Object或array更改该Object或array的值，则它将通过value传递。object1＝｛item:“car”｝；数组1=[1,2,3]；此处是将新对象或数组分配给旧对象或数组。您没有更改属性的值旧对象的。因此它是按值传递的。如果要更改对象或数组的属性值，则会通过引用传递。object1.key1=“汽车”；阵列1[0]=9；此处您正在更改旧对象的属性值。您没有将新对象或数组分配给旧对象或数组。因此它是通过引用传递的。

Code

    function passVar(object1, object2, number1) {

        object1.key1= "laptop";
        object2 = {
            key2: "computer"
        };
        number1 = number1 + 1;
    }

    var object1 = {
        key1: "car"
    };
    var object2 = {
        key2: "bike"
    };
    var number1 = 10;

    passVar(object1, object2, number1);
    console.log(object1.key1);
    console.log(object2.key2);
    console.log(number1);

Output: -
    laptop
    bike
    10