菜单

浅谈 JS 创立对象的 8 栽形式

2018年12月15日 - JavaScript

浅尝辄止谈 JS 创制对象的 8 栽形式

2015/10/16 · JavaScript
· 对象

初稿出处: Tomson   

1.Object 模式

var o1 = {};//字面量的表现形式
var o2 = new Object;
var o3 = new Object();
var o4 = new Object(null);
var o5 = new Object(undefined);
var o6 = Object.create(Object.prototype);//等价于 var o = {};//即以 Object.prototype 对象为一个原型模板,新建一个以这个原型模板为原型的对象
//上面6种都是一样
//区别
var o7 = Object.create(null);//创建一个原型为 null 的对象

1.Object 模式

JavaScript

var o1 = {};//字面量的表现形式 var o2 = new Object; var o3 = new
Object(); var o4 = new Object(null); var o5 = new Object(undefined); var
o6 = Object.create(Object.prototype);//等价于 var o = {};//即坐
Object.prototype 对象也一个原型模板,新建一个坐之原型模板也原型的对象
//区别 var o7 = Object.create(null);//创制一个原型为 null 的目的

1
2
3
4
5
6
7
8
var o1 = {};//字面量的表现形式
var o2 = new Object;
var o3 = new Object();
var o4 = new Object(null);
var o5 = new Object(undefined);
var o6 = Object.create(Object.prototype);//等价于 var o = {};//即以 Object.prototype 对象为一个原型模板,新建一个以这个原型模板为原型的对象
//区别
var o7 = Object.create(null);//创建一个原型为 null 的对象

以 chrome 里查看各样新建对象的分:
图片 1

可以看到前6栽情势开创出来的目的如故一致的,第七种不同点在于其即便为为
Object
对象只是其无外性质(包括没有外可以持续的性,因为成立的时没点名其原型)

2.厂模式

//工厂方法1 通过一个方法来创建对象 利用 arguments 对象获取参数设置属性(参数不直观,容易出现问题)
function createCar(){
    var oTemp = new Object();
    oTemp.name = arguments[0];//直接给对象添加属性,每个对象都有直接的属性
    oTemp.age = arguments[1];
    oTemp.showName = function () {
        alert(this.name);
    };//每个对象都有一个 showName 方法版本
    return oTemp;
}
createCar("tom").showName();//在 JS 中没有传递的实参,实际形参值为 undefined(这里的 age 为 undefined)
createCar("tim",80).showName();
alert(createCar("tom") instanceof Object);//true 判断对象是否 Object 类或子类

//工厂方法2 通过传参设置属性(参数直观明了)
function createCar(name,age){
    var oTemp = new Object();
    oTemp.name = name;//直接给对象添加属性,每个对象都有直接的属性
    oTemp.age = age;
    oTemp.showName = function () {
        alert(this.name);
    };//每个对象都有一个 showName 方法版本
    return oTemp;
}
createCar("tom").showName();
createCar("tim",80).showName();
alert(createCar("tom") instanceof Object);//true 判断对象是否 Object 类或子类

2.厂子格局

JavaScript

