javascript中的prototype和__proto__的理解

in 操作符:無論該屬性存在於例項中還是原型中。只要存在物件中，都會返回true。但是可以同時使用 hasOwnProperty()方法和 in 操作符，就可以確定該屬性到底是存在於物件中，還是存在於原型中。

    var person1 = new Person();
    var person2 = new Person();
    alert(person1.hasOwnProperty("name")); //false
    alert("name" in person1); //true
    person1.name = "Greg";
    alert(person1.name); //"Greg" —— 來自例項
    alert(person1.hasOwnProperty("name")); //true
    alert("name" in person1); //true
    alert(person2.name); //"Nicholas" —— 來自原型
    alert(person2.hasOwnProperty("name")); //false
    alert("name" in person2); //true
    delete person1.name;
    alert(person1.name); //"Nicholas" —— 來自原型
    alert(person1.hasOwnProperty("name")); //false
    alert("name" in person1); //true
複製程式碼

5、 獲取或遍歷物件中屬性的幾種方法

for-in： 通過for-in迴圈的返回的是能夠被訪問的、可列舉的屬性，不管該屬性是在例項中，還是存在原型中。

    function Person(name, age, job) {
		this.name = name;
		this.age = age;
		this.job = job;	
	}
	Person.prototype={
		sayName:function(){
			return this.name;
		}
	}
	var p=new Person("李明",30,"詩人");
	for(var prop in p){
		console.log(prop);//name、age、job、sayName
	}
    console.log(Object.keys(p));//["name", "age", "job"]
    console.log(Object.keys(Person.prototype));//["sayName"]
    console.log(Object.getOwnPropertyNames(Person.prototype))
    // ["constructor", "sayName"] 
複製程式碼

Object.keys()： 取得例項物件上所有可列舉的屬性。 Object.getOwnPropertyNames(): 獲取例項物件所有屬性，無論它是否可列舉。

  注意：使用物件字面量來重寫整個原型物件時，本質上完全重寫了預設的 prototype 物件，因此 constructor 屬性也就變成了新物件的 constructor 屬性（指向 Object 建構函式），不再指向 Person。但是可以通過在重寫原型物件時指定constructor屬性，使之還是指向原來的constructor。此時，儘管 instanceof 操作符還能返回正確的結果，但通過 constructor 已經無法確定物件的型別了。

object instanceof constructor: 檢測 constructor.prototype 是否存在於引數 object 的原型鏈上。

    function Person() {}
    var friend2 = new Person();
    Person.prototype = {
    	//constructor : Person,
    	name: "Nicholas",
    	age: 29,
    	job: "Software Engineer",
    	sayName: function() {
    		alert(this.name);
    	}
    };
    var friend = new Person();
    console.log(friend2 instanceof Object); //true
    console.log(friend2 instanceof Person); //false,
    console.log(friend2.constructor == Person); //true
    console.log(friend2.constructor == Object); //false
    
    console.log(friend instanceof Object); //true
    console.log(friend instanceof Person); //true
    console.log(friend.constructor == Person); //false
    console.log(friend.constructor == Object); //true
複製程式碼

  由於原型的動態性，呼叫建構函式時會為例項新增一個指向最初原型的Prototype指標，而把原型修改為另外一個物件就等於切斷了建構函式與最初原型之間的聯絡。看下面的例子

    function Person(){
    }
    var friend = new Person();
    Person.prototype = {
        constructor: Person,
        name : "Nicholas",
        age : 29,
        job : "Software Engineer",
        sayName : function () {
            alert(this.name);
        }
    };
    var friend2=new Person();
    friend.sayName(); //Uncaught TypeError: friend.sayName is not a function 
    friend2.sayName();//Nicholas
    console.log(friend instanceof Person);//false
    console.log(friend instanceof Object);//true
    console.log(friend2 instanceof Person);//true
複製程式碼

  結果分析：這是因為friend1的prototype指向的是沒重寫Person.prototype之前的Person.prototype，也就是建構函式最初的原型物件。而friend2的prototype指向的是重寫Person.prototype後的Person.prototype。如下圖所示

6、 原型鏈

    function SuperType(){
        this.property = true;
    }
    SuperType.prototype.getSuperValue = function(){
        return this.property;
    };
    function SubType(){
        this.subproperty = false;
    }
    //繼承了 SuperType
    SubType.prototype = new SuperType();
    SubType.prototype.getSubValue = function (){
        return this.subproperty;
    };
    var instance = new SubType();
    alert(instance.getSuperValue()); //true
複製程式碼

    console.log(instance.constructor===SuperType);//true
複製程式碼

就拿上面的例子來說，呼叫 instance.getSuperValue()會經歷4個搜尋步驟：

1. 搜尋instance例項；
2. 搜尋 SubType.prototype；
3. 搜尋SuperType的例項；
4. 搜尋 SuperType.prototype，最後一步才會找到該方法。