如何在 JavaScript 中通过引用传递变量？
我有三个变量要对其执行多个操作，因此我想将它们放入 for 循环中并对每个变量执行操作。
伪代码：
myArray = new Array(var1, var2, var3);
for (var x = 0; x < myArray.length; x++){
// Do stuff to the array
makePretty(myArray[x]);
}
// Now do stuff to the updated variables
做这个的最好方式是什么？
JavaScript 中没有可用的“通过引用传递”。您可以传递一个对象（也就是说，您可以按值传递对对象的引用），然后让函数修改对象内容：
function alterObject(obj) {
obj.foo = "goodbye";
}
var myObj = { foo: "hello world" };
alterObject(myObj);
alert(myObj.foo); // "goodbye" instead of "hello world"
如果需要，您可以使用数字索引迭代数组的属性并修改数组的每个单元格。
var arr = [1, 2, 3];
for (var i = 0; i < arr.length; i++) {
arr[i] = arr[i] + 1;
}
重要的是要注意“传递引用”是一个非常具体的术语。这不仅仅意味着可以传递对可修改对象的引用。相反，这意味着可以以允许函数在调用上下文中修改该值的方式传递简单变量。所以：
function swap(a, b) {
var tmp = a;
a = b;
b = tmp; //assign tmp to b
}
var x = 1, y = 2;
swap(x, y);
alert("x is " + x + ", y is " + y); // "x is 1, y is 2"
在像 C++ 这样的语言中，可以这样做，因为该语言确实（排序）具有按引用传递。
编辑- 最近（2015 年 3 月）在 Reddit 上再次通过一篇类似于下面提到的我的博客文章在 Reddit 上大放异彩，尽管在这种情况下是关于 Java。我在阅读 Reddit 评论中的来回评论时突然想到，很大一部分混乱源于涉及“引用”一词的不幸冲突。术语“通过引用传递”和“通过值传递”早于在编程语言中使用“对象”的概念。它真的完全不是关于对象的。它是关于函数参数，特别是函数参数如何“连接”（或不连接）到调用环境。特别是，，它看起来与 JavaScript 中的非常相似。但是，您也可以在调用环境中修改对象引用，这是您在 JavaScript 中无法做到的关键。传递引用语言不会传递引用本身，而是传递对引用的引用。
编辑-这是关于该主题的博客文章。（注意那篇文章的评论，它解释了 C++ 并没有真正通过引用传递。这是真的。然而，C++ 确实具有创建对普通变量的引用的能力，无论是在函数点显式调用以创建指针，或在调用其参数类型签名要求完成的函数时隐式调用。这些是 JavaScript 不支持的关键。）
如果您要设置对象或数组的值，则它是按值传递。
object1 = { prop: "car" };
array1 = [1,2,3];
如果您要更改对象或数组的属性值，则它是按引用传递。
object1.prop = "car";
array1[0] = 9;
代码
function passVar(obj1, obj2, num) {
obj1.prop = "laptop"; // will CHANGE original
obj2 = { prop: "computer" }; //will NOT affect original
num = num + 1; // will NOT affect original
}
var object1 = {
prop: "car"
};
var object2 = {
prop: "bike"
};
var number1 = 10;
passVar(object1, object2, number1);
console.log(object1); // output: Object { prop: "laptop" }
console.log(object2); // output: Object { prop: "bike" }
console.log(number1); // ouput: 10通过引用传递变量的解决方法：
var a = 1;
inc = function(variableName) {
window[variableName] += 1;
};
inc('a');
alert(a); // 2
是的，实际上你可以在不访问全局变量的情况下做到这一点：
inc = (function () {
var variableName = 0;
var init = function () {
variableName += 1;
alert(variableName);
}
return init;
})();
inc();
function foo(x) {
// Function with other context
// Modify `x` property, increasing the value
x.value++;
}
// Initialize `ref` as object
var ref = {
// The `value` is inside `ref` variable object
// The initial value is `1`
value: 1
};
// Call function with object value
foo(ref);
// Call function with object value again
foo(ref);
console.log(ref.value); // Prints "3"rvar/**
* Aux function to create by-references variables
*/
function rvar(name, value, context) {
// If `this` is a `rvar` instance
if (this instanceof rvar) {
// Inside `rvar` context...
// Internal object value
this.value = value;
// Object `name` property
Object.defineProperty(this, 'name', { value: name });
// Object `hasValue` property
Object.defineProperty(this, 'hasValue', {
get: function () {
// If the internal object value is not `undefined`
return this.value !== undefined;
}
});
// Copy value constructor for type-check
if ((value !== undefined) && (value !== null)) {
this.constructor = value.constructor;
}
// To String method
this.toString = function () {
// Convert the internal value to string
return this.value + '';
};
} else {
// Outside `rvar` context...
// Initialice `rvar` object
if (!rvar.refs) {
rvar.refs = {};
}
// Initialize context if it is not defined
if (!context) {
context = this;
}
// Store variable
rvar.refs[name] = new rvar(name, value, context);
// Define variable at context
Object.defineProperty(context, name, {
// Getter
get: function () { return rvar.refs[name]; },
// Setter
set: function (v) { rvar.refs[name].value = v; },
// Can be overrided?
configurable: true
});
// Return object reference
return context[name];
}
}
// Variable Declaration
// Declare `test_ref` variable
rvar('test_ref_1');
// Assign value `5`
test_ref_1 = 5;
// Or
test_ref_1.value = 5;
// Or declare and initialize with `5`:
rvar('test_ref_2', 5);
// ------------------------------
// Test Code
// Test Function
function Fn1(v) { v.value = 100; }
// Test
function test(fn) { console.log(fn.toString()); console.info(fn()); }
// Declare
rvar('test_ref_number');
// First assign
test_ref_number = 5;
test(() => test_ref_number.value === 5);
// Call function with reference
Fn1(test_ref_number);
test(() => test_ref_number.value === 100);
// Increase value
test_ref_number++;
test(() => test_ref_number.value === 101);
// Update value
test_ref_number = test_ref_number - 10;
test(() => test_ref_number.value === 91);另一种通过引用传递任何（本地、原始）变量的方法是通过eval. 这也适用于“使用严格”。（注意：注意这eval对 JavaScript 优化器不友好，而且变量名周围缺少引号可能会导致不可预测的结果）
"use strict"
// Return text that will reference variable by name (by capturing that variable to closure)
function byRef(varName){
return "({get value(){return "+varName+";}, set value(v){"+varName+"=v;}})";
}
// Demo
// Assign argument by reference
function modifyArgument(argRef, multiplier){
argRef.value = argRef.value * multiplier;
}
(function(){
var x = 10;
alert("x before: " + x);
modifyArgument(eval(byRef("x")), 42);
alert("x after: " + x);
})()
实时示例：https : //jsfiddle.net/t3k4403w/