//工厂方法1 经一个道来创建对象 利用 arguments
对象得到参数设置属性(参数不直观,容易并发问题) function createCar(){ var
oTemp = new Object(); oTemp.name =
arguments[0];//直接叫目的上加属性,每个对象还发一直的属性 oTemp.age =
arguments[1]; oTemp.showName = function () { alert(this.name);
};//每个对象都出一个 showName 方法版本 return oTemp; }
createCar(“tom”).showName();//在 JS 中没传递的实参,实际形参值为
undefined(这里的 age 为 undefined) createCar(“tim”,80).showName();
alert(createCar(“tom”) instanceof Object);//true 判断目的是不是 Object
类或子类

1
2
3
4
5
6
7
8
9
10
11
12
13
//工厂方法1 通过一个方法来创建对象 利用 arguments 对象获取参数设置属性(参数不直观,容易出现问题)
function createCar(){
    var oTemp = new Object();
    oTemp.name = arguments[0];//直接给对象添加属性,每个对象都有直接的属性
    oTemp.age = arguments[1];
    oTemp.showName = function () {
        alert(this.name);
    };//每个对象都有一个 showName 方法版本
    return oTemp;
}
createCar("tom").showName();//在 JS 中没有传递的实参,实际形参值为 undefined(这里的 age 为 undefined)
createCar("tim",80).showName();
alert(createCar("tom") instanceof Object);//true 判断对象是否 Object 类或子类

JavaScript

//工厂方法2 经过传参设置属性(参数直观明了) function createCar(name,age){
var oTemp = new Object(); oTemp.name =
name;//直接叫目的上加属性,每个对象还有一向的属性 oTemp.age = age;
oTemp.showName = function () { alert(this.name); };//每个对象都发一个
showName 方法版本 return oTemp; } createCar(“tom”).showName();
createCar(“tim”,80).showName(); alert(createCar(“tom”) instanceof
Object);//true 判断目的是否 Object 类或子类

1
2
3
4
5
6
7
8
9
10
11
12
13
//工厂方法2 通过传参设置属性(参数直观明了)
function createCar(name,age){
    var oTemp = new Object();
    oTemp.name = name;//直接给对象添加属性,每个对象都有直接的属性
    oTemp.age = age;
    oTemp.showName = function () {
        alert(this.name);
    };//每个对象都有一个 showName 方法版本
    return oTemp;
}
createCar("tom").showName();
createCar("tim",80).showName();
alert(createCar("tom") instanceof Object);//true 判断对象是否 Object 类或子类

3.构造器情势

//构造器方法1
function Car(sColor,iDoors){  //声明为构造器时需要将函数名首字母大写
    this.color = sColor;      //构造器内直接声明属性
    this.doors = iDoors;
    this.showColor = function(){
        return this.color;
    };//每个 Car 对象都有自己的 showColor方法版本
    this.showDoor = function () {
        return this.doors;
    }
}

用模式1底题材大扎眼,没道是 showDoor
方法重用,每回新建一个靶就如于积里新开拓一切片内存空间.立异如下

//构造器方法2
function showDoor(){      //定义一个全局的 Function 对象
    return this.doors;
}

function Car(sColor,iDoors){//构造器
    this.color = sColor;      //构造器内直接声明属性
    this.doors = iDoors;
    this.showColor = function(){
        return this.color;
    };
    this.showDoor = showDoor();//每个 Car 对象共享同一个 showDoor 方法版本(方法有自己的作用域,不用担心变量被共享)
}

alert(new Car("red",2).showColor());//通过构造器创建一个对象并调用其对象方法

3.构造器格局

JavaScript

//构造器方法1 function Car(sColor,iDoors){
//阐明为社团器时需要用函数叫首字母大写 this.color = sColor;
//构造器内直接表明属性 this.doors = iDoors; this.showColor = function(){
return this.color; };//每个 Car 对象都有自己之 showColor方法版本
this.showDoor = function () { return this.doors; } }

1
2
3
4
5
6
7
8
9
10
11
//构造器方法1
function Car(sColor,iDoors){  //声明为构造器时需要将函数名首字母大写
    this.color = sColor;      //构造器内直接声明属性
    this.doors = iDoors;
    this.showColor = function(){
        return this.color;
    };//每个 Car 对象都有自己的 showColor方法版本
    this.showDoor = function () {
        return this.doors;
    }
}

采纳办法1之题目极度明显,没道是 showDoor
方法重用,每便新建一个对象就是假使于积里新开辟一首空间.立异如下

JavaScript

