js类

一

1．工厂方式

    javaScript中创建自己的类和对象，我们应该是必须掌握的，我们都知道javaScript中对象的属性可以在对象创建后动态定义，比如下面的代码：
<script type="text/javascript">
    //定义
    var oCar = new Object();
    oCar.color = "red";
    oCar.doors = 4;
    oCar.showColor = function() {
        alert(this.color);
    }
    //调用
    oCar.showColor();
</script>
    我们很容易使用oCar对象，但是我们创就是想创建多个Car实例。我们可以使用一个函数来封装上面的代码来实现：<script type="text/javascript">
    //定义
    function createCar() {
        var oCar = new Object();
        oCar.color = "red";
        oCar.doors = 4;
        oCar.showColor = function() {
            alert(this.color);
        }
        return oCar;
    }
    //调用
    var ocar1 = createCar();
    var ocar2 = createCar();
    ocar1.color = "black";
    ocar1.showColor();
    ocar2.showColor();
</script>
    顺便说一下，javaScript对象默认成员属性都是public 的。这种方式我们称为工厂方式，我们创造了能创建并返回特定类型的对象的工厂。
    这样做有点意思了，但是在面向对象中我们经常使用创建对象的方法是：
Car car=new Car();
    使用new 关键字已经深入人心，因此我们使用上面的方法去定义总感觉别扭，并且每次调用时都去创建新的属性以及函数，功能上也不实际。下来我们看看构造函数的形式定义类。
2．构造函数
这种方式看起来有点象工厂函数。具体表现如下：
<script type="text/javascript">
    //定义
    function Car(color, doors) {
        this.color = color;
        this.doors = doors;
        this.showColor = function() {
            alert(this.color);
        };
    }
    //调用
    var car1 = new Car("red", 4);
    var car2 = new Car("blue", 4);
    car1.showColor();
    car2.showColor();
</script>
    看起来效果很明显，有差别了吧。感觉有点意思了。在构造函数内部创造对象使用this 关键字，使用new 运算符创建对象感觉非常亲切。但是也有点问题：每次new 对象时都会创建所有的属性，包括函数的创建，也就是说多个对象完全独立，我们定义类的目的就是为了共享方法以及数据，但是car1对象与car2对象都是各自独立的属性与函数，最起码我们应该共享方法。这就是原形方式的优势所在。
3．原型方式
利用对象的prototype属性，可把它看出创建新对象所依赖的原型。方法如下：
<script type="text/javascript">
    //定义
    function Car() {
    };
    Car.prototype.color = "red";
    Car.prototype.doors = 4;
    Car.prototype.drivers = new Array("Tom", "Jerry");
    Car.prototype.showColor = function() {
        alert(this.color);
    }
    //调用：
    var car1 = new Car();
    var car2 = new Car();
    car1.showColor();
    car2.showColor();
    alert(car1.drivers);
    car1.drivers.push("stephen");
    alert(car1.drivers); //结果：Tom,Jerry,stephen
    alert(car2.drivers); //结果：Tom,Jerry,stephen
//可以用json方式简化prototype的定义:
        Car.prototype =
        {
            color: "red",
            doors: 4,
            drivers: ["Tom", "Jerry",'safdad'],
            showColor: function() {
                alert(this.color);
            }
        }</script>
    首先这段代码的构造函数，其中没有任何代码，接下来通过对象的prototype属性添加属性定义Car对象的属性。这种方法很好，但是问题是Car的对象指向的是Array指针，Car的两个对象都指向同一个Array数组，其中一个对象car1改变属性对象的引用（数组Array）时，另一个对象car2也同时改变，这是不允许的。
    同时该问题也表现在原型不能带任何初始化参数，导致构造函数无法正常初始化。这需要另一种方式来解决：那就是混合的构造函数/原型模式。
4. 混合的构造函数/原型模式
联合使用构造函数和原型方式，定义类就非常方便。
<script type="text/javascript">
//定义
    function Car(color,doors)
   {
        this.color=color;
        this.doors=doors;
        this.drivers=new Array("Tom","Jerry");
   }
   Car.prototype.showColor=function(){
        alert(this.color);
   }
   
   //调用：
   var car1=new Car('red',4);
   var car2=new Car('blue',4);
   
   car1.showColor();
   car2.showColor();
   
   alert(car1.drivers);
   car1.drivers.push("stephen");
   alert(car1.drivers); //结果：Tom,Jerry,stephen
   alert(car2.drivers); //结果：Tom,Jerry
   alert(car1 instanceof Car);
</script>
    该方法是把属性放在内部定义，把方法放在外边利用prototype进行定义。解决了第三种方法的问题。
    这种方法其实应该来说非常友好了，但是比起java的语法来，应该有一些不和谐，感觉比较凌乱，对C++来说，我们就没有那么麻烦的感觉了，可是开发C++的研发人员一般情况下很少涉及javaScript，而对J2EE的研发人员来说，这种方式总有一些别扭。总感觉不是友好的封装，其实只不过是视觉上封装效果不是很好而已，要想达到视觉封装效果而又能达到这种方法的效果的也可以以，个人认为其实比较麻烦。那就是动态原型法。
5.动态原型
对于习惯使用其他语言的开发者来说，使用混合的构造函数/原型方式感觉不那么和谐。毕竟，定义类时，大多数面向对象语言都对属性和方法进行了视觉上的封装。考虑下面的C#类：
class Car //class
{
    public string color = "red";
    public int doors = 4;
    public int mpg = 23;
    public Car(string color, int doors, int mpg) //constructor
    {
        this.color = color;
        this.doors = doors;
        this.mpg = mpg;
    }
    public void showColor() //method
    {
        Console.WriteLine(this.color);
    }
}
C#很好的打包了Car类的所有属性和方法，因此看见这段代码就知道它要实现什么功能，它定义了一个对象的信息。批评混合的构造函数/原型方式的人认为，在构造函数内存找属性，在其外部找方法的做法不合逻辑。因此，他们设计了动态原型方法，以提供更友好的编码风格。
动态原型方法的基本想法与混合的构造函数/原型方式相同，即在构造函数内定义非函数属性，而函数属性则利用原型属性定义。唯一的区别是赋予对象方法的位置。下面是用动态原型方法重写的Car类：
    <script type="text/javascript">
        //定义
        function Car() {
            this.color = "red";
            this.doors = 4;
            this.drivers = new Array("Tom", "Jerry");
            if (typeof Car.prototype._initialized == "undefined") {
                Car.prototype.showColor = function() {
                    alert(this.color);
                }
                //............

                //最后定义
                Car.prototype._initialized = true;
            }
        }
    </script>
直到检查typeof Car._initialized是否等于"undefined"之前，这个构造函数都未发生变化。这行代码是动态原型方法中最重要的部分。如果这个值未定义，构造函数将用原型方式继续定义对象的方法，然后把Car._initialized设置为true。如果这个值定义了（它的值为true时，typeof的值为Boolean），那么就不再创建该方法。简而言之，该方法使用标志（_initialized）来判断是否已给原型赋予了任何方法。该方法只创建并赋值一次，为取悦传统的OOP开发者，这段代码看起来更像其他语言中的类定义了。
6  混合工厂方式
这种方式通常是在不能应用前一种方式时的变通方法。它的目的是创建假构造函数，只返回另一种对象的新实例。这段代码看来与工厂函数非常相似：
function Car() {
            var oTempCar = new Object();
            oTempCar.color="red";
            oTempCar.doors=4;
            oTempCar.mpg=23;
            oTempCar.showColor = function() {
                alert(this.color);
            }
            return oTempCar;
        }
与经典方式不同，这种方式使用new运算符，使它看起来像真正的构造函数：
var oCar = new Car();
由于在Car()构造函数内部调用了new运算符，所以将忽略第二个new运算符（位于构造函数之外）。在构造函数内部创建的对象被传递回变量var。这种方式在对象方法的内部管理方面与经典方式有着相同的问题。强烈建议：除非万不得已（请参阅第15章），还是避免使用这种方式。
总结：（采用哪种方式)
目前使用最广泛的是混合的构造函数/原型方式。此外，动态原型方法也很流行，在功能上与构造函数/原型方式等价。可以采用这两种方式中的任何一种。不过不要单独使用经典的构造函数或原型方式，因为这样会给代码引入问题。
//ps
//static class (1:function)
    var CarCollection = new function() {
        var _carCollection = new Array(); //global,private
        this.Add = function(objCar) {
            alert('Add');
        }
        this.Get = function(carid) {
            alert('Get');
        }
    }
//static class (2:json)
    var Car = {
        color: 'red',
        doors: 4,
        showColor: function() { alert(this.color); }
    }

    Car.showColor();

二

1. 定义js类
js并不是一种面向对向的语言, 没有提供对类的支持, 因此我们不能像在传统的语言里那样 用class来定义类, 但我们可以利用js的闭包封装机制来实现js类, 我们来封装一个简的Shape类.

复制代码 代码如下:

function ShapeBase() {
this.show = function()
{
alert("ShapeBase show");
};
this.init = function(){
alert("ShapeBase init");
};
}

这个类里定义了两个方法:show和init, 需要注意的是这里用到了this来声明, 而不是var, 因为用var是用来定义私有方法的.
另外, 我们还可以用prototype属性来定义Shape的方法.

复制代码 代码如下:

ShapeBase.prototype.show=function()
{
alert("ShapeBase show");
}
ShapeBase.prototype.init=function()
{
alert("ShapeBase init");
}

上面这种写法看起来不太直观，我们可以将所有的方法写在一起.

复制代码 代码如下:

ShapeBase.prototype={
show:function()
{
alert("ShapeBase show");
},
init:function() {
alert("ShapeBase init");
}
};

现在, 类是写好了， 让我们写个js来测试下, 看看结果是不是跟我们想象的一样呢?

复制代码 代码如下:

function test(src){
var s=new ShapeBase();
s.init();
s.show();
}

看到了吧, 其调用方式和C#一模一样, 而结果也如我们所料.
到目前为止, 我们学会了如何创建js的类了, 但还只是实例方法，要是实现跟C#中的静态方法要怎么做呢？
其实, 实现js的静态方法很简单, 看下面如何实现:

复制代码 代码如下:

//静态方法
ShapeBase.StaticDraw = function()
{
alert("method draw is static");
}

2. 实现JS类抽象和继承
同样, js中也不支持类继承机制，但我们可以通过将父类prototype中的成员方法复制到子类的prototype中来实现.
和类的继承一样,JavaScript也没有任何机制用于支持抽象类.但利用JavaScript语言本身的性质.可以实现自己的抽象类.
首先来看看js中的虚方法, 在传统语言中虚方法是要先定义的, 而包含虚方法的类就是抽象类,不能被实例化,而在JavaScript中，虚方法就可以看作该类中没有定义的方法，但已经通过this指针使用了.
和传统面向对象不同的是，这里虚方法不需经过声明，而直接使用了, 并且类也可以被实例化.
先定义object的extend方法, 一个为静态方法，一个为实例方法, 这两个方法用于实现继承的prototype复制

复制代码 代码如下:

Object.extend = function(destination, source) {
for (property in source) {
destination[property] = source[property];
}
return destination;
}
Object.prototype.extend = function(object) {
return Object.extend.apply(this, [this, object]);
}

接下来我们实现一个继承类Rect, 这里先用一种简单的方法来实现。

复制代码 代码如下:

function Rect() {
}
Rect.prototype = ShapeBase.prototype; //只这一句就行了
//扩充新的方法
Rect.prototype.add=function() {
alert("Rect add");
}

这种方法不能用于重写,如果改变了show方法, ShapeBase的show也会指向同一函数可能是由于prototype赋值只是简单的改变指向地址.
如果上面也定义了:
Rect.prototype.show=function() {
alert("Rect show");
}
那么执行结果如下:
function test(){
var s=new ShapeBase();
s.show(); //结果:Rect show
var r=new Rect();
r.show(); //结果:Rect show
r.add();
}
我们再使用object.extend实现继承, 并实现一个oninit虚方法, 修改ShapeBase如下:

复制代码 代码如下:

ShapeBase.prototype={
show:function()
{
alert("ShapeBase show");
},
initialize:function () {
this.oninit();
}
};

实现Rect类继承.

复制代码 代码如下:

Rect.prototype=(new ShapeBase).extend({
//添加新的方法
add:function() {
alert("Rect add");
},
//使用这种方法可以重写show方法
show:function() {
alert("Rect show");
},
//实现虚方法
oninit:function() {
alert("Rect oninit");
}
})

现在我们的类写好了， 测试下看看:

复制代码 代码如下:

function test(src){
ShapeBase.StaticDraw();
var s=new ShapeBase();
s.show(); //alert("ShapeBase show")
var r=new Rect();
r.show(); //alert("Rect show")
r.add();
r.initialize(); //alert("Rect oninit")
}

另外,在网上看到一篇用专门的对象来创建类，代码如下:

复制代码 代码如下:

//
//对象属性复制方法,很多库都有实现,如PrototypeJS里面的extend和Ext里面的Ext.apply
//
function extend(des, src) {
if (!des)
des = {};
if (src) {
for (var i in src) {
des[i] = src[i];
}
}
return des;
}
var CC = {}; //全局变量
//
//create 用于创建类
//
CC.create = function(superclass, constructor){
var clazz = (function() {
this.initialize.apply(this, arguments);
});
//如果无参数,直接返回类.
if(arguments.length == 0)
return clazz;
//如果无父类,此时constructor应该为一个纯对象,直接复制属性返回.
if(!superclass){
extend(clazz.prototype, constructor);
return clazz;
}
var absObj = clazz.prototype,
sprPropty = superclass.prototype;
if(sprPropty){
//用于访问父类方法
clazz.superclass = sprPropty;
extend(absObj, sprPropty);
//调用属性构造函数创建属性,这个是实现关键.
extend(absObj, constructor(sprPropty));
// 子类实例直接通过obj.superclass访问父类属性,
// 如果不想造成过多引用,也可把这句注释掉,因为多数时候是没必要的.
absObj.superclass = sprPropty;
//
clazz.constructor = constructor;
}
return clazz;
}
//
//创建一个动物类
//
var Animal = CC.create(null, {
//属性
footprint : '- - - - - - =',
//类初始化方法,必须的,当用 new 生成一个类时该方法自动被调用,参见上定义.
initialize : function(options){
extend(this, options);
alert('Animal initialize method is called.');
},
eat : function(){
alert('Animal eat method is called.');
},
move : function(){
alert('I am moving like this '+ this.footprint +' .');
}
});
//
//创建一个Duke类
//
var Duke = CC.create(Animal, function(superclass){
//在这可以定义一些类全局静态数据,该类每个实例都共享这些数据.
//计算实例个类,包括派生类实例.
var static_instance_counter = 0;
function classUtilityFuncHere(){ }
//返回类具体属性.
return {
//重写初始化方法
//@override
initialize : function(options) {
alert('Initializing Duke class..');
//调用父类初始化,这种方法比一般其它库的要简洁点吧,可以不管父类是什么.
superclass.initialize.call(this, options);
//做一些子类喜欢做的事.
alert('Duke initialize method is called.');
//读取或修改类静态属性
static_instance_counter++;
},
//重写move方法,增加Duke自己的移动方式.
move : function(){
this.footprint = this.footprint + 'zzzzzzzz';
superclass.move.call(this);
},
//重写eat方法,注意,里面不调用父类方法,即父类eat被覆盖了.
eat : function(){
alert('Duke is eating..');
},
//新增一个say方法,显示当前已经初始化的Duke类实例数量.
say : function(){
alert('the number of Duke instances is '+static_instance_counter);
}
};
});
var DukeChild = CC.create(Duke, function(superclass){
return {
move : function(){
this.footprint = this.footprint + '++++++++++++=';
superclass.move.call(this);
},
say : function(){
alert(this.msg || '');
}
};
});
(function test() {
var animal = new Animal();
animal.eat();
animal.move();
var dukeA = new Duke();
dukeA.eat();
dukeA.move();
dukeA.say();
var dukeB = new Duke();
dukeB.eat();
dukeB.move();
dukeB.say();
var dukeC = new DukeChild({msg : 'I am a child of duke.'});
dukeC.move();
dukeC.say();
})();

三

1、   创建对象：

 

 

var obj = new Object();//第一种方式。

var obj = {};//第二种方法。顺带一句可以通过var arr = [] 来创建数组

 

 

2、   给对象的属性赋值

 

nahao.gender = 'male';

nahao.yearOfBirth = 1989;

nahao.name = 'Topcss';//对象的属性也可以叫做对象的成员。像普通的变量一样，JS对象的属性可以是是字符串，数组，数字，甚至可以是对象或者是函数。

 

 

3、   给对象添加方法其实对象的属性如果是函数，那么这个属性就可以叫做对象的方法

 

 

nahao.gender = 'male';

nahao.yearOfBirth = 1989;

nahao.name = 'Topcss';

nahao.info = function(){

var str = '姓名：' +

this.name + ',性别：' +

this.gender + ',出生年：' +

this.yearOfBirth;

alert(str);

}

nahao.info();

 

 

4、   我们可以使用下面的简略语法定义上面的对象：

 

 

var nahao = {

gender : 'male',

yearOfBirth : 1989,

name : 'Topcss',

info : function(){

var str = '姓名：' + this.name + ',性别：' + this.gender + ',出生年：' +this.yearOfBirth;

alert(str);

}

};//如果调用nahao.info()，将会得到和上面一样的结果。需要注意的是，属性之间使用逗号隔开，最后一个属性之后没有逗号。

 

 

5、 构造函数构造函数可以帮助我们来缩减代码量。首先，构造函数也是一个函数。雏形如下：

function Person(){}/和定义普通的函数没有什么区别。下面就来向Person构造函数中添加内容：

 

 

function Person(name,gender,yearOfBirth,site){

this.name = name;

this.gender = gender;

this.yearOfBirth = yearOfBirth;

this.site = site;

this.info = function(){

var str = '姓名：' + this.name + ',性别：' + this.gender

+ ',出生年：' + this.yearOfBirth + '网站:' + this.site;

alert(str);

}

}//这样，构造函数就完成了。我们现在就可以使用如下语句来定义多个对象了：

var nahao = new Person('Top css',male,1989,'www.javava.org);

var gaoshou = newPerson('Widen','male',1980,'www.baidu.net');

var wudi = newPerson('不详','不知道','保密','bbs.blueidea.net');通过他们的方法来调用

nahao.info();

gaoshou.info();

wudi.info();

 

注意：在上面的构造函数中，参数的名字和对象属性的名字是相同的，例如：

this.name =name;虽然这样是合法的，但是如果要定义私有属性的话就不行了（后面会提），而且看起来比较混乱。所以最好将构造函数修改如下：

 

 

function Person(nameArg,genderArg,yearOfBirthArg,siteArg){

this.name = nameArg;

this.gender = genderArg;

this.yearOfBirth = yearOfBirthArg;

this.site = siteArg;

this.info = function(){

var str = '姓名：' + this.name + ',性别：' + this.gender

+ ',出生年：' + this.yearOfBirth + '网站:' + this.site;

alert(str);

}

}

 

 

6、 静态方法什么是静态方法呢？就是直接添加在某个对象上的属性或者方法，它仅对一个对象有效，例如：

nahao.skill ='会点XHTML，CSS，现在还会说JavaScript了';添加完这个语句之后，nahao就拥有了skill属性。但是出自同一个构造函数的gaoshou和wudi却不受任何影响。当然了，我们可以给它们也加上这个属性：

gaoshou.skill ='精通HTML,CSS,JS,FLEX,PHP,.NET,Linux编程,Perl,Ruby,XXX...';

wudi.skill = '能用啤酒瓶盖与沙子手工打磨出CPU等PC基本零部件。';

同样，我们也可以给构造函数添加静态方法，但是这同样不会影响使用该构造函数定义的对象。例如：

 

 

Person.showName = function(){

alert(this.name);

};

Person.showName();

nahao.showName();//我们给Person定义了一个showName函数，但是它只对构造函数Person本身有用（但是没有什么实际意义），如果在nahao对象上调用这个方法将会出错。

 

 

7、给对象定义私有成员公开的对象？在前面定义的所有对象，其所有的属性都是暴露在外的，可以随便访问，甚至修改也没问题。例如我们可以通过nahao.name直接访问到对象的名字等等属性。如果我们希望有一个属性对外保密，就可以给对象定义私有属性：

 

 

functionPerson(nameArg,genderArg,yearOfBirthArg,siteArg,privacyArg){

……

var privacy = privacyArg;

……

}

var nahao = new Person('Topcss',male,1989,'www.javava.org','有10跟脚趾头');

alert(nahao.privacy);//对构造函数作出一定修改之后，我们给nahao对象添加了一个privacy属性，如果试图alert它的值的话将会显示undefined。

下面再来看看私有方法，如果我们对Person构造函数作出如下修改：

 

 

functionPerson(nameArg,genderArg,yearOfBirthArg,siteArg,privacyArg){

function insideOnly(){

alert('我只在对象内部可以调用!');

}

}//那么insideOnly将不能被外部所访问，如果试图执行这个函数将会出错。需要注意的是，私有方法并没有绑定到对象上，它的this关键字也并不指向对象。如果需要在私有方法内引用对象，那么可以使用如下方法：

 

 

functionPerson(nameArg,genderArg,yearOfBirthArg,siteArg,privacyArg){

……

var myOwner = this;

function insideOnly(){

alert(myOwner.name);

}

}//首先在构造函数中定义一个myOwner变量，将this关键字赋给它，之后就可以在私有函数里使用这个变量来访问对象本身了。

 

 

8、特权方法私有成员不能在对象的外部访问，不能访问的对象有什么用？我们可以使用特权方法来访问这些私有属性。所谓特权方法就是使用this关键字定义的函数，例如：

 

 

functionPerson(nameArg,genderArg,yearOfBirthArg,siteArg,privacyArg){

……

this.showPrivacy = function(){

var str = '秘密:' + this.name + privacy + '!';

alert(str);

};

}

var nahao = new Person('Topcss',male,1989,'www.javava.org','有10跟脚趾头');

nahao.showPrivacy();

 

我们首先给Person构造函数添加了一个showPrivacy特权方法，方法中使用了私有变量privacy的值。最后我们在nahao对象上调用该方法，结果如下：

 

9、prototype浅析首先，我们要否定上面这句话“对Person.prototype的修改同样会影响到使用Person定义的对象。”请看如下代码：

 

 

Person.prototype = {

mark:'Person.Proto'

}

var nahao = new Person('Topcss',male,1989,'www.javava.org');

Person.prototype = {

mark:'Person.NewProto'

}

alert(nahao.mark);

 

alert的输出会是什么呢？根据上面的经验，在alert之前，对Person.prototype的最后修改将它的mark属性赋值为'Person.NewProto'。但是实际的输出结果：Person.Proto

这不是bug，而且各个浏览器里都一样。原因分析如下：

 

Person.prototype = {

mark:'Person.Proto'

}

一段首先创建一个对象字面量，并且赋值给Person.prototype，我们称这个对象字面量为Proto。

 

var nahao = new Person('Topcss',male,1989,'www.javava.org');

 

在创建nahao对象并且按照构造函数初始化对象的同时，会悄悄给nahao对象设置一个内部属性，我们暂且将其命名为xxx，并且将其赋值为Person.prototype的值，也就是上面提到的对象字面量Proto，JavaScript的动态继承也就是由这个xxx实现的。（这个JavaScript的内部实现机制不是我拍脑门想出来的，是Netscape的工作人员的一篇文章里提到的，下面也会用程序来证明这个流程。）然后，

 

 

Person.prototype = {

mark:'Person.NewProto'

}

 

这里我们将创建另外一个对象字面量NewProto，并且赋值给Person.prototype。到这里就很明显了，尽管我们修改了Person.prototype，但是并没有影响到nahao对象。当我们访问nahao.mark的时候，它首先在自己内部找，找不到就会去找xxx，自然就找到了Proto，而非NewProto。那么xxx这个实现动态继承的关键究竟是什么呢？在FireFox中它是__proto__，有以下代码为证。至于在IE中xxx是什么我还没找到。

 

 

Person.prototype = {

mark:'Person.Proto'

}

var nahao = newPerson('Topcss','male',1989,'www.nahao8.com');

nahao.prototype = {

mark:'Person.NewProto'

}

alert(nahao.mark);

alert(nahao.__proto__.mark);//两次alert的结果都是一样的，都是Proto。

 

alert(nahao.__proto__===Person.prototype);//结构为true。

 

以上代码经过测试适用于FireFox和chrome。NetScape应该也可以，IE不行。

个人观点：Person.prototype ={}的方式最好只在定义构造函数的时候使用一次，而且要紧跟着构造函数写，以后修改prototype的时候都使用Person.prototype.protertyA= ‘valueA’的形式。

 

 

10、   最后的构造函数我们在上面看到了定义对象，以及设这和修改其属性的各种方法，我们可以在构造函数中定义属性，可以在对象外部定义（静态）属性，也可以在对象的prototype中定义属性。下面是我使用的大致格式：

 

 

functionPerson(nameArg,genderArg,yearOfBirthArg,siteArg,privacyArg){

//公有属性

this.name = nameArg;

this.gender = genderArg;

this.yearOfBirth = yearOfBirthArg;

this.site = siteArg;

//私有属性

var privacy = privacyArg;

//特权方法

this.showPrivacy = function(){

};

}

Person.prototype = {

//公有方法

info : function(){

},

func:function(){

}

}