第九章：Javascript类和模块

            //一个简单的javascript类
            //实现一个能表示值的范围的类
            
            //inherit函数
            //inherit()返回了一个继承自原型对象p属性的新对象
             //这里是有ECMAScript5中的Object.create()函数（如果存在的话）
             //如果不存在Object.create,则使用其他方法
            function inherit(p) {
                if (p == null) throw TypeError(); //p是一个对象，不能是null
                if (Object.create) //如果Object.create存在
                    return Object.create(p); //直接使用它
                var t = typeof p; //否则进一步检测
                if (t !== "object" && t !== "function") throw TypeError;

                function f() {}; //定义一个空构造函数
                f.prototype = p; //将其原型属性设置p
                return new f(); //将f()创建p的继承对象
            }
            //inherit函数结束
            
            //这个工厂方法返回一个新的“范围对象”
            function range(from,to){
                //使用inherit()函数来创建对象，这个对象继承自下面定义的原型对象
                //原型对象作为函数的一个属性存储，并定义所有“范围对象”所共享的方法（行为）
                var r = inherit(range.methods);
                
                //储存新的“范围对象”启始位置和结束位置（状态）
                //这两个属性是不可继承的，每个对象都拥有唯一的属性
                r.from = from;
                r.to = to;
                
                //返回这个新创建的对象                
                return r;
                
            }
            
            //原型对象定义方法，这些方法为每个范围对象所继承
            range.methods = {
                //如果x在范围内，则返回true；否则返回false
                //如果这个方法可以比较数字范围。也可以比较字符串和日期范围
                includes:function(x){
                    return this.from <= x && x <= this.to;},
                //对于范围内每个整数都调用一次f
                //这个方法只可用作数字范围
                foreach:function (f){
                    for (var x = Math.ceil(this.from); x <= this.to ; x++) f(x);
                },
                //返回表示这个范围的字符串
                toString:function(){return "("+ this.from + "..." + this.to + ")";}
            };
            
            //这是使用范围对象的一些例子
            var r =range(1,3); //创建一个范围对象
            r.includes(2); //true:2 在这个范围内
//            r.foreach(console.log);
            console.log(r)

             //表示值的范围的类的另一种实现

             //这是一个构造函数，用以初始化新创建的“范围对象”
             //注意，这里并没有创建并返回一个对象，仅仅是初始化
            function Range(from, to) {
                //存储这个“范围对象”的起始位置和结束位置（状态）
                //这两个属性是不可继承的，每个对象都拥有唯一的属性
                this.from = from;
                this.to = to;
            }

             //所有的“范围对象”都继承自这个对象
             //属性的名字必须是"prototype"
            Range.prototype = {
                //如果x在范围内，则返回true;否则返回false
                //这个方法可以比较数字范围，也可以比较字符串和日期范围
                includes: function(x) {
                    return this.from <= x && x <= this.to;
                },
                //对于这个范围内的每个整数都调用一次f
                //这个方法只可用于数字范围
                foreach: function(f) {
                    for (var x = Math.ceil(this.from); x <= this.to; x++) f(x);
                },
                //返回表示这个范围的字符串
                toString: function() {
                    return "(" + this.from + "..." + this.to + ")";
                }
            };

             //这里是使用“范围对象”的一些例子
            var r = new Range(1, 3); //创建一个范围对象
            r.includes(2); //=>true 2在这个范围 内
            r.foreach(console.log); //输出1 2 3
            console.log(r); //输出对象(1...3)

r instanceof Range // 如果r继承自Rang.prototype,则返回true

            var F = function() {}; //这是一个函数对象：
            var p = F.prototype; //这是F相关联的原型对象
            var c = p.constructor; //这是与原型相关的函数
            c === F; //=>true  对于任意函数F.prototype.constructor == F

            var o = new F(); //创建类F的一个对象
            o.constructor === F //=>true ,constructor属性指代这个类

            Range.prototype = {
                constructor: Range, //显式的设置构造函数反向引用
                includes: function(x) {
                    return this.from <= x && x <= this.to;
                },
                foreach: function(f) {
                    for (var x = Math.ceil(this.from); x <= this.to; x++) f(x);
                },
                toString: function() {
                    return "(" + this.from + "..." + this.to + ")";
                }
            };

            Rang.prototype = {
                //扩展预定义的Range.prototype对象，而不重写之
                //这样就自动创建Range.prototype.constructor属性
                Range.prototype.includes = function(x) {
                    return this.from <= x && x <= this.to;
                };
                Range.prototype.foreach = function(f) {
                    for (var x = Math.ceil(this.from); x <= this.to; x++) f(x);
                }
                toString: function() {
                    return "(" + this.from + "..." + this.to + ")";
                }
            };

             ///一个用以简单类的函数
            function defineClass(constructor, //用以设置实例的属性的函数
                    methods, //实例的方法，复制至原型中
                    statics) //类属性，复制至构造函数中
                {
                    if (methods) extend(constructor.prototype, methods);
                    if (statics) extend(constructor, statics);
                    return constructor;
                }
                //这个是Rang类的另一个实现
            var SimpleRange =
                defineClass(function(f, t) {
                    this.f = f;
                    this.t = t;
                }, {
                    inclueds: function(x) {
                        return this.f <= x && x <= this.t;
                    },
                    toString: function() {
                        return this.f + "..." + this.t;
                    }
                }, {
                    upto: function(t) {
                        return new SimpleRange(o, t);
                    }
                });

             //这个文件定义了Complex类，用来描述复数
             //回忆一下，复数是实数和虚数的和，并且虚数i是-1的平方根
             //
             //这个构造函数为它所创建的每个实例定义了实例字段r和i
             //这两个字段分别保存复数的实部和虚部
             //他们是对象的状态
            function Complex(real, imaginary) {
                    if (isNaN(real) || isNaN(imaginary)) //确保两个实参都是数字
                        throw new TypeError();
                    this.r = real;
                    this.i = imaginary;
                }
                //类的实例方法定义为原型对象的函数值的属性
                //这个库定义的方法可以被所有实例继承，并为它们提供共享的行为
                //需要注意的是，javascript的实例方法必须使用关键字this才存取实例的字段

             //当前复数对象加上另外一个复数，并返回一个新的计算乘积之后的复数对象
            Complex.prototype.add = function(that) {
                return new Complex(this.r + that.r, this.i + that.i);
            };
            
            //当前复数乘以另外一个复数，并返回一个新的计算乘积之后的复数对象
            Complex.prototype.mul = function(that){
                return new Complex(this.r * taht.r - this.i * that.i,this.r * that.i + this.i * that.r);
            };
            
            //计算复数的模，复数的模的定义为原点（0,0）到复平面的距离
            Complex.prototype.mag = function(){
                return Math.sqrt(this.r * this.r + this.i * this.i);
            };