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

如果您想要像其他语言一样的（正常）函数参数行为（传递值的副本）然后在传递到函数之前克隆对象：

function run()
{
    var test = [];
    test.push(1);

    console.log('before: '+test); // 1

    changeVariable(_.clone(test)); // (Note: I am using lodash _.clone() function)
 
    console.log('after: '+test); // 1 
}


function changeVariable(test2) {
  var test1 = test2;
  test1.push(2); 
  console.log('inside func:', test1);  // inside func: [1,2]
}   


run();    

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

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”｝）。术语“引用”有时也出现在规范中的不相关章节中。

在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;
}

在低级语言中，如果要通过引用传递变量，则必须在创建函数时使用特定语法：

int myAge = 14;
increaseAgeByRef(myAge);
function increaseAgeByRef(int &age) {
  *age = *age + 1;
}

&age是对myAge的引用，但如果您需要该值，则必须使用*age转换引用。

JavaScript是一种高级语言，可以为您进行这种转换。

因此，尽管对象是通过引用传递的，但语言将引用参数转换为值。您不需要在函数定义上使用&来通过引用传递它，也不需要在功能体上使用*来将引用转换为值，JavaScript会为您执行此操作。

这就是为什么当您试图通过替换函数中的对象的值（即age={value:5}）来更改该对象时，更改不会持久，但如果您更改了它的财产（即age.value=5），更改就会持久。

了解更多信息

JavaScript总是按值传递；一切都是价值型的。

对象是值，对象的成员函数本身是值（请记住，函数是JavaScript中的一级对象）。此外，关于JavaScript中的一切都是一个对象的概念；这是错误的。字符串、符号、数字、布尔值、空值和未定义值都是基元。

有时，他们可以利用从基本原型继承的一些成员函数和财产，但这只是为了方便。这并不意味着它们本身就是对象。请尝试以下操作以供参考：

x=“测试”；console.log（x.foo）；x.foo=12；console.log（x.foo）；

在两个console.log中，您都会发现值未定义。