JS this绑定的绑定细节、超过规则之外、面试题、优先级

作者: 咸鱼不咸_123 | 来源:发表于2022-04-20 00:51 被阅读0次

JS this绑定的绑定细节、超过规则之外、面试题、优先级
JS this机制
this对象
js中的this详细介绍
RN中的this机制
js -> this
DOM的事件绑定、事件监听
如何正确的判断this? 箭头函数的this是什么？
this绑定规则优先级
this

1.number内存优化

在js中，number占的内存大小是8个字节。但是这其实会在V8做一些优化，小的数据类型其实并不会占用8个字节，只占4个字节

function createFnArray(){
  /**
   * B KB MB GB TB 进制转换是1024
   * js的number类型是占内存中占8个字节，但是在V8中会进行优化
   * 小的数据类型在V8中，是Sim，只占4个字节
   * 
   */
  var arr=new Array(1024*1024).fill(1); //这个空间占据了4KB
  return function(){
    console.log(arr.length);
  }
}

2.内置函数的this

2.1 setTimeout

setTimeout函数是独立调用的，所以this指向的是window，但如果传入的是箭头函数就不一样了

setTimeout(function(){
  console.log(this);//window
},2000)

2.2 dom元素的相关操作

2.2.1 onclick事件的添加

const boxDiv=document.querySelector(".box")
boxDiv.onclick=function(){ //这个只能添加一个
  console.log("我被点击了",this);
}
boxDiv.onclick=function(){ //这个只能添加一个，后面添加的会覆盖前面的
  console.log("我被点击了2",this);
}



//内部应该进行了这样的调用 boxDiv.onclick()，所以this隐式绑定了这个对象,也就是绑定了这个dom元素上

2.2.2 addEventListener

/**
 * * 监听.box的点击 addEventListener 可以添加多个
 * * 内部的实现应该是把函数放在这个dom元素的对象的数组里面，然后点击的时候，遍历这个函数的点击的数组，进行调用，this指向的是这个dom元素
 */
const  boxDiv=document.querySelector(".box")
boxDiv.addEventListener("click",function(){
  console.log("我被点击了1",this);
})
boxDiv.addEventListener("click",function(){
  console.log("我被点击了2",this);
})
boxDiv.addEventListener("click",function(){
  console.log("我被点击了3",this);
})

2.3 数组的方法map、filter、find等

2.3.1 不指定默认this指向的是window

var names=["wjy","hyz","tqy"];
names.forEach(function(item){
  console.log(item,this);
})

28.png

2.3.2 指定数组方法的this绑定

数组的方法，是可以传入第二个参数的，第一个参数是函数，第二个参数可以传一个对象，this会绑定到这个对象上

var names=["wjy","hyz","tqy"];
names.forEach(function(item){
  console.log(item,this);
},"aabbcc")

29.png

31.png

32.png

this的绑定细节和面试题分析.png

2.4 内置函数绑定的思考

有些时候，我们会调用一些javascript的内置函数，或者第三方库的函数

这些内置函数会要求我们传入另外一共函数
我们并不会显式的调用这些函数，因为javascript的内部或者第三方库内部会帮助我们执行
这些函数中的this又是如何绑定的呢

如

setTimeout、div的点击、数组的相关方法

3.绑定规则的优先级

学习了四条规则，接下来开发中我们只需要查找函数调用应用哪些规则即可，但是如果一个函数调用位置应用了多条规则，优先级谁更高呢？

默认绑定优先级别最低的
显式绑定高于隐式绑定
new绑定高于隐式绑定
new绑定高于显式绑定

new绑定>显式绑定>隐式绑定>默认绑定

3.1 显式绑定高于隐式绑定

以下是隐式绑定：

var obj={
  name:"wjy",
  foo:function(){
    console.log(this);
  }
}
obj.foo()

30.png

以下是应用了多条规则：隐式绑定、显式绑定

var obj={
  name:"wjy",
  foo:function(){
    console.log(this);
  }
}
obj.foo.call("aaa")

31.png

bind的绑定高于隐式绑定

function foo(){
  console.log(this);
}

var obj={
  name:"wjy",
  foo:foo.bind("abc")
}
obj.foo()

3.2 new绑定高于隐式绑定

var obj={
  name:"wjy",
  foo:function(){
    console.log(this);
  }
}
var f=new obj.foo()

32.png

3.3 new绑定高于显式绑定

new关键字不能和call、apply一起使用

// new关键字不能和call、apply一起使用
function foo(){
  console.log(this);
}
var bar=foo.bind("aaa");
var fn=new bar()

4.this规则之外

4.1忽略显式绑定

我们讲到的规则已经足以应付平时的开发，但是总有一些语法、超出了我们的规则之外。

如果显式绑定this的值为null、undeifned，那么this指向并不是指向null、undefined，而是指向了全局对象
- 如果是在浏览器中，则指向的是window
- 如果是在node环境中，则指向的是node的全局对象

function foo(){
  console.log(this);
}
foo.apply("abc")//指向这个字符串 "abc"
foo.call({}) //指向了这个空对象
foo.apply(null)//指向window
foo.apply(undefined) //指向window

