对象 原型 原型方法

对象  

原型

原型方法

 

知识点：

原型方法

1、hasOwnProperty

obj.hasOwnProperty(prop)

hasOwnProperty() 方法会返回一个布尔值，指示对象是否具有指定的属性作为自身（不继承）属性。

2、isPrototypeOf

prototypeObj.isPrototypeOf(object)

isPrototypeOf() 方法用于测试一个对象是否存在于另一个对象的原型链上。

function Fee() {
           
        }
        function Fi() {
           
        }
        Fi.prototype=new Fee();
        function Fo() {
           
        }
        Fo.prototype=new Fi();
        function Fun() {
           
        }
        Fun.prototype=new Fo();
        var fun=new Fun();
        if(Fi.prototype.isPrototypeOf(fun)){
            console.log("确实挂载在这个原型链下")
        }
        console.log(fun)

3、

propertyIsEnumerable

obj.propertyIsEnumerable(prop)

propertyIsEnumerable() 方法返回一个布尔值，表明指定的属性名是否是当前对象可枚举的自身属性。

枚举就是用for in可以罗列出来的属性

var o={};
        var a=[];
        o.prop="属性";
        a[0]=3;
        console.log(o.propertyIsEnumerable("prop"));
        console.log(a.propertyIsEnumerable(0))

 

4、constructor

属性，返回一个指向创建了该对象原型的函数引用。需要注意的是，该属性的值是那个函数本身，而不是一个包含函数名称的字符串。对于原始值（如1，true 或 "test"），该属性为只读。

 

 var o={};
        console.log(o.constructor===Object);
        var a=[];
        console.log(a.constructor===Array);
        var n=4;
        console.log(n.constructor===Number);
        function Tree(name) {
            this.name=name;
        }
        var theTree=new Tree("big");
        console.log(theTree.constructor)

 

 

function fn1() {};
    var f1 = new fn1();
    console.log(f1.constructor === fn1); //true
    //替换默认原型
    function fn2() {};
    fn2.prototype = {};
    var f = new fn2();
    console.log(f.constructor === fn2); //false
    console.log(f.constructor === Object); //true

字面量方式为什么constructor会指向Object?因为Box.prototype={};这种写法其实就是创建了一个新对象。而每创建一个函数，就会同时创建它prototype,这个对象也会自动获取constructor属性。所以，新对象的constructor重写了Box原来的constructor,因此会指向新对象，那个新对象没有指定构造函数，那么就默认为Object.原型的声明是有先后顺序的，所以，重写的原型会覆盖之前的原型。

 

 

举例：

     var o=Object.create(obj);

         o.c=10;

        // c是o的对象属性，a是o的原型链的属性

        //  console.log("c" in o);

        //  console.log("a" in o);

        // SSS

        // 判断某个属性是不是该对象的对象属性，如果是原型链属性或者没有则返回false

        // console.log(o.hasOwnProperty("c"));

        // console.log(o.hasOwnProperty("a"));

            // SSS

        // a.isPrototypeOf(b)  判断a是不是b的原型链中的一个原型对象

        // 或者说b对象的原型链中有没有a对象

        // console.log(obj.isPrototypeOf(o));

        // console.log(o.isPrototypeOf(obj));

        // var o1=Object.create(o);

        // console.log(obj.isPrototypeOf(o1));

        // console.log(o.isPrototypeOf(o1));

        Object.defineProperty(obj,"e",{

            value:10

        });

        

        // property 属性

        // prototype 原型

        // 判断对象上的某个属性是不是可枚举属性

        // console.log(obj.propertyIsEnumerable("a"));

        // console.log(obj.propertyIsEnumerable("e"));

        // 将对象中不可以枚举的属性名放在数组arr1

        // var arr=Object.getOwnPropertyNames(obj);

        // var arr1=arr.filter(function(item){

        //     return !obj.propertyIsEnumerable(item);

        // });

        // console.log(arr1);

        

        // SSS

        // 可以获取到对象的类型

        // console.log(obj.constructor)

        // var arr=[];

        // console.log(arr.constructor===Array);

        // var reg=/a/g;

        // console.log(reg.constructor===RegExp)

        var div=document.querySelector("div");

        // console.log(div.constructor===HTMLDivElement);

        // 也可以根据类型反射形成新对象

        // var arr=[1,2,3,4];

        // var arr={a:1,b:2};

        // var arr=/ab/g;

        // var arr=new Date();

        // var o=new arr.constructor();

        // console.log(o);

        // var obj={a:1};

        // console.log(div.__proto__);

        // 判断某个对象是否是某一种类型的子类生成的对象

        // console.log(HTMLElement.prototype.isPrototypeOf(div));

        // 对象的__proto__原型链与该对象类型prototype原型是完全相等

        // div.__proto__===HTMLDivElement.prototype;

        // console.log(div.__proto__===HTMLDivElement.prototype);

        // var arr=[];

        // arr.__proto__===Array.prototype;

        // var date=new Date();

        // date.__proto__===Date.prototype;

            // SSS

        // 判断某个对象是否是某一中类型子类生成的对象

        // console.log(div instanceof HTMLElement);

        // console.log(obj instanceof HTMLElement);