-
Notifications
You must be signed in to change notification settings - Fork 0
/
1-2-1.html
607 lines (587 loc) · 16.3 KB
/
1-2-1.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
<!DOCTYPE html>
<html lang="zh-TW">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<link rel="icon" href="./public/favicon.ico" />
<meta http-equiv="cache-control" content="no-cache" />
<title></title>
<link rel="stylesheet" href=" https://necolas.github.io/normalize.css/8.0.1/normalize.css" />
<link rel="stylesheet" href="./hightlight/default.min.css" />
<link rel="stylesheet" href="./css/main.css" />
<link rel="stylesheet" href="./css/copybutton.css" />
<link rel="stylesheet" href="./css/hightlight.css" />
<script src="./hightlight/hightlight.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.11/clipboard.min.js"></script>
<!-- Google tag (gtag.js) -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-BEVZJDBC7Z"></script>
<script src="./js/gtag.js"></script>
</head>
<body>
<header>
<nav>
<h1>
<span id="toggle-menu"></span>
<a href="index.html"></a>
</h1>
</nav>
</header>
<main>
<aside>
<nav></nav>
</aside>
<article>
<h2 id="1-2-1">1-2-1 this</h2>
<h3>this 指向的規則</h3>
<ul>
<li>
在函數本體中，非顯性或隱式地簡單呼叫函數時，在嚴格模式下，函數內 的
<code>this</code>
會被綁定到 undefined 上，在非嚴格模式下則會被綁定到全域物件
<code>window/global</code>
上。
</li>
<li>
一般使用 new 方法呼叫建構函數時，建構函數內的
<code>this</code>
會被綁定到新建立的物件上。
</li>
<li>
一般透過 call/apply/bind 方法顯性呼叫函數時，函數本體內的
<code>this</code>
會被綁定 到指定參數的物件上。
</li>
<li>
一般透過上下文物件呼叫函數時，函數本體內的
<code>this</code>
會被綁定到該物件上。
</li>
<li>
在節頭函數中，
<code>this</code>
的指向是由外層 （函數或全域）作用域來決定的。
</li>
</ul>
<h3>全域環境中的 this</h3>
<p>
函數在瀏覽器全域環境中被簡單呼叫，在非嚴格模式下
<code>this</code>
指向
<code>window</code>
，在透過
<code>use strict</code>
指明嚴格模式的情況下指向
<code>undefined</code>
。
</p>
<pre><code class="language-js">
function f1(){
console.log(this)
}
function f2(){
'use strict'
console.log(this)
}
f1() // window
f2() // undefined
</code></pre>
<p>下列案例為上一個案例的變種：</p>
<pre><code class="language-js">
const foo = {
bar: 10,
fn: function(){
console.log(this)
console.log(this.bar)
}
}
var fn1 = foo.fn
fn1()
// 結果如下：
// window
// undefined
// 因為 window[bar] === undefined
</code></pre>
<p>
這裡的
<code>this</code>
仍然指向
<code>window</code>
。雖然切函數在 foo 物件中用來作為物件的方法，但是在設定值給
<code>fn1</code>
之後，
<code>fn1</code>
仍然是在
<code>window</code>
的全域環境中執行的。 因此，以上程式會輸出
<code>window</code>
和
<code>undefined</code>
。
</p>
<p>
改變呼叫行為會改變
<code>this</code>
指向。
</p>
<pre><code class="language-js">
const foo = {
bar: 10,
fn: function(){
console.log(this)
console.log(this.bar)
}
}
foo.fn()
// 結果如下：
// {bar: 10, fn:f()}
// 10
</code></pre>
<p>
這時，
<code>this</code>
指向的是最後呼叫它的物件。
</p>
<h3>上下文物件呼叫中的 this</h3>
<p>根據上面的例子，不難理解下列案例結果。</p>
<pre><code class="language-js">
const student = {
name: 'Lucas'
fn: function(){
return this
}
}
console.log( student.fn() === student) // true
</code></pre>
<p>
當存在更複雜的呼叫關係時，如以下程式中的巢狀結構關係，
<code>this</code>
會指向最後呼叫它的物件，因此輸出將是 Mike。
</p>
<pre><code class="language-js">
const person = {
name: 'Lucas'
brother:{
name: 'Mike!',
fn: function (){
return this.name
}
}
}
console.log( person.brother.fn() ) // 'Mike!'
</code></pre>
<p>以上都可以理解後來看更為複雜的案例：</p>
<pre><code class="language-js">
const o1 = {
text:'o1',
fn: function(){
return this.text
}
}
const o2 = {
text: 'o2',
fn: function(){
return o1.fn()
}
}
const o3 = {
text: 'o3',
fn: function(){
var fn = o1.fn
return fn()
}
}
console.log(o1.fn()) // 'o1'
console.log(o2.fn()) // 'o1'
console.log(o3.fn()) // undefined
// 原因是 var fn = o1.fn 設定裸奔呼叫，fn 位置所存的只有
// function(){
// return this.text
// }
// o3.fn() 可以看做 fn() 也就是直接執行上述 function
// 故<code>this</code>會指向 window
</code></pre>
<p>如果我們需要讓 console.log(o2.fn()) 敘述輸出 'o2'， 該怎麼做 ？</p>
<pre><code class="language-js">
const o1 = {
text: 'o1',
fn: function(){
return this.text
}
}
const o2 = {
text: 'o2',
fn: o1.fn
}
console.log(o2.fn())
</code></pre>
<p>
以上方法同樣應用了那個重要的結論：
<code>this</code>
指向最後呼叫它的物件。在上面的 程式中，我們提前進行了設定值操作，將函數 fn 掛載到 o2
物件上， fn 最後作 為 o2 物件的方法被呼叫。
</p>
<h3>
透過
<code>bind、call、apply</code>
改變
<code>this</code>
指向
</h3>
<p>
<code>call</code>
和
<code>apply</code>
會直接進行相關函數呼叫；
<code>bind</code>
不會執行相關函數，而是傳回一個新的函數，這個新的函數已經自動綁 定了新的
<code>this</code>
指向，開發者可以手動呼叫它。如果再說實際一點，就是
<code>call</code>
和
<code>apply</code>
之間的區別主要表現在參數設定上。
</p>
<p>以下 3 段程式是相等的</p>
<pre><code class="language-js">
// 1
const target = {}
fn.call(target,'arg1')
// 2
const target = {}
fn.apply(target, ['arg1', 'arg2'])
// 3
const target = {}
fn.bind(target,'arg1','arg2')()
</code></pre>
<pre><code class="language-js">
const foo = {
name: 'lucas',
logName: function () {
console.log(this.name)
}
}
const bar = {
name: 'mike'
}
console.log(foo.logName.call(bar))
</code></pre>
<p>
以上程式的執行結果為 'mike'，這不難了解。但是對
<code>call</code>
、
<code>apply</code>
、
<code>bind</code>
的進階考驗常常需要面試者結合建構函數及組合來實現繼承。關於建構函數的使用案例，我們會結合接下來的例題組合進行展示。
</p>
<h3>建構函數和 this</h3>
<pre><code class="language-js">
function Foo() {
this.bar = 'Lucas'
}
const instance = new Foo()
console.log(instance.bar) 'Lucas'
</code></pre>
<p>關於建構子的作用以上函式可以很直接地說明。就是在創建物件同時設定預設參數。</p>
<p>以下函式可以表述上述過程。</p>
<pre><code class="language-js">
function Foo() {
this.bar = 'Lucas'
}
var obj = {}
obj.__proto__ = Foo.prototype
Foo.call(obj)
</code></pre>
<p>
如果在建構函數中出現了顯性
<code>return</code>
的情況，那麼需要注意，其可以細分為兩種場景。場景1：執行以下程式將輸出
<code>undefined</code>
，此時
<code>instance</code>
傳回的是空白物件。
</p>
<pre><code class="language-js">
//場景1
function Foo(){
this.user = 'Lucas'
const o = {}
return o
}
const instance = new Foo()
console.log(instance.user) // undefined
</code></pre>
<p>
場景2：執行以下程式將輸出 Lucas，也就是說，
<code>instance</code>
此時傳回的是目標物件實例
<code>this</code>
。
</p>
<pre><code class="language-js">
//場景2
function Foo(){
this.user = 'Lucas'
return 1
}
const instance = new Foo()
console.log(instance.user) // 'Lucas'
</code></pre>
<p>
所以，如果建構函數中顯性傳回一個值，且傳回的是一個物件(傳回複雜類 型)，那麼
<code>this</code>
就指向這個傳回的物件；如果傳回的不是一個物件(傳回基本 類型)，那麼
<code>this</code>
仍然指向實例。
</p>
<h3>箭頭函數中的 this</h3>
<p>
箭頭函數中的
<code>this</code>
指向是由其所屬函數或全域作用域決定的。
</p>
<p>
來看一段範例程式。在這段程式中，
<code>this</code>
出現在
<code>setTimeout()</code>
的匿名函數 中，因此
<code>this</code>
指向
<code>window</code>
物件
</p>
<pre><code class="language-js">
const foo = {
fn: function(){
setTimeout(function(){
console.log(this)
},1)
}
}
console.log(foo.fn())
</code></pre>
<p>
如果需要讓
<code>this</code>
指向 foo 物件，則可以用箭頭函數來解決，程式如下
</p>
<pre><code class="language-js">
const foo = {
fn: function(){
setTimeout(()=> {
console.log(this)
},1)
}
}
console.log(foo.fn())
// {fn: f}
</code></pre>
<p>
單純的箭頭函數中的
<code>this</code>
指向問題非常簡單，但是如果綜合所有情況，並結合
<code>this</code>
的優先順序進行考驗，那麼這時
<code>this</code>
的指向並不容易確定。下面就來學習
<code>this</code>
優先順序的相關知識。
</p>
<h3>this 優先順序</h3>
<p>
透過
<code>call、apply、bind、new</code>
對
<code>this</code>
進行綁定的情況稱為顯性綁定，而把根據呼叫關係確定
<code>this</code>
指向的情況稱為隱式綁定。
</p>
<pre><code class="language-js">
function foo (a) {
console.log(this.a)
}
const obj1 = {
a: 1,
foo: foo
}
const obj2 = {
a: 2,
foo: foo
}
obi1.foo.call(obi2) // 2
obj2.foo.call(obi1) // 1
</code></pre>
<p>
觀察上述案例，
<code>call、apply</code>
的顯性綁定一般來說優先順序更高。下面再來看另一段範例程式。
</p>
<pre><code class="language-js">
function foo (a) {
this.a = a
}
const obj1 = {}
var bar = foo.bind(obj1)
bar(2)
console.log(obj1.a)
</code></pre>
<p>
上述程式透過
<code>bind</code>
將 bar 函數中的
<code>this</code>
<code>
綁定為 obj1 物件。執行 bar(2)後 obj1.a 值為 2 ，即執行 bar(2) 後， obj1 物件為 {a:2} 。
</code>
</p>
<p>當再使用 bar 作為建構函數時，例如執行以下程式，則會輸出 3</p>
<pre><code class="language-js">
var bar = new bar(3)
console.log(bar.a)
</code></pre>
<p>
bar 函數本身是透過
<code>bind</code>
方法建置的函數，其內部已經將
<code>this</code>
綁定為
<code>obj1</code>
，當 它再次作為建構函數透過
<code>new</code>
被呼叫時，傳回的實例就已經與
<code>obj1</code>
解綁了。
</p>
<p>
也就是說，
<code>new</code>
綁定修改了
<code>bind</code>
綁定中的
<code>this</code>
指向，因此
<code>new</code>
綁定的優先順 序比顯性
<code>bind</code>
綁定的更高。
</p>
<pre><code class="language-js">
function foo{
return a => console.log(this.a)
}
const obj1 = {
a: 2
}
const obj2 = {
a: 3
}
const bar = foo.call(obj1)
console.log(bar.call(obj2))
</code></pre>
<p>
以上程式的輸出結果為 2。由於 foo 中的
<code>this</code>
綁定到了
<code>obj1</code>
上，所以 bar (參考箭頭函數) 中的
<code>this</code>
也會綁定到
<code>obj1</code>
上，箭頭函數的綁定無法被修改
</p>
<p>如果將 foo 完全寫成如下所示的箭頭函數的形式，則會輸出 123。</p>
<pre><code class="language-js">
var a = 123
const foo = () => a => {
console.log(this.a)
}
const obj1 ={
a: 2
}
const obj2 = {
a: 3
}
var bar = foo.call(obj1)
console.log(bar.call(obj2))
</code></pre>
<p>這裡再做個小變化，僅將上述程式中第一處變數 a 的宣告修改一下，即變成 如下所示的樣子</p>
<pre><code class="language-js">
const a = 123
const foo = () => a =>{
console.log(this.a)
}
const obj1 = {
a: 2
}
const obj2 = {
a: 3
}
var bar = foo.call(obi1)
console.log(bar.call(obj2))
</code></pre>
<p>
答案為
<code>undefined</code>
，原因是使用
<code>const</code>
宣告的變數不會掛載到
<code>window</code>
全域物件上。因此，
<code>this</code>
指向
<code>window</code>
時，自然也找不到 a 變數了。
</p>
<h3>開放例題分析</h3>
<p>
其中，最典型的一道題目為：實現一個
<code>bind</code>
函數。
</p>
<pre><code class="language-js">
Function.prototype.bind = Function.prototype.bind || function(context){
var me = this;
var args = Array.prototype.slice.call(arguments, 1);
return function bound(){
var innerArgs = Array.prototype.slice.call(arguments) ;
var finalArgs = args.concat(innerArgs) ;
return me.apply(context,finalArgs);
}
}
</code></pre>
<p>
這樣的實現已經非常不錯了。但是，就如之前在
<code>this</code>
優先順序分析那裡所展示的規則：
<code>bind</code>
傳回的函數如果作為建構函數搭配
<code>new</code>
關鍵字出現的話，綁定的
<code>this</code>
就會「被忽略」。
</p>
<p>
為了實現這樣的規則，開發者需要考慮如何區分這兩種呼叫方式。實際來講 就是，要在 bound
函數中進行
<code>this</code>
<code>instanceof</code>
判斷。
</p>
<p>
另外一個細節是，函數具有
<code>length</code>
屬性，用來表示形式參數的個數。在上
述實現方式中，形式參數的個數顯然會失真。所以，改進的實現方式需要對
<code>length</code>
屬性進行還原。可是困難在於，函數的
<code>length</code>
屬性值是不可重新定義的。
</p>
</article>
</main>
</body>
<script type="module" src="./js/main.js"></script>
</html>