转载：http://blog.youkuaiyun.com/tenfyguo/article/details/5780986
javascript的函数既可以作为普通的函数进行调用，也可以作为构造函数进行创建对象。在作为普通函数进行调用的情况，由于大家比较熟悉，并且平时使用也比较多，所以这里就不做进一步的阐述了，本文重点是分析javascript函数作为一个构造函数进行创建对象的过程和在构建高可复用的框架的一些技巧tips。
我们知道，调用构造函数创建一个javascript的对象过程是很容易的，实例代码如下：
var myObj = new myConstructor(); //这里当然可以传递一些参数；
但如果拆分new 操作符对应的函数调用系列，可以拆分理解成下列的执行步骤：
var myObj = new Object(); //创建一个本地的javascript native object
myConstructor.call(myObj); //把当前创建的对象作为myConstructor的this参数并且调用构造函数进行初始化；
myObj[[prototype]] = myConstructor.prototype; //把myConstructor的prototype的引用赋给对象myObj的内部原型属性
通过第三步骤的赋值，使得通过prototype增加的函数均在构造的各个实例中都是可访问的，并且只保留一份拷贝。
有了上面的预备知识，下面理解私有，公有，静态和特权成员就比较容易了。还是以例子代码为例。
//构造函数如下
function myContructor(info) {
this.info = info; //这是实例的属性，并且是公有的，每new 一个实例都生成一个新的属性
//这个是私有的属性，对每new一个的实例来说，是不可见的，但构造函数执行完毕就消失了，
//注意这里的var 关键字
var _innerVar = 'this is private var';
//这个是私有方法，同样对每new一个实例来说，也是不可见的，只在构造函数的执行过程中可见
//私有方法可以使用私有属性和实例的各个属性
function _innerFn(){
//TODO HERE
};
_innerFn();
//特权方法，本身也是公有的方法，任何生成的实例都可以调用，但这里之所以称为“特权”方法，是因为该方法
//由于放到了构造函数的内部，使得具有权限访问构造函数执行过程的作用域链的各个属性和函数，包括私有属性
//和私有方法，但同时由于作为实例的一个成员方法，每new一个对象，都会创建一个单独的特权方法的拷贝，
//从根本目的上看，特权方法的存在是为了访问私有方法和私有属性并且发布为实例的公共成员方法。这里其实
//已经形成了一个闭包
this.specialFn = function(){
_innerFn();
this.message = this.info + _innerVar;
};
};
//通过prototype实现的方法均是公有方法，并且每个实例都共享一份拷贝，通过上面的new的拆分过程可以理解到这点。
myConstructor.prototype.publicFn = function(){};
//静态方法
myConstructor.staticFn = function(){};
//静态成员
myConstructor.staticVar = 'abc';
其实静态方法只是作为function对象实例自身的一个成员方法和成员函数而言，跟构造函数本身没太大的关系，常用于定义常量和保持唯一值的存储，比如Math.PI等。
------------------------------------
JavaScript中的公有成员，私有成员和静态成员
私有成员就是在类的内部实现中可以共享的成员。但是并不对外公开，JavaScript中并没有特殊的机制来定义私有成员，但是可以用一些技巧来实现这个功能。主要是通过变量的作用域性质来实现的，在一个函数内部定义的变量称为局部变量，该变量不能被函数外的程序所访问，可以被函数内部定义的嵌套函数所访问。
在类的构造函数中可以为类添加成员，通过这种方式定义的成员，实际上共享了在构造函数内部定义的局部变量，这些变量就可以看作是类的私有成员。如：
实现私有成员
<script>
function class1(){
var pp="this is a private property";//私有属性成员pp
function pm(){//私有方法成员pm，显示pp的值
alert(pp);
}
this.method1=function(){ //在公有成员中改变私有属性的值
pp="pp has been changed";
}
this.method2=function(){//在公有成员中调用私有方法
pm();
}}
var obj1 = new class1();
obj1.method1();
obj1.method2();
</script>
注意：
局部变量(私有成员)被所有在构造函数中定义的公有方法所共享，而且仅被在构造函数中定义的公有方法所共享，这意味着，在prototype中定义的类成员不能访问在构造器中定义的局部变量。
实现静态成员：
和私有成员勉强相比，静态成员就要正统的多了，静态成员就是属于一个类的成员，如：
function class1(){
}
class1.staticProperty="sample";
class1.staticMethod=function(){
alert(class1.staticProerty);
}
class1.staticMethod();
如果要给每个函数对象都添加通用的静态方法，还可以函数对象所对应的类Function来实现：
Function.prototype.showArgsCount=function(){
alert(this.length);
}
function class1(a){
}
class1.showArgsCount();
由此可见，通过Function的prototype原型对象，可以给任何函数都加上通用的静态成员。
--------------------------------------------------------------------------------------------------
[JS]Javascript静态属性和方法介绍与示例
JavaScript中，每个function都拥有一个原型对象prototype，通过这个对象可以为这个类定义各种属性和方法，但是这样定义的属性 和方法是所有该类的对象所共有的，效果上和同这个类的父类中继承的字段和方法差不多。通常我们使用function的原型来创建类的方法，而用普通方式来 创建类的属性。
1.为什么不用原型来创建属性
因为原型创建的内容是这个类所有对象所共享的，对于一个属性而言，不同的类的对象的值都不一样。如果使用原型对象来创建对象属性，那么任何一个类的对象修改了自己的某个属性，其他对象的相同属性也会被修改。
这么做的本质是因为：属性是各个对象不同的，要求对象自己保存自己该属性的值，而方法对于所有对象而言都是一样的，没有必要每个对象都保存一个方法，只要由类的原型保存一份，各个对象使用方法的时候调用这些方法就可以了。
2.为什么要用原型来保存方法
因为方法对所有类对象来说都是一样的，如果用传统方式定义，那样每个类的对象被定义的时候，该对象都会保存这个方法的信息，这样会耗
费很多资源。而使用原型来保存，所有的方法都保存在原型中，每个对象需要使用方法的时候就调用原型对象中保存的方法。节省了资源。
在类中定义共享的共有方法，私有静态属性和方法，共有静态属性和方法。
//一种更为合适的公用属性和方法的定义，把共有方法在类第一次调用的时候加到类的原型对象中
var Book = function(name){
//公有属性，在构造方法里面来定义，通过this关键字
this.name = name;
//第一次执行该对象的构造方法，这个时候执行下面的代码
//为类的原型对象上定义共有的方法
//所有该类的对象共享相同的共有对象，减小了内存的消耗
if (typeof Book._init == "undefined") {//在第一次定义该类对象的时候会成立
//共有的方法，在原型对象上定义
Book.prototype.setName = function(nname) {
this.name = nname;
};
Book.prototype.getName = function(){
return this.name;
};
Book.prototype.getCount = function(){
addCount();
return count;
};
}
//类已经被定义过了，以后就不再重新定义原型对象上的方法了
Book._init = true;
//利用局部变量来模拟私有静态属性和方法
//这些局部变量定义出来的方法和属性外界不能直接访问，只能通过公有方法访问，
var count = 0;
var addCount = function(){
count++;
}
};
//定义共有静态属性
Book.staticValue = 10;
//定义共有的静态方法
Book.changeValue = function() {
Book.staticValue++;
}
对上面类的调用方法
//这个new操作相当于先创建了一个简单对象，调用了类的构造方法
var book1 = new Book("AJAX");
var book2 = new Book("AJAX1");
alert(book1.getName());
alert(book2.getName());
book1.setName("JAVA");
alert(book1.getName());
alert(book2.getName());
alert(book1.getCount());
alert(book2.getCount());
alert(book1.getCount());
//共有的静态属性和方法要用类名来调用
alert(Book.staticValue);
Book.changeValue();
alert(Book.staticValue);
定义一个对象，希望这个对象拥有一些自己独享的私有信息
方法：直接定义一个匿名的类
//一个单独的对象，期望拥有一些私有有的信息
下面的方法和上面的起到一样的效果，
//利用匿名方法直接调用的方式，来实现一个对象拥有私有的信息
var priObj = (function(name){
//由于这个变量是在方法内定义的，起到的效果就是私有的
var priname = name;
//这个格式要求返回的是一个对象，
//这个对象要求有getName和setName两个方法
return {
getName:function() {
return priname;
},
setName:function(nname) {
priname = nname;
}
};
})("wang");
下面是上面对象的使用方法
//var priObj1=new priObj("a");
//var priObj2=new priObj("b");
上面的做法是错误的，因为这个priObj已经是个定义好的对象了，在定义匿名类的同时就定义好的，所以不能再这么去new了。
//priObj.priname是私有内容，无法访问
alert(priObj.priname);
alert(priObj.getName());
priObj.setName("Lee");
alert(priObj.getName());
alert("");
扫一扫
693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