//构造器方法2 function showDoor(){ //定义一个大局的 Function 对象 return
this.doors; } function Car(sColor,iDoors){//构造器 this.color = sColor;
//构造器内一向讲明属性 this.doors = iDoors; this.showColor = function(){
return this.color; }; this.showDoor = showDoor();//每个 Car
对象同享同一个 showDoor 方法版本(方法有友好的效用域,不用顾虑变量被共享)
} alert(new
Car(“red”,2).showColor());//通过构造器创制一个靶并调用其目的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//构造器方法2
function showDoor(){      //定义一个全局的 Function 对象
    return this.doors;
}
 
function Car(sColor,iDoors){//构造器
    this.color = sColor;      //构造器内直接声明属性
    this.doors = iDoors;
    this.showColor = function(){
        return this.color;
    };
    this.showDoor = showDoor();//每个 Car 对象共享同一个 showDoor 方法版本(方法有自己的作用域,不用担心变量被共享)
}
 
alert(new Car("red",2).showColor());//通过构造器创建一个对象并调用其对象方法

点出现的题材不怕是语义不够清除,呈现不出类的封装性,立异为 prototype 形式

4.透过Function对象实现创立对象

我们领略各个阐明一个函数实际是创设了一个Function 实例 JS
函数
.

function function_name(param1,param2){alert(param1);}
//等价于
var function_name = new Function("param1","pram2","alert(param1);");

var Car2 = new Function("sColor","iDoors",
         "this.color = sColor;"+
         "this.doors = iDoors;"+
         "this.showColor = function(){ return this.color; }"
);
alert(new Car2("blue",3).showColor());

4.由此Function对象实现创造对象

咱了然各类声明一个函数实际是创办了一个Function 实例 JS
函数
.

JavaScript

function function_name(param1,param2){alert(param1);} //等价于 var
function_name = new Function(“param1″,”pram2″,”alert(param1);”);

1
2
3
function function_name(param1,param2){alert(param1);}
//等价于
var function_name = new Function("param1","pram2","alert(param1);");

JavaScript

var Car2 = new Function(“sColor”,”iDoors”, “this.color = sColor;”+
“this.doors = iDoors;”+ “this.showColor = function(){ return this.color;
}” ); alert(new Car2(“blue”,3).showColor());

1
2
3
4
5
6
var Car2 = new Function("sColor","iDoors",
         "this.color = sColor;"+
         "this.doors = iDoors;"+
         "this.showColor = function(){ return this.color; }"
);
alert(new Car2("blue",3).showColor());

5.prototype模式

在意:通过类实例化出目的后对象内无 prototype
属性,但目的只是一直像看属性一样的访问类的 prototype
域的始末,实例对象来只个人属性proto,proto性外含有类的
prototype 域内之性能和办法

方法1
function Car3(){}//用空构造函数设置类名
Car3.prototype.color = "blue";//每个对象都共享相同属性
Car3.prototype.doors = 3;
Car3.prototype.drivers = new Array("Mike","John");
Car3.prototype.showColor = function(){
    alert(this.color);
};//每个对象共享一个方法版本,省内存。

var car3_1 = new Car3();
var car3_2 = new Car3();

alert(car3_1.color);//blue
alert(car3_2.color);//blue
alert(Car3.prototype.color);//blue

car3_1.drivers.push("Bill");
alert(car3_1.drivers);//"Mike","John","Bill"
alert(car3_2.drivers);//"Mike","John","Bill"
alert(Car3.prototype.drivers);//"Mike","John","Bill"

//直接修改实例对象的属性,解析器会先去找实例对象是否有这个属性(不会去找实例对象的 _proto_ 属性内的那些类的 prototype 属性,而是直接查看这个实例是否有对应的属性(与_proto_同级))
//如果没有则直接给这个实例对象添加该属性,但不会修改类的prototype域的同名属性,既实例对象的_proto_属性内的那些类 prototype 域属性不会被修改
car3_1.color = "red";//car3_1对象内无名为 color 的对象属性,故将该属性添加到该对象上

