读书笔记----javascript类和模块

傷城~ 2022-07-27 15:54 192阅读 0赞

1.  构造函数时用来初始化新创建的对象的，使用new关键字来初始化这个对象。使用new调用构造函数会自动创建一个新对象，因此构造函数本身只需要初始化这个新对象即可。

//range,js 实现一个能表示值的范围的类 
        function range(from,to){ 
         //使用inherit()创建对象，这个对象继承下面定义的原型对象
         var r=inherit(range.methods);//创建一个对象r,继承原型对象range.methods
         //定义起始位置和结束为止，这两个属性是非共享的不可继承的，每个对象都拥有唯一的属性
          r.from=from;
          r.to=to;
          return r;//返回创建的新对象 
    
            }
    
        //原型对象的定义方法，这些方法为每个范围对象继承
        range.methods={
            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);//输出1 2 3
            console.log(r);//输出（1...3）
            // form to都是非共享的，不可继承的，但是range.methods中定义的可共享的，可继承的方法
            //都用到了from和to,而且使用了this关键字。任何类的方法都可以通过this读取对象的属性

这里写代码片

1.  调用构造函数，构造函数的prototype属性被用做新对象的原型。所以通过构造函数创建的对象都继承一个相同的对象，他们都是同一个类的成员。

//使用构造函数定义范围类
                function Range(from,to){   //定义构造函数就是定义类，并且类的首字母大写
                    this.from=from;
                    this.to=to;
                    }
                Range.prototype={  //Range()构造函数调用会自动使用Range.prototype作为新的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+")";}
                    };
                var r=range(1,3);
                r.includes(2);
                r.foreach(console.log);
                console.log(r);
    
            //上述构造函数定义类，定义的Range类使用它自身的一个对象重写预定义的Range.prototype对象。
            //这个心定义的原型对象不含有constructor属性，因此Range类实例也不含有constructor属性

1.  原型对象是类的唯一标识，当且仅当两个对象继承同一个原型对象是，它们才是同一个类的实例。  
    r instanceof Range//如果r继承自Range.prototype,则返回true  
    instanceof运算符并不会检查r是否由Range构造函数初始化来的，只会检查r是否继承自Range.prototype
2.  每个javscript函数都拥有一个prototype属性，这个属性的值是一个对象，这个对象包含唯一一个不可枚举的属性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+")";}
                };

var p=F.prototype;//这是F相关联的原型对象  
var c=p.constructor;//这是与原型相关联的函数  
c===F //true 对于任意函数F.prototype.constructor==F  
对象继承的constructor均指代它们的构造函数  
var 0=new F();//提供F的一个对象  
o.constructor===F //true constructor属性指代这个类

//使用预定义的原型对象，预定义的原型对象包含constructor属性，然后依次给原型对象添加方法
                //扩展预定义的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);
                    };
                Range.prototype.toString=function(){ 
                    return "("+this.from+"..."+this.to+")";
                    };

1.  构造函数对象：为javascript的类定义了名字，任何添加到这个构造函数对象中的属性都是类字段和类方法  
    原型对象：属性被类的所有实例所继承，如果原型对象的属性值是函数的话，这个函数就作为类的实例方法来调用  
    实例对象：类的每个实例都是一个独立的对象
2.  定义类的步骤：第一步先定义一个构造函数，并设置初始化新对象的实例属性  
    第二步给构造函数prototype对象定义实例方法  
    第三步给构造函数定义类字段和类属性

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

1.  js中的原型继承机制是动态的，对象从原型继承属性，如果创建对象之后原型的属性发生改变，也会影响到继承这个原型的所有实例对象。
2.  检测对象类的技术 instanceof isPrototypeOf constructor  
    instanceof检测对象继承关系，而不是检测创建对象的构造函数  
    isPrototypeOf()检测对象原型链上是否存在某个特定的原型对象  
    这两种方法的缺点：无法通过对象获得类名，只能检测对象是否属于指定的类名。在多个执行上下文中存在构造函数的多个副本的时候，检测结果出错。
3.  辅助构造函数

//辅助构造函数
        function SetFromArray(a){ 
            //将a的元素作为参数传入
            Set.apply(this,a);
            }
        //设置原型，以便SetFormArray能够创建Set实例
        SetFromArray.prototype=Set.prototype;
        var s=new SetFromArray([1,2,3]);
         s instanceof Set  //true

1.  如果O是类B的实例，B是A 的子类，那么O一定从A中继承了属性。为此首先确保B的原型对象继承自A的原型对象  
    B.prototype=inherit(A.prototype); //子类派生自父类  
    B.prototype.constructor=B; //重载继承来的constructor属性  
    这是创建子类的关键，如果不这样做，原型对象仅仅是一个普通对象，它只继承Object.prototype。
2.  Object.preventExtensions()可以将对象设置为不可扩展的，不能为对象添加新的属性
3.  Object.seal()除了阻止用户给对象添加新属性，还能将当前已有的属性设置为不可配置。

//定义一个复数类
            function Complex(real,imaginary){ 
                if (isNaN(real)||isNaN(imaginary))
                throw new TypeError();
                this.r=real;
                this.i=imaginary;
                }
            Complex.prototype.add=function(that){ 
                return new Complex(this.r+that.r,this.i+that.i);
                }
            Complex.prototype.equals=function(that){ 
                return that!=null&&  //必须有定义且不能是null
                that.constructor===Complex&&  //必须是Complex实例
                this.r===that.r&&this.i===that.i;  //包含相同的值
    
                }
                //定义对复数运算有帮助的类字段，他们都是常量
                Complex.ZERO=new Complex(0,0);
                Complex.ONE=new Complex(1,0);

function typeAndValue(x){ 
                if (x==null)  return " "；// null undefined 没有构造函数
                switch (x.constructor){
                    case Number: return "Number:"+x;//处理原始类型
                    case String: return "String:' "+x+" '" ;
                    case Date:return "Date: "+x;  //处理内置对象
                    case RegExp: return "Regexp: "+x;
                    case Complex:return "Complex: "+x;//定义自定义类型
                    }
                }
                //case后的表达式都是函数，如果改为typeof 运算符或获取到对象的class属性的话，应当改为字符串