这些短语/概念最初是在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”仍指向原始数组

嗯，这是关于“性能”和“速度”的，在编程语言中，简单地说就是“内存管理”。

在javascript中，我们可以将值放在两层：type1对象和type2所有其他类型的值，如字符串和布尔值等

如果你把记忆想象成下面的方块，其中每个方块中只能保存一个type2值：

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

重点是，如果你想指示一个type2值，地址是很简单的，但如果你想对type1值做同样的事情，那根本不容易！：

在一个更复杂的故事中：

所以这里的参考资料可以拯救我们：

虽然这里的绿色箭头是一个典型变量，但紫色箭头是对象变量，所以因为绿色箭头（典型变量）只有一个任务（这表示一个典型值），所以我们不需要将它的值与它分开，所以我们将绿色箭头与它的值一起移动到任何位置，在所有赋值、函数等中。。。

但我们不能用紫色箭头做同样的事情，我们可能想把“约翰”牢房搬到这里或其他很多事情。。。，所以紫色的箭头会固定在它的位置上，而分配给它的典型箭头会移动。。。

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

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'];

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

首先，并非每个人都能理解抽象的多个层次。学习过第四代或第五代语言的较新程序员可能很难围绕汇编语言或C语言程序员熟悉的概念进行思考，而不是通过指向指针的指针来实现。通过引用传递不仅仅意味着能够使用函数参数变量更改被引用对象。

变量：引用内存中特定位置值的符号的组合概念。在讨论细节时，这个术语通常太过沉重，不能单独使用。

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

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

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

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

函数参数：调用方传递给函数的函数外部的变量。

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

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

函数参数和参数不是一回事。此外，变量的值不是变量的对象（正如许多人已经指出的，但显然被忽略了）。这些区别对于正确理解至关重要。

通过值传递或通过共享调用（对于对象）：函数参数的值被COPIED到另一个由函数参数符号引用的内存位置（无论它是在堆栈上还是在堆上）。换句话说，函数参数收到了传递参数值的副本。。。AND（关键）参数的值从不被调用函数更新/更改/更改。记住，对象变量的值不是对象本身，而是指向对象的指针，因此逐个传递对象变量会将指针复制到函数参数变量。函数参数的值指向内存中完全相同的对象。对象数据本身可以通过函数参数直接更改，但函数参数的值从未更新，因此在整个函数调用过程中，甚至在函数调用之后，它都将继续指向同一对象（即使其对象的数据已更改，或者如果函数参数被完全分配了不同的对象）。仅仅因为被引用的对象可通过函数参数变量更新，就断定函数参数是通过引用传递的，这是不正确的。

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

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

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

我发现Undercore.js库的extend方法非常有用，当我想将一个对象作为一个参数传递时，它可以被修改或完全替换。

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

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

这些短语/概念最初是在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”仍指向原始数组

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

功能更改Stuff（a、b、c）{a=a*10；b.项目=“已更改”；c＝｛item:“changed”｝；}变量num=10；var obj1=｛item:“未更改”｝；var obj2=｛item:“未更改”｝；changeStuff（num，obj1，obj2）；控制台日志（num）；console.log（obj1.item）；console.log（obj2.item）；

这将产生以下输出：

10
changed
unchanged

如果obj1根本不是引用，则更改obj1.item不会对函数外部的obj1产生影响。如果这个论点是正确的参考，那么一切都会改变。num将为100，obj2.item将为“changed”。相反，num保持10，obj2.item保持“不变”。

相反，情况是传入的项是按值传递的。但通过值传递的项本身就是一个引用。从技术上讲，这叫做共享呼叫。

实际上，这意味着如果更改参数本身（如num和obj2），则不会影响输入到参数中的项。但是，如果更改参数的内部结构，则会向上传播（与obj1一样）。