JS学习-练习题 call apply bind

function test() {
    
}(1,2,3,4,5)
//如果后面是() 会报错，但是往里传入参数后不会报错，因为JS会把()执行成运算符 输出最后一个参数 >> 因为逗号操作符
console.log((1,2,3,4,5,3)) // 3 会输出最后一个

function foo() {
    bar.apply(null,arguments);  // 不改变this值，只是传递参数
}
function bar() {
    console.log(arguments); //没有形参也能输入arguments
}
foo(1,2,3,4,5) //Arguments(5) [1, 2, 3, 4, 5, callee: ƒ, Symbol(Symbol.iterator): ƒ]

<script>
    // 基本数据类型
    // number类型
    var num = 1;
    console.log(typeof num);//返回的是number
    // string 类型
    var str = 'jack';
    console.log(typeof str);//返回的是string
    // boolean类型
    var boo =true;
    console.log(typeof boo);//返回的是boolean
    // undefined类型
    var und ;
    console.log(typeof und);//返回的是undefined
    // null类型
    var nul =null;
    console.log(nul); //返回的是null

    // 可以得出：基本数据类型返回的是自己对应的类型
    
    
    // 复杂数据类型
    // Array类型
    var arr = new Array();
    console.log(typeof arr); //返回的是object 
    // function类型
    var fn = function(){};
    console.log(typeof fn); //返回的是function
    // Object类型
    var  obj = new Object();
    console.log(typeof obj); //返回的是object
    // 字面量的数组
    var arr2 = [1,32];
    console.log(typeof arr2);//返回的是object

    // 自定义对象
    function Person(name){
        this.name =name;
    }

    var stu = new Person();
    console.log(typeof stu); //返回的是object
    //null 返回的是object

    // 可以得出：复杂数据类型，如果是对象，则返回的是object,如果的function类型,则返回的是function 

    // 所以：typeof 可以返回的类型为：number、string、boolean、undefined、null、object、function
 
</script>

call和apply的作用和区别？
都是用来改变函数this指向的，call传的实参列表，apply传的是一个实参的数组。
和bind的区别？
call和apply是直接某个函数的时候使用，bind是记录某个函数，当他被调用的时候才改变this值的时候去使用。·

var f = (
    function f() {
        return "1";
    },
    function g() {
        return 2;
    }
)();
console.log(typeof f)
//逗号操作符，返回fng，返回2 所以结果是number

undefined == null //true
undefined == 0
false
undefined > 0
false
undefined < 0
false

null== 0
false
null> 0
false
null< 0
false

{} == {}
false
引用值比的是地址，地址一样才相等

// 如何重写isNaN
    function isNan(val) {
        var ret = Number(val);
        ret += "";
        if (ret == "NaN") {
            return true
        }else{
            return false
        }
    }
    //因为NaN不等于任何，需要转换成字符串

// 考点：this
    var name = "222";
    var a = {
        name : "111",
        say : function () {
            console.log(this.name);
        }
    }
    var fun = a.say;
    fun(); //222
    a.say() // 111
    var b = {
        name : "333",
        say : function (fun) {
            // b.say----->this -----> b 
            // 但是注意此处没有任何对象调用fun() ,所以console.log()里的this对象指向window
            fun();
        }
    }
    b.say(a.say);   //222
    b.say = a.say;
    b.say(); // 333

var foo = 123;
function test() {
    this.foo = 234;
    console.log(foo)
}
test() 
    //打印出234，因为方法里并没有声明foo,所以方法里打印的foo是全局的foo，但是执行test时，调用他的对象时window,所以全局this的foo被改变了
   //如果test() 改成new test() 那么打印出123，因为构造函数隐式的执行了var this = Object.create(test.prototype)，改变了this的指向

// bind总结
    function A() {
        
    }
    var o = {};
    var x = 1;
    var y = 2;
    var z = 3;
    var B = A.bind(0,x,y)
    B('c');
    // 总结：
    // 1.函数A调用bind方法时，可以传递参数o,x,y,z.....
    // 2.返回新的函数 B
    // 3.函数B在执行时，具体功能实际上还是使用A，支不不是this的指向编程了o window
    // 4.函数B在执行时，传递的参数是会拼接到x,y,z后面 一并在内部传递给A执行
    // 5.new B() 构造函数依旧是A，而且o不会起到任何作用


    // 自己实现一个bind方法

    function show() {
        console.log(this)
    }
    var obj = {
        x : 20
    }
    

    //在Function的原型上自定义myBind()方法
    Function.prototype.myBind = function myBind(context) {
        //获取要操作的函数
        var that = this;
        //获取实参（context除外）
        var args = Array.prototype.slice.call(arguments, 1);

        //判断当前浏览器是否兼容bind()方法
        if ('bind' in Function.prototype) {
            //如果浏览器兼容bind()方法，则使用bind()方法，并返回bind()方法执行后的结果
            return that.bind(context, args);
        }
        //如果不兼容bind()方法，则返回一个匿名函数
        return function () {
            that.call(context, args);
        }
    }
    var newShow = show.myBind(obj);
    newShow();