“特权”方法调用成员方法问题

Question

考虑以下代码：

function Dog()
{
    this.foo = function() {};

    this.walk = function()
    {
        if(canWalk())
        {
            alert('walking');
            return;
        }

        alert('I have no legs!');
    }

    canWalk = function()
    {
        this.foo();
        return false;
    }
}

var instance = new Dog();
instance.walk();

假设this 指针指向Dog 的实例，该代码中的“特权”canWalk() 方法存在错误。它实际上似乎指向了让我感到困惑的全局对象！我读过，由于闭包，我可以在构造函数的范围内获取对 this 的引用，然后在我的“特权”方法中使用该引用，但这似乎是一种 hack。

我只是勉强掌握this 指针在各种上下文中的行为。我了解“附加”到对象的方法将收到指向附加对象的this。例如，foo.doStuff() 将有一个 this 指向 foo 实例。

令人不安的是，虽然我认为我很聪明并在我的 OBJECT 上创建了“特权”方法，但似乎我实际上是在将函数转储到全局范围内！也许有一个名为 init() 的全局方法（很可能）来自另一个库或文件，而不是我自己创建的。如果我随后用名为init() 的“特权”方法定义了一个漂亮的小封装对象，我将替换另一个全局init() 方法。

我的问题是，创建“特权”方法（以及与此相关的字段）的最佳实践是什么？我的示例对象还有哪些其他方法可以提供私有或特权方法，同时也具有适当的范围。我不是在寻找满足要求的晦涩解决方案，而是在寻找最佳实践。

Answer 1

不要使用this。将 var self = this; 放在 Dog 函数的顶部并使用 self。这样，您将始终对 Dog 有一个“安全”的引用。

在您的示例中，this 应该指向 Dog，除非我也遗漏了什么。

至于您的特权方法，您忘记定义变量。添加var canWalk;

还有另一种方式：闭包。我举个例子：

function create_dog() {
    function canWalk() {
        return false;
    }
    function walk() {
        if (canWalk()) {
            alert("walking");
            return;
        }
        alert("I have no hands!");
    }
    return {
        "walk": walk // points to the function walk()
    }; // this the API of dog, like public functions (or properties)
}
var dog = create_dog();
dog.walk();

现在您不需要this 或new。此外，您可以这样做：

function create_dog() {
    function canWalk() {
        return false;
    }
    function walk() {
        if (canWalk()) {
            alert("walking");
            return;
        }
        alert("I have no hands!");
    }
    var dog = {
        "walk": walk
    };
    return dog;
}
var dog = create_dog();
dog.walk();

因此您可以在您的权限函数中引用dog。 如果您不打算使用原型设计，我会建议关闭方法。

顺便说一句。为避免混淆：

function my_func() {}

和

var my_func = function () {};

是等价的。如果您在两个函数之间有循环引用并且想要强制使用前定义，则后者会很有用。

Answer 2

首先，您需要在 canWalk 前面添加一个 var。这样一来，canWalk 函数就被限制在dog() 的范围内，而不是隐式全局。

this 指向函数的“所有者”。使用 new 运算符时，该函数会创建自己的作用域。所以，在dog() 的主体中，this 指的是狗实例对象。在您的 walk 函数中，this 还指代 dog 实例，因为您将 walk 函数设置为 dog (this.walk = function () { ... }) 的实例。但是在canWalk中，没有所有者，所以this指向全局对象window。

我意识到我的解释可能令人困惑，所以这里是我的解释的代码注释版本：

var obj = {
    'f': function () {
        // this === obj, because obj "owns" this function
        // In other words, this function is callable by obj.f()
    },
    'o': {
         'f': function () {
             // this === obj.o, because obj.o "owns" this function
             // In other words, this function is callable by obj.o.f()
         }
    }
};

// The new operator essentially sets "this" within the 
// function to an empty object and returns that object
var instance = new Dog();

function Dog() {
    // this === instance, because of the "new" operator

    // For demonstration
    var self = this;

    this.walk = function () {
        // this === instance === self, because self/instance "owns" this function
        // In other words, this function is callable by self.walk()
    };

    var canWalk = function () {
        // What's the owner of this object? Nothing,
        // so it defaults to the global object, window
        // this === window

        // Instead, we can access the Dog instance by
        // using the "self" variable we set earlier.
        // self === instance
    };
}

希望能解决问题。

Answer 3

如您所见，像这样直接调用 canWalk 意味着“this”关键字被设置为该函数调用的全局对象。

如果你想在当前狗的上下文中运行调用，你可以明确地这样做：

canWalk.call(this)