~~~ let 與var區別 1. 變量提升； 2. 重復聲明； 3. let 聲明的和Window沒有關系； 4. 暫時性死區； 5. let 可以形成塊級作用域； 嚴格模式this是undefined 構造函數，this是當前類的實例 /* * 用來改變某一個函數中THIS關鍵字指向的 * call * apply * bind */ window.name = '珠峰'; let fn = function () { console.log(this.name); }; let obj = { name: "OBJ", fn: fn // obj 有個屬性叫fn,fn的值是fn函數 }; let oo = {name: "OO"}; // fn();//=>this:window "珠峰" // obj.fn();//=>this:obj "OBJ" oo.fn() // 報錯 fn.call(oo) //oo ~~~  ~~~ /* * call * 1. [fn].call([this],[param]...) * fn.call：當前實例(函數FN)通過原型鏈的查找機制，找到 * Function.prototype上的call方法 =>function call(){[native code]} * * fn.call()：把找到的call方法執行 * * 當call方法執行的時候，內部處理了一些事情 * =>1。首先把要操作函數中的THIS關鍵字變為CALL方法第一個傳遞的實參值 * =>2。把CALL方法第二個及第二個以后的實參獲取到 * =>3。把要操作的函數執行，并且把第二個以后的傳遞進來的實參傳給要操作的函數 * fn.call(obj,10,20,30) 10,20,30傳給fn */ var ary = []; ary.slice; ary.__proto__slice; //ary這個實例直接通過__proto__找到Array這個原型slice fn.call ; // 找到方法 fn.call(); //找到并執行； // fn.call(oo);//=>this:oo // fn.call(obj,10,20,30);//=>this:obj ,把fn中的this改成call中的第一個參數 /*Function.prototype.call = function () { let param1 = arguments[0], paramOther = [];//=>把ARG中除了第一個以外的實參獲取到 //=>this:fn 當前要操作的函數(函數類的一個實例) //把FN中的THIS關鍵字修改為PARAM1 => 把THIS(CALL中)中的this關鍵字修改為param1 //=>把fn執行，把paramOther分別傳遞給fn // this(paramOther) =>fn(paramOther) }; fn.call({name:'xx'}) sum.call({..}) */ let sum=function(a,b){ console.log(this);//=>opt }; let opt={n:20}; // sum.call(opt,20,30);//=>call執行 call中的this是sum 把this(call中的)中的“this關鍵字”改為opt 把this(call中的)執行， 把20,30分別傳遞給它 //=>sum中this:opt a=20 b=30 sum.call.call(opt) //1.sum.call 找到Function.prototype上的call方法(也是一個函數， 也是函數類的一個實例，也可以繼續調用call/apply等方法) =>A（函數） //2.A.call(opt) 繼續找到原型上的call方法，把call方法執行： 把A中的this關鍵字修改為opt，然后把A執行 ~~~ ~~~ /* Function.prototype.call=function callAA(){ //=>1.把THIS(FN)中的"THIS關鍵字"修改為第一個參數值(OBJ) //=>2.把THIS(FN)執行,把第二個及以后接受的參數值傳遞給函數(10,20) //this(10,20) }; fn.call(obj,10,20) */ function fn1(){console.log(1);} //么有this function fn2(){console.log(2);} fn1.call(fn2);//=>找到CALL-AA把它執行,CALL-AA中的THIS是FN1, 第一個參數傳遞的是FN2 =>在CALL-AA中執行的是FN1 =>1 fn1.call.call(fn2);//=>找到CALL-AA讓它執行,CALL-AA中的THIS是FN1.CALL, 第一個參數是FN2 (把FN1.CALL中的THIS變為FN2，再讓FN1.CALL執行 =>先找到CALL-AA，把它執行，只不過此時它中的THIS是FN2 =>讓FN2中的THIS變為UNDEFINED，因為執行FN1.CALL的時候沒有傳遞參數值， 然后讓FN2執行) =>2 Function.prototype.call(fn1);//=>先找到CALL-AA把它執行， 它中的THIS是Function.prototype =>讓F.P中的THIS變為FN1,然后讓F.P執行, F.P是一個匿名函數也是一個空函數，執行沒有任何的輸出 Function.prototype.call.call(fn1);//=>先找到CALL-AA把它執行，它中的THIS是F.P.CALL =>把F.P.CALL中的THIS修改為FN1,讓F.P.CALL執行 =>F.P.CALL(CALL-AA)第二次把它執行(此時它里面的THIS已經是FN1) =>這一次其實在CALL-AA中是讓FN1執行 =>1 //<==> fn1.call.call(fn2) //<==> fn1.call===Function.prototype.call ：true fn1.call.call.call.call.call(fn2); //=>fn1.call.call.call.call===Function.prototype.call ~~~ **一個call執行前面的，2個2個以上，讓后面的執行 **