前端面试题集锦（4）

✏️  对象属性的this 指向对象外上下文环境的 this

✏️  对象方法( 普通函数 ) 中的 this ，指向当前对象 ( 谁执行该方法， this 就指向谁 )

✏️  setTimeout ， setInterval 回调函数不管是否是严格模式都会指向 window 。

✏️  通过在函数内执行当前回调函数 非严格模式：this 指向 window ， 严格模式时： this 指向undefined 。

✏️  递归函数中的this 非严格模式： this 指向 window ， 严格模式时： this 指向 undefined 。

✏️   使用 arguments 0 执行函数时 this 指向 arguments 。

✏️  事件中的回调函数,this 指向事件侦听的对象 (e.currentTarget);

✏️  如果call,apply,bind 传参时，第一个参数传入的不是 null 或者 undefined ，传入什么 this 指向什么

✏️  如果第一个参数传入的是null 或者 undefined , 非严格模式下指向 window

✏️  构造函数中的this 指向实例当前类所产生的新的实例对象

✏️  类中实例化方法中this 指向谁执行该方法， this 指向谁

✏️  类中静态方法中this 执行该类或者该类的构造函数

✏️  类中实例化箭头方法，this 仍然指向当前类实例化的实例对象

✏️  在原型的方法中，this 指向实例化当前构造函数的实例化对象（谁执行该方法， this 指向谁） ;

✏️  三种改变this 指向的方式

✏️  函数名.call （this,....） this 写谁就指谁。

✏️  函数名.apply(this,[ 参数 1 ，参数 2 ， ...]) this 写谁就指谁。

✏️  函数名. bind (this,1,2,3) this 写谁就指谁。

<script>
   function A(x,y){
     this.x = x
     this.y = y
   }
   A.prototype.run = function(){}
 
   // 寄生继承 二者一起使用
   function B(x,y){
      A.call(this,x,y) // 借用继承
   }
   B.prototype = new A() // 原型继承
 
  // 组合继承
  Function.prototype.extends = function(superClass){
       function F(){}
       F.prototype = superClass.prototype
       if(superClass.prototype.constructor !== superClass){
           Object.defineProperty(superClass.prototype,'constructor',{value:superClass})
  }
  let proto = this.prototype
  this.prototype = new F()
  let names = Reflect.ownKeys(proto)
  for(let i = 0; i < names.length;i++){
      let desc = Object.getOwnPropertyDescriptor(proto,names[i])
      Object.defineProperty(this.prototypr,name[i],desc)
  }
  this.prototype.super = function(arg){
     superClass.apply(this,arg)
  }
  this.prototype.supers = superClass.prototype
}
script>

<script>
   function thro(cb,wait){
      let timeOut
      return function(){
        if(timeOut) return
        timeOut = setTimeout(function(){
           cb()
           clearTimeout(timeOut)
           timeOut = null
          },wait)
       }
    }
script>

for(var i=0;ilength;i++){
    for(var j=i+1;jlength;){
        if(arr[i]===arr[j]) arr.splice(j,1);
          else j++; // 核心
     }
}

📕 第二种：

var arr1=[];
for(var i=0;ilength;i++){
   for(var j=0;jlength;j++){
      if(arr1[j]===arr[i]) continue xt;
   }
   arr1.push(arr[i]);
}

📕 第三种：

var arr1=[];
for(var i=0;ilength;i++){
    if(arr1.indexOf(arr[i])<0) arr1.push(arr[i])
}

📕 第四种：

var arr1=[];
for(var i=0;ilength;i++){
    if(!(~arr1.indexOf(arr[i]))) arr1.push(arr[i])
}

📕 第五种：

var arr1=[];
for(var i=0;ilength;i++){
    if(!arr1.includes(arr[i])) arr1.push(arr[i])
}

📕 第六种：

arr=[1,2,3,1,2,3,1,2,3]
new Set(arr);

9、如何实现数组的复制 ?

var arr1=[];
for(var i=0;ilength;i++){
    if(i in arr) arr1[i]=arr[i]
}

var arr1=[...arr];

var arr1=arr.slice();

var arr1=arr.concat();

var arr1=arr.map(item=>item);

var arr1=arr.reduce((v,t)=>v.push(t),[])