Javascript是否通过引用传递？
Javascript是通过引用还是传递值？ 这里是一个来自Javascript的例子：好的部分。 我对很困惑my的矩形函数参数。 它实际上是undefined ，并在函数内重新定义。 没有原始参考。 如果我从函数参数中删除它，内部区域功能将无法访问它。
它是封闭的吗？ 但是没有函数返回。
var shape = function (config) {
var that = {};
that.name = config.name || "";
that.area = function () {
return 0;
};
return that;
};
var rectangle = function (config, my) {
my = my || {};
my.l = config.length || 1;
my.w = config.width || 1;
var that = shape(config);
that.area = function () {
return my.l * my.w;
};
return that;
};
myShape = shape({
name: "Unhnown"
});
myRec = rectangle({
name: "Rectangle",
length: 4,
width: 6
});
console.log(myShape.name + " area is " + myShape.area() + " " + myRec.name + " area is " + myRec.area());
基元通过值传递，对象通过“参考副本”传递。
特别是，当你传递一个对象（或数组）时，你（无形地）传递了该对象的引用，并且可以修改该对象的内容，但是如果你试图覆盖该引用，它将不会影响调用者所持有的引用 - 即引用本身按值传递：
function replace(ref) {
ref = {}; // this code does _not_ affect the object passed
}
function update(ref) {
ref.key = 'newvalue'; // this code _does_ affect the _contents_ of the object
}
var a = { key: 'value' };
replace(a); // a still has its original value - it's unmodfied
update(a); // the _contents_ of 'a' are changed
与C ++相比，更改引用类型可以完全替代调用者传递的对象：
void replace(mytype& ref) {
ref = *new mytype(); // ignoring the memory leak for the purposes of this example
}
mytype a;
replace(a); // a is now a _different_ object
像这样想：
每当你在ECMAscript中创建一个对象时，这个对象就形成了一个神秘的ECMAscript普遍的地方，人们永远无法得到它。 你在这个神秘的地方得到的是对这个对象的引用。
var obj = { };
即使obj只是对象（它位于特别美妙的地方）的引用，因此，你只能通过这个引用。 实际上，访问obj的任何一段代码都会修改距离很远的对象。
我的2美分....这是没有关系，是否通过参考或价值传递参数。 真正重要的是赋值与变异。
我在这里写了一个更长，更详细的解释（JavaScript是传递引用还是传值语言？）
当你传递任何东西时（无论是对象还是原语），所有的javascript都会在函数内部分配一个新变量，就像使用等号（=）一样，
这个参数在函数内的行为方式与使用等号分配一个新变量时的行为完全相同。请拿这些简单的例子。
var myString = 'Test string 1';
// Assignment - A link to the same place as myString
var sameString = myString;
// If I change sameString, it will not modify myString,
// it just re-assigns it to a whole new string
sameString = 'New string';
console.log(myString); // logs 'Test string 1';
console.log(sameString); // logs 'New string';
如果我将myString作为参数传递给一个函数，它的行为就好像我简单地将它分配给一个新变量。 现在，让我们做同样的事情，但用一个函数来代替简单的赋值
function myFunc(sameString) {
// Re assignment.. again, it will not modify myString
sameString = 'New string';
}
var myString = 'Test string 1';
// This behaves the same as if we said sameString = myString
myFunc(myString);
console.log(myString); // Again, logs 'Test string 1';
当您将对象传递给函数时，可以修改对象的唯一原因是您不重新分配对象......相反，对象可以被更改或变异......同样，它也以相同的方式工作。
var myObject = { name: 'Joe'; }
// Assignment - We simply link to the same object
var sameObject = myObject;
// This time, we can mutate it. So a change to myObject affects sameObject and visa versa
myObject.name = 'Jack';
console.log(sameObject.name); // Logs 'Jack'
sameObject.name = 'Jill';
console.log(myObject.name); // Logs 'Jill'
// If we re-assign it, the link is lost
sameObject = { name: 'Howard' };
console.log(myObject.name); // Logs 'Jill'
如果我将myObject作为参数传递给一个函数，它的行为就好像我简单地将它分配给一个新变量。 同样，具有完全相同行为但具有功能的相同事物。
function myFunc(sameObject) {
// We mutate the object, so the myObject gets the change too... just like before.
sameObject.name = 'Jill';
// But, if we re-assign it, the link is lost
sameObject = { name: 'Howard' };
}
var myObject = { name: 'Joe'; }
// This behaves the same as if we said sameObject = myObject;
myFunc(myObject);
console.log(myObject.name); // Logs 'Jill'
每次你将一个变量传递给一个函数，就像你使用了相等（=）符号一样，你是“赋值”给参数的名字。
永远记住等号（=）意味着分配。 将参数传递给函数也意味着赋值。 它们是相同的，两个变量的连接方式完全相同。
修改变量的唯一时间会影响不同的变量，即基础对象发生变化时。
在对象和原语之间进行区分是毫无意义的，因为它的工作方式与您没有函数并且使用等号分配给新变量相同。
链接地址: http://www.djcxy.com/p/3487.html