第198天：js---内置对象的原型链和其他知识

一、内置对象的原型链

1、Object原型

function test() {}
   alert(test.toString());
   
   //新增属性
   Object.prototype.mytest = function() {
       alert("123");
   }
   var o = new Object();
   o.mytest();
   
   //重写属性
    Object.prototype.toString = function()
   {
       alert("破坏之王");
   }
   o.toString();

2、Object对象是Function对象的实例

/*object的__proto__指向Function对象的原型*/
    //Object对象是Function对象的一个实例
    console.log(Object.__proto__ === Function.prototype);//true

    /*Function.prototype对象的原型的__proto__属性指向Object.prototype*/
    console.log(Function.prototype.__proto__ === Object.prototype)

    /*object的原型的__proto__属性为null*/
    console.log(Object.prototype.__proto__ )


    /*总结*/
    /*一个自定义对象可以访问到Function对象的所有属性和方法，也可以访问到Object对象的所有属性和方法*/

3、内置对象的实例指向

//Object对象是Function对象的一个实例
   //Object对象的__proto__指向Function的原型
   console.log(Object.__proto__===Function.prototype);//true

   console.log(Object.prototype.__proto__);//null

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

   //内置对象的_proto_的指向
   console.log(Number.__proto__ ===Function.prototype);//true
   console.log(Boolean.__proto__ ===Function.prototype);//true
   console.log(String.__proto__ ===Function.prototype);//true
   console.log(Object.__proto__ ===Function.prototype);//true
   console.log(Function.__proto__ ===Function.prototype);//true
   console.log(RegExp.__proto__ ===Function.prototype);//true
   console.log(Error.__proto__ ===Function.prototype);//true
   console.log(Date.__proto__ ===Function.prototype);//true


   //自定义对象的原型的__proto__指向
   function Product(){};

   Product.prototype={};

   var iphone=new Product();
   console.log(Product.prototype.__proto__);//object
   console.log(Product.prototype.__proto__===Object.prototype);//true

   //构造函数就是一个函数，函数都是由Function实现的，都是它的一个实例
   console.log(Product.__proto__===Function.prototype);//true

   var obj = new Object();
   //toString是object的方法，因为在原型中，所以所有对象都可以访问
   //Object.prototype.toString=function(){};
   console.log(obj.toString());//[object Object]

   /*object的实例指向Object的原型对象*/
   console.log(obj.__proto__ === Object.prototype);//true

4、自定义对象的原型链

//object的__proto__指向的是Function.prototype
    console.log(Object.__proto__ ===Function.prototype)


    /*null*/
    console.log(Object.prototype.__proto__);


    /*object*/
    console.log(Function.prototype.__proto__ === Object) //false
    console.log(Function.prototype.__proto__ === Object.prototype)  //ture


    /*内置对象的__proto__指向*/
    console.log(Number.__proto__ === Function.prototype)  // true
    /*
    Boolean.__proto__ === Function.prototype // true
    String.__proto__ === Function.prototype  // true
    Object.__proto__ === Function.prototype  // true
    Function.__proto__ === Function.prototype //true
    Array.__proto__ === Function.prototype   // true
    RegExp.__proto__ === Function.prototype  // true
    Error.__proto__ === Function.prototype   // true
    Date.__proto__ === Function.prototype    // true*/


    /*自定义对象的原型的__proto__指向*/
    function Product(){}

    Product.prototype={}

    var iphone = new Product()

    console.log(Product.prototype.__proto__)
    console.log(Product.prototype.__proto__ === Object)  //false
    console.log(Product.prototype.__proto__ === Object.prototype) //true

    var obj = new Object()

   /* Object.prototype.toString=function(){
        alert('破坏之王')
    }*/

    console.log(obj.toString())
    /*构造函数其实就是一个函数
    函数都是Function实现的。都是它的一个实例*/

   /* Function
    Function.prototype
    Object
    Object.prototype*/

    console.log(Product.__proto__ ===Function.prototype);

    console.log(Array.prototype.__proto__  === Object.prototype );

二、其他知识

1、hasOwnproperty

var person= function(){
         age=1
      };
  
  person.prototype={
         name:'wangshukui'
      };


