Question

我知道我可以在函数对象中访问外部变量，但是，这就是我所坚持的。

zero = function (one) {
    this.one = one;
    this.two = {
        three: {
            four: function() {
                one.test();
            }
        }
    }
}

抱歉脏代码命名:(。但这是测试用例。

foo = {
    test: function() {
        console.log('foo test');
    }
}
bar = new zero(foo);
bar.two.three.four(); // prints 'foo test'
foo2 = {
    test: function() {
        console.log('another foo test');
    }
};
bar.one = foo2;
bar.two.three.four(); // still prints 'foo test' instead of 'another foo test'

看起来four保留one的引用，因为它的创建不是bar中变量的引用。我无法弄清楚如何直接访问外部变量。感谢您阅读我的问题。

Answer 1

使用

var zero = function (one) {
    var _this = this;
    this.one = one;
    this.two = {
        three: {
            four: function () {
                _this.one.test();
            }
        }
    };
};

而不是

one.test();

它使用闭包变量而不是公开可见的实例属性。

执行此操作时：

this.one = foo2;

你实际上在做的是覆盖公众可见的财产。但是，这与您的函数one的参数不同，后者属于您创建的函数的范围。 one永远不会在您的代码中更改，因此您从构造函数中的初始赋值中获取阀门是很自然的。为对象分配属性并不意味着它们将是相同的。如果你在构造函数中执行此操作：

function Test()
{   var test = {};
    this.test = test;
    test = { a: 1 };
    console.log(this.test.a);
}

new Test; // undefined is logged

在新函数中使用_this的原因是this的值仅在调用函数时设置，而不是在定义函数时设置。例如，采取以下行为：

function Example()
{   var _this = this;
    this.test1 = { func: function () { return this; }
    this.test2 = { func: function () { return _this; }
}

var instance = new Example;
var randomFunction1 = instance.test1.func;
var randomFunction2 = instance.test2.func;

instance.test1.func(); // the instance.test1 object
instance.test2.func(); // the actual instance

randomFunction1(); // the global object (though this will be undefined in strict mode)
randomFunction2(); // still the instance

第一种方式是因为方法的父对象是instance.test1，而不是instance。通过将对象引用当时分配给变量，我们可以永久存储此引用并随时引用它。

注意：您可能希望使用var来声明您的变量 - 这可以防止隐含的全局变量，这可能特别令人讨厌，并且在严格模式下也不允许对未声明的变量进行赋值。

访问首次创建后已更改的外部变量

1 个答案: