在工作中经常用到JavaScript，今天总结一下JavaScript编写类的几种写法以及这几种写法的优缺点，关于JavaScript编写类的方式，在网上看到很多，而且每个人的写法都不太一样，经常看到的就是以下几种方式。
1、构造函数方式
用构造函数模拟"类"，在其内部用this关键字指代实例对象。
基本语法：
function 类名(){
this.属性名;//公共属性
var 属性名;//私有属性
/*凡是定义类的公共属性和公共方法都要使用this*/
//定义类的公共函数
this.函数名=function(){
.....
}
//定义类的私有函数
function 函数名(){
......
}
}
范例：
1 /*定义一个Person类*/
2 function Person(_name,_age,_salary){
3 //Person类的公开属性，类的公开属性的定义方式是：”this.属性名“
4 this.name=_name;
5 //Person类的私有属性，类的私有属性的定义方式是：”var 属性名“
6 var age=_age;//私有属性
7 var salary=_salary;//私有属性
8
9 /*定义私有属性Age的对外公开访问方法*/
10 this.setAge = function(intAge) {
11 age = intAge;
12 }
13 /*定义私有属性Age的对外公开访问方法*/
14 this.getAge = function() {
15 return age;
16 }
17
18 //定义Person类的公开方法(特权方法)，类的公开方法的定义方式是：”this.functionName=function(){.....}“
19 this.Show=function(){
20 document.writeln("在公开方法里面访问类的私有属性是允许的，age="+age+"\t"+"salary="+salary);//在公开方法里面访问类的私有属性是允许的
21 }
22 //公共方法
23 this.publicMethod = function(){
24 document.writeln("在公开方法里面访问类的私有方法是允许的");
25 privateFn();//在公开方法里面调用类的私有方法
26 privateFn2();//在公开方法里面调用类的私有方法
27 }
28 /*
29 定义Person类的私有方法(内部方法)，
30 类的私有方法的定义方式是：”function functionName(){.....}“，
31 或者 var functionName=function(){....}
32 */
33 function privateFn(){
34 document.writeln("我是Person类的私有函数privateFn");
35 }
36
37 var privateFn2=function(){
38 document.writeln("我是Person类的私有函数privateFn2");
39 }
40 }
测试Person类
1 var p1 = new Person("孤傲苍狼",24,2300);
2 var p2 = new Person("白虎神皇",24,2300);
3 document.write("<pre>");
4 document.writeln("p1 instanceof Person的结果是："+(p1 instanceof Person));//p1是Person类的实例，结果是true
5 document.writeln("p2 instanceof Person的结果是："+(p2 instanceof Person));//p2是Person类的实例，结果是true
6 //当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等
7 document.writeln("当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等");
8 document.writeln("比较p1和p2这两个对象的show方法的内存地址是否一样：p1.show== p2.show的结果是："+(p1.show == p2.show));//false
9 document.writeln("p1.show == p2.show的结果是："+(p1.show == p2.show)+"，这证明p1对象和p2对象不是共享一个show方法，在内存中show方法的代码有2份，存放在两块内存区域");
10 document.writeln("name是Person类定义的public属性，可以使用类的对象去直接访问类的public属性");
11 document.writeln("p1.name="+p1.name);//访问公有属性，这是可以正常访问的
12 document.writeln("age和salary是Person类定义的private属性，不能使用类的对象去直接访问类私有属性，这是访问不了的，结果都是undefined");
13 document.writeln("p1.age="+p1.age+"，"+"p1.salary="+p1.salary)//不能使用类的对象去直接访问类私有属性，这是访问不了的，结果都是undefined
14 p1.show();//调用类的公共函数，这次允许的
15 p1.publicMethod();//调用类的公共函数，这次允许的
16 p1.setAge(24);//使用public方法setAge方法为私有属性age赋值
17 document.writeln("使用public方法getAge方法获取私有属性age的值，p1.getAge()="+p1.getAge());//使用getAge方法获取私有属性age的值
18 //document.writeln("p1.privateFn()："+p1.privateFn()+" p1.privateFn2()："+p1.privateFn2());//不能使用类的对象去调用类的私有方法，这里会报错”对象不支持此属性或者方法
19 document.write("</pre>");
测试结果：
aaarticlea/png;base64,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" alt="" />
这种方式的优点是：可以根据参数来构造不同的对象实例 ，每个对象的属性一般是不相同的，缺点是构造每个实例对象时，方法不能共享，Person类里面定义的那些方法，p1对象有一份，p2也有一份，那么在内存中就得开辟两块内存空间来分别存储p1的方法和p2的方法，这样就造成了内存的浪费。对于一个类的不同实例对象，这些对象的属性一般是不相同的，但是方法是相同的，所以节约内存的做法就是把方法放到内存的一块区域中存放，然后每个实例对象都从这块内存中取出方法。
2、原型方式
需要说明的是，使用原型方式编写JavaScript类是无法给类添加私有属性和私有方法的，使用原型方式添加的属性和方法都是public的。
写法一：
1 /*定义一个Person类*/
2 function Person(_name,_age,_weight,_height){
3 this.init(_name,_age,_weight,_height);
4 }
5
6 /*使用原型的方式定义Person类的public属性：name,age,weight,height，使用原型的方式添加的属性都是public的*/
7 Person.prototype.name;
8 Person.prototype.age;
9 Person.prototype.weight;
10 Person.prototype.height;
11 /*使用原型的方式给Person类添加public方法，使用原型的方式添加的方法都是public的*/
12 /*使用原型的方式给Person类添加init方法*/
13 Person.prototype.init = function(_name,_age,_weight,_height) {
14 if(_name != undefined && _age!=undefined && _weight!=undefined && _height!=undefined){
15 this.name = _name;
16 this.age = _age;
17 this.weight=_weight;
18 this.height=_height;
19 document.writeln("this.name="+this.name+",this.age="+this.age+",this.weight="+this.weight+",this.height="+this.height);
20 }
21
22 }
23 /*使用原型的方式给Person类添加show方法*/
24 Person.prototype.show = function(){
25 document.writeln("show method");
26 }
测试Person类
1 document.write("<pre>");
2 var p1 = new Person("孤傲苍狼",24,115,160);
3 var p2 = new Person("白虎神皇",25,120,170);
4 var p3 = new Person();
5 p3.init("玄天邪帝",26,130,180);//调用public方法init初始化p3对象
6 document.writeln("p1 instanceof Person的结果是："+(p1 instanceof Person));//p1是Person类的实例，结果是true
7 document.writeln("p2 instanceof Person的结果是："+(p2 instanceof Person));//p2是Person类的实例，结果是true
8 document.writeln("p3 instanceof Person的结果是："+(p3 instanceof Person));//p3是Person类的实例，结果是true
9 //当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等
10 document.writeln("当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等");
11 document.writeln("比较p1和p2这两个对象的show方法的内存地址是否一样：p1.show == p2.show的结果是："+(p1.show == p2.show));//true
12 document.writeln("p1.show == p2.show的结果是："+(p1.show == p2.show)+"，这证明p1对象和p2对象共享一个show方法，在内存中show方法的代码只有一份，存放在内存的一块区域");//true
13 document.writeln("p1.name="+p1.name+"，p1.age="+p1.age+"，p1.weight="+p1.weight+"，p1.height="+p1.height);//访问公有属性，这是可以正常访问的
14 document.writeln("p2.name="+p2.name+"，p2.age="+p2.age+"，p2.weight="+p2.weight+"，p2.height="+p2.height);//访问公有属性，这是可以正常访问的
15 p3.name="灭世魔尊";//为公共属性重新赋值
16 document.writeln("p3.name="+p3.name);//访问公有属性，这是可以正常访问的
17 p1.show();//调用类的公共函数，这次允许的
18 document.write("</pre>");
测试结果：
aaarticlea/png;base64,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" alt="" />
写法二：
使用原型方式给类定义public属性和public方法更加优雅的写法，我个人推荐使用这种方式，这种方式看起来比较舒服
1 /*定义类Person2*/
2 function Person2(){
3
4 }
5
6 /*使用原型方式给类定义public属性和public方法更加优雅的写法*/
7 Person2.prototype = {
8 name:"",//public属性
9 age:0,//public属性
10 weight:0,//public属性
11 height:0,//public属性
12 /*public方法*/
13 init:function(_name,_age,_weight,_height) {
14 this.name = _name;
15 this.age = _age;
16 this.weight=_weight;
17 this.height=_height;
18 document.writeln("this.name="+this.name+",this.age="+this.age+",this.weight="+this.weight+",this.height="+this.height);
19 },
20 /*public方法*/
21 show:function(){
22 document.writeln("show method");
23 }
24 };
测试代码：
1 document.write("<pre>");
2 var p2_1 = new Person2();
3 var p2_2 = new Person2();
4 p2_1.init("孤傲苍狼",24,115,160);
5 p2_2.init("白虎神皇",25,120,170);
6 document.writeln("p2_1.name="+p2_1.name+"，p2_1.age="+p2_1.age+"，p2_1.weight="+p2_1.weight+"，p2_1.height="+p2_1.height);//访问公有属性，这是可以正常访问的
7 document.writeln("p2_2.name="+p2_2.name+"，p2_2.age="+p2_2.age+"，p2_2.weight="+p2_2.weight+"，p2_2.height="+p2_2.height);//访问公有属性，这是可以正常访问的
8 document.writeln("p2_1 instanceof Person2的结果是："+(p2_1 instanceof Person2));//p2_1是Person2类的实例，结果是true
9 document.writeln("p2_2 instanceof Person2的结果是："+(p2_2 instanceof Person2));//p2_2是Person2类的实例，结果是true
10 //当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等
11 document.writeln("当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等");
12 document.writeln("比较p2_1和p2_2这两个对象的init方法的内存地址是否一样：p2_1.init == p2_2.init的结果是："+(p2_1.init == p2_2.init));//true
13 p2_1.name="灭世魔尊";//为公共属性重新赋值
14 document.writeln("p2_1.name="+p2_1.name);//访问公有属性，这是可以正常访问的
15 p2_1.show();//调用类的公共函数，这次允许的
16 document.write("</pre>");
测试结果：
aaarticlea/png;base64,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" alt="" />
原型方式的优点：所有对象实例都共享类中定义的方法，这样就没有造成内存浪费。缺点，第一，不能定义类的私有属性和私有方法，第二，给在创建对象，给对象的属性初始化时，需要额外写一个初始化对象的方法。
3、构造函数+原型
构造函数方式和原型方式都有各自的优缺点，因此可以把这两种方式合并起来，用构造函数方式来定义类的属性(public属性，private属性)，用原型方式来定义类的方法(public方法)。互补不足，这就有了第三种写法。
1 /*定义一个Person类*/
2 function Person(_name,_age,_salary){
3 //在Person类内部定义类的public属性和private属性以及private方法
4 //Person类的公开属性，类的公开属性的定义方式是：”this.属性名“
5 this.name=_name;
6 //Person类的私有属性，类的私有属性的定义方式是：”var 属性名“
7 var age=_age;//私有属性，只能在类内部使用
8 var salary=_salary;//私有属性，只能在类内部使用
9 /*
10 定义Person类的私有方法(内部方法)，只能在类内部使用
11 类的私有方法的定义方式是：”function functionName(){.....}“，
12 或者 var functionName=function(){....}
13 */
14 function privateFn(){
15 document.write("<pre>");
16 document.writeln("我是Person类的私有属性age，只能在Person类内部使用，初始化后age="+age);
17 document.writeln("我是Person类的私有函数privateFn，只能在Person类内部使用");
18 document.write("</pre>");
19 }
20
21 var privateFn2=function(){
22 document.write("<pre>");
23 document.writeln("我是Person类的私有属性salary，只能在Person类内部使用，初始化后salary="+salary);
24 document.writeln("我是Person类的私有函数privateFn2，只能在Person类内部使用");
25 document.write("</pre>");
26 }
27
28 privateFn();//在Person类内部调用私有方法
29 privateFn2();//在Person类内部调用私有方法
30 }
31
32 //使用prototype原型方式定义的方法(public方法)是无法访问类的私有属性和私有方法的
33 //使用prototype原型方式定义Person类的方public方法
34 Person.prototype={
35 setName:function(_name){
36 this.name = _name;
37 //privateFn();//不能调用Person类定义的私有方法privateFn()，会报错：缺少对象
38 },
39 getName:function(){
40 return this.name;
41 },
42 show:function(){
43 document.writeln("公开方法show");
44 },
45 //公共方法
46 publicMethod:function(){
47 document.writeln("公开方法publicMethod");
48 }
49 };
测试代码：
1 var p1 = new Person("孤傲苍狼",24,2300);
2 var p2 = new Person("白虎神皇",25,3000);
3 document.write("<pre>");
4 document.writeln("p1 instanceof Person的结果是："+(p1 instanceof Person));//p1是Person类的实例，结果是true
5 document.writeln("p2 instanceof Person的结果是："+(p2 instanceof Person));//p2是Person类的实例，结果是true
6 //当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等
7 document.writeln("当==两边的内容是对象或者是对象的函数属性时，则比较内存地址是否相等");
8 document.writeln("比较p1和p2这两个对象的show方法的内存地址是否一样：p1.show== p2.show的结果是："+(p1.show == p2.show));//true
9 document.writeln("p1.show == p2.show的结果是："+(p1.show == p2.show)+"，这证明p1对象和p2对象共享一个show方法，在内存中show方法的代码有1份，存放在1块内存区域");
10 document.writeln("name是Person类定义的public属性，可以使用类的对象去直接访问类的public属性");
11 document.writeln("p1.name="+p1.name);//访问公有属性，这是可以正常访问的
12 document.writeln("age和salary是Person类定义的private属性，不能使用类的对象去直接访问类私有属性，这是访问不了的，结果都是undefined");
13 document.writeln("p1.age="+p1.age+"，"+"p1.salary="+p1.salary)//不能使用类的对象去直接访问类私有属性，这是访问不了的，结果都是undefined
14 p1.show();//调用类的公共函数，这次允许的
15 p1.publicMethod();//调用类的公共函数，这次允许的
16 p1.setName("玄天邪帝");//调用类的公共函数设置为name属性重新赋值
17 document.writeln("p1.getName="+p1.getName());
18 //document.writeln("p1.privateFn()："+p1.privateFn()+" p1.privateFn2()："+p1.privateFn2());//不能使用类的对象去调用类的私有方法，这里会报错”对象不支持此属性或者方法
19 document.write("</pre>");
运行结果：
aaarticlea/png;base64,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" alt="" />
第三种方式通过前两种方式的结合，算是达到了一个比较理想的写法了，可以通过传参构造对象实例，对象实例都共享同一份方法不造成内存浪费。第三种方式在开发中用得最多，我本人也是采用这种方式来编写JavaScript类。