在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中，值的类型仅控制该值是由值副本分配还是由引用副本分配。

基本值始终由值副本分配/传递：

无效的未定义一串数字布尔型ES6中的符号

复合值始终由引用副本分配/传递

物体阵列作用

例如

var a = 2;
var b = a; // `b` is always a copy of the value in `a`
b++;
a; // 2
b; // 3

var c = [1,2,3];
var d = c; // `d` is a reference to the shared `[1,2,3]` value
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

在上面的代码段中，因为2是标量原语，所以a保存该值的一个初始副本，而b被分配了该值的另一个副本。更改b时，绝对不能更改a中的值。

但c和d都是对同一共享值[1，2]的单独引用，这是一个复合值。需要注意的是，c和d都没有“拥有”[1,2,3]值——两者都只是对该值的对等引用。因此，当使用任意一个引用来修改（.push（4））实际的共享数组值本身时，它只影响一个共享值，并且两个引用都将引用新修改的值[1,2,3,4]。

var a = [1,2,3];
var b = a;
a; // [1,2,3]
b; // [1,2,3]

// later
b = [4,5,6];
a; // [1,2,3]
b; // [4,5,6]

当我们赋值b=[4,5,6]时，我们没有做任何事情来影响a仍然引用的位置（[1,2,3]）。要做到这一点，b必须是指向a的指针，而不是对数组的引用——但JS中不存在这样的功能！

function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // later
    x = [4,5,6];
    x.push( 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [1,2,3,4]  not  [4,5,6,7]

当我们传入参数a时，它将一个引用的副本分配给x。x和a是指向相同[1,2,3]值的独立引用。现在，在函数内部，我们可以使用该引用来改变值本身（push（4））。但是当我们赋值x=[4,5,6]时，这不会影响初始引用a指向的位置——仍然指向（现在已修改）[1,2,3,4]值。

要有效地通过值副本传递复合值（如数组），需要手动复制它，这样传递的引用就不会指向原始值。例如：

foo( a.slice() );

可以通过引用副本传递的复合值（对象、数组等）

function foo(wrapper) {
    wrapper.a = 42;
}

var obj = {
    a: 2
};

foo( obj );

obj.a; // 42

这里，obj充当标量基元属性a的包装器。当传递给foo（..）时，将传入obj引用的副本，并将其设置为wrapper参数。我们现在可以使用包装器引用来访问共享对象，并更新其属性。函数完成后，obj.a将看到更新的值42。

来源

基本体通过值传递，对象通过引用传递。这与C、Visual Basic或Delphi等其他语言截然不同。我不能说它们如何准确地处理对象和原语，但我知道VisualBasic和Delphi可以（也应该）指定它们。

PHP在版本5之后做了类似的事情：所有对象都是通过引用传递的，但所有原语都可以通过引用传递，如果前面有一个与符号（&）。否则，基元按值传递。

所以在JavaScript中，如果我通过一个参数将一个对象X传递给一个函数，它仍然是X。如果你在函数（或任何其他对象，但这并不重要）内部更改数据，那么新值也可以在函数外部使用。

MDN文档对其进行了清晰的解释，但并不过于冗长：

函数调用的参数是函数的参数。参数按值传递给函数。如果功能发生变化参数的值，此更改不会在全局或调用函数。但是，对象引用也是值，并且它们是特殊的：如果函数更改引用对象的财产，该更改在函数外部可见，（…）

资料来源：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions#Description

基本体（数字、布尔值等）按值传递。字符串是不可变的，所以对它们来说并不重要。对象通过引用传递（引用通过值传递）。

观察：如果观察者无法检查引擎的底层内存，则无法确定是否复制了不可变值或传递了引用。

JavaScript或多或少与底层内存模型无关。没有参考²。JavaScript有值。两个变量可以保持相同的值（或者更准确：两个环境记录可以绑定相同的值）。唯一可以变异的值类型是通过抽象[[Get]]和[[Set]]操作的对象。如果您忘记了计算机和内存，这就是描述JavaScript行为所需的全部内容，它可以让您理解规范。

 let a = { prop: 1 };
 let b = a; // a and b hold the same value
 a.prop = "test"; // The object gets mutated, can be observed through both a and b
 b = { prop: 2 }; // b holds now a different value

现在你可能会问自己，两个变量如何在计算机上保持相同的值。然后，您可能会查看JavaScript引擎的源代码，很可能会发现引擎所用语言的程序员会调用引用。

所以事实上，你可以说JavaScript是“值传递”，而值可以被共享，你可以称JavaScript是“引用传递”，这对于低级语言的程序员来说可能是一个有用的逻辑抽象，或者你可以将行为称为“共享调用”。

由于JavaScript中没有引用，所有这些都没有错，也没有切中要害。因此，我不认为搜索答案特别有用。

²规范中的术语“参考”不是传统意义上的参考。它是一个对象和属性名称的容器，并且是一个中间值（例如，a.b计算为Reference｛value=a，name=“b”｝）。术语“引用”有时也出现在规范中的不相关章节中。