//解析器对实例对象读取属性值的时候会先查找该实例有无同名的直接属性
//如果没有,则查找__proto__属性内保存的那些 当前类的 prototype 域的属性
//有就返回,无则继续查找是否有原型链中的对应的方法属性
//有就返回,无则返回undefined
alert(car3_1.color);//red
alert(car3_2.color);//blue
alert(car3_2.color2);//undefined

//直接修改类的 prototype 域内的属性,不会影响该类的实例对象的对象属性,但会影响实例对象的_proto_属性(_proto_属性内存放的是类的 prototype 域的内容)
Car3.prototype.color = "black";
alert(car3_1.color);//red 该对象有同名的直接属性,故不会去_proto_属性内查找类的 prototype 域的属性
alert(car3_2.color);//black 受影响

//直接修改实例对象的方法,解析器会先去找实例对象是否有这个方法(不会去找实例对象的 _proto_ 属性内的那些类的 prototype 域的方法,而是直接查看这个实例是否有对应的方法(与_proto_同级))
//如果没有则直接给这个实例对象添加该方法,但不会修改类的prototype域的同名方法,既实例对象的_proto_属性内的那些类 prototype 域方法不会被修改
//car3_1对象内无名为 showColor 的对象方法属性,故将该方法属性添加到该对象上
car3_1.showColor = function () {
    alert("new function");
}
//解析器对实例对象调用方法属性的时候会先查找该实例有无同名的直接方法属性
//如果没有,则查找_proto_属性内保存的那些 当前类的 prototype 域的方法属性
//有就返回,无则继续查找是否有原型链中的对应的方法属性
//找到就返回,无则报错

car3_1.showColor();//new function
car3_2.showColor();//blue
car3_1.abcd();//直接报错

//直接修改类的 prototype 域内的方法属性,不会影响该类的实例对象的方法属性,但会影响实例对象的_proto_属性(_proto_属性内存放的是类的 prototype 域的内容)
Car3.prototype.showColor = function () {
    alert("second function");
}
car3_1.showColor();//new function 该对象有同名的方法属性,故不会去_proto_属性内查找类的 prototype 域的方法属性
car3_2.showColor();//second function 受影响

可看看使用该格局则说于起减弱了内存的浪费,但如故发出问题,某个对象的特性一旦改变,所有因而类实例化拿到的对象的proto内属性值也会面随着变(实也援),立异如下

5.prototype模式

注意:通过类实例化出目标后对象内凭 prototype
属性,但目的然则直接像看属性一样的访问类的 prototype
域的始末,实例对象来只个人属性__proto__,__proto__性能外含有类的
prototype 域内之属性与格局

JavaScript

