基本类型（数字，字符串等）按值传递，但是对象是未知的，因为它们都可以按值传递（如果我们认为保存对象的变量实际上是对该对象的引用） ）和按引用传递（当我们认为对象的变量包含对象本身时）。

尽管最后并没有什么大不了，但我想知道呈现通过惯例的参数的正确方法是什么。是否有JavaScript规范的摘录，该摘录定义了与此相关的语义？

JavaScript很有趣。考虑以下示例：

function changeStuff(a, b, c)
{
  a = a * 10;
  b.item = "changed";
  c = {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);

产生输出：

10
changed
unchanged

• 如果obj1根本不是参考，那么更改obj1.item不会obj1对函数的外部产生影响。
• 如果该论点是适当的参考，那么一切都会改变。num会100并且obj2.item会阅读"changed"。

相反，情况是传入的项目是按值传递的。但是，按值传递的项目本身就是参考。从技术上讲，这称为共享呼叫。

实际上，这意味着如果您更改参数本身（如num和一样obj2），则不会影响输入该参数的项目。但是，如果您更改参数的INTERNALS，则该值将向上传播（与一样obj1）。

它总是按值传递，但是对于对象，变量的值是一个引用。因此，当您传递对象并更改其成员时，这些更改会在函数外部持久存在。这使它看起来像通过引用传递。但是，如果您实际上更改了对象变量的值，则会看到该更改不会持续存在，证明它确实是按值传递的。

例：

function changeObject(x) {
  x = { member: "bar" };
  console.log("in changeObject: " + x.member);
}

function changeMember(x) {
  x.member = "bar";
  console.log("in changeMember: " + x.member);
}

var x = { member: "foo" };

console.log("before changeObject: " + x.member);
changeObject(x);
console.log("after changeObject: " + x.member); /* change did not persist */

console.log("before changeMember: " + x.member);
changeMember(x);
console.log("after changeMember: " + x.member); /* change persists */

输出：

before changeObject: foo
in changeObject: bar
after changeObject: foo

before changeMember: foo
in changeMember: bar
after changeMember: bar

变量不会“保留”对象；它具有参考。您可以将该引用分配给另一个变量，现在两者都引用同一个对象。它总是按值传递（即使该值是引用...）。

无法更改作为参数传递的变量所持有的值，如果JavaScript支持通过引用传递，则可以实现。

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

现在该丢掉您所知道的关于按值/引用传递的所有信息。

因为在JavaScript中，按值，按引用或其他方式传递都无关紧要。重要的是传递给函数的参数的变异与赋值。

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

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

我们要做的是“赋值” ...我们已经为变量“ object1”和“ object2”分配了2个单独的空对象。

现在，让我们说我们更喜欢object1 ...因此，我们“分配”了一个新变量。

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;

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

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

呃哦...发生了什么事。我们无法通过更改favoriteString来更改string1 ...为什么？因为我们没有更改字符串对象。我们所做的只是将“ favoriteString” 变量 “重新分配” 为新字符串。这实际上将其与string1断开了连接。在上一个示例中，当我们重命名对象时，我们没有分配任何东西。（但是，不是将变量本身分配给...，但是，我们确实将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中的函数也意味着赋值。它们是相同的，并且2个变量以完全相同的方式连接（也就是说，它们不是一样，除非您算出它们已分配给同一对象）。

“修改变量”唯一会影响其他变量的时间是基础对象发生突变时（在这种情况下，您尚未修改变量，而是对象本身。

在对象和基元之间进行区分是没有意义的，因为它的工作方式与您没有函数并且只是使用等号分配给新变量的方式相同。

唯一的难题是，当您传递给函数的变量名称与函数参数的名称相同时。发生这种情况时，您必须将函数内部的参数视为是函数专有的全新变量（因为它是）

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'

考虑以下：

1. 变量是指向内存中值的指针。
2. 重新分配变量只是将该指针指向一个新值。
3. 重新分配变量将永远不会影响指向同一对象的其他变量

因此，不要忘记“按引用/值传递”，不要因为“按引用/值传递”而挂断电话，因为：

1. 这些术语仅用于描述语言的行为，而不一定是实际的基础实现。由于这种抽象，丢失了对体面的解释必不可少的关键细节，这不可避免地导致当前情况，即单个术语不能充分描述实际行为，因此必须提供补充信息
2. 这些概念最初并不是为了描述javascript而定义的，因此当它们只会增加混乱时，我不觉得必须使用它们。

回答您的问题：传递指针。

// 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'

最后的评论：

• 容易想到原语是由特殊规则强制执行的，而对象不是，而原语只是指针链的末尾。
• 作为最后一个示例，请考虑为什么清除数组的常规尝试无法按预期进行。

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

a = [];
console.log(b); // [1,2]
// doesn't work because `b` is still pointing at the original array

函数外部的对象通过提供对外部对象的引用而传递到函数中。

当您使用该引用操纵其对象时，外部对象因此受到影响。但是，如果您决定在函数内部将引用指向其他对象，则根本不会影响外部对象，因为您所做的只是将引用重定向到其他对象。

这样思考：它总是通过价值传递。但是，对象的值不是对象本身，而是对该对象的引用。

这是一个传递数字（原始类型）的示例

function changePrimitive(val) {
    // At this point there are two '10's in memory.
    // Changing one won't affect the other
    val = val * 10;
}
var x = 10;
changePrimitive(x);
// x === 10

对一个对象重复此操作会产生不同的结果：

function changeObject(obj) {
    // At this point there are two references (x and obj) in memory,
    // but these both point to the same object.
    // changing the object will change the underlying object that
    // x and obj both hold a reference to.
    obj.val = obj.val * 10;
}
var x = { val: 10 };
changeObject(x);
// x === { val: 100 }

再举一个例子：

function changeObject(obj) {
    // Again there are two references (x and obj) in memory,
    // these both point to the same object.
    // now we create a completely new object and assign it.
    // obj's reference now points to the new object.
    // x's reference doesn't change.
    obj = { val: 100 };
}
var x = { val: 10 };
changeObject(x);
// x === { val: 10}

在“ JavaScript：权威指南”这本书的这一章中，有一个关于按值复制和传递以及按值进行比较的非常详细的解释。

在离开通过引用操作对象和数组的主题之前，我们需要弄清楚术语的点。

短语“通过引用”可以具有多种含义。对某些读者而言，该短语指的是一种函数调用技术，该技术允许函数为其参数分配新值并使这些修改后的值在函数外部可见。这不是本书中使用该术语的方式。

在这里，我们的意思是简单地将对对象或数组的引用（而不是对象本身）传递给函数。函数可以使用引用来修改对象或数组元素的属性。但是，如果函数用对新对象或数组的引用覆盖了引用，则该修改在函数外部不可见。

熟悉该术语其他含义的读者可能更喜欢说对象和数组是通过值传递的，但是传递的值实际上是引用，而不是对象本身。

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

对象是值，对象的成员函数本身就是值（请记住，函数是JavaScript中的一流对象）。另外，关于JavaScript中的所有内容都是对象的概念；这是错误的。字符串，符号，数字，布尔值，空值和未定义是原语。

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

x = "test";
alert(x.foo);
x.foo = 12;
alert(x.foo);

在这两个警报中，您都将找到未定义的值。

在JavaScript中，值的类型仅控制该值是由value-copy还是由reference-copy分配。

原始值始终由value-copy分配/传递：

• null
• undefined
• 串
• 数
• 布尔值
• 符号在 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,3]（是一个复合值）的单独引用。重要的是要注意，既c没有d“拥有”该[1,2,3]值，也没有更多“拥有”该值-两者都是对该值的同等引用。因此，当使用任一引用修改（.push(4)）实际共享array值本身时，它仅影响一个共享值，并且两个引用都将引用新修改的值[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而不是对它的引用，array但是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，它将为分配a引用的副本x。x并且a是指向相同[1,2,3]值的单独引用。现在，在函数内部，我们可以使用该引用来改变值本身（push(4)）。但是，当我们进行赋值时x = [4,5,6]，这绝不会影响初始引用a指向的位置-仍然指向（现在已修改）[1,2,3,4]值。

要array通过value-copy 有效地传递复合值（如），您需要手动制作它的副本，以使传递的引用仍然不指向原始值。例如：

foo( a.slice() );

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

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

var obj = {
    a: 2
};

foo( obj );

obj.a; // 42

在这里，obj用作标量基本属性的包装a。传递给时foo(..)，将obj传递引用的副本并将其设置为wrapper参数。现在，我们可以使用wrapper引用来访问共享库，并更新其属性。功能完成后，obj.a将看到更新的值42。

资源

嗯，这是关于“性能”和“速度”以及编程语言中简单的“内存管理”一词。

在JavaScript中我们可以把值在2层：TYPE1 - objects和类型2 -所有其他类型的值，如string＆boolean＆等

如果您将内存想象成下面的正方形，那么在每个正方形中只能保存一个type2值：

每个type2值（绿色）是一个正方形，而type1值（蓝色）是其中的一组：

关键是，如果要指示类型2值，则地址是简单的，但如果要对类型1值执行相同的操作，那根本就不容易！：

还有一个更复杂的故事：

因此，这里的引用可以挽救我们：

虽然此处的绿色箭头是一个典型变量，而紫色箭头是一个对象变量，所以因为绿色箭头（典型变量）只有一项任务（这表示一个典型值），所以我们不需要将其值与因此，我们将绿色箭头及其值移动到所有位置，所有分配，函数等中……

但是我们不能用紫色箭头做同样的事情，我们可能想将“ john”单元格移到这里或其他许多事情...，所以紫色箭头会固定在其位置，只有分配给它的典型箭头会移动...

一个非常令人困惑的情况是您无法意识到所引用变量的变化，让我们来看一个非常好的示例：

let arr = [1, 2, 3, 4, 5]; //arr is an object now and a purple arrow is indicating it
let obj2 = arr; // now, obj2 is another purple arrow that is indicating the value of arr obj
let obj3 = ['a', 'b', 'c'];
obj2.push(6); // first pic below - making a new hand for the blue circle to point the 6
//obj2 = [1, 2, 3, 4, 5, 6]
//arr = [1, 2, 3, 4, 5, 6]
//we changed the blue circle object value (type1-value) and due to arr and obj2 are indicating that so both of them changed
obj2 = obj3; //next pic below - changing the direction of obj2 array from blue circle to orange circle so obj2 is no more [1,2,3,4,5,6] and it's no more about changing anything in it but we completely changed its direction and now obj2 is pointing to obj3
//obj2 = ['a', 'b', 'c'];
//obj3 = ['a', 'b', 'c'];

这只是关于按值传递和按引用传递（JavaScript）的更多说明。在这个概念中，他们正在谈论通过引用传递变量和通过引用传递变量。

按值传递（原始类型）

var a = 3;
var b = a;

console.log(a); // a = 3
console.log(b); // b = 3

a=4;
console.log(a); // a = 4
console.log(b); // b = 3

• 适用于JavaScript中的所有原始类型（字符串，数字，布尔值，未定义和null）。
• 为a分配了一个内存（例如0x001），而b在内存中创建了该值的副本（例如0x002）。
• 因此，更改变量的值不会影响其他变量，因为它们都位于两个不同的位置。

通过引用传递（对象）

var c = { "name" : "john" };
var d = c;

console.log(c); // { "name" : "john" }
console.log(d); // { "name" : "john" }

c.name = "doe";

console.log(c); // { "name" : "doe" }
console.log(d); // { "name" : "doe" }

• JavaScript引擎将对象分配给变量 c，并且它指向一些内存，例如（0x012）。
• 当d = c时，在此步骤中 d指向相同的位置（0x012）。
• 更改任何变量的值都会更改两个变量的值。
• 功能就是对象

特殊情况，通过引用传递（对象）

c = {"name" : "jane"};
console.log(c); // { "name" : "jane" }
console.log(d); // { "name" : "doe" }

• equal（=）运算符设置新的内存空间或地址

分享我对JavaScript中引用的了解

在JavaScript中，将对象分配给变量时，分配给变量的值是对该对象的引用：

var a = {
  a: 1,
  b: 2,
  c: 3
};
var b = a;

// b.c is referencing to a.c value
console.log(b.c) // Output: 3
// Changing value of b.c
b.c = 4
// Also changes the value of a.c
console.log(a.c) // Output: 4

语义学！设置具体的定义必然会导致某些答案和注释不兼容，因为即使使用相同的单词和短语它们也不会描述相同的事物，但是克服这种混乱至关重要（尤其是对于新程序员而言）。

首先，并不是每个人都似乎掌握了多个抽象级别。在第4代或第5代语言上学习过的较新的程序员可能难以将注意力集中在汇编或C程序员熟悉的概念上，而这些概念不是由指向指针的指针阶段化的。引用传递不仅仅意味着具有使用功能参数变量更改引用对象的能力。

变量：符号的组合概念，它引用内存中特定位置的值。这个术语通常过于繁琐，无法在讨论细节时单独使用。

符号：用于引用变量的文本字符串（即变量的名称）。

值：存储在存储器中并使用变量符号引用的特定位。

内存位置：存储变量值的位置。（该位置本身由与该位置存储的值分开的数字表示。）

函数参数：在函数定义中声明的变量，用于引用传递给函数的变量。

函数参数：函数外部的变量，调用者将其传递给函数。

对象变量：其基本基础值不是“对象”本身的变量，而是其值是指向内存中存储对象实际数据的另一个位置的指针（内存位置值）。在大多数高级语言中，“指针”方面在各种情况下都可以通过自动取消引用来有效隐藏。

原始变量：其值为实际值的变量。即使自动装箱和各种语言的类对象上下文也可能使此概念变得复杂，但是一般的想法是，变量的值是由变量的符号表示的实际值，而不是指向另一个内存位置的指针。

函数参数和参数不是同一件事。同样，变量的值也不是变量的对象（正如各种人已经指出的那样，但是显然被忽略了）。这些区别对于正确理解至关重要。

按值传递或按共享共享（用于对象）：函数参数的值被复制到另一个存储位置，该位置由函数的参数符号引用（无论它在堆栈还是堆上）。换句话说，函数参数接收到传递的参数值的副本...并且（关键）参数的值不会被调用函数更新/更改/更改。请记住，对象变量的值不是对象本身，而是对象的指针，因此按值传递对象变量会将指针复制到函数参数变量。函数参数的值指向内存中完全相同的对象。可以通过函数参数直接更改对象数据本身，但是函数参数的值是“永不更新”，因此它将继续指向相同的值整个对象，甚至在函数调用之后（即使其对象的数据已更改，或者功能参数完全分配了另一个对象）也是如此。仅仅因为所引用的对象可通过功能参数变量进行更新而得出结论，认为函数参数是通过引用传递的，这是不正确的。

呼叫/转接参考：可以/将通过相应的函数参数直接更新函数参数的值。如果有帮助，函数参数将成为该参数的有效“别名”-它们有效地引用了相同内存位置处的相同值。如果函数参数是对象变量，则更改对象数据的能力与传递值的情况没有区别，因为函数参数仍将指向与参数相同的对象。但是在对象变量的情况下，如果将功能参数设置为完全不同的对象，则参数同样会指向不同的对象，这在传递值的情况下不会发生。

JavaScript不通过引用传递。如果仔细阅读，您会发现所有相反的意见都会误解传递值的含义，并且他们错误地得出结论，通过功能参数更新对象数据的能力与“传递值”同义。

对象克隆/复制：创建一个新对象，并复制原始对象的数据。这可以是深层副本，也可以是浅层副本，但重点是要创建一个新对象。创建对象的副本是与值传递不同的概念。一些语言区分类对象和结构（或类似结构），并且对于传递不同类型的变量可能具有不同的行为。但是，在传递对象变量时，JavaScript不会自动执行此类操作。但是缺少自动对象克隆功能并不能转换为按引用传递。

JavaScript按值传递原始类型，按引用传递对象类型

现在，人们喜欢无休止地争论“按引用传递”是否是描述Java等人的正确方法。确实可以。关键是这样的：

1. 传递对象不会复制该对象。
2. 传递给函数的对象可以通过函数修改其成员。
3. 传递给函数的原始值不能被该函数修改。复制。

在我的书中称为通过引用传递。

- 布莱恩碧 - 哪些编程语言是按引用传递？

更新资料

这是对此的反驳：

JavaScript中没有可用的“通过引用传递”。

我了解这一点的简单方法...

• 调用函数时，您传递的是参数变量的内容（引用或值），而不是变量本身。

  var var1 = 13;
  var var2 = { prop: 2 };
  
  //13 and var2's content (reference) are being passed here
  foo(var1, var2); 

• 在函数内部，参数变量inVar1和inVar2接收要传递的内容。

  function foo(inVar1, inVar2){
      //changing contents of inVar1 and inVar2 won't affect variables outside
      inVar1 = 20;
      inVar2 = { prop: 7 };
  }

• 由于inVar2收到的引用{ prop: 2 }，因此您可以更改对象属性的值。

  function foo(inVar1, inVar2){
      inVar2.prop = 7; 
  }

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

对于编程语言律师，我阅读了ECMAScript 5.1的以下部分（比最新版本更容易阅读），并在ECMAScript邮件列表中进行了询问。

TL; DR：一切都是通过值传递的，但是对象的属性是引用，并且标准中非常缺乏对象的定义。

构造论证清单

第11.2.4节“自变量列表”在生成仅包含1个自变量的自变量列表时说以下内容：

生产ArgumentList：AssignmentExpression的评估如下：

1. 令ref为评估AssignmentExpression的结果。
2. 令arg为GetValue（ref）。
3. 返回唯一项为arg的列表。

本节还列举了参数列表包含0或> 1个参数的情况。

因此，所有内容都通过引用传递。

访问对象属性

第11.2.1节“属性访问器”

生产的MemberExpression：MemberExpression [Expression]的计算如下：

1. 令baseReference为评估MemberExpression的结果。
2. 令baseValue为GetValue（baseReference）。
3. 令propertyNameReference为计算Expression的结果。
4. 设propertyNameValue为GetValue（propertyNameReference）。
5. 调用CheckObjectCoercible（baseValue）。
6. 设propertyNameString为ToString（propertyNameValue）。
7. 如果要评估的语法产生包含在严格模式代码中，则使strict为真，否则使strict为假。
8. 返回类型为Reference的值，其基值为baseValue，其引用名称为propertyNameString，其严格模式标志为strict。

因此，对象的属性始终可以用作参考。

参考上

在第8.7节“引用规范类型”中对此进行了描述，引用不是该语言中的实类型-它们仅用于描述delete，typeof和赋值运算符的行为。

“对象”的定义

在5.1版中定义“对象是属性的集合”。因此，我们可以推断出，对象的值就是集合，但是关于什么是集合的值在规范中定义得很差，需要一些努力才能理解。

MDN文档对其进行了清晰的解释，而不必太冗长：

函数调用的参数是函数的参数。参数通过值传递给函数。如果函数更改了参数的值，则此更改不会在全局或调用函数中反映出来。但是，对象引用也是值，并且它们很特殊：如果函数更改了所引用对象的属性，则该更改在函数外部是可见的（...）

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

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

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

该&age是一个参考myAge，但如果你想要的值，你必须参考转换，使用*age。

Javascript是为您执行此转换的高级语言。因此，尽管对象是通过引用传递的，但语言会将引用参数转换为值。您不需要&在函数定义上使用，而在*函数体上通过引用来传递它，也不需要在函数体上使用，来将引用转换为值，JS会为您完成。

这就是为什么当您尝试通过替换函数的值（即age = {value:5}）来更改对象时，更改不会持久化，但是如果您更改其属性（即age.value = 5），则更改仍然存在。

学到更多

我已经多次阅读了这些答案，但是直到我了解了Barbara Liskov所说的“共享通话”的技术定义后，我才真正理解它。

通过共享进行调用的语义与通过引用进行调用的不同之处在于，调用者看不到对函数内函数自变量的分配（与通过引用语义不同）[需要引用]，因此例如，如果传递了变量，则不可能在调用者的作用域中模拟对该变量的分配。但是，由于该函数可以访问与调用方相同的对象（不进行任何复制），因此，如果对象可变，则这些对象的突变（如果对象是可变的）对调用方可见，这似乎与按值调用有所不同语义。调用者可以看到函数中可变对象的突变，因为该对象没有被复制或克隆，而是共享的。

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

最简单的方法

// Copy JS object without reference
var first = {"a":"value1","b":"value2"};
var clone = JSON.parse( JSON.stringify( first ) ); 

var second = ["a","b","c"];
var clone = JSON.parse( JSON.stringify( second ) ); 

我已经发现了延伸方法的的Underscore.js库非常有用的，当我想在一个目的是通过作为可以要么被修改或替换完全的参数。

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

   var newObj = new MyObject();
   // _.extend(destination, *sources) 
   _.extend(newObj, aObj);
  }
}

