this指向的問題也是JavaScript中的難點之一了，也是面試常問的問題，很多時候對this指向的問題就很懵逼，明明應該是指向他，為什么又指向他了…所以我就學習了一下這方面的知識，整理了一下，希望能夠幫助大家
為什么要用this?
首先看一段代碼
function identify(){
return this.name.toUpperCase()
}
function speak(){
var greeting = '你好,我是'+identify.call(this)
console.log(greeting)
}
var me ={
name:'kyle'
}
var you ={
name:"reader"
}
identify.call(me)
identify.call(you)
speak.call(me) //? 你好,我是KYLE
speak.call(you) //? 你好,我是READER
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
-
14
-
15
-
16
-
17
-
18
-
19
-
20
上面的這段代碼中可以從不同的上下文對象 me 和 you 中重復的使用identify函數和speak函數
如果你不使用this的話 你就要顯式的將上下文對象作為參數傳遞進去，比如這樣:
function identify(context){
return context.name.toUpperCase()
}
function speak(context){
var greeting = '你好,我是'+identify(context)
console.log(greeting)
}
var me ={
name:'kyle'
}
var you ={
name:"reader"
}
identify(me)
identify(you)
speak(me)
speak(you)
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
-
14
-
15
-
16
-
17
-
18
-
19
-
20
就像這樣,這樣看起來就不想上面那樣簡潔了,你要把一個對象傳來傳去的
認識this
剛見到this的時候 覺得this指向是這個函數自身，或者是函數的作用域，后來發現其實不是這樣的的，不過也不能說錯了,因為有些情況確實是這樣的,比如這樣:
function foo(num){
console.log('foo'+ num)
this.count ++
}
foo.count = 0
var i;
for(i = 0;i<10;i++){
if(i>5){
foo.call(foo,i)
}
}
console.log(foo.count) //4 這樣的話 this指向了foo本身 foo上面的count屬性++
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
-
14
無法指向函數作用域
var a = 3
function foo() {
var a = 2;
bar.call(foo);
}
function bar() {
console.log( this.a );
}
foo(); // undefined
我們要記住非常重要的一點:this是在運行的時候進行綁定的，而不是在定義的時候綁定，this的綁定跟函數聲明的位置沒有關系，主要是取決于函數的調用方式,想要找到this指向誰，我們就要看懂函數是怎么調用的。
綁定規則
1.默認綁定
當一個獨立函數正常調用的時候，不帶任何修飾的調用
// 非嚴格模式下
var a = 3
function foo(){
console.log(this.a) //a
}
foo()
這種情況下 this.a被解析成了了 全局變量a，this指向是全局對象
// 嚴格模式下
var a = 3
function foo(){
"use strict"
console.log(this.a) //TypeError
}
foo()
嚴格模式下 this不會指向全局對象 this綁定的是undefined
2.隱式綁定
調用位置上是否有上下文對象
function foo(){
console.log(this.a)
}
var obj = {
a:2,
foo:foo
}
obj.foo() //2
調用位置會使用obj上下文對象來引用函數，foo被調用的時候 他的落腳點指向是obj對象，隱式綁定的規則就會把this指向這個上下文對象。所以this.a就跟 obj.a是一樣的
function foo(){
console.log(this.a)
}
var obj = {
a:2,
foo:foo
}
var obj2 = {
a:3,
obj:obj
}
obj2.obj.foo() //2
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
當多層調用的時候 只有最后一層才會影響函數的調用位置 比如上面這個 this綁定的還是 obj 而不是obj2
注意
隱式綁定會出現隱式丟失的問題，會失去綁定對象,最后應用默認綁定
var a = 3;
function foo(){
console.log(this.a);
}
var obj = {
a:2,
foo:foo
}
var bar = obj.foo
bar() //3
bar 是 obj.foo的一個引用 他引用的是foo函數本身，此時bar就是一個不帶任何修飾的函數調用 應用默認綁定
var a = 3;
function foo(){
console.log(this.a);
}
var obj = {
a:2,
foo:foo
}
setTimeout( obj.foo, 100 ) //3
setTimeout(function(fn){
fn()
},100,obj.foo) //3
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
參數傳遞也是一種隱式賦值，回調函數丟失this是非常常見的…
3.顯式綁定
隱式綁定的時候我們必須在一個對象內部包含一個指向函數的屬性，然后通過屬性間接引用函數，把這個this間接隱式的綁定到這個對象上
如果我們不想在對象內部包含函數的引用 ，而想在某個對象上強制調用函數
我們可以把這個函數綁定到對象的原型上，也算是不用再對象內部包含函數了吧…
更好的辦法是我們可以使用函數的 call() apply() bind() 這種方法
function foo(){
console.log(this.a)
}
var obj = {
a:2
}
foo.call(obj) //2
foo.apply(obj) //2
如果你第一個參數傳入的是一個原始類型 比如字符串 布爾 數字作為綁定對象 這些原始類型會被轉換為 對象的形式 new String() new Number()…
硬綁定
Function.prototype.bind()
function foo(){
console.log(this.a)
}
var obj = {
a:2
}
var obj2 = {
a:3
}
var bar = foo.bind(obj) //會返回一個硬編碼的新函數 他會把參數設置為this的上下文
bar.call(obj2) //2 返回的新函數
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
有些api 方法 會提供一個可選參數 context 其作用跟bind一樣 確保你的回調函數使用指定的this 比如 array.forEach(fn,context)…
4.new綁定
使用new 來調用函數的時候會執行以下操作
1.創建一個全新的對象
2.這個新對象會被執行原型的鏈接
3.新對象會綁定到函數調用的this
4.如果沒有返回其他的對象，那么函數會自動返回這個對象
function Foo(a){
this.a = a
}
var bar = new Foo(2)
console.log(bar.a) //2
使用new 來調用Foo函數 會構造一個新對象并把它綁定到Foo調用中的this上 然后返回了
優先級
函數不帶任何修飾的時候單獨調用才會觸發默認綁定 所以說默認綁定是優先級最低的了
那剩下三個規則哪個的優先級最高？
顯示綁定跟隱式綁定比較
function foo(){
console.log(this.a)
}
var obj1 = {
a:1,
foo:foo
}
var obj2 = {
a:2,
foo:foo
}
obj1.foo() //1
obj2.foo() //2
obj1.foo.call(obj2) //2
obj2.foo.call(obj1) //1
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
-
14
-
15
-
16
-
17
可以看到 顯示綁定的優先級還是更高一點
new 綁定跟隱式綁定比較
function foo(arg){
this.a = arg
}
var obj1 ={
foo:foo
}
var obj2 ={}
obj1.foo(2)
console.log(obj1.a) //2
var bar = new obj1.foo(4)
console.log(obj1.a) //2
console.log(bar.a) //4
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
-
14
-
15
可以看到 new綁定的優先級比隱式綁定要高
new 綁定跟顯示綁定比較
new跟call apply無法一起使用 無法通過new foo.call(obj)，試一下硬綁定
在這里插入代碼片
function foo(arg){
this.a = arg
}
var obj1 ={}
var bar = foo.bind(obj1)
bar(3)
console.log(obj1.a) //3
var baz = new bar(4)
console.log(baz.a) //4
console.log(obj1.a) //3
new 調用bar修改了硬綁定時候的 函數的this new的優先級高一點
所以我們可以根據下面的優先級規則進行判斷了
1.函數是否在new中調用 是的話this綁定新創建的對象 var bar = new Foo()
2.函數是否通過call apply 顯示綁定或者是 bind硬綁定 如果是的話this指向指定的對象 foo.call(obj)
3.函數是否在某個上下文中調用 隱式綁定，如果是 this綁定那個上下文對象 注意綁定丟失的問題
4.如果都不是 就是默認綁定非嚴格模式下綁定的是全局對象 嚴格模式下綁定的是undefined
綁定例外
1.將null和undefined作為call apply參數 作為this綁定對象的時候 這些值會被忽略 應用的是默認綁定
var a =3
function foo(){
console.log(this.a) //3
}
foo.call(null)
2.箭頭函數
function foo(){
return ()=>{
console.log(this.a)
}
}
var obj1 = {
a:3
}
var obj2 = {
a:4
}
var bar = foo.call(obj1)
bar.call(obj2) //3 this綁定的是obj1 而不是obj2!!!
-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
在看一個
function foo(){
setTimeout(()=>{
console.log(this.a) //2
},100)
}
var obj = {
a:2
}
foo.call(obj)
箭頭函數不使用this綁定的四種規則，而是根據外層作用域來決定this的，外層作用域的this綁定的是什么 他的this就是什么
轉自：csdn 論壇 作者：Selfimpr歐
藍藍設計( www.lzhte.cn )是一家專注而深入的界面設計公司，為期望卓越的國內外企業提供卓越的UI界面設計、BS界面設計 、 cs界面設計 、 ipad界面設計 、 包裝設計 、 圖標定制 、 用戶體驗 、交互設計、 網站建設 、平面設計服務