方法1 function Car3(){}//用空构造函数设置类名 Car3.prototype.color =
“blue”;//每个对象都共享相同属性 Car3.prototype.doors = 3;
Car3.prototype.drivers = new Array(“麦克”,”约翰(John)”);
Car3.prototype.showColor = function(){ alert(this.color);
};//每个对象共享一个办法版本,省内存。 var car3_1 = new Car3(); var
car3_2 = new Car3(); alert(car3_1.color);//blue
alert(car3_2.color);//blue alert(Car3.prototype.color);//blue
car3_1.drivers.push(“Bill”);
alert(car3_1.drivers);//”Mike”,”John”,”Bill”
alert(car3_2.drivers);//”麦克”,”约翰(John)”,”比尔”
alert(Car3.prototype.drivers);//”麦克”,”约翰”,”比尔”
//直接修改实例对象的习性,解析器会优先夺探寻实例对象是不是出之特性(不会面去摸索实例对象的
_proto_ 属性内的那多少个看似的 prototype
属性,而是一直翻此实例是否出照应之性(与_proto_同级))
//如若没有则直被那个实例对象上加该属性,但未会师修改类的prototype域的同名属性,既实例对象的_proto_属性内的那个类
prototype 域属性不相会吃修改 car3_1.color = “red”;//car3_1靶内无名为
color 的对象属性,故将该属性添加到拖欠目的上
//解析器对实例对象读取属性值的时节会先查找该实例有无同名的直性
//假如没有,则寻__proto__属于性内保存的那个 当前类的 prototype
域的属性 //有就回去,无则连续找是否出原型链中的附和之情势属性
//有就赶回,无则再次来到undefined alert(car3_1.color);//red
alert(car3_2.color);//blue alert(car3_2.color2);//undefined
//直接修改类的 prototype
域内之性能,不会见影响该类的实例对象的靶子属性,但会影响实例对象的_proto_属性(_proto_特性外存放的是近似的
prototype 域的情) Car3.prototype.color = “black”;
alert(car3_1.color);//red
该目的来同名的第一手性,故不会合去_proto_性内查找类的 prototype
域的性能 alert(car3_2.color);//black 受影响
//直接修改实例对象的法门,解析器会预先夺找寻实例对象是否来夫法子(不会师去寻觅实例对象的
_proto_ 属性内的这多少个看似的 prototype
域的措施,而是直接翻此实例是否出照应的格局(与_proto_同级))
//假如没有则直让此实例对象上加该措施,但切莫汇合修改类的prototype域的同名方法,既实例对象的_proto_属性内的这么些类
prototype 域方法不碰面让改 //car3_1目的内无名为 showColor
的靶子方法属性,故将欠法属性添加到拖欠目的及 car3_1.showColor =
function () { alert(“new function”); }
//解析器对实例对象调用方法属性之下会先查找该实例有管同名的直白格局属性
//倘使没有,则寻_proto_属性内保存之那个 当前类的 prototype
域的道属性 //有就回,无则连续查找是否有原型链中的照应的艺术属性
//找到就回到,无则报错 car3_1.showColor();//new function
car3_2.showColor();//blue car3_1.abcd();//直接报错 //间接修改类的
prototype
域内之法子属性,不谋面影响该类的实例对象的点子属性,但会影响实例对象的_proto_属性(_proto_性能外存放的是近乎的
prototype 域的内容) Car3.prototype.showColor = function () {
alert(“second function”); } car3_1.showColor();//new function
该对象有同名的不二法门属性,故未相会失掉_proto_性内查找类的 prototype
域的法子属性 car3_2.showColor();//second function 受影响

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
方法1
function Car3(){}//用空构造函数设置类名
Car3.prototype.color = "blue";//每个对象都共享相同属性
Car3.prototype.doors = 3;
Car3.prototype.drivers = new Array("Mike","John");
Car3.prototype.showColor = function(){
    alert(this.color);
};//每个对象共享一个方法版本,省内存。
 
var car3_1 = new Car3();
var car3_2 = new Car3();
 
alert(car3_1.color);//blue
alert(car3_2.color);//blue
alert(Car3.prototype.color);//blue
 
car3_1.drivers.push("Bill");
alert(car3_1.drivers);//"Mike","John","Bill"
alert(car3_2.drivers);//"Mike","John","Bill"
alert(Car3.prototype.drivers);//"Mike","John","Bill"
 
//直接修改实例对象的属性,解析器会先去找实例对象是否有这个属性(不会去找实例对象的 _proto_ 属性内的那些类的 prototype 属性,而是直接查看这个实例是否有对应的属性(与_proto_同级))
//如果没有则直接给这个实例对象添加该属性,但不会修改类的prototype域的同名属性,既实例对象的_proto_属性内的那些类 prototype 域属性不会被修改
car3_1.color = "red";//car3_1对象内无名为 color 的对象属性,故将该属性添加到该对象上
 
//解析器对实例对象读取属性值的时候会先查找该实例有无同名的直接属性
//如果没有,则查找__proto__属性内保存的那些 当前类的 prototype 域的属性
//有就返回,无则继续查找是否有原型链中的对应的方法属性
//有就返回,无则返回undefined
alert(car3_1.color);//red
alert(car3_2.color);//blue
alert(car3_2.color2);//undefined
 
