javascript中call(),apply()用法

​
//上下文模式：根据用户传递的参数产生不同的结果
    //实现方式：call/apply：这两个都是定义在Function.prototype.call——>目的：任何函数都可以访问到call/apply
    //call方法的第一个参数表示（本次调用该函数，）函数内部的this的值
    function fn(){
        console.log(this.name);//张三
    }
    fn();//函数调用模式——>this指向window window自带一个name属性：""
    fn.call({name:"张三"});
    var o={};
    fn.call(o);//本次调用，fn函数内部的this的值指向o对象
    //——>打印结果：undefined（一个对象中访问不到某个属性的时候，值就是undefined）

function foo(){
        console.log(this.name);
        return [1,3,5];
    }
    foo();//函数调用模式——>foo函数内部的this指向window，返回值由return决定
    //window.name——>""
    var f1=foo.call({name:"张三"});//上下文调用模式——>foo函数内部this指向传递的参数
    //this.name——>"张三"
    console.log(f1.__proto__);//返回值由return语句决定
    //——>Array.prototype
    var f2=new foo();//构造函数调用模式——>foo函数内部this指向构造函数的实例
    //——>this.name：undefined
    console.log(f2.__proto__);//——>Array.prototype
 function fn(){
        for (var i = 0; i < arguments.length; i++) {
            console.log(arguments[i]);
        }
    }
    //利用call方法来调用fn函数的时候，如果需要传递实参，将实参作为call方法的的第二个参数开始依次传递
    fn.call(null,1,3,5);//call方法的第二个参数是fn方法的第一个实参，第三个参数是fn方法的第二个实参
    fn.apply(null,[1,3,5]);//apply方法的第二个参数是一个数组对象，这个数组中第一个元素是fn的第一个实参，数组的第二个元素是fn的第二个实参。。。
    //fn.apply(函数内部的this的值，[实参1，实参2。。。实参n])
    //面试题：call/apply方法有什么异同？
    //1、相同点：a、他们都是Function.prototype对象中定义的方法
    //           b、第一个参数都是表示函数内部的this的值
    //2、不同点：如果需要给函数传递参数的时候，利用call方法，将函数的参数从第二个参数开始依次排开
    //       利用apply方法，apply方法的第二个参数是一个数组对象，数组的第一个参数表示函数的第一个实参，依次以此类推

  //数组里面的push方法实现的功能：往数组里面添加一个元素
    var arr=[1,3,5];//{0:1,1:3,2:5,length:3}
    arr.push(10);//{0:1,1:3,2:5,3:10,length:4}
    //伪数组
    var o={0:10,length:1};
//    o[1]=20;
//    o.length++;
//    o[2]=30;
//    o.length++;
//    o[3]=50;
//    o.length++;
    //借用数组的push方法：首先需要访问到push方法
    //使用场景1、借用数组的push方法往伪数组里面添加元素
    [].push.call(o,10,30,50,70,80,100);
    [].push.apply(o,[10,30,50,70,80,100]);
    //使用场景2：借用数组的push方法往数组中添加多个元素（这多个元素在一个数组中）
    var arr1=[1,3,5];
    var arr2=[10,20,30];
    //要将arr2中的元素依次添加到arr1中
//    for (var i = 0; i < arr2.length; i++) {
//        arr1.push(arr2[i]);
//    }
    //[].push.call(arr1,arr2);//——>往arr1中添加一个元素，该元素是一个数组
    [].push.apply(arr1,arr2);//——>往arr1中添加了多个元素
    //——>push方法内部通过隐式迭代的方式添加多个元素

/借用构造函数实现继承:需要2个构造函数
    function Person(name,age){
        this.name=name;
        this.age=age;
    }
//    function Student(name,age,number){
//        this.name=name;
//        this.age=age;
//        this.number=number;
//    }
    function Student(name,age,number){
        //借用构造函数实现继承
        Person.call(this,name,age);
        this.number=number;
    }
    var s1=new Student("张三",20,666);
    //借用构造函数实现继承：子类构造函数(Student)借用父类构造函数(Person)来完成：给子类的实例添加属性
    //注意条件：由于要借用父类构造函数，所以父类构造函数的功能要对子类对象通用
​