function hasPrototypeProperty(object,name){
		return (name in object) && (!object.hasOwnProperty(name));
	}
	
	console.debug( hasPrototypeProperty(p2,‘name‘));//返回true name属性在原型中
	p2.name = ‘kobe‘;//实例p2增加name属性
	console.debug( hasPrototypeProperty(p2,‘name‘));//返回false name属性不在原型中

	function ownPrototypeHasProperty(object,name){
		while( Object.getPrototypeOf(object).constructor != Object){//object的原型的构造函数不为Object
			var pro = Object.getPrototypeOf(object);//获取这个原型
			//如果原型中有这个属性
			if(pro.hasOwnProperty(name)){
				return true;
			}
			//顺着原型向上搜索
			object = pro;
		}
		
		return false;
	}
	
	var v3 = new Person();
	console.debug( ownPrototypeHasProperty(v3,‘name‘));//true  v3的原型中有name属性
	console.debug( ownPrototypeHasProperty(v3,‘sex‘));//false v3的原型中木有sex属性
	

function Person() {
	}
	Person.prototype.name = "Nicholas";
	Person.prototype.age = 29;
	Person.prototype.job = "Software Engineer";
	Person.prototype.sayName = function() {
		console.debug(this.name);
	};
	function Per (){
		console.debug(‘Per构造函数‘);
	}
	//设置per的原型 使用对象字面量的方式,但是这样会使Per的原型失去construtor(会使用Object() ),所以要制定constructor 为 Per
	Per.prototype = {
			name : ‘kobe‘,
			sayName : function(nameStr){
				this.name = nameStr;
			},
			constructor : Per
	};
	var p1 = new Per();
	var p2 = new Per();
	console.debug(p1);
	console.debug(p2);

 function Person(){
        }
        
        //Person的原型指向新对象 
        Person.prototype = {
            constructor: Person,
            name : "Nicholas",
            age : 29,
            job : "Software Engineer",
            sayName : function () {
                alert(this.name);
            }
        };
        
        var friend = new Person();
        
        Person.prototype.sayHi = function(){
            alert("hi");
        };
        friend.sayHi();   //"hi" works!

            
        function Person(){
        }
        
        var friend = new Person();
                
        //Person的原型对象指向了一个新的对象
        Person.prototype = {
            constructor: Person,
            name : "Nicholas",
            age : 29,
            job : "Software Engineer",
            sayName : function () {
                alert(this.name);
            }
        };
        
        //friend.sayName();   //Uncaught TypeError: Object #<Person> has no method ‘sayName‘ 
	//friend对象的原型指针仍然指向的是旧的Person的原型对象导致错误的发生

	
	/**
		原型模式不仅仅适用于创建自定义类型,原生的引用类型也是采用原型模式创建的
	**/
	console.debug(typeof Array.prototype.sort); //"function"
	console.debug(typeof String.prototype.substring); //"function"
	//通过原型对象的原型 不仅仅可以取得默认方法的引用,并且可以修改原声对象的引用
	//下面的代码给基本包装类型String添加一个名为startsWith()的方法
	String.prototype.startsWith = function(text) {
		return this.indexOf(text) == 0;
	};

	var msg = "Hello world!";
	console.debug(msg.startsWith("Hello")); //true

//主人  默认名字为kobe
	var per_1 = new Person();
	//Dog构造函数
	function Dog(){
	}
	//Dog原型
	Dog.prototype = {
		constuctor : Dog,
		name : ‘Hachi‘,
		master : per_1,//主人为per_1  per_1的name默认为Kobe
		sayName : function(){
			console.debug(this.name + ‘ 主人‘ +this.master.name);
		}
	};
	//实例化两只狗狗
	var d1 = new Dog();
	var d2 = new Dog();

	d1.sayName();//Hachi 主人kobe 


	d2.sayName();//Hachi 主人kobe 

	d1.master.name = ‘Garnett‘;//改变狗狗1的主人	

	d1.sayName();//Hachi 主人Garnett 

	d2.sayName();//Hachi 主人Garnett  逻辑上不应该更改的吧
	

        
        function Person(name, age, job){
            this.name = name;
            this.age = age;
            this.job = job;
            this.friends = ["Shelby", "Court"];
        }
        Person.prototype = {
            constructor: Person,
            sayName : function () {
                console(this.name);
            }
        };
        var person1 = new Person("Nicholas", 29, "Software Engineer");
        var person2 = new Person("Greg", 27, "Doctor");
        person1.friends.push("Van");
        console(person1.friends);    //"Shelby,Court,Van"
        console(person2.friends);    //"Shelby,Court"
        console(person1.friends === person2.friends);  //false
        console(person1.sayName === person2.sayName);  //true