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

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

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

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

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

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

Answer 1

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

在你的例子中，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 也指的是狗实例，因为您将 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)