首页 教程 API文档

创建模块

2015-09-11 10:23:23

属性


复杂程度 中高
使用频率
成员类型 静态函数

描述


Std.module是一个用于创建通用模块的方法.

在StdJS中模块创建是一个最基础的方法,内置的所有模块都是通过Std.module方法来创建的.

有组织性的模块化代码可以很大程度的节省代码量,让维护工作变得非常轻松.

成员列表


方法名称 成员类型 描述
::property static 得到模块指定配置
::isProtected static 判断模块成员是否受保护的

语法


获取已经创建的模块


Object Std(String name);
Object Std.module(String name);
        

创建模块


Object Std.module(Object config);
Object Std.module(String name,Object config);
        

参数


名称 类型 描述
name String 模块的名称,如果指定了该值,那么创建之后的模块将会以该值为名称保存在Std.modules中.
config Object 模块的配置,一个包含配置的Object对象,如果该参数是一个函数,那么这个函数的返回值必须是一个Object,因为这个函数会被立即执行,并且将返回值作为配置.

模块配置


名称 类型 默认值 描述
type Number 0 该参数只有一个取值,0和1,当该参数为1的时候,那么直接执行模块方法的本身即可创建并返回其实例对象,而无需使用new关键字来创建.
parent Std Module Object null 父模块,指定需要继承的模块,当模块继承于父模块的时候,会自动有了父模块的所有静态成员,公有成员,受保护的成员,私有成员,选项,主函数方法,等所有特征.
mix Array,Object,Function null 指定需要混合到当前模块的一个对象,或者一个函数,该对象或者函数的所有静态方法,原型方法都将会被混合到当前模块中,如果需要混合多个对象,那么把需要混合的对象放入一个数组即可.
model String,Object,Array null

该选项指定模块需要引用的模型,如果该值是一个字符串,那么模块会自动根据字符串作为名称得到已经定义的模型(多个名称可以用空格分开)

如果这个值可以是一个对象,表示这个是一个模型的对象.

或者也可以是包含多个模型的数组,在通常情况下都使用模型名称作为值传递.

option Object null

option用于配置模块的默认参数选项,当指定了该配置之后,模块上会自动增加一个静态方法 "opts",与公有成员方法 "opt","init_opts","call_opts"

这些方法用于管理模块的参数选项.

static Object null 定义模块所包含的静态成员,这是一个静态成员名称与值对应的Object对象,模块静态成员无需创建模块实例即可被使用,例如 module1.member1();
public Object null 定义模块所包含的公有成员,这是一个公有成员名称与值对应的Object对象,使用公有模块成员的时候必须创建模块实例,公有成员可以在模块实例的内部以及外部被使用.
protected Object null

定义模块的受保护成员,一个成员名称与值对应的Object对象,受保护的成员无法被枚举, 当模块被继承的时候,受保护的成员也无法被覆盖重写,但在继承当前模块的情况下,仍然可以扩展受保护的成员函数.

受保护的成员仍然可以在模块实例外部被访问.

private Object null

定义模块的私有成员,一个成员名称与值对应的Object对象,私有成员被定义之后,其名称前面会自动被加上下划线 "_", 私有成员无法被枚举.

私有成员仍然可以在模块实例的外部被访问,也可以被继承.

extend Object null

如果指定了父模块,也就是如果这个模块是从另一个模块下继承的,extend中包含的函数的作用就是对现有父模块下的函数进行扩展.

如果父模块下的函数在执行时候返回了一个值,而这个值不是undefined或者this对象的时候,那么扩展的这个函数将不会被执行.

被扩展的函数如果没有返回值,那么将会返回this对象.

main Function null 模块的主函数,用于模块以函数方式被直接执行或者实例对象入口函数,例如 module1() , new module1();
entrance Function null 模块入口,当创建模块时候额外需要执行的函数,这与main方法不同,该方法仅仅用于模块创建完毕之后的执行,并且是一次性的, 通常情况下,该入口用于执行一些特殊的更原始的配置,该方法包含2个参数,第一个是模块对象的入口(main),第二个是模块的原型对象.
__constructor__ Function null 如果加入了该选项,那么将会直接替代main选项作为模块的入口函数,通常情况下,不建议加入该选项,除非你非常清楚的知道StdJS模块内部是如何运作的.

option选项增加的默认方法


静态方法 opts

该方法用于设置模块选项中的默认值,当没有传递任何参数的时候,该方法将会返回一个Std.options实例对象.


Object opts();
void opts(Object option);
        
类型 描述
Object 一个包含名称与值对应的Object对象,这些值将会覆盖默认的选项值

原型方法 opt

原型方法opt用于获取或者设置模块实例中选项的默认值.


(Any) opt(String name);
Object opt(String name,(Any) value);
Object opt(String name,(Any) value,Function callback);
        
名称 类型 描述
name String 要设置或者要获取的选项名称
value Any 需要设置的值
callback Function 在设置完值的之后需要执行的回调函数.

原型方法 init_opts

init_opts方法用于初始化模块实例的参数选项,该方法只能被执行一次.

当参数选项被初始化之后,将会自动增加一个成员变量 "opts" ,该变量保存的是当前实例对象参数选项,同时该值将会作为init_opts的返回值返回.


Object init_opts(Object option);
        
类型 描述
Object 需要设置的参数选项,这些值将会覆盖默认值.

原型方法call_opts

该方法用于执行与参数选项名称相同的成员函数,并且将参数选项对应的值作为参数.返回this对象.


//直接执行指定名称的成员函数,将该名称的选项值作为参数
Object call_opts(String name);
        

