如何在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"
if you are setting the value of an object or array it is Pass by Value.
object1 = { prop: "car" };
array1 = [1,2,3];
if you are changing a property value of an object or array then it is Pass by Reference.
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);/workspace/Main.js:43 context = window; ReferenceError: window is not defined。 - Anton Shepelevrvar解决方案无疑具有教育价值。 - Anton Shepelev另一种传递任何（本地的、原始的）变量的引用的方法是通过使用 eval 在“飞行中”包装变量的闭包。这也适用于“use strict”。（注意：请注意，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);
})()
x=>value=x实际上更短，而双向输入输出参数并不经常需要。请参见我的答案中对重复问题的另一种基于eval的方法，其中您可以传递变量名称并评估整个函数的结果。 - Anton Shepelev//The Function
function doSomething(ref value) {
value = "Bar";
}
//The Calling Code
var value = "Foo";
doSomething(value);
console.log(value); //Bar
相反，我更愿意像这样做：
//The Function
function doSomething(value) {
value = "Bar";
return value;
}
//The Calling Code:
var value = "Foo";
value = doSomething(value); //Reassignment
console.log(value); //Bar
如果我需要编写一个返回多个值的函数，我也不会使用参数传递引用。因此，我会避免这样的代码：
//The Function
function doSomething(ref value) {
value = "Bar";
//Do other work
var otherValue = "Something else";
return otherValue;
}
//The Calling Code
var value = "Foo";
var otherValue = doSomething(value);
console.log(value); //Bar
console.log(otherValue); //Something else
//The Function
function doSomething(value) {
value = "Bar";
//Do more work
var otherValue = "Something else";
return {
value: value,
otherValue: otherValue
};
}
//The Calling Code:
var value = "Foo";
var result = doSomething(value);
value = result.value; //Reassignment
console.log(value); //Bar
console.log(result.otherValue);
findStuff方法简单地返回结果数组。你也不需要再声明一个foundArray变量，而是直接将结果数组赋值给它：var foundArray = findStuff(inArray); if (foundArray.length > 0) { /* 处理foundArray */ }。这样做可以 1）使调用代码更易读/易懂，2）大大简化findStuff方法的内部功能（因此也可以更轻松地测试），从而使它在不同的（重新）使用情况/场景中更加灵活。 - Bart Hofland实际上有一个很好的解决方案:
function updateArray(context, targetName, callback) {
context[targetName] = context[targetName].map(callback);
}
var myArray = ['a', 'b', 'c'];
updateArray(this, 'myArray', item => {return '_' + item});
console.log(myArray); //(3) ["_a", "_b", "_c"]
function Wrapper(val){
this.VAL = val;
}
Wrapper.prototype.toString = function(){
return this.VAL.toString();
}
function DECLARE(val, callback){
var valWrapped = new Wrapper(val);
callback(valWrapped);
}
function INC(ref){
if(ref && ref.hasOwnProperty('VAL')){
ref.VAL++;
}
else{
ref++;//or maybe throw here instead?
}
return ref;
}
DECLARE(5, function(five){ //consider this line the same as 'let five = 5'
console.log("five is now " + five);
INC(five); // increment
console.log("five is incremented to " + five);
});
let five = 5;，因为它没有在外部上下文中设置变量，只能在函数内部使用。这就是为什么你不需要使用字符串的原因。尽管如此，我还是点赞这个新颖的想法，即利用闭包来唯一地引用、存储和本地化该引用中的值。不过，这也可以通过一个 class 或对象来实现。然后，您可以存储引用对象，并将其用于比 INC(ref) 更通用的目的。我正在为我的一个项目做这件事。 - Andrew实际上这很容易。问题是要理解一旦传递了经典参数，你就被限制在另一个只读区域中。
解决方案是使用JavaScript的面向对象设计来传递参数。这与将参数放入全局/作用域变量相同，但更好...
function action(){
/* Process this.arg, modification allowed */
}
action.arg = [["empty-array"], "some string", 0x100, "last argument"];
action();
function action(){
/* Process this.arg, modification allowed */
this.arg = ["a", "b"];
}
action.setArg = function(){this.arg = arguments; return this;}
action.setArg(["empty-array"], "some string", 0x100, "last argument")()
action.setArg(["empty-array"],"some string",0x100,"last argument").call()
this.arg 只能与 action 实例一起使用。这不起作用。 - Eduardo Cuomoclass来解决这个问题。 我发现在JS中，this关键字是class的主要功能提供目的。 - AndrewJavaScript可以在函数内修改数组项（它作为对象/数组的引用传递）。
function makeAllPretty(items) {
for (var x = 0; x < myArray.length; x++){
// Do stuff to the array
items[x] = makePretty(items[x]);
}
}
myArray = new Array(var1, var2, var3);
makeAllPretty(myArray);
function inc(items) {
for (let i=0; i < items.length; i++) {
items[i]++;
}
}
let values = [1,2,3];
inc(values);
console.log(values);
// Prints [2,3,4]
makePretty(var1); makePretty(var2); makePretty(var3); ...- BFTrickarr = [var1, var2, var3]; for (var i = 0, len = arr.length; i < len; i++) { arr[i] = makePretty(arr[i]); }-- 您只需要将makePretty返回的值存储回数组中的槽位即可。 - dylnmc