<1>.
基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)
var obj = new Object();
obj.name = "userObject";
obj.printName = function(name){
this.name = name;
console.log(this.name);
}
obj.printName("newUserObject");
<2>.
工厂方式创建对象(每次创建一个object后,其中对应的方法(本例中是get)也被创建一次,事实上每个对象共享了同一个函数):
[1].简单工厂模式
a.不带参数的构造方法
function Dog(){
var dog = Object();
dog.name = "xiaoHuang";
dog.color = "Yellow";
dog.get = function(){
console.log(this.name+","+this.color);
}
return dog;
}
var dog1 = Dog();
var dog2 = Dog();
dog1.get();
dog2.get();
dog1.get() === dog2.get() // true;
b.带参数的构造方法
function Dog(name,color){
var dog = Object();
dog.name = name;
dog.color = color;
dog.get = function(){
console.log(this.name+","+this.color);
}
return dog;
}
var dog1 = Dog("xiaoBlue","blue");
dog1.get();
c.让函数被多个创建的对象所共享,而不是每一个对象都创建一个相同的函数(缺点:对象定义本身和方法分离了)
function get(){
console.log(this.name+","+this.color);
}
function Dog(name,color){
var dog = Object();
dog.name = name;
dog.color = color;
dog.get = get;
return dog;
}
var dog1 = new Dog("xiaoRed","red");
var dog2 = new Dog("xiaoGreen","green");
dog1.get();
dog2.get();
dog1.get() === dog2.get();
<3>.混合工厂模式(创建假的构造函数,只返回另一种对象的新实例)
同样与简单工厂模式一样有三种方式
function Dog(){
var dog = new Object();
dog.name = "xiaoRed";
dog.color = "red";
dog.get = function(){
console.log(this.name+","+this.color);
}
return dog;
}
与工厂方式所不同的是,这种方式使用new运算符。
<4>.构造函数方式
a.无参构造函数
function Person(){
this.username = "zhangsan";
this.pwd = "123";
this.toString = function(){
console.log(this.username+","+this.pwd);
}
}
var person = new Person();
person.toString();
b.有参构造函数
unction Person(username,pwd){
this.username =
username
;
this.pwd =
pwd
;
this.toString = function(){
console.log(this.username+","+this.pwd);
}
}
var person = new Person("xiaoHong","123456");
person.toString();
构造函数方式在函数内部没有创建对象,是用this关键字。因为在调用构造函数时已经创建了对象,而在函数内部只能用this来访问对象属性。
它同工厂方式一样。每次调用都会为对象创建自己的方法。
它同工厂方式一样。每次调用都会为对象创建自己的方法。
<5>.使用原型(prototype)方式创建对象
优点:创建的多个对象共享同一个方法(getInfo)
缺点:创建的多个对象在共享同一个方法的同时也共享了同样的属性(username,password),实际开发中这样儿是不行的,必须是多个对象都要有自己的属性。采用该方式创建对象通常是用来扩展已有对象的某一个方法。
a.无参构造函数
function Person(){}
Person.prototype.username = "zhangsan";
Person.prototype.password = "123";
Person.prototype.getInfo = function(){
console.log(this.username + ", " + this.password);
}
var person = new Person();
var person2 = new Person();
person.username = "lisi";
person.getInfo();
person2.getInfo();
function Person(){}
Person.prototype.username = "zhangsan";
Person.prototype.password = "123";
Person.prototype.getInfo = function(){
console.log(this.username + ", " + this.password);
}
var person = new Person();
var person2 = new Person();
person.username = "lisi";
person.getInfo();
person2.getInfo();
b.利用原型方式有个很严重的问题,创建对象,生成的所有对象将会共享原型中的属性,这样一个对象改变了该属性也会反应到其他的对象上,例如数组
function Car(){
}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.arr = new Array("a","b");
Car.prototype.showColor = function(){
console.log(this.color);
}
var car1 = new Car();
var car2 = new Car();
car1.arr.push("cc");
console.log(car1.arr); //aa,bb,cc
console.log(car2.arr); //aa,bb,cc
}
Car.prototype.color = "red";
Car.prototype.doors = 4;
Car.prototype.arr = new Array("a","b");
Car.prototype.showColor = function(){
console.log(this.color);
}
var car1 = new Car();
var car2 = new Car();
car1.arr.push("cc");
console.log(car1.arr); //aa,bb,cc
console.log(car2.arr); //aa,bb,cc
<6>.联合的构造函数/原型方式
用构造函数/原型方式就可以像其他程序设计语言一样创建对象,是用构造函数定义对象的非函数属性,用原型方式定义对象的方法。
function Car(color,door){
this.color = color;
this.doors = door;
this.arr = new Array("aa","bb");
}
Car.prototype.showColor=function(){
console.log(this.color);
}
var car1 = new Car("red",4);
var car2 = new Car("blue",4);
car1.arr.push("cc");
console.log(car1.arr); //aa,bb,cc
console.log(car2.arr); //aa,bb
this.color = color;
this.doors = door;
this.arr = new Array("aa","bb");
}
Car.prototype.showColor=function(){
console.log(this.color);
}
var car1 = new Car("red",4);
var car2 = new Car("blue",4);
car1.arr.push("cc");
console.log(car1.arr); //aa,bb,cc
console.log(car2.arr); //aa,bb
<7>.
动态原型方式
动态原型的方式同混合的构造函数/原型方式原理相似。唯一的区别就是赋予对象方法的位置。
动态原型方式:在构造函数中通过标志量让所有对象共享一个方法,而每个对象拥有自己的属性。
function Person(){
this.username = "zhangsan";
this.password = "123";
if(typeof Person.flag == "undefined"){
Person.prototype.toString = function(){
console.log(this.username + ", " + this.password);
}
Person.flag = true;
}
}
var p = new Person();
var p2 = new Person();
p.toString();
p2.toString();
this.username = "zhangsan";
this.password = "123";
if(typeof Person.flag == "undefined"){
Person.prototype.toString = function(){
console.log(this.username + ", " + this.password);
}
Person.flag = true;
}
}
var p = new Person();
var p2 = new Person();
p.toString();
p2.toString();
动态原型方式是使用一个标志来判断是否已经给原型赋予了方法。这样可以保证该方法只创建一次