Javascript 回调嵌套及其作用域

我在理解“this”的范围时遇到问题，尤其是在嵌套代码时

这是一个我有问题的例子

var callbacks = [];
MyClass.protoype.CallServer = function(name,index,callback)
{
   //some code
   callbacks[callback.length]  = callback;
   callserverfor(name,index, callbacks.length-1);

}

MyClass.prototype.ReceiveFromServer = function(callbackId,param)
{
   //somecode for simplicity let's say
   if(param)
    callbacks[callbackId].call(param);
  else
   callbacks[callbackId].call();
}

MyClass.prototype.Connect(Index,callback)
{
       CallServer('Connect' , Index, callback);
}

MyClass.prototype.Start= function(Index)
{

    this.Connect(Index,function()
    {
        this.ISConnected = true;

       //HERE this lost scope
        this.GetIdentified(Index, function( Identifier)
        { 
           alert('Identifier');

        });
    });
}

我甚至试过绑定

MyClass.prototype.ReceiveFromServer = function(callbackId,param)
{
   //somecode for simplicity let's say
   if(param)
    callbacks[callbackId].call(param);
  else
   callbacks[callbackId].call();
}

MyClass.prototype.Connect(Index,callback)
{
       CallServer('Connect' , Index, callback);
}

MyClass.prototype.Start= function(Index)
{

    this.Connect(Index,function()
    {
        this.ISConnected = true;
        var GetIdentifier = this.GetIdentifier;
        GetIdentifier.bind(this);
       //HERE this lost scope
        this.GetIdentifier(Index, function( Identifier)
        { 
           alert('Identifier');

        });
    });
}

当我试图使用我的代码中的哪一个指向这个。。它起作用了。。 我不明白这里发生了什么，我能理解吗

MyClass.prototype.ReceiveFromServer = function(callbackId,param)
{
   //somecode for simplicity let's say
   if(param)
    callbacks[callbackId].call(param);
  else
   callbacks[callbackId].call();
}

MyClass.prototype.Connect(Index,callback)
{
       CallServer('Connect' , Index, callback);
}

MyClass.prototype.Start= function(Index)
{
    var Me= this;

    this.Connect(Index,function()
    {
        Me.ISConnected = true;


       //HERE this lost scope
        Me.GetIdentifier(Index, function( Identifier)
        { 
           alert('Identifier');

        });
    });
}

---

是否有更好的方法来执行此操作或确定回调的范围？任何建议

让我用一个小例子来解释一下：

var functions=[]; //a common array
functions.name="functions" //we add an attribute to that object

function generator(v) {
    var temp=v;
    return function () {
            console.log(this.name+temp);

    };
}

for (var i=0;i<5;i++) {
    functions[i]=generator(i); // here we add a bunch of functions to that object
}

它将打印

“2”

，因为f是作为“独立”函数执行的，因此上下文是“全局上下文”，没有创建“name”属性

要小心回调，因为它们可以由其他对象或函数执行。例如，如果您设置了一个事件侦听器回调（您创建了一个当用户单击某个位置时要执行的函数），那么将执行它的是该事件的侦听器。因此，一个经典的技巧是创建一个变量“me”、“self”或“_this”，将所需的上下文存储在子句中：

var myObj={ name:'my object'};
myObject= function () {
  var self=this; //here
  window.onclick=function(e) {
    console.log("I'm keeping a link to myObj: "+ self.name);
  }
}

---

如果要选择其他上下文，还可以使用

f.call（context，first_参数）

或

f.apply（context，[param0，param1…]）

此

在javascript中的工作方式不同于其他语言。具体来说，所有函数都有

此

，而不仅仅是方法。因此，如果嵌套函数，那么嵌套函数中的

this

来自

function（）{}

而不是

MyClass

。下面的答案解释了

这个

是如何工作的：

var myObj={ name:'my object'};
myObject= function () {
  var self=this; //here
  window.onclick=function(e) {
    console.log("I'm keeping a link to myObj: "+ self.name);
  }
}