4.2 间接函数引用

另外一种情况，创建一共函数的间接引用。这种情况使用默认绑定规则

赋值(obj2.foo=obj1.foo)的结果是foo函数
foo函数被直接调用，那么是默认绑定

var obj1={
  name:"obj1",
  foo:function(){
    console.log(this);
  }
}
var obj2={
  name:"obj2"
};
(obj2.bar=obj1.foo)();//会返回一共foo函数，这个属于独立的函数调用，this指向的是全局对象

4.3 ES6箭头函数

箭头函数不使用this的四种绑定规则（也就是不绑定this），而是根据外层的作用域来决定this

var name="wjy";
var foo=()=>{
  console.log(this);
}
foo();//window
foo.call('aaa')//window
foo.call({name:'hyz'})//window

4.3.1 应用场景

在没有箭头函数之前，需要这样做，才能使用到外层的data

var obj={
  data:[],
  getData:function(){
    // 在箭头函数之前的解决方案
    var _this=this;
    //网络请求
    setTimeout(function(){
      var result=["abc","def","why"];
      _this.data=result
    })
  }
} 
obj.getData();
console.log(obj);

箭头函数出现之后，可以这样来做:

var obj={
  data:[],
  getData:function(){
    //网络请求
    setTimeout(()=>{
      var result=["abc","def","why"];
      this.data=result
    })
  }
} 
obj.getData();
console.log(obj);

5.箭头函数 arrow function

箭头函数是ES6之后增加的一种编写函数的方法，并且它比函数表达式更加简洁

箭头函数不会绑定this、arguments属性
箭头函数不能作为构造函数来使用（不能和new关键字一起使用，会抛出错误）

语法形式：

(参数列表)=>{
    //执行体
}

例如：

var foo=(num1,num2)=>{
  return num1+num2
}

5.1 箭头函数的简写

5.1.1 当参数只有一个小括号可以省略,多个参数、没有参数不可省略

小括号可以省略

var bar=(item)=>{
  return item;
}

简写形式

var bar=item=>{
  return item;
}

5.1.2 如果函数执行体只有一行代码，那么大括号是可以省略的

如果函数执行体只有一行代码，大括号是可以省略的，并且它默认会将这行代码的执行结果作为返回值

var nums=[1,2,3,4,5];
nums.forEach(item=>console.log(item))

var nums=[1,2,3,4,5];
var nums2=nums.filter(item=>item%2==0)
console.log(nums2);// [2,4]

5.1.3 如果一个箭头函数，只有一行代码，并且返回一个对象，这个时候如何编写简写

直接用小括号将对象括起来，一般小括号里面的内容会当作一个整体

var bar=()=>{
  return {name:'wjy',age:20}
}

简写:

var bar=()=>( {name:'wjy',age:20})

6.面试题

6.1 面试题1

var name="window";
var person={
  name:"person",
  sayName:function(){
    console.log(this.name);
  }
}
function sayName(){
  var sss=person.sayName;
  sss();
  person.sayName();
  (person.sayName)();
  (b=person.sayName)();
}
sayName();

window person person window

6.2 面试题2

var name="window";
var person1={
  name:'person1',
  foo1:function(){
    console.log(this.name);
  },
  foo2:()=>console.log(this.name),
  foo3:function(){
    return function(){
      console.log(this.name);
    }
  },
  foo4:function(){
    return ()=>{
      console.log(this.name);
    }
  }
}

var person2={name:'person2'};
person1.foo1(); 
person1.foo1.call(person2) 

person1.foo2();
person1.foo2.call(person2) 


person1.foo3()(); 
person1.foo3().call(person2) 

person1.foo4()() 
person1.foo4().call(person2)

person1 person2 window window window window person1 person1

6.3 面试题3

var name="window";
function Person(name){
  this.name=name;
  this.foo1=function(){
    console.log(this.name);
  }
  this.foo2=()=>console.log(this.name);  //这个对象
  this.foo3=function(){
    return function(){
      console.log(this.name);
    }
  }
  this.foo4=function(){
    return ()=>{ //这个对象
      console.log(this.name); 
    }
  }
}

var person1=new Person("person1");
var person2=new Person("person2");
person1.foo1(); //person1
person1.foo1.call(person2); //person2

person1.foo2();// person1
person1.foo2.call(person2);//person1

person1.foo3()();// window
person1.foo3.call(person2)();//window
person1.foo3().call(person2)// person2

person1.foo4()(); //person1
person1.foo4.call(person2)()//person2
person1.foo4().call(person2);//person1

6.4 面试题4

var name='window';
function Person(name){
  this.name=name;
  this.obj={
    name:'obj',
    foo1:function(){ 
      return function(){
        console.log(this.name);
      }
    },
    foo2:function(){
      return ()=>{ // obj
        console.log(this.name);
      }
    }
  }
}

var person1=new Person('person1');
var person2=new Person('person2');

person1.obj.foo1()(); //window
person1.obj.foo1.call(person2)(); //window
person1.obj.foo1().call(person2)// person2

person1.obj.foo2()();//obj
person1.obj.foo2.call(person2)();//person
person2.obj.foo2().call(person2);//obj

7.总结