JS进阶--闭包

JS进阶–闭包

instanceof拓展 :

arr instanceof Array //true
（基础阶段的时候认为是判断某个对象是否是某个构造函数的实例）

arr instanceof Object //true
现在可以用来判断一个构造函数的原型是否在对象的原型链上

实例在创建的时候就确定了原型链，如果在创建之后更改了原型对象，原型链不会变

        function Person() { }
        var one = new Person();
        Person.prototype = {
            constructor: Person,
            sayName: function () { },
            type: 'human'
        }
        var two = new Person();

        one instanceof Person; //false
        two instanceof Person; //true

上下文调用函数：

函数中的this指向，只有在调用的时候才确定
谁调用函数，函数中的this就指向谁

上下文调用模式可以自己指定this的指向

call()方法指定函数中this的指向

第一个参数是确定this指向，第二个是被调用函数的实参（传递方法为参数列表，即直接逗号隔开）返回值是被调用函数的返回值

        function fn(x, y) {
            console.log(this);
            return x + y;
        }
        var obj = { name: 'hah' }
        fn.call(obj, 1, 2);

apply()指定函数中this的指向，

第一个参数是this要指向的对象，第二个参数是一个存实参的数组,返回值为被调用函数的返回值。
fn.apply(obj, [1, 2])

bind()指定this的指向

不会调用函数，会复制当前函数
第一个参数是新拷贝出的函数this指向，第二个参数是新函数需要的实参（传递方法为参数列表，即直接逗号隔开）返回新的函数

var newFn = fn.bind(obj, 1, 2);

如何分析this的指向?
this在哪个函数当中– > 这个函数被怎样调用

for in 遍历对象问题：

for (var key in obj) 会把个性和共性的属性全部打出来

可以用.hasOwnProperty()判断是否为自家的属性，改为：

        for (var key in obj) {
            if (key.hasOwnProperty('属性')) {
                console.log(key);
            }
        }

JS中的继承：

        //（王健林wjl和王思聪wsc）
        for (var key in wjl) {
            if (!wsc.hasOwnProperty(key)) {
                wsc[key] = wjl[key];
            }
        }

作用:返回一个新的对象，新对象的.__proto__指向传入的对象，也就是使用原型链的方式继承或者用 Object.create(被继承的对象)实现对象的继承

        var wsc = Object.create(wjl);
        wsc.wife = 'baby';

        //可以使用wsc.money（继承于wjl），wsc.wife（自己添加的）

构造函数的继承：

        function Person(name, age) {
            this.name = name;
            this.age = age;
        }
        Person.prototype.sayName = function () {
            console.log(this.name);
        }

        function Student(name, age, score) {
            Person.call(this, name, age);  //只能继承私有属性
            this.score = score;
        }
        Student.prototype = new Person();//加继承公有属性
        var kemp = new Student('kemp', 24, 100);

闭包：内部函数访问外部函数的变量

        function fn() {
            var money = 100;//初始金额
            return {
                query: function () {
                    return money;
                },
                pay: function (num) {
                    money -= num;
                },
                add: function (num) {
                    money += num;
                }
            }
        }

        //面试题需求: 利用闭包实现打印li中的内容,不能使用this
        for (var i = 0; i < lis.length; i++) {
            (function (i) {
                lis[i].onclick = function () {
                    console.log(lis[i].innerText);
                }
            })(i);//自执行函数
        }

Function 自己创造了自己， Object 是Function的实例
原型链最终都是Object的原型，再往上就是null

补充：
定时器是在代码执行结束最后执行，全局变量相当于顶级对象window的属性。
arguments[]函数参数的伪数组