//判断指定名称的默认选项值是否与当前选项值相同,如果相同则执行指定名称的成员函数,当前选项值作为参数
Object call_opts(String name,Boolean check);
        

//执行多个指定名称的成员函数方法
Object call_opts(Array names);
        

//判断指定数组中名称的默认选项值是否与当前选项值相同,如果相同则执行指定名称的成员函数,当前选项值作为参数
Object call_opts(Array names,Boolean check);
        

//执行名称为options键名的成员函数,将其键值作为参数
Object call_opts(Object options);
        

//检查options中的键值如果键值与对应键名的选项值不同,则指定这个键名的成员函数,这个键值作为参数
Object call_opts(Object options,Boolean check);
        
名称 类型 描述
name String 选项名称
names Array 包含多个选项名称的数组
check Boolean 如果进行选项值的检查
options Object 名称与选项值对应的Object对象

返回值


创建之后的模块对象

相关例子


例子1(常规配置)


var module1 = Std.module({
    //配置静态成员
    static:{
        func1:function(){
            console.log("static member : func1");
        },
        func2:function(){
            console.log("static member : func2")
        }
    },
    //配置公有成员
    public:{
        func1:function(){
            console.log("public member : func1");
        },
        func2:function(){
            console.log("public member : func2");
        }
    },
    //配置私有成员
    private:{
        func1:function(){
            console.log("private member : func1");
        },
        func2:function(){
            console.log("private member : func2");
        }
    },
    //主函数
    main:function(n){
        console.log(n)
    }
});

//执行静态方法func1,输出 "static member : func1"
module1.func1();

//创建模块实例,模块中的main函数被触发,输出abc
var instance1 = new module1("abc");

//执行public方法func1,输出 "public member : func1"
instance1.func1();

//执行public方法func2,输出 "public member : func2"
instance1.func2();

//执行private方法func1,输出 "private member : func1"
instance1._func1();

//执行private方法func2,输出 "private member : func2"
instance1._func2();

//枚举instance1,得到 "func1","func2" ,2个公有成员函数名称,private以及protected成员是无法被枚举的.
for(var name in instance1){
    console.log(name)
}
        

例子2(模型与继承)


/*
* 创建一个模型 : "model1"
*/
Std.model("model1",{
    //配置公有成员
    public:{
        func1:function(){
            console.log("func1")
        },
        func2:function(){
            console.log("func2");
        }
    },
    //主方法
    main:function(){
        console.log("model main");
    }
});
/*
 * 创建一个模块,引用模型 : "model1"
*/
var module1 = Std.module({
    //引入刚创建的模型
    model:"model1",
    //配置公有成员
    public:{
        func3:function(){
        console.log("func3");
    }
    },
    //主函数,模型中的main方法将会被覆盖
    main:function(){
        console.log("module main");
    }
});

/*
* 创建一个模块,继承 module1
*/
var module2 = Std.module({
    //加入parent选项,继承module1
    parent:module1,
    //扩展module1中已有的公有成员函数
    extend:{
        /*
        * 扩展func3
        */
        func3:function(){
            console.log("hello");
        }
        },
        public:{
        /*
        * 重写 func2
        */
        func2:function(){
            console.log("3.1415926");
        }
    }
});

//创建模块实例,输出 "module main"
var instance1 = new module2();
//执行成员函数func1,输出 "func1"
instance1.func1();
//执行成员函数func2,输出 "3.1415926"
instance1.func2();
//执行成员函数func3,输出 "func3" "hello"
instance1.func3();

//判断是否为module1的实例
if(instance1 instanceof module1){
    console.log("yes");
}

//判断是否为module2的实例
if(instance1 instanceof module2){
    console.log("yes");
}
        

例子3(参数选项):


//创建带有option选项的模块
var module1 = Std.module({
    //默认参数选项
    option:{
        color:"red",
        name:"example"
    },
    //配置公有成员
    public:{
        /*
         * 如果没有传递参数,返回返回参数选项中的color值,否则设置参数选项中的color值,返回this对象
        */
        color:function(color){
            return this.opt("color",color);
        }
    },
    //主函数
    main:function(opts){
        //一旦使用init_opts成员函数,this.opts会被创建
        this.init_opts(opts);

        console.log(this.opts.color);
        console.log(this.opts.name);
    }
});

//创建模块实例,输出blue,example
var instance1 = new module1({
    color:"blue"
});

//创建模块实例,输出blue,test1
var instance2 = new module1({
    color:"blue",
    name:"test1"
});

//设置选项color值
instance2.opt("color","green");

//获取选项color值
instance2.opt("color");

//还可以使用 module1.opts 方法改变其选项默认值
module1.opts("color","gray");
        

例子4(type值为1,自动创建实例对象)


//type值为1的时候,当执行模块主方法时会自动创建当前模块的实例对象,并且将其返回
var module1 = Std.module({
    type:1,
    main:function(){
        console.log("main");
    }
});
//创建模块实例对象
var instance1 = new module1();
//省去new关键字直接执行,也是自动创建实例对象
var instance2 = module1();
        

例子5,创建一个可以被StdJS内部直接管理的模块



//创建模块
Std.module("module1",{
    static:{
        func1:function(){
            console.log("static member: func1");
        }
    },
    public:{
        func1:function(){
            console.log("public member: func1");
        }
    },
    main:function(){
        console.log("main")
    }
});

//直接执行模块静态方法
Std("module1").func1();
//或者
Std.module("module1").func1();
//或者
var module1 = Std("module1");
module1.func1();

//创建模块实例,因为Std方法本身要创建模块实例至少要包含2个参数
var instance1 = Std("module1",null);
instance1.func1();

//用Std.create方法创建
var instance1 = Std.create("module1");
instance1.func1();