我发现的最简洁的解释是在AirBNB样式指南中：

• 基元：访问基元类型时，可以直接使用其值

  • 串
  • 数
  • 布尔值
  • 空值
  • 未定义

例如：

var foo = 1,
    bar = foo;

bar = 9;

console.log(foo, bar); // => 1, 9

• 复杂：访问复杂类型时，需要引用其值

  • 宾语
  • 数组
  • 功能

例如：

var foo = [1, 2],
    bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

也就是说，有效的原始类型是通过值传递的，而复杂类型是通过引用传递的。

我会说这是通过副本-

考虑参数和变量对象是在函数调用开始时创建的执行上下文中创建的对象-传递给函数的实际值/引用仅存储在此参数+变量对象中。

简而言之，对于基本类型，值在函数调用的开始被复制，对于对象类型，引用被复制。

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

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

（摘自上述文章。）

一种简单的确定是否“通过引用传递”的方法是是否可以编写“交换”函数。例如，在C中，您可以执行以下操作：

void swap(int *i, int *j)
{
    int t;
    t = *i;
    *i = *j;
    *j = t;
}

如果您无法在JavaScript中完成等效操作，则它不是“通过引用传递”。

1. 像字符串，数字之类的原始类型变量始终按值传递。

2. 基于这两个条件，数组和对象按引用传递或按值传递。

   • 如果要使用新的对象或数组更改该对象或数组的值，则按值传递。

     object1 = {item: "car"}; array1=[1,2,3];

   在这里，您将新对象或数组分配给旧对象。您没有更改旧对象的属性值，因此按值传递。

   • 如果要更改对象或数组的属性值，则通过引用传递它。

     object1.key1= "car"; array1[0]=9;

   在这里，您正在更改旧对象的属性值。您没有将新对象或数组分配给旧对象，因此它通过引用传递。

码

    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

1. 基元（数字，布尔值等）按值传递。
   • 字符串是不可变的，因此对它们而言并不重要。
2. 对象通过引用传递（引用通过值传递）。

函数内部的简单值将不会更改函数外部的值（它们通过值传递），而复杂的值会（通过引用传递）。

function willNotChange(x) {

    x = 1;
}

var x = 1000;

willNotChange(x);

document.write('After function call, x = ' + x + '<br>'); // Still 1000

function willChange(y) {

    y.num = 2;
}

var y = {num: 2000};

willChange(y);
document.write('After function call y.num = ' + y.num + '<br>'); // Now 2, not 2000