javascript的動態this與動態綁定

window.name = "window";
var run = function() {
alert("My name is " + this.name);
}
run();

運行代碼
這裏你不能說run是作爲window的一個屬性而存在，但它的確是被window屬性調用了。實質上大多數暴露在最上層的東西都則window 接管了。在它們需要調用時被拷貝到window這個對象上（不過在IE中window並不繼承對象），於是有了window['xxx']與 window.xxx性能上的差異。這是內部實現，不深究了。
另一個例子，綁定到一個明確的對象上
window.name = "window";
object = {
name: "object",
run: function() {
alert("My name is " + this.name);
}
};
object.run();

運行代碼
答案顯然易見，this總是爲它的調用者。但如果複雜一點呢？
window.name = "window";
object = {
name: "object",
run: function() {
var inner = function(){
alert("My name is " + this.name);
}
inner();
}
};
object.run();

運行代碼
儘管它是定義在object內部，儘管它是定義run函數內部，但它彈出的既不是object也不是run，因爲它既不是object的屬性也不 是run的屬性。它鬆散在存在於run的作用域用，不能被前兩者調用，就只有被window拯救。window等原生對象浸透於在所有腳本的內部，無孔不 入，只要哪裏需要到它做貢獻的地方，它都義不容辭。但通常我們不需要它來幫倒忙，這就需要奠出call與apply兩大利器了。
window.name = "window";
var object = {
name: "object",
run: function() {
inner = function() {
alert( this.name);
}
inner.call(this);
}
}

object.run();

運行代碼
call與apply的區別在於第一個參數以後的參數的形式，call是一個個，aplly則都放到一個數組上，在參數不明確的情況，我們可以借 助arguments與Array.slice輕鬆搞定。
window.name = "Window";

var cat = {
name: "Cat"
};
var dog = {
name: "Dog",
sound: function(word) {
alert(this.name + word);
}
};

dog.sound(" is pooping");
dog.sound.call(window, " is banking");
dog.sound.call(dog, " is banking");
dog.sound.apply(cat, [" miaowing"]);

運行代碼
由此Prototype開發者搞了一個非常有名的函數出來，bind!以下是它的一個最簡單的版本：
var bind = function(context, fn) {
return function() {
return fn.apply(context, arguments);
}
}

運行代碼
不過爲了面對更復雜的情況建議用以下版本。
function bind(context,fn) {
var args = Array.prototype.slice.call(arguments, 2);
return args.length == 0 ? function() {
return fn.apply(context, arguments);
} : function() {
return fn.apply(context, args.concat.apply(args, arguments));
};
};
它還有一個孿生兄弟叫bindAsEventListener ，綁定事件對象，沒什麼好說的。
var bindAsEventListener = function(context, fn) {
return function(e) {
return fn.call(context, (e|| window.event));
}
}
Prototype的版本
Function.prototype.bind = function() {
if (arguments.length < 2 && (typeof arguments[0]==='undefined'))
return this;
var _slice = Array.prototype.slice
var __method = this, args = _slice.call(arguments,0), context = args.shift();
return function() {
return __method.apply(context, args.concat(_slice.call(arguments,0)));
}
}

運行代碼
bind函數是如此有用，google早早已把它加入到Function的原型中了（此外還有inherits，mixin與partial）。

運行代碼
有綁定就有反綁定，或者叫剝離更好！例如原生對象的泛化方法我們是無法通過遍歷取出它們的。
for(var i in Array){
alert(i + " : "+ Array[i])
}
for(var i in Array.prototype){
alert(i + " : "+ Array.prototype[i])
}

運行代碼
要取出它們就需要這個東西：
var _slice = Array.prototype.slice;
function unbind(fn) {//第一步取得泛化方法
return function(context) {//第二部用對應原生對象去重新調用！
return fn.apply(context, _slice.call(arguments, 1));
};
};
示例以前也給過了，請見這裏
總結：
this 的值取決於 function 被調用的方式，一共有四種，
如果一個 function 是一個對象的屬性，該 funtion 被調用的時候，this 的值是這個對象。如果 function 調用的表達式包含句點（.）或是 []，this 的值是句點（.）或是 [] 之前的對象。如myObj.func 和myObj["func"] 中，func 被調用時的 this 是myObj。
如果一個 function 不是作爲一個對象的屬性，那麼該 function 被調用的時候，this 的值是全局對象。當一個 function 中包含內部 function 的時候，如果不理解 this 的正確含義，很容易造成錯誤。這是由於內部 function 的 this 值與它外部的 function 的 this 值是不一樣的。解決辦法是將外部 function 的 this 值保存在一個變量中，在內部 function 中使用它來查找變量。
如果在一個 function 之前使用 new 的話，會創建一個新的對象，該 funtion 也會被調用，而 this 的值是新創建的那個對象。如function User(name) {this.name = name}; var user1 = new User("Alex"); 中，通過調用new User("Alex") ，會創建一個新的對象，以user1 來引用，User 這個 function 也會被調用，會在user1 這個對象中設置名爲name 的屬性，其值是Alex 。
可以通過 function 的 apply 和 call 方法來指定它被調用的時候的 this 的值。 apply 和 call 的第一個參數都是要指定的 this 的值。由於它們存在，我們得以創建各種有用的函數。