1. 创建对象的方法：
直接使用new 对Object对象进行操作，即对Object 对象进行实例化
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<script>
var obj = new Object();
obj.userName = "huanying2015";
obj.showName = function() {
return this.userName;
}
console.log(obj.userName);
</script>
</head>
<body>
</body>
</html>
运行结果：
2.直接创建一个对象：使用大括号包裹起来，在其中写属性和方法
<script>
var obj = {
userName: 'huanying2015',
showName: function() {
return this.userName;
}
}
console.log(obj.showName());
</script>
运行结果：
3.使用工厂模式创建对象：设置一个函数，每次调用都会创建一个函数，开辟一个内存空间，每次调用都会开辟不同的空间，各个空间都不相同，互不干扰；在最后返回这个在构造函数中创建的对象
<script>
function creatObj(uName) {
var o = new Object();
o.userName = uName;
o.showName = function() {
return this.userName;
}
return o;
}
var OT1 = new creatObj('孙权');
var OT2 = new creatObj('刘备');
var OT3 = new creatObj('曹操');
console.log(OT1.showName()); //孙权
console.log(OT2.showName()); //刘备
console.log(OT3.showName()); //曹操
OT3.userName = '曹丕';
console.log(OT1.showName()); //孙权
console.log(OT2.showName()); //刘备
console.log(OT3.showName()); //曹丕
</script>
运行结果：
4. 使用构造函数的方式，创建对象：和工厂模式有点类似，也有差异，工厂模式是：每次调用，都对Object对象实例化一次，然后返回这个实例化的对象；构造函数模式是：调用一次，即是得到构造函数的一个实例
<script>
function createObj(uName) {
this.userName = uName;
this.showName = function() {
return this.userName;
}
}
var OT1 = new createObj("huanying2015");
var OT2 = new createObj("alhouha");
console.log(OT1.showName()); //huanying2015
console.log(OT2.showName()); //alhouha
console.log(OT1.showName === OT2.showName); //false 两个函数虽然都是showName ,但是他们出现在不同的对象，
// 而函数是地址，他们在不同的对象中，所以也就是在不同的地址中，所以结果为false
</script>
运行结果：
5. 使用函数的原型对象创建函数：其实是在构造函数的原型对象上增减方法，调用实例时，通过原型链都调用原型对象上的方法，
<script>
function createObj(uName) {
this.userName = uName;
}
createObj.prototype.showName = function() {
return this.userName;
}
var OT1 = new createObj("huanying2015");
var OT2 = new createObj("alhouha");
console.log(OT1.showName()); //huanying2015
console.log(OT2.showName()); //alhouha
console.log(OT1.showName === OT2.showName); //true 两个函数都是原型对象上的，所以结果为true
console.log(OT1.__proto__ == createObj.prototype); //true 因为实例的隐式原型属性__proto__指向构造函数的原型对象
console.log(OT2.__proto__ == createObj.prototype); //true 因为实例的隐式原型属性__proto__指向构造函数的原型对象
console.log(createObj.prototype.__proto__ == Object.prototype); //true 因为构造函数的原型对象上的隐式原型属性，指向Object对象的原型对象
console.log(Object.prototype.__Proto__ == null); // true 因为Object 对象的原型对象上的隐式原型属性__proto__指向null
</script>
运行结果：
6. 判断一个方法是否是实例本身的：hasOwnProperty()
<script>
function createObj() {
this.userName = "huanying2015";
}
createObj.prototype.userName = "aluoha";
createObj.prototype.guestName = "代号：猎鹰行动";
var obj1 = new createObj();
var obj2 = new createObj();
console.log(obj1.userName); //huanying2015
console.log(obj2.userName); //huanying2015
console.log(obj1.guestName); //代号：猎鹰行动 // 要判断一个属性或方法是否是实例本省的， 使用函数： hasOwnProperty(); console.log(obj1.hasOwnProperty("userName")); // true 因为userName 是实例上的方法，所以返回true ，在原型链中，根据就近原则进行查找
console.log(obj1.hasOwnProperty("guestName")); // false 因为guestName 不是实例上的方法，而是原型上的方法，所以返回false
</script>
运行结果：
7. in 操作符：如果一个属性或者方法在实例上或者在原型上，则返回true,否则返回false
<script>
//in:如果一个属性在实例或者原型对象(prototype), 返回true
console.log('toString' in Object.prototype); //true 原型对象上可以调用 toString
console.log('toString' in Object); // true 实例可以调用 toString
console.log('valueOf' in Object.prototype); // true 原型对象上可以调用 valueOf
console.log('hasOwnProperty' in Object.prototype); //true 原型对象上可以调用 hasOwnProperty console.log(Object.prototype); var obj = {
userName: "huanying2015",
}
console.log('userName' in obj); // true 属性在实例上，所以为true
console.log('guestName' in obj); // false 属性不在实例上，所以为false function createObj() {
this.userName = "huanying2015";
}
createObj.prototype.guestName = "aluoha";
var OT = new createObj();
console.log('guestName' in OT); // true 属性在构造函数的原型对象上，所以为true
</script>
运行结果：
8. 判断一个属性是否在原型对象上：使用hasOwnProperty 和 in 来创建函数
<script>
// 有两个函数可以选择，一个是 hasOwnProperty(),判断是否在实例上；一个是 in ,判断属性是否在实例或者原型对象上
// 业务逻辑：先使用hasOwnProperty 判断，如果返回true，说明这个属性在实例上；但是我们要判定的是属性是否在原型对象上，所以要先把实例上的属性给删除掉
// 然后在用 in 来循环，因外之前已经删除了实例上的属性，如果此时判定结果为true，则在原型对象上；如果返回false,则说明不在原型对象上了
function hasprototypeProperty(obj, name) {
var catchObj = {};
if (obj.hasOwnProperty(name)) { // 如果实例上有
catchObj[name] = obj[name]; // 把实例上的属性存入缓存
delete obj[name]; //清除实例上的属性
if (name in obj) { // 在针对确认原型上有没有，如果有
obj[name] = catchObj[name]; //因为刚才清除了实例上的属性，为了不改变对象，现在进行恢复实例上的属性
return true; //说明原型对象上也有改属性，则返回true
} else {
obj[name] = catchObj[name]; //因为刚才清除了实例上的属性，为了不改变对象，现在进行恢复实例上的属性
return false; // 说明原型对象上没有改属性，则返回false
}
} else { //另一方面，如果实例上没有，则对原型对象进行循环遍历
if (name in obj) { // 如果循环为真，这说明属性在原型对象上
return true; // 返回true
} else { // 如果循环为假，则说明属性不在原型对象上，
return false; // 返回false
}
}
} function createObj() {
this.userName = "huanying2015";
this.guestName = "aluoha"; this.show = function() {
return this.userName;
}
}
createObj.prototype.userName = "huanying2015";
createObj.prototype.helloName = "nihaome";
var obj = new createObj();
console.log(hasprototypeProperty(obj, "userName")); // true 原型对象种有这个属性 ----实例有，原型对象上也有，所以返回true
console.log(hasprototypeProperty(obj, "helloName")); //true 原型对象中有这个属性 ----实例无，原型对象上有，所以返回true
console.log(hasprototypeProperty(obj, "guestName")); //false 原型对象中没有这个属性----实例有，原型对象上无，所以返回false console.log(obj.userName); // huanying2015
console.log(obj.guestName); //aluoha
console.log(obj);
</script>
运行结果：