var xiaowang = new person();
//实例化之后 重新分配内存 系统会自动屏蔽原型同名 -- 原理 开辟新的空间

  //
 alert(xiaowang.hasOwnProperty("name"));//false --表明是原型属性

 alert(xiaowang.hasOwnProperty("age")); //false --类属性
 
 
 //当定义一个实例化属性之后，会自动屏蔽原型属性
 xiaowang.name='小李';
 alert(xiaowang.hasOwnProperty('name')) //true
 
 xiaowang.sex='nan';
  alert(xiaowang.hasOwnProperty('sex')) //true

2、isPrototypeOf

判断iphone是否拥有Product的原型属性

function Product(){
        this.name='iphone8';
        this.description='手机中的战斗机';
        this.price=7777;
        this.date=new Date();
        this.add = function(){};
    }

    Product.prototype={
        test:11111,
        buy:function(){}
    }
    var iphone = new Product()
    console.log(Product.prototype.isPrototypeOf(iphone));//true

3、constructor 查看对象的构造函数

//constructor : 查看对象的构造函数

        /*function Aaa(){
         }

         var a1 = new Aaa();

         alert( a1.constructor );  //Aaa

         var arr = [];
         alert( arr.constructor == Array );  //true*/


        /*function Aaa(){
         }
         //Aaa.prototype.constructor = Aaa;   //每一个函数都会有的，都是自动生成的

         //Aaa.prototype.constructor = Array;

         var a1 = new Aaa();
         alert( a1.hasOwnProperty == Object.prototype.hasOwnProperty );  //true*/


        /*function Aaa(){
         }

         Aaa.prototype.name = '小明';
         Aaa.prototype.age = 20;

         Aaa.prototype = {
         constructor : Aaa,
         name : '小明',
         age : 20
         };

         var a1 = new Aaa();
         alert( a1.constructor );*/


        function Aaa(){
        }

        Aaa.prototype.name = 10;
        Aaa.prototype.constructor = Aaa;

        for( var attr in Aaa.prototype ){
            alert(attr);
        }

4、instanceof : 对象与构造函数在原型链上是否有关系

//instanceof : 对象与构造函数在原型链上是否有关系

        function Aaa(){
        }

        var a1 = new Aaa();

        //alert( a1 instanceof Object );  //true


        var arr = [];

        alert( arr instanceof Array );//true

5、静态属性、原型属性和实例属性

 //对象构造函数
    function Atest(name){
        //私有属性，只能在对象构造函数内部使用
        var className = "Atest";
        //公有属性,在对象实例化后调用
        this.name = name;
        //对象方法
        this.hello = function(){
            alert(this.name);
            alert(this.msg());//使用原型方法扩充的方法可以在类内部使用
            alert(this.sex);//使用原型方法扩充的属性可以在类内部使用
            alert(Atest.age);//静态属性调用时格式为[对象.静态属性]
        }
    }
    //类方法 (实际是静态方法直接调用) 位置：Person类的外部 语法格式：类名称.方法名称 = function([参数...]){ 语句行; }
    Atest.Run = function(){
        alert("我是类方法 Run");
    }


    //原型方法
    Atest.prototype.msg = function(){
        alert("我的名字是："+this.name);//如果原型方法当作静态方法直接调用时，this.name无法被调用
    }

    //公有静态属性 在类的外部
    Atest.age = 20;//公有静态属性不能使用 【this.属性】，只能使用 【对象.属性】 调用

    //原型属性，当作是类内部的属性使用【this.原型属性】，也可以当成公有静态属性使用【对象.prototype.原型属性】
    Atest.prototype.sex = "男";

    Atest.Run(); //类方法也是静态方法，可以直接使用 【对象.静态方法()】
    Atest.prototype.msg();//原型方法当成静态方法使用时【对象.prototype.方法()】
    alert(Atest.prototype.sex);//原型属性当作静态属性使用时【对象.prototype.方法()】
    var a = new Atest("zhangsan");//对象方法和原型方法需要实例化对象后才可以使用
    a.hello();//对象方法必须实例化对象
    a.msg();//原型方法必须实例化对象
    alert(a.age)://错误，公有静态属性只能使用 【对象.属性】调用

    //ps:尽量将方法定义为原型方法，原型方法避免了每次调用构造函数时对属性或方法的构造，节省空间,创建对象快.