//直接修改类的 prototype 域内的属性,不会影响该类的实例对象的对象属性,但会影响实例对象的_proto_属性(_proto_属性内存放的是类的 prototype 域的内容)
Car3.prototype.color = "black";
alert(car3_1.color);//red 该对象有同名的直接属性,故不会去_proto_属性内查找类的 prototype 域的属性
alert(car3_2.color);//black 受影响
 
//直接修改实例对象的方法,解析器会先去找实例对象是否有这个方法(不会去找实例对象的 _proto_ 属性内的那些类的 prototype 域的方法,而是直接查看这个实例是否有对应的方法(与_proto_同级))
//如果没有则直接给这个实例对象添加该方法,但不会修改类的prototype域的同名方法,既实例对象的_proto_属性内的那些类 prototype 域方法不会被修改
//car3_1对象内无名为 showColor 的对象方法属性,故将该方法属性添加到该对象上
car3_1.showColor = function () {
    alert("new function");
}
//解析器对实例对象调用方法属性的时候会先查找该实例有无同名的直接方法属性
//如果没有,则查找_proto_属性内保存的那些 当前类的 prototype 域的方法属性
//有就返回,无则继续查找是否有原型链中的对应的方法属性
//找到就返回,无则报错
 
car3_1.showColor();//new function
car3_2.showColor();//blue
car3_1.abcd();//直接报错
 
//直接修改类的 prototype 域内的方法属性,不会影响该类的实例对象的方法属性,但会影响实例对象的_proto_属性(_proto_属性内存放的是类的 prototype 域的内容)
Car3.prototype.showColor = function () {
    alert("second function");
}
car3_1.showColor();//new function 该对象有同名的方法属性,故不会去_proto_属性内查找类的 prototype 域的方法属性
car3_2.showColor();//second function 受影响

可看看使用该形式则说从起裁减了内存的荒废,但还有题目,某个对象的性能一旦改变,所有因此类实例化拿到的对象的__proto__内属性值也会随之变(实也援),立异如下

6.构造器形式和原型情势的混合形式

//每个对象有专属的属性不会与其他对象共享
function Car4(sColor,iDoors){
    this._color = sColor;//私有属性变量名称头加下划线标识
    this._doors = iDoors;
    this.drivers = new Array("Mike","John");//公有属性标识
}
//所有对象共享一个方法版本,减少内存浪费
Car4.prototype.showColor = function () {
    alert(this._color);
};

var car4_1 = new Car4("red",4);
var car4_2 = new Car4("blue",3);

car4_1.drivers.push("Bill");

alert(car4_1.drivers);//"Mike","John","Bill"
alert(car4_2.drivers);//"Mike","John"

6.构造器模式与原型形式的交集格局

JavaScript

//每个对象有专属的性质不会师与外对象共享 function Car4(sColor,iDoors){
this._color = sColor;//私有性变量名称头加下划线标识 this._doors =
iDoors; this.drivers = new Array(“麦克”,”约翰”);//公有属性标识 }
//所有对象共享一个艺术版本,裁减内存浪费 Car4.prototype.showColor =
function () { alert(this._color); }; var car4_1 = new Car4(“red”,4);
var car4_2 = new Car4(“blue”,3); car4_1.drivers.push(“Bill”);
alert(car4_1.drivers);//”Mike”,”John”,”Bill”
alert(car4_2.drivers);//”Mike”,”John”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//每个对象有专属的属性不会与其他对象共享
function Car4(sColor,iDoors){
    this._color = sColor;//私有属性变量名称头加下划线标识
    this._doors = iDoors;
    this.drivers = new Array("Mike","John");//公有属性标识
}
//所有对象共享一个方法版本,减少内存浪费
Car4.prototype.showColor = function () {
    alert(this._color);
};
 
var car4_1 = new Car4("red",4);
var car4_2 = new Car4("blue",3);
 
car4_1.drivers.push("Bill");
 
alert(car4_1.drivers);//"Mike","John","Bill"
alert(car4_2.drivers);//"Mike","John"

