Javascript 为什么内部函数中当前对象的方法未定义？

在外部函数中，this.foo是bar，这是我所期望的。但是，在内部函数中，this.foo是未定义的，这非常令人惊讶。有人能帮我吗？谢谢

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }());
    }
};
myObject.func();

---

在外部函数中，它引用myObject，因此可以正确地引用和访问foo

在内部函数中，它是一个闭包，但是，它不再指myObject。因此，this.foo在内部函数中未定义（在ECMA 5之前，内部函数中的this将引用全局窗口对象；而在ECMA 5之前，内部函数中的this.foo将未定义） 为了解决这个问题，我们可以在引用它之前将它存储在一个局部变量中，比如self

var myObject = {
    foo: "bar",
    func: function () {
        var self = this;
        console.log("outer func:  self.foo = " + self.foo);
        (function () {
            console.log("inner func:  self.foo = " + self.foo);
        }());
    }
};
myObject.func();

---

在外部函数中，它引用myObject，因此可以正确地引用和访问foo

在内部函数中，它是一个闭包，但是，它不再指myObject。因此，this.foo在内部函数中未定义（在ECMA 5之前，内部函数中的this将引用全局窗口对象；而在ECMA 5之前，内部函数中的this.foo将未定义） 为了解决这个问题，我们可以在引用它之前将它存储在一个局部变量中，比如self

var myObject = {
    foo: "bar",
    func: function () {
        var self = this;
        console.log("outer func:  self.foo = " + self.foo);
        (function () {
            console.log("inner func:  self.foo = " + self.foo);
        }());
    }
};
myObject.func();

---

在外部函数中，它引用myObject，因此可以正确地引用和访问foo

在内部函数中，它是一个闭包，但是，它不再指myObject。因此，this.foo在内部函数中未定义（在ECMA 5之前，内部函数中的this将引用全局窗口对象；而在ECMA 5之前，内部函数中的this.foo将未定义） 为了解决这个问题，我们可以在引用它之前将它存储在一个局部变量中，比如self

var myObject = {
    foo: "bar",
    func: function () {
        var self = this;
        console.log("outer func:  self.foo = " + self.foo);
        (function () {
            console.log("inner func:  self.foo = " + self.foo);
        }());
    }
};
myObject.func();

---

在外部函数中，它引用myObject，因此可以正确地引用和访问foo

在内部函数中，它是一个闭包，但是，它不再指myObject。因此，this.foo在内部函数中未定义（在ECMA 5之前，内部函数中的this将引用全局窗口对象；而在ECMA 5之前，内部函数中的this.foo将未定义） 为了解决这个问题，我们可以在引用它之前将它存储在一个局部变量中，比如self

var myObject = {
    foo: "bar",
    func: function () {
        var self = this;
        console.log("outer func:  self.foo = " + self.foo);
        (function () {
            console.log("inner func:  self.foo = " + self.foo);
        }());
    }
};
myObject.func();

---

第一项实施是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

第二个实施方案是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

---

第一项实施是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

第二个实施方案是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

---

第一项实施是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

第二个实施方案是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

---

第一项实施是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

第二个实施方案是：

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func:  this.foo = " + this.foo);
        (function (self) {
            console.log("inner func:  self.foo = " + self.foo);
        }(this));
    }
};
myObject.func();

var myObject = {
    foo: "bar",
    func: function () {
        console.log("outer func: this.foo = " + this.foo);
        (function () {
            console.log("inner func:  this.foo = " + this.foo);
        }.bind(this));
    }
};
myObject.func();

---

ES5严格模式

未定义

，否则

窗口

。ES5严格模式

未定义

，否则

窗口

。ES5严格模式

未定义

，否则

窗口

。第二个模式未真正执行。你只是把它绑起来，就这样。利奥是对的。第二个没有被执行。要执行它，只需将（）放在后面。var myObject={foo:“bar”，func:function（）{console.log（“外部func:this.foo=“+this.foo”）；（函数（）{console.log（“内部func:this.foo=“+this.foo”）；}.bind（this）（）；}；myObject.func（）；我错过了括号（）（（第二个没有真正执行。你只是绑定了它，仅此而已。Leo是对的。第二个没有执行。要执行它，只需将（）放在它后面。var myObject={foo:“bar”，func:function（）{console.log（“outer func:this.foo=“+this.foo”）；（function（）{console.log(“内部func:this.foo=“+this.foo”）；}.bind（this）（）；}}；myObject.func（）；我错过了方括号（）（（第二个没有真正执行。你只是绑定了它，就这样。Leo是对的。第二个没有执行。要执行它，只需在它后面放（）。var myObject={foo:“bar”，func:function（）{console.log（”外部func:this.foo=“+this.foo”）；（函数（）{console.log（“内部func:this.foo=“+this.foo”）；}.bind（this）（）；}}}；myObject.func（）；我错过了方括号（）（（第二个方括号没有真正执行。您只是绑定了它，仅此而已。Leo是对的。第二个没有执行。要执行它，只需放置（）在它之后.var myObject={foo:“bar”，func:function（）{console.log（“外部func:this.foo=“+this.foo”）；（函数（）{console.log（“内部func:this.foo=“+this.foo”）；}.bind（this）（）；}}；myObject.func（）；我错过了括号（）((