使用_self所以我總是可以有對象上下文

Question

什麼是使用_self總是有權訪問一個對象的正確方法？正在使用_self好，還是不好的做法？

我想要一個很好的方法來獲取myObject的屬性和方法，即使是在myObject上下文中沒有調用的函數。有像.bind(this)，使用_self和jQuery的$.proxy()的解決方案。

例如：

var myObject = { 
    name: 'Tyrion', 
    alias: 'imp', 
    _self: function() { 
    return this; 
    }, 

    // I know this context is fine, but let's pretend it's being called from elsewhere. 
    getAlias: function() { 
    var _self = myObject._self(); 
    return _self.alias; 
    } 
} 

Answer 1

爲了做你希望做什麼，你就必須改變一些東西。 @elclanrs是正確的關於你的this上下文是。下面我會提供兩個選項。

var myObject = { 
    name: 'Tyrion', 
    alias: 'imp', 
    // I know this context is fine, but let's pretend it's being called from elsewhere. 
    getAlias: function() { 
    // you'd have to do this in every method. 
    var _self = this; 
    return _self.alias; 
    } 
} 

另一種選擇是有點不同的，而不是可用的，但我加入，所以你可以看到它：在二審

var myObject = function() { 
    var _self = this; 
    _self.name = 'Tyrion'; 
    _self.alias = 'imp'; 
    _self.getAlias = function() { 
     return _self.alias; 
    }; 
}; 

，getAlias會作爲一個更好的原型方法，但您將無法訪問_self變量，只有this。

Answer 2

你也可以這樣做，但我不一定會推薦它。

var obj = { 
    _self: this.obj, // if you don't have .obj it points to window 
    thing: 'thingy', 
    alsoThis: function() { 
    return 'another thing' 
    } 
}; 

obj._self; 

它也有可能是因爲它不是一個封閉，或。換句話說函數內，的this._self上下文如果上下文是由它的在所引用的範圍改變可能不正確。

通常，我正好在var _self = this;之前，我正在嵌套另一個函數，因爲嵌套的函數不能訪問嵌套的值，所以需要this上下文。

根據我的經驗，這通常不會太常見，而且您確實不應該聲明這樣的屬性/ var需要用於_self vars服務的目的。這不是一個好的做法，最好不要做。

如果遇到需要擁有_self =其他上下文的情況，該怎麼辦？

Answer 3

this由調用函數決定。 （也就是函數的調用方式）請參閱我的其他answers以獲取更多details。

var myObject = { 
    name: 'Tyrion', 
    alias: 'imp', 
    _self: function() { 
     return this; 
    }, 

    // I know this context is fine, but let's pretend it's being called from elsewhere. 
    getAlias: function() { 
     var _self = myObject._self(); 
     return _self.alias; 
    } 
}; 

//member invocation 
console.log(myObject._self() === myObject); // true 

var aFucntion = myObject._self; 
//functional invocation 
console.log(aFucntion() === myObject); // false 
console.log(aFucntion() === this); //true 

相反擔心的this上下文，一個解決方法是將分配到this在外部函數的值，然後訪問在內部函數值。這就是所謂的封閉

var MyObject = function (title) { 
    var _self = this, 
     helper = function() { 
      return _self.title + " " + _self.name; 
     }; 
    this.title = title; 
    this.fullName = function() { 
     return helper(); //functional invocation 
     //if helper used this, this would be global 
    }; 
    this.name = 'Tyrion'; 
    this.alias = 'imp'; 
    this.getAlias = function() { 
     //access to _self through closure 
     return _self.alias; 
    }; 
}; 

//constructor invocation 
var aObject = new MyObject("Mr."); 
console.log(aObject.getAlias()); //imp 
console.log(aObject.fullName()); //Mr. Tyrion 

FYI：

如果_self返回myObject的，上下文不會母校。

_self: function() { 
     return myObject; 
    }