JS2(数组去重--this指向)

1. 如何消除一个数组里面重复的元素

   • Set 去重

       function unique(arr){
       return Array.from(new Set(arr))
       }
     

   • for循环 + splice方法

       function unique(arr){
       for(var i=0;i<arr.length;i++){
       for(var j=i+1;j<arr.length;j++){
       if(arr[i]==arr[j]){
           arr.splice(j,1)
           j--
       		}
       	}
       }
       return arr
       }
     

   • indexOf方法

       function unique(arr){
       var newArr=[]
       for(var i=0;i<arr.length;i++){
       if(newArr.indexOf(arr[i])===-1){
       newArr.push(arr[i])
       	}
       }
       return newArr
       }
     

2. 改变函数内部的this指针的指向
   • bind(生成一个新的函数长期绑定给某个函数或者某个对象使用)
     • 直接改变这个函数的this，指向并返回一个新的函数，之后调用都是返回bind绑定的第一个参数
   • call(需要传递的参数不多)
     • 与apply方法用法一样，但是call的参数只能一个一个的传
   • apply(传递的参数很多)
     • 只支持传入一个数组，即使只有一个参数，最终调用时会将其拆分成一个一个的参数传入
3. 关于this指向

   1. 函数调用模式
      (当一个函数并非一个对象的属性，那么他就是被当作函数调用，这种模式下，this被绑定给全局对象，浏览器环境下是window对象)

       function a(){
       var a='hello'
       console.log(this.a)//undefined
       console.log(this)//window对象
       	}
       a()  
      

   2. 方法调用模式
      (当一个函数被当作一个对象的属性，此时this就绑定到这个对象上，如果调用的表达式包含一个提取属性的动作(’.’/’[]’)，那么他就是被当作方法调用)

       var o={
       name:'hello',
           sayName:function(){
               console.log(this.name)//hello
               console.log(this)//o这个对象
           }
       }
       o.sayName()  
      
       var o={
           name:'hello',
           b:{
               fn:function(){
                   console.log(this.name)//undefined
                   console.log(this)//fn这个对象
               }
           }
       
       }
       o.b.fn()  
      

   3. 构造函数模式
      (new关键字调用，那么就会连接到该函数的prototype成员的新对象，同时this会绑定在这个新对象上，此时，这个函数就是这个对象的构造函数)

       function Fn(){
           console.log(this)//Fn(){}
       }
       var a =new Fn()  
      

      ---

       function Fn(){
           this.name='hello'
       }
       //每new出一个新对象，this就会指向这个构造函数
       var a =new Fn()
       console.log(a.name)//hello
       var b=new Fn()
       console.log(b.name)//hello  
      

      ---

       function Fn(){
           this.name='hello'
          /*  return {} //undefined
              return [] //undefined
       使用new，如果返回的是一个对象，this就指向那个对象
           */
           /* return null //hello
              return 1 //hello
              return undefined //hello
       返回的不是对象，还是指向函数实例
           */ 
       }
       var a =new Fn()
       console.log(a.name)  
      

   4. apply&call调用模式
      (所有函数对象都有这两种方法，改变this的指向)

       var name='window'
       var o=function(){
           name:'o'
       }
       function sayName(){
           console.log(this.name)
           console.log(this)
       }
       // sayName()//undefined Window
       // sayName.apply/call(o)//o Function: o
      

   • 总结：
     • 全局—指向全局对象
     • 对象函数—指向当前对象
     • 全局函数—指向全局对象
     • new实例化对象—指向新创建的对象
     • call&apply—指向上下文传入的第一个