类和模块

一、类

　　JavaScript中类的实现是基于原型机制的。如果两个实例都从同一个原型上继承属性，则他们它们是同一个类的实例，类的所有实例对象都从同一个原型对象上继承属性。

　  使用构造函数定义类

//使用构造函数定义一个范围类
function Range(from,to){
    this.from=from;
    this.to=to;
}
Range.prototype={
    //定义构造器属性
    constructor:Range,
    //判断x是否在范围内
    include:function (x){
        return this.from<=x&&x<=this.to;
    },
     //对范围内的每一个整数执行f;
    foreach:function (f){
        for(var i=Math.ceil(this.from);i<=this.to;i++)
        {
            f(i);
        }
    },
    //返回表示范围的字符串
    toString(){
        return this.from+'...'+this.to;
    }  
}
//调用构造函数
var range=new Range(1,10);
console.log(range.include(5));//true
range.foreach((ele)=>{console.log(ele)});//1  2  3  4 5..10
console.log(range.toString());//1...10

　　构造函数是类的公共表示（往往代表类明），而原型对象是类的唯一标识。

　  类的实例是一个独立的对象，直接给实例定义的属性不会被所有实例共享。可以用来模拟实例字段。

　  原型对象的属性和方法或被类的实例所共享，可以用来模拟类的实例方法。

　  构造函数上定义的方法可以直接用构造函数对象调用，可以用来模拟类的方法（通过类名调用）

　  java中用final表示声明字段为常量。JavaScript可以使用属性名字全部大写来暗示这是一个常量。

　  java中可以把字段设置为私有成员（类的外部不可见）。JavaScript中使用属性名以下划线开始暗示这是一个私有变量。　

//使用构造函数定义一个范围类
function Range(from,to){
    //定义实例方法：对象字段；保存对象的独立状态
    this.from=from;
    this.to=to;
}
    //定义实例方法：所有实例共享
Range.prototype={
    //定义构造器属性
    constructor:Range,
    //判断x是否在范围内
    include:function (x){
        return this.from<=x&&x<=this.to;
    },
     //对范围内的每一个整数执行f;
    foreach:function (f){
        for(var i=Math.ceil(this.from);i<=this.to;i++)
        {
            f(i);
        }
    },
    //返回表示范围的字符串
    toString(){
        return this.from+'...'+this.to;
    }  
}
//类的方法和属性
Range.NAME='Range';//大写表示只读的。
Range._format="";//下划线表示它是私有变量  

可以将上面的过程封装成一个defineClass方法。

 

//将p对象的属性复制到o对象，覆盖同名方法
//构造器属性只能复制值
function extend(o, p) {
    for (var s in p) {
        if (p.hasOwnProperty(s))
            o[s] = p[s];
    }
    return o;
}
function defineClass(constructor, method, static) {
    //constructor代表创建类的构造函数
    //method  实例方法
    //static 类方法
    if (method)
        extend(constructor.prototype, method);
    if (static)
        extend(constructor, static);
    return constructor;
}
//定义一个SimpleRange
var SimpleRange = defineClass(function () { this.x = 1; this.y = 2 },
    { add: function () { return 10 } },
    { pi: 3.14 });
var s=new SimpleRange();
console.log(SimpleRange.pi)//3,14
console.log(s.x);//1
console.log(s.add());//10

 

二、类的扩充

　 JavaScript基于原型的继承是动态的，给对象的原型添加的方法，继承这个原型对象也会继承这些方法。　　　

Pange.prototype.toJson=function(){
    return ....//
}

　　类的实例对象都会添加toJson();

　　我们可以内置对象的原型上添加方法，是内置对象都可以使用这个方法。

三、检测对象类的方法　

　　 intanceof、对象的constructor属性、isprototype()　　　　

var o={};
console.log(o instanceof Object);//true
console.log(Object.prototype.isPrototypeOf(o));//true
console.log(o.constructor);//Object函数的引用

