改变函数this的指向。严格模式、高阶函数、闭包

1 call

obj.call(改变this指向的对象,参数1，参数3) 参数可选
1.1 call 第一可调用函数 第二可以改变函数的this指向
1.2 call 的主要作用他可以实现继承

         <script>

    var o = {
        name:'andy'
    }
    function fn(a,b){
        console.log(this);
        console.log(a+b);
    }
    fn.call(o,1,2)

</script> 继承
       function Father(user,age,sex){
        this.user=user;
        this.age=age;
        this.sex= sex;
    }
    function Son(uset,age,sex){
        Father.call(this,uset,age,sex);
    }
    var son =new Son('123',18,'nan')

apply

fun.apply(thisArg,[argsArray]);
thisArg:在fun函数运行时指定的this
artgsArray:船体的值，必须要包含在数据里
返回值就是函数的返回值，应为它要调用函数。

 <script>
    var o = {
        name:'ssss'
    }
    function fn (arr){
        console.log(this);
        console.log('------');
        console.log(arr);
        }
    //1.这里改变函数内部this  的指向，同时调用函数
    //2.参数必须是数组格式。
    fn.apply(o,['1']);
    // 3.apply的主要应用
    var arr=[1,33,4,45,56,22,22];
    var max = Math.max.apply(Math,arr);
    console.log(max);
</script>

bind

bind()方法不会调用函数，但是能改变函数内部this指向。
fun.bind(thisArg,arg1,arg2,...)

• thisArg:在fun函数运行时指定的this

• arg1,arg2 传递的其他参数

• 返回由指定的this之后初始化参数改造的原函数拷贝。

  <script>
    var o ={
    name:'name'
  }
  function fn (a,b){
    console.log(this);
    console.log(a+b);
  }
  //这里返回的是改变 this后的新函数
  var f=fn.bind(o,1,2);
  // 调用函数
  f();
  </script>
  

call apply bind 总结

1. call apply 会调用函数，并改变函数内部this指向
2. call apply 传递的参数不一样，call 传递阐述arg1，arg2形式。apply必须是数组的形式。
   3.bind 不会调用函数，可以变函数内部的this指向。
   主要应用
   1.call 主要做继承、
   2.apply 经常和数组相关，比如借助数学对象实现数组最大值，最小值。
   3.bind 不调用 函数，但是还想改变this指向。比如改变定时器内部的this 指向

严格模式

ES5在IE10 以上的版本才会被支持。

1. 消除了javascript 语法的一些不合理、不严谨之处，减少了一些怪异行为
   2.消除了一些不安全的地方
   3.提高变异效率
   4.为未来语法的javascript 做好了铺垫
   严格模式的开启
   1.为脚本开启严格模式
   直接写 'use strict'

   <script>
    'use strict'
    // 下面的js diamante会严格执行代码
   </script>
   

2 为函数开启严格模式
在指定的函数中写 ‘use strict’

<script>
    function fn(){
        'use strict'

    }
    function fun(){

    }
</script>

3 严格模式的变化

1 . 变量 变量必要要先声明后使用
2 . 不能删除已经申明好的变量。
3 . 以前全局作用下this 指向的是window ，在严格模式下执行的undefined。
4 . 以前构造函数不加new 可以直接调用，在严格模式下必须要new一下。
5.定时器this 还是指向window
6.事件、对象还是指向调用者。

严格模式下函数变化

1 . 不能定义相同的形参。
2 . 函数必须声明在顶层。

高阶函数

高阶函数是对其他函数进行操作的函数。它接收函数作为参数或将函数作为返回值输出。
下面就是将函数作为参数

 <script>
      function fn(callBack){\
        callBack&&callBack();
        }
 </script>
  fn(function(){
  alert{'hi'};
  }

闭包

闭包：指有权访问另一个函数作用域中变量的函数。
闭包的作用：延伸了变量的作用范围。
下面代码在fun函数中访问了fn函数中的变量num fn 函数就是闭包。

  <script>
    function fn(){
        var num =10;
        function fun(){
            console.log(num);
        }  
        fun();

    }
    fn();

</script>

浅拷贝和深拷贝

1. 浅拷贝只拷贝一层，更深层次对象级别的只拷贝引用】

2. 深拷贝是多层的，每一层都会拷贝
   3.在ES6中可以直接使用Object.assign浅拷贝(要拷贝成的对象，拷贝的对象)

   Object.assign(o,obj);
   

深拷贝

    <script>
    var obj = {
        id:1,
        age:2,
        msg:{
            name1:1,
            sex:2
        },
        color:[1,3,56]
    }
    var o ={}
    // for(var k in obj){
    //     o[k] = obj[k];
    // }

    function deepCopu(newObj,oldObj){
        for(var k in oldObj){
            var item = oldObj[k];
            if(item instanceof Array){
            // 这里要注意
                newObj[k]={};
                deepCopu(newObj[k],item);
            }else if(item instanceof Object){
                newObj[k]={};
                deepCopu(newObj[k],item);
            }else{
                newObj[k]=item;
            }
        }
    }
    deepCopu(o,obj);