立为是常用之创造对象格局有

7.动态原型格局

function Car5(sColor,iDoors,iMpg){
    this.color = sColor;
    this.doors = iDoors;
    this.mpg = iMpg;
    this.drivers = new Array("Mike","John");

    //使用标志(_initialized)来判断是否已给原型赋予了任何方法,保证方法永远只被创建并赋值一次
    if(typeof Car5._initialized == "undefined"){//因为这里的标记是附加在类上,故如果后期直接对其进行修改,还是有可能出现再次创建的情况
        Car5.prototype.showColor = function () {//为Car5添加一个存放在 prototype 域的方法
            alert(this.color);
        };
        Car5._initialized = true;//设置一个静态属性
    }
}
var car5_1 = new Car5("red",3,25);
var car5_2 = new Car5("red",3,25);

7.动态原型形式

JavaScript

function Car5(sColor,iDoors,iMpg){ this.color = sColor; this.doors =
iDoors; this.mpg = iMpg; this.drivers = new Array(“Mike”,”约翰(John)”);
//使用标志(_initialized)来判定是否早已受原型赋予了其他方法,保证措施永远只有于创立并赋值一浅
if(typeof Car5._initialized ==
“undefined”){//因为这边的标记是增大以类似及,故使先前时期直接针对这进展改动,仍然暴发或出现又创造的情形Car5.prototype.showColor = function () {//为Car5添加一个存放于 prototype
域的艺术 alert(this.color); }; Car5._initialized =
true;//设置一个静态属性 } } var car5_1 = new Car5(“red”,3,25); var
car5_2 = new Car5(“red”,3,25);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function Car5(sColor,iDoors,iMpg){
    this.color = sColor;
    this.doors = iDoors;
    this.mpg = iMpg;
    this.drivers = new Array("Mike","John");
 
    //使用标志(_initialized)来判断是否已给原型赋予了任何方法,保证方法永远只被创建并赋值一次
    if(typeof Car5._initialized == "undefined"){//因为这里的标记是附加在类上,故如果后期直接对其进行修改,还是有可能出现再次创建的情况
        Car5.prototype.showColor = function () {//为Car5添加一个存放在 prototype 域的方法
            alert(this.color);
        };
        Car5._initialized = true;//设置一个静态属性
    }
}
var car5_1 = new Car5("red",3,25);
var car5_2 = new Car5("red",3,25);

这种形式使定义类像强类型语言比如 java 等语言的概念形式

8.混合工厂情势

function Car6(){
    var oTempCar = new Object;
    oTempCar.color = "blue";
    oTempCar.doors = 4;
    oTempCar.showColor = function () {
        alert(this.color);
    };
    return oTempCar;
}
var car6 = new Car6();

由当 Car6()构造函数内部调用了 new 运算符,所以用忽略第二单 new
运算符(位于构造函数之外),
当构造函数内部成立的目的为传送回变量car6,这种形式以靶方法的内部管理方面和经典格局(工厂方法)有着同样之问题.应尽可能制止

8.混合工厂情势

JavaScript

function Car6(){ var oTempCar = new Object; oTempCar.color = “blue”;
oTempCar.doors = 4; oTempCar.showColor = function () {
alert(this.color); }; return oTempCar; } var car6 = new Car6();

1
2
3
4
5
6
7
8
9
10
function Car6(){
    var oTempCar = new Object;
    oTempCar.color = "blue";
    oTempCar.doors = 4;
    oTempCar.showColor = function () {
        alert(this.color);
    };
    return oTempCar;
}
var car6 = new Car6();

由于当 Car6()构造函数内部调用了 new 运算符,所以将忽略第二只 new
运算符(位于构造函数之外),
在构造函数内部创建的靶子吃传送回变量car6,这种措施在对象方法的内部管理方面与经模式(工厂方法)有着一样的问题.应尽量避免

1 赞 3 收藏
评论

图片 2

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图