　　intanceof和constructor属性会在web应用存在问题，web的框架和多窗中会有独立的上限下文，独立上下文包含独立的变量和构造方法。一个框架页面中的数组不是另一个框架页面中Array()的实例，所以instance和constructor返回false;

四.　面向对象技术

定义一个集合类Set

 

//定义集合类 ：将传入的值建立一个唯一的到字符串的映射，然后将字符串和值保存进对象中

//定义一个构造函数
function Set() {
    //用于将值保存在对象中
    this.value = {};
    //集合中值得个数
    this.n = 0;
    //初始化集合中的值。
    this.add.apply(this, arguments);
}
//定义一个类内部使用的私有属性；用来产生值对应的字符串
Set._v2s = function (val) {
    switch (val) {
        case undefined: return "u";
        case null: return 'n';
        case true: return 't';
        case false: return 'f';
        default: switch (typeof val) {
            case "number": return "#" + val;
            case "string": return '"' + val;
            default: return "@" + objectid(val);
        }
    }
}
//生成对象的id方法
function objectid(val) {
    //相同的对象产生相同的id,不同的对象产生不同的id
    var prop = "|*prop*|";//定义一个私有属性
    if (!val.hasOwnProperty(prop))
        val[prop] = Set._v2s.next++;
    return val[prop];
}
//定义一个类属性
Set._v2s.next = 100;
//给集合添加实例方法
Set.prototype.add = function () {
    for (var i = 0; i < arguments.length; i++) {
        var val = arguments[i];
        //得到值到字符串的映射
        var str = Set._v2s(val);
        //检验集合中是否存在这个字符串
        if (!this.value.hasOwnProperty(str)) {
            //当集合中不存在这个值时，将值保存近集合
            this.value[str] = val;
            this.n++;
        }
    }
    return this;//支持链式编程
}
//删除集合中的值
Set.prototype.remove = function () {
    for (var i = 0; i < arguments.length; i++) {
        var val = arguments[i];
        //得到值到字符串的映射
        var str = Set._v2s(val);
        //检验集合中是否存在这个字符串
        if (this.value.hasOwnProperty(str)) {
            //当集合中存在这个值时，将值删除
            delete this.value[str]
            this.n--;
        }
    }
    return this;//支持链式编程
}
//判断集合中是否有这个值
Set.prototype.contains = function (val) {
    var str = Set._v2s(val);
    return val.hasOwnProperty(str);
}
//遍历集合，使用指定的上下文执行f函数
Set.prototype.forEach=function(f,content){
   for(var p in this.value){
       if(this.value.hasOwnProperty(p)){
           f.call(content,this.value[p]);
       }
   }
   return this;
}
//返回集合的大小
Set.prototype.size=function(){
    return this.n;
}
//创建一个集合
var set=new Set(1,2,3);
set.add(4,5,6,{},{},{x:1});
set.remove(4,5);
set.forEach((ele)=>{console.log(ele)});
console.log(set.size());
console.log(set.contains(1));

 

五、标准转化方法

　　应该给类的原型上定义一些标准转发方法：toString()、valueOf()、toJSON()、toLocalString()。这些方法在对象的类型转换时会用到。如果没有定义最好是刻意为之而不是忘了定义。

　　对象的比较是引用的比较，我们可以自己在原型定义一类比较方法。

六、方法借用

　　多个类中的方法可以共用一个函数，我们称之为方法借用。

　　如；Set.prototype.equals=A.equals;

七、可以利用闭包实现变量的私有　

//变量只能被类的实例方法访问，类的外面不可见
function Range(from,to){
    this.from=function(){
        return from;
    }
    this.to=function(){
        return to;
    }
}
Range.prototype.include=function(x){
    return this.from()<=x&&x<=this.to;
}

 

八、构造方法的重载和工厂方法

　　有时候，我们希望对象的初始化有多种方式，比如我们用构造函数创建初始化一个数组。