简单的对象

函数foo(x) { //使用其他上下文函数 //修改' x '属性，增加值 x.value + +; ｝ //初始化' ref '为对象 Var = { // ' value '在' ref '变量对象中 //初始值为' 1 ' 值:1 }; //用对象值调用函数 foo (ref); //再次调用带有对象值的函数 foo (ref); console.log (ref.value);//打印"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);

其实有一个很好的解决方案:

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"]

通过引用传递变量的变通方法:

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();

我喜欢在JavaScript中解决引用的不足，就像这个例子所显示的那样。

这样做的本质是，您不必尝试创建一个通过引用。相反，您可以使用返回功能，并使其能够返回多个值。因此，不需要在数组或对象中插入值。

var x = "First"; var y = "Second"; var z = "Third"; log('Before call:',x,y,z); with (myFunc(x, y, z)) {x = a; y = b; z = c;} // <-- Way to call it log('After call :',x,y,z); function myFunc(a, b, c) { a = "Changed first parameter"; b = "Changed second parameter"; c = "Changed third parameter"; return {a:a, b:b, c:c}; // <-- Return multiple values } function log(txt,p1,p2,p3) { document.getElementById('msg').innerHTML += txt + '<br>' + p1 + '<br>' + p2 + '<br>' + p3 + '<br><br>' } <div id='msg'></div>

由于我们没有javascript的引用传递功能，唯一的方法是让函数返回值，并让调用者分配它:

So

"makePretty(myArray[x]);"

应该是

"myArray[x] = makePretty(myArray[x]);"

这是在函数内部需要赋值的情况下，如果只需要突变，那么传递对象并突变它就足够了

JavaScript可以在函数中修改数组项(它作为对象/数组的引用传递)。

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]