(1)对象字面量的方式创建
person={name:"aaa",age:25};缺点，一次只能创造一个，要创造多个对象时会产生许多重复代码，创建出的对象没有具体的类型，它们只是Object类型的一个实例。
（2）单例模式
var person = new Object();
person.name = "june";
person.age = 29;
person.job = "student";
person.sayName = function() {
alert(this.name);
};缺点：一次只能创造一个，要创造多个对象时会产生许多重复代码，创建出的对象没有具体的类型，它们只是Object类型的一个实例。
(3)用function来模拟无参的构造函数
function Person(){}
var person = new Person();
person.name = "lois";
person.age = "23";
person.work = function() {
alert("Hello " + person.name);
}
person.work();(4)用构造函数来实现（用this关键字定义构造的上下文属性）
function Person(name,age,work) {
this.name = name;
this.age = age;
this.work = work;
this.info = function() {
alert(this.name);
}
}
var Xiaosong = new Person("aa",23,"aaaaa"); //实例化、创建对象
Xiaosong.info(); //调用info()方法特点：
- 没有显式创建对象；
- 直接将属性和方法赋给了this对象；
- 没有return语句；
- 要创建新实例，必须使用new操作符；（否则属性和方法将会被添加到window对象）
- 可以使用instanceof操作符检测对象类型
构造函数的问题：
构造函数内部的方法会被重复创建，不同实例内的同名函数是不相等的。可通过将方法移到构造函数外部解决这一问题（
代码：
function Person(name,age) {
this.name = name; //this作用域：当前对象
this.age = age;
}
function my() {
alert(this.name);
}），但面临新问题：封装性不好。
(5)用工厂方式来创建（内置对象）
function Person(name,age){
var o=new Object();
o.name=name;
o.age=age;
o.sayName=function(){
alert(this.name);
};
return o;
}
var person1= Person("aa",12);
var person2= Person("bb",22);特点：解决了创建多个相似对象的问题，可以无数次调用它
缺点：无法解决对象识别的问题（即如何知道一个对象的类型），内存浪费，
person1.sayName()和person2.sayName()并不是引用的同一个函数实例，而是不同的实例
(6)用原型方式来创建
function EX(){}
EX.prototype.name = "EXxxxx";
EX.prototype.get = function() {
alert(this.name);
}
var aa = new EX();
aa.get();特点：
实例无法重写原型的值，在实例新建属性与原型属性重名的时候，实例的值会屏蔽原型的值
使用hasOwnProperty可以检测一个属性是存在于实例中还是原型中（存在实例中返回true）。
缺点：属性和方法都是共享的,无法传参数
(7)用混合方式来创建
function set(name) {
this.name = name;
}
set.prototype.say= function() {
alert(this.name);
}
var aaa= new set("ggg");
aaa.say();特点：
构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。所以每个实例都会有自己的一份实例属性的副本，但同时共享着对方法的引用，最大限度的节省了内存。同时支持向构造函数传递参数
（8）动态原型模式
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
if(typeof this.sayName!="function"){
Person.prototype.sayName=function(){
alert(this.name);
};
}
}
var a=new Person("ww",12,"ss");
a.sayName();特点：
- 把所有信息都封装在了构造函数中，同时通过在构造函数中初始化原型（仅在必要的情况下），又保持了使用原型和构造函数的优点。
- 可以使用instanceof确定类型
- 使用动态原型模式时，不能使用对象字面量重写原型。因为，如果在已经创建了实例的情况下重写原型，那么就会切断现有实例与新原型之间的联系（现有实例认为的原型还是以前那个）。
例：
if(typeof this.sayName != "function") {
//不能用这样的方法初始化原型
Person.prototype = {
sayName: function() {
alert(this.name);
}
};
}
对象的创建先于原型对象的初始化，对象获得指向原型对象的指针发生在对象创建时刻，所以在这种情况下，创建的对象早已指向了原型对象，通过Person.prototype修改原型对象能被新对象的[[prototype]]访问到；然而使用对象字面量时，Person.prototype通过赋值的方式指向了另一个对象，但此时[[prototype]]仍指向初始的原型对象。
参考链接：