function Person(){}
Person.prototype.name = 'Nicholas';
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function () {console.log(this.name);
};
var person1 = new Person();
person1.sayName(); //Nicholasvar person2 = new Person();
person2.sayName(); //Nicholas
console.log(person1.sayName === person2.sayName);  // true

         // 返回[[Prototype]]的值console.log(Object.getPrototypeOf(person1) === Person.prototype); // true使用Object.getPrototypeOf()返回的对象其实就是这个对象的原型，而这在利用原型实现继承的情况下是非常重要的

   function Dog(){}Dog.prototype.name = "tom";var dog_a = new Dog();console.log(dog_a.hasOwnProperty("name")); // falsedog_a.name = "jack";  // 该实例重写了name属性console.log(dog_a.hasOwnProperty("name")); // true

            // 如果属性只存在原型中则返回truefunction test(obj,val){return (!obj.hasOwnProperty(val)) && val in obj;}

        function Person(age){this.age = age;}Person.prototype = {area : "CHINA",say : function () {console.log('hello');}}var p1 = new Person(11);console.log(p1.constructor);  //ƒ Object() { [native code] }// 这里出了一个意外，constructor属性不再指向Person了。我们刚才的语法，实际上是重写了默认的prototype对象，因此constructor属性//变成了新对象的constructor属性(指向Object)构造函数，尽管instanceof操作符还能返回正确结果，但通过constructor已无法确定对象类型console.log(p1 instanceof Person);console.log(p1.constructor == Person);console.log(p1.constructor == Object);// 解决方式初级版Person.prototype = {constructor : Person,area : "CHINA",say : function () {console.log('hello');}}//弊端：这种方式重设constructor属性会导致它的[[Enumerable]]特性为true。默认情况下，原生的constructor属性是不可枚举的。//最终解决方法Object.defineProperty(Person.prototype,"constructor",{enumerable : false,value : Person})

        function Person  (name) {this.name = name;}Person.prototype.area = 'china';var friend = new Person('cl');console.log(friend.area);  // chinaPerson.prototype.area = 'japan';console.log(friend.area);  // japan// 实例与原型对象之间的连接只不过是一个指针，而非一个副本Person.prototype = {area : 'test',}console.log(friend.area);  // japan// 重写原型对象切断了现有原型与之前已经存在的对象实例之间的联系；它们引用的仍然是最初的原型。

            console.log(typeof Array.prototype.sort); // functionconsole.log(typeof String.prototype.substring); // function// 通过原生对象的原型，不仅可以取得所有默认方法的引用，而且也可以定义新方法。可以像修改自定义对象的原型一样修改原生对象的原型// 因此可以随时添加方法String.prototype.startsWith = function () {return this.indexOf(text) == 0;}// 尽管可以这样做，但是不推荐。因为这样会导致命名冲突或者意外的重写原生方法

    function Person(name ,age, job){this.name = name;this.age = age;this.job = job;if(typeof this.sayName != "function"){// 这段代码只有在初次调用构造函数才会执行Person.prototype.sayName = function () {console.log(this.name);}}}// 使用动态原型模式时，不能使用对象字面量重写原型。如果在已经创建了实例的情况下重写原型，那么就会切断现有实例与新原型之间的联系

    function Person(name,age,job){var o = new Object();o.name = name;o.age = age;o.job = job;o.sayName = function () {console.log(this.name);}return o;}var friend = new Person('Ni',29,"eng");friend.sayName(); //  Ni//在这个例子中，Person函数创建了一个对象，并以相应的属性和方法初始化该对象，然后又返回了这个对象。除了使用new操作符并且把使用的包装函数// 叫做构造函数之外，这个模式跟工厂模式其实是一模一样的

function Person(name){var o = new Object();o.sayName = function () {console.log(name);}return o;
}var friend = Person('Ni');
friend.sayName(); //  Ni//注意 ： 在以这种模式创建的对象中，除了使用sayName()方法之外，没有其他方法访问name的值// 即使有其他代码会给这个对象添加方法和数据成员，但也不可能有别的方法传入构造函数中的初始数据。// 构造函数模式提供的这种安全性，使得它非常适合在某些安全执行环境。