原型链(自定义对象以及内置对象)

• 原型链
  每一个构造函数都有自己的原型对象 原型对象也是对象 (对象都有一个__proto__属性) 也有自己的原型对象 以此类推 形成的链式结构称之为原型链
• 对象访问原型链中成员的规则
  就近原则
  (对象访问成员 先看自己有没有 有则访问 没有则从原型寻找 如果原型有则访问 原型没有 就从原型的原型寻找 以此类推 直到原型链的终点null 如果都没有 属性返回undefined 方法返回程序报错)

 		function Person(name, age) {
            this.name = name;
            this.age = age;
        }
        var p = new Person('人', 20);
        console.log(p.gender);//对象取值 不存在返回undefined
        // p.say();//undefined没有方法 所以报错
        console.log(p);
        console.log(p.toString());//[object Object]
        //p中没有toString方法 原型中也没有 但是原型的原型中有toString方法 所以不会报错

        console.log(p.constructor);//Person构造函数
        console.log(p.__proto__ === Person.prototype);//true

        console.log(p.__proto__.__proto__.constructor);//Object
        console.log(p.__proto__.__proto__ === Object.prototype);//true

        console.log(p.__proto__.__proto__.__proto__);//null

• 内置对象的原型链
• Date日期对象原型链

		var date = new Date();
        //日期对象不能用log 会自动转成toString字符串
        //查看对象内存空间 用dir
        console.dir(date)
        console.log(date.constructor);//Date构造函数
        console.log(date.__proto__ === Date.prototype);//true

        console.log(date.__proto__.__proto__.constructor);//Object
        console.log(date.__proto__.__proto__ === Object.prototype);//true

        console.log(date.__proto__.__proto__.__proto__);//null

• 数组对象的原型链

 		var arr = [10, 20, 30];
        //底层用了new Array()构造函数
        // var arr = new Array([10,20,30]);

        console.log(arr)
        console.log(arr.constructor);//Array构造函数
        console.log(arr.__proto__ === Array.prototype);//true

        console.log(arr.__proto__.__proto__.constructor);//Object
        console.log(arr.__proto__.__proto__ === Object.prototype);//true

        console.log(arr.__proto__.__proto__.__proto__);//null

• String对象原型链

var str = '123';
        //底层用了基本包装类型new String()构造函数 
        // var str = new String('123');

        console.log(str)
        console.log(str.constructor);//String构造函数
        console.log(str.__proto__ === String.prototype);//true

        console.log(str.__proto__.__proto__.constructor);//Object
        console.log(str.__proto__.__proto__ === Object.prototype);//true

        console.log(str.__proto__.__proto__.__proto__);//null

• DOM对象的原型链
  

• 函数也是对象类型 是一个特殊的对象 所有的函数都是由Function构造函数创建的
• 也可以通过点语法动态添加成员

		function fn() {
            console.log('fn函数');
        }
        fn.say = function () {
            console.log('函数动态添加方法');
        }
        fn.show = '函数动态添加属性'
        // 下面不报错说明函数也是对象类型 是特殊的对象 
        fn.say();
        console.log(fn.show);
        console.log(fn);//打印函数中存储的代码
        console.dir(fn);//打印函数对象中存储的属性

        console.log(fn.__proto__.constructor);//Function构造函数 

        //得出函数都是由Function构造函数创建的
        console.log(Object.__proto__.constructor);//Function构造函数
        console.log(Array.__proto__.constructor);//Function构造函数


        console.log(fn.__proto__ === Function.prototype);//true

        console.log(fn.__proto__.__proto__.constructor);//Object
        console.log(fn.__proto__.__proto__ === Object.prototype);// true

        console.log(fn.__proto__.__proto__.__proto__);//null

• 拓展
• Function构造函数创建对象 参数都是字符串 有很多个参数
• 前面所有的参数都是函数的形参
• 最后一个参数是函数体代码

//函数的两种声明方式
        //1.函数声明
        function fn(a, b) {
            return a + b;
        }
        //2.表达式声明
        var fn1 = function (a, b) {
            return a + b;
        }
        //函数的底层都是new Function
        //Function构造函数 
        //前面所有参数都是函数的形参 最后一个参数是函数体代码
        //参数都是字符串
        var fn2 = new Function('a', 'b', 'return a+b');
        var res = fn2(10, 20);
        console.log(res);
      //所以js所有构造函数对象 都是Function构造函数生成的

• 完整的原型链
• js中所有的对象都是构造函数创建的
  1.原型对象由Object构造函数创建
  2.函数对象由Function构造函数创建
  3.实例化对象由对应的构造函数创建
• 只要是构造函数 就有prototype属性指向与之对应的原型对象
• 只要是原型对象 就有constructor属性指向对应的构造函数
• 只要是对象 就有__proto__属性指向对应的构造函数的原型对象
• 函数也是对象 js中所有的函数对象都是由Function构造函数创建的