var object1 = new Object();
object1.name = "nameTest1";
object1.sayName = function(){console.log(this.name);
}
var object2 = {name:"nameTest2",sayName: new Function("console.log(this.name);")
};
object1.sayName();//nameTest1
object2.sayName();//nameTest2

function createPerson(name){return {name: name,sayName: function(){console.log(this.name)}}
}
var person = createPerson("nameTest");
person.sayName();//nameTest

function Person(name){//2.将构造函数的作用域赋值给personCopy，this指向personCopythis.name = name;//3.执行构造函数中的代码,personCopy.name = name;this.sayName = new Function("console.log(this.name)")//3.执行构造函数中的代码
}
var person = new Person("testName");//1.创建新的对象，personCopy//4.返回personCopy给person
person.sayName();//testName

function Person(name){this.name = name;this.sayName = new Function("console.log(this.name)")
}

function Person(name){this.name = name;this.sayName = new Function("console.log(this.name)")
}
var person1 = new Person("testName1");
var person2 = new Person("testName2");
console.log(person1 instanceof Object);//true 对象类型检测
console.log(person2 instanceof Object);//true 对象类型检测
console.log(person1 instanceof Person);//true 对象类型检测
console.log(person2 instanceof Person);//true 对象类型检测
console.log(person1.sayName === person2.sayName);//false 不同对象的同一方法不同
//通过实例对象可以访问构造函数的原型对象中的constructor属性,这个属性指向构造函数
console.log(person1.constructor === Person);//true
console.log(person1.hasOwnProperty("constructor"));//false 可以说明实例对象本身没有constructor属性

function Person(name){this.name = name;this.sayName = fn;
}
function fn(){console.log(this.name);
}
var person1 = new Person("testName1");
var person2 = new Person("testName2");
person1.sayName();
person2.sayName();
console.log(person1.sayName === person2.sayName);//true
//通过这种方法使得构造函数中的方法只创建了一次,那么不同的实例对象的同一方法也就相同了
//但如上这种做法有问题，如果构造函数中有很多方法，都定义在全局作用域中没有封装，并且浪费（毕竟定义在全局作用域中的函数只给一个函数调用）

function Person(name){this.name = name;
}
Person.prototype.age = 15;

Person.prototype.sayName = function(){console.log(this.name)};

console.log(Person.prototype.constructor === Person);//true 原型对象的构造函数属性指向构造函数

function Person(){}
Person.prototype.name = "nameTest1";
Person.prototype.sayName = function(){console.log(this.name)};
console.log(Person.prototype.constructor === Person);//true 原型对象的构造函数属性指向构造函数
var person1 = new Person();
var person2 = new Person();
//Object.getPrototypeOf(value)取得value的原型对象，这个方法返回[[prototype]]的值（不能直接访问[[prototype]]属性）
console.log(Object.getPrototypeOf(person1) === Person.prototype);//true
console.log(person1.hasOwnProperty("name"));//false
console.log(person1.hasOwnProperty("sayName"));//false
console.log(person1.sayName === person2.sayName);//true 同一方法在不同实例对象上是相同的
person1.sayName();//nameTest1
person2.sayName();//nameTest1

function Person(){this.job = "coder"
}
Person.prototype.name = "nameTest1";
Person.prototype.sayName = function(){console.log(this.name)};
var person1 = new Person();
person1.name = "nameTest2";//前面的属性会屏蔽后面的属性，可以用来设置不同的实例对象
console.log(person1.hasOwnProperty("name"));//true 搜索属性的过程到达：实例对象本身
console.log(person1.hasOwnProperty("sayName"));//false 搜索属性的过程到达：原型对象本身
console.log(person1.job);//coder 搜索属性的过程到达：构造函数
person1.sayName();//nameTest2 前面的属性会屏蔽后面的属性
person1.name = null;
person1.sayName();//null 设置为null不会恢复与原型对象的连接
delete person1.name;
console.log(person1.hasOwnProperty("name"));//false
person1.sayName();//nameTest1 delete操作符可以恢复与原型对象的连接

function Person(){}
var person1 = new Person();
Person.prototype = {constructor: Person,//如果没有这一步的话Person.prototype的constructor属性将指向Object构造函数name: "nameTest1",sayName: function(){console.log(this.name)}
}
var person2 = new Person();
console.log("name" in person1);//false 如果在实例对象后重写原型对象，实例对象与新的原型对象是不能建立连接的
console.log("name" in person2);//true 如果在实例对象前重写原型对象，是能够建立新的连接的

function Person(){}
Person.prototype = {constructor: Person,name: "nameTest1",job: ["coder","ITer"],sayName: function(){console.log(this.name)},sayJob: function(){console.log(this.job)},
}
var person1 = new Person();
var person2 = new Person();
person1.name = "newName";
person1.sayName();//newName 对非引用类型的值在实例对象上修改会屏蔽原型对象上的同名属性
person2.sayName();//nameTest1
person1.job.push("LOLer"); //对引用类型的值在实例对象上修改会修改原型对象中的同名属性
person1.sayJob();//coder, ITer, LOLer
person2.sayJob();//coder, ITer, LOLer 因为共享的本质，使得其他实例对象对原型对象的修改也会反映在该实例对象上

function Person(name){this.name = name;this.job = ["coder","ITer"];
}//对象字面量重写原型对象
Person.prototype = {constructor: Person,sayName: function(){console.log(this.name)},sayJob: function(){console.log(this.job)},
}
var person1 = new Person("name1");
var person2 = new Person("name2");
person1.name = "newName";
person1.sayName();//newName
person2.sayName();//name2
person1.job.push("LOLer");
person1.sayJob();//coder, ITer, LOLer
person2.sayJob();//coder, ITer

function Person(name){this.name = name;this.job = ["coder","ITer"];//只有在sayName方法不存在的情况下，才给原型对象添加属性，也就是说下面这段代码只会在第一次调用构造函数时才会执行//再次调用构造函数实例对象时，sayName属性已经存在于原型对象中，不会再重复创建，并且只要判断一个就可以了if(typeof this.sayName != "function") {console.log("这个log只会在第一个调用构造函数时出现一次，再次调用时不会出现");Person.prototype.sayName = function(){console.log(this.name)};Person.prototype.sayJob = function(){console.log(this.job)};//不能在已经创建实例的情况下使用对象字面量法重写原型对象，会切断实例与新原型之间的联系// Person.prototype = {//     constructor: Person,//     sayName: function(){//         console.log(this.name)//     },//     sayJob: function(){//         console.log(this.job)//     }// }
    };
}
var person1 = new Person("name1");
var person2 = new Person("name2");
person1.name = "newName";
person1.sayName();//newName
person2.sayName();//name2
person1.job.push("LOLer");
person1.sayJob();//coder, ITer, LOLer
person2.sayJob();//coder, ITer