QoBean的元语言系统(二)
------------------------------------------------------------------------
第二部分:元语言下的编程基本方法
------------------------------------------------------------------------
三、代码组织形式
---------------------
1. 物理代码块(代码文本、代码行)
---------------------
代码到底应该如何组织?如果我们认为代码是由序列调用的例程构成的,那么我们可以把代码的
形式回溯到很“远古”的时代,例如:
简单地说,就是我们可以通过函数来组织代码块,并通过函数的连续调用完成运算。那么,函数
又是如何“组织成代码块”的呢?
这个过程被分解为三个部分,也就是:
- body : 函数的代码体
- name : 函数名
- param : 函数参数表
其基本规则为:
QoBean中的Block()这个函数,用于从代码文本中分离上述三个部分。Block()可以处理任何一个
符合JavaScript语法的函数(的文本)。例如(param返回数组, 其它两种情况返回文本字符串):
Block的上述三种参数,用于获取一个函数(的文本格式)中三个部分的物理代码块。
2. 逻辑代码块(闭包、全局闭包)
---------------------
一个函数如果不是局部的,就是全局的。局部的,就是指被物理上包含在其它函数内部的函数。
基于这样的规则,显然一个(全局的)语句中包括的函数会是全局的(而非局部的)。例如:
由于逻辑代码块事实上就两种,因此Block()提供了两种方式来实现它:
这两种方式得到的新函数都以是func为参考的,也就是说复制了一个一模一样的函数——但改
变了它们的闭包作用域。如下例:
3. Scoped(),绑定到指定的作用域(全局或指定对象的闭包)
---------------------
原则上,Scope()的处理对象是函数,其结果或者是一个代码文本,或者是一个函数闭包。但如果
你试图将一个函数绑定到一个对象的闭包中,那么你需要用Scoped()这个函数,其含义是“作用
域化”。返回一个函数,该函数位于指定的对象或全局的闭包中。Scope()与Scoped()的区别在于:
- Scope()用于根据函数func,返回新函数(或用于eval()的函数文本);
- Scoped()用于将函数绑定到目标对象obj,返回绑定后的函数;
绑定到指定作用域是一个有趣的功能,例如:
四、重写的基础技术与思想
---------------------
1. 重写
---------------------
QoBean认为一个项目中的代码,是通过开发人员不断地在一个基础代码上繁殖衍生而得到的。这个所
谓的基础代码的最原始的、基底性的版本,就是下面这样一个函数:
其最终执行的方法为:
其繁殖衍生的过程就称为“重写”。例如:
2. JS中的重写方法
---------------------
JS中本身就具有多种重写的方法,例如编译期重写与执行期重写(注意,编译期的重写是由编译器根
据代码上下文中的标识符,及其出现的次序来决定的。它的效果不能由用户代码来改变):
3. 保留旧有代码的两种基本方法
---------------------
在执行期的重写中,可以保留旧有的代码。例如:
这种技术非常类似于桌面软件开发中的HOOK(钩子)技术,因此在这里我们将它使为“Hook重写”。
还有一种重写技术,也可以做到上述的“保留旧有代码”的效果。他利用了JS代码可以序列化的特性:
上述代码的基本思想在于通过"new Function()"来得到新的函数,而旧的函数被序列化为一个字符串,
作为新的代码的一部分。这个过程中,_r_codebody的作用是获取一个函数的body区——函数代码块。
从这个视角来看,下面的函数:
其实相当于如下代码重写过程(给一个空函数内部attach一行代码):
4. 通过链接代码来组织更大的代码块(或函数)
---------------------
源于函数可以被序列化的特性。attach_code()第二个参数的代码文本,也可以视为第一个函数的body
区。也就是说:
而从这里,我们也得到一个启发,如下代码:
其实执行效果相当于把func1()与func2()合并起来,而合并的效果也就是:
如果attach_func()函数可以联合足够多的函数,我们也就可以拼合足够多的代码块——并让他足够复杂。
attach_func()的实现思想与上述过程是直接相关的:
五、QoBean中的重写技术
---------------------
1. QoBean所面临的更复杂的问题
---------------------
QoBean提供了Block()函数来取得一个function中的各个部分,同时也提供了Scoped()函数来产生指定
闭包环境下的函数。这也就意味着,我们可以在任意位置,通过上述的方法来“重写出”一个新的函
数——这个函数是象打补丁的过程一样,一次次增量叠加起来的。
有趣的是,如同上面所分析的,QoBean认为开发人员在书写原始代码的过程中的行为,的确就是这样
一个过程:不断地改写一个函数代码块的内部,或创建新的函数代码块——然后连接它们。所以,我
们可以写出任意大的程序来,本质上也就是我们在不停地用Block、Scope、Scope、Block……
这个过程在QoBean来说,叫做“编织(weave)”。Weave()这个函数用于简化“不停地Block、Scope”
这一过程。该过程首先包括了一个简单的逻辑:
也就是说,你可以为任何一个函数使用Weave()功能,以使得它可以在指定位置“where”增加一段代
码。这个指定位置可以是一个正则表达式、或者一个字符串。所以上一小节中的例子可以这样实现:
同时,QoBean对这个过程进行了扩展,使得它可以支持:
- 在Weave()处理的函数中,支持函数形式参数;
- 在代码中可以使用'$&'等正则表达式中允许的替换匹配。
这个过程,通过Weave()函数自身的一些编织过程来实现——也就是Weave()自身其实被重写过一次。
2. 两种重写方法的选择
---------------------
“Weave重写”与“Hook重写”各有应用的场合。一般来说,Hook重写更简洁也更容易让人接受,因
为它毕竟是JS自身支持的一种重写方法。但是它存在一个致命的问题——改变了调用栈:
“Weave重写”的确没有这个问题,但它要求重写时对被重写代码有充分的了解——Hook重写则没
有这个要求。Weave重写至少需要了解被重写代码所在闭包的位置——全局的或局部的。这是因为
Weave重写后将产生一个函数,而这个函数(默认)是全局的,例如:
当你需要它是某个局部的函数时,你不得不重新创建一个(当前闭包内的)scope。例如:
由于对闭包位置有显性的要求,因此Weave()重写事实上并不太适合于函数内的重写——当然如
果你总是确知这些信息的话,又另当别论了。所以,Weave()重写通常只用在全局的(匿名或具名
的)函数中——能较为方便地控制闭包的位置。
3. 模拟形式参数表(arugments)的问题
---------------------
当然,我们可以随时通过apply/call方法来传递一个参数表。——尽管我们看起来也可以通过对
象闭包来模拟参数表中的形式参数,例如:
但其中的一个严重的问题是,在通过Block()构造的这个函数f()内部,使用arguments时并不能访
问到对象o中的成员——而在正常情况下,arugments与形式参数是存在对应关系的。所以事实上在
使用Scope()方法时,我们无法通过对象闭包来模拟参数表。
六、基本的元类声明,与元类系统的实现
---------------------
1、Meta.js中的元类系统声明
---------------------
QoBean声明了基本的元类系统,它的声明非常简单:
也就是说,对于QoBean来说,元类和元对象都是函数——按照前面所讲述的,也就是说是“执行
体”。QoBean规定了这些执行体的返回结果,也就是:
======
MetaClass()将返回一个类类型(函数),它声明了一个“基于类的对象系统”的组织形式;
MetaObject()将返回一个构造器函数,它可以放在TMyObject.Create成员中,用于构建一个对象实例。
======
Meta.js中,上述两个声明只是抽象声明,并没有实现,也没有描述任务逻辑细节。这也是元语言系
统的一个特点:元语言是最基底的声明、描述或实现。它约定了范围与边界,但不一定去直接实现它。
这有点像架构师的工作。呵呵。
2、Class.js中的实现
---------------------
Class.js中实现了一个类注册函数,用于将一个普通的函数注册为一个“类类型”,或者说它是通过
类注册的方式,构建了基于类的对象系统。
类注册函数为Class(),它描述了类注册以及从类构建一个对象实例的基本方法。包括四个主干步骤:
======
1、通过MetaClass()取得一个新的类,即cls = MetaClass(AConstructor);
2、设定原构造器的原型继承关系,即AConstructor.prototype = Parent.Create.prototype;
3、初始化类,即Initializtion(cls);
4、重写原来的构造器,即AConstructor = cls.Create
======
在第3步的初始化类过程中,存在四个小的分支步骤:
======
1、填写用于类系统识别的类信息;
2、从MetaObject()中取得一个元对象构造器到cls.Create,以支持“对象创建”的行为;
3、重写上述构造器cls.Create的prototype属性,以支持“对象继承”的能力;
4、重写上述prototype的constructor属性,以支持对象的“构造器(外部)链回溯”。
======
QoBean中的Class.js代码也很简单,就如下几行:
类注册过程的更多说明可以参见QoBean项目发起时的一篇文章:
http://blog.csdn.net/aimingoo/archive/2007/12/31/2006534.aspx
3、Object.js中的实现
---------------------
我们看到,Meta.js定义了元语言级别的“类、对象”的抽象,而Class.js中则描述了类和对象的
逻辑关系。然而MetaClass()和MetaObject()并没有具体的实现——也就是说,到现在为止我们得
到的仍然只是“具有逻辑关系的抽象系统”。我们必须要说明“实体系统是怎样的”,也就是要
说明“元类如何创建类、元对象如何创建对象(构造器)”。
而这部分就是在Object.js中实现的。其结果则是完成了全部的类系统,在装载完Object.js之后,
QoBean的类、类类型系统也就构建完成了,这个类类型的基本使用与Qomo历来的版本是完全一致
的。也就是下面的基本模式:
QoBean中的Object.js代码也很简单,就如下几行:
七、QoBean中,从元系统开始的系统结构栈
---------------------
QoBean的元系统只有Meta.js一个文件,约70行代码。
QoBean的基本对象系统需要载入(参考QoBean代码包中的t_Object.html):
Meta.js
Class.js
Object.js
后两个文件不超过30行代码。整个的基本语言系统在100行JS代码以内。
如果更加增强的、完整的QoBean类类型系统,需要按如下栈载入JS文件:
Meta.js
Class.js
Namespace.js
ObjectEx.js
TObject.js
通过这个代码栈,可以支持Qomo 2.0版本中的全部对象特性。包括get/setter,
以及Inherted继承,以及匿名类类型等。此外,通过TObject.js,支持了Txxxx
风格的类类型继承描述。这些内容,可以参考QoBean代码包中的:
t_ObjectEx.html
t_ObjectEx2.html
QoBean当前版本已经支持了Qomo 2.0底层中的全部语言特性,包括接口、切面等等。
这些完整的特性可以通过如下栈来装载:
<!-- Qomo V2版本的JS增强和(切面的)切点
../trunk/Framework/RTL/JSEnhance.js
../trunk/Framework/RTL/JoPoints.js
-->
Intfs/QomoIntfs.js
Intfs/Interface.js
Meta.js
Class.js
Namespace.js
ObjectEx.js
Intfs/ClassIntf.js
TObject.js
<!-- Qomo V2版本中的切面
../trunk/Framework/RTL/Aspect.js
-->
这个示例可以参考QoBean代码包中的:
t_ObjectEx3.html
QoBean内部版本已经可以完全使用QoBean来替代Qomo V2的语言内核了。通过实测,
上述的新的内核,比Qomo V2旧的版本减少了1/3的代码,且同时提高了1/3的执行
性能。所以,我们在这个节点上发布了QoBean Beta 1.0。
第二部分:元语言下的编程基本方法
------------------------------------------------------------------------
三、代码组织形式
---------------------
1. 物理代码块(代码文本、代码行)
---------------------
代码到底应该如何组织?如果我们认为代码是由序列调用的例程构成的,那么我们可以把代码的
形式回溯到很“远古”的时代,例如:
简单地说,就是我们可以通过函数来组织代码块,并通过函数的连续调用完成运算。那么,函数
又是如何“组织成代码块”的呢?
这个过程被分解为三个部分,也就是:
- body : 函数的代码体
- name : 函数名
- param : 函数参数表
其基本规则为:
QoBean中的Block()这个函数,用于从代码文本中分离上述三个部分。Block()可以处理任何一个
符合JavaScript语法的函数(的文本)。例如(param返回数组, 其它两种情况返回文本字符串):
Block的上述三种参数,用于获取一个函数(的文本格式)中三个部分的物理代码块。
2. 逻辑代码块(闭包、全局闭包)
---------------------
一个函数如果不是局部的,就是全局的。局部的,就是指被物理上包含在其它函数内部的函数。
基于这样的规则,显然一个(全局的)语句中包括的函数会是全局的(而非局部的)。例如:
由于逻辑代码块事实上就两种,因此Block()提供了两种方式来实现它:
这两种方式得到的新函数都以是func为参考的,也就是说复制了一个一模一样的函数——但改
变了它们的闭包作用域。如下例:
3. Scoped(),绑定到指定的作用域(全局或指定对象的闭包)
---------------------
原则上,Scope()的处理对象是函数,其结果或者是一个代码文本,或者是一个函数闭包。但如果
你试图将一个函数绑定到一个对象的闭包中,那么你需要用Scoped()这个函数,其含义是“作用
域化”。返回一个函数,该函数位于指定的对象或全局的闭包中。Scope()与Scoped()的区别在于:
- Scope()用于根据函数func,返回新函数(或用于eval()的函数文本);
- Scoped()用于将函数绑定到目标对象obj,返回绑定后的函数;
绑定到指定作用域是一个有趣的功能,例如:
四、重写的基础技术与思想
---------------------
1. 重写
---------------------
QoBean认为一个项目中的代码,是通过开发人员不断地在一个基础代码上繁殖衍生而得到的。这个所
谓的基础代码的最原始的、基底性的版本,就是下面这样一个函数:
其最终执行的方法为:
其繁殖衍生的过程就称为“重写”。例如:
2. JS中的重写方法
---------------------
JS中本身就具有多种重写的方法,例如编译期重写与执行期重写(注意,编译期的重写是由编译器根
据代码上下文中的标识符,及其出现的次序来决定的。它的效果不能由用户代码来改变):
3. 保留旧有代码的两种基本方法
---------------------
在执行期的重写中,可以保留旧有的代码。例如:
这种技术非常类似于桌面软件开发中的HOOK(钩子)技术,因此在这里我们将它使为“Hook重写”。
还有一种重写技术,也可以做到上述的“保留旧有代码”的效果。他利用了JS代码可以序列化的特性:
上述代码的基本思想在于通过"new Function()"来得到新的函数,而旧的函数被序列化为一个字符串,
作为新的代码的一部分。这个过程中,_r_codebody的作用是获取一个函数的body区——函数代码块。
从这个视角来看,下面的函数:
其实相当于如下代码重写过程(给一个空函数内部attach一行代码):
4. 通过链接代码来组织更大的代码块(或函数)
---------------------
源于函数可以被序列化的特性。attach_code()第二个参数的代码文本,也可以视为第一个函数的body
区。也就是说:
而从这里,我们也得到一个启发,如下代码:
其实执行效果相当于把func1()与func2()合并起来,而合并的效果也就是:
如果attach_func()函数可以联合足够多的函数,我们也就可以拼合足够多的代码块——并让他足够复杂。
attach_func()的实现思想与上述过程是直接相关的:
五、QoBean中的重写技术
---------------------
1. QoBean所面临的更复杂的问题
---------------------
QoBean提供了Block()函数来取得一个function中的各个部分,同时也提供了Scoped()函数来产生指定
闭包环境下的函数。这也就意味着,我们可以在任意位置,通过上述的方法来“重写出”一个新的函
数——这个函数是象打补丁的过程一样,一次次增量叠加起来的。
有趣的是,如同上面所分析的,QoBean认为开发人员在书写原始代码的过程中的行为,的确就是这样
一个过程:不断地改写一个函数代码块的内部,或创建新的函数代码块——然后连接它们。所以,我
们可以写出任意大的程序来,本质上也就是我们在不停地用Block、Scope、Scope、Block……
这个过程在QoBean来说,叫做“编织(weave)”。Weave()这个函数用于简化“不停地Block、Scope”
这一过程。该过程首先包括了一个简单的逻辑:
也就是说,你可以为任何一个函数使用Weave()功能,以使得它可以在指定位置“where”增加一段代
码。这个指定位置可以是一个正则表达式、或者一个字符串。所以上一小节中的例子可以这样实现:
同时,QoBean对这个过程进行了扩展,使得它可以支持:
- 在Weave()处理的函数中,支持函数形式参数;
- 在代码中可以使用'$&'等正则表达式中允许的替换匹配。
这个过程,通过Weave()函数自身的一些编织过程来实现——也就是Weave()自身其实被重写过一次。
2. 两种重写方法的选择
---------------------
“Weave重写”与“Hook重写”各有应用的场合。一般来说,Hook重写更简洁也更容易让人接受,因
为它毕竟是JS自身支持的一种重写方法。但是它存在一个致命的问题——改变了调用栈:
“Weave重写”的确没有这个问题,但它要求重写时对被重写代码有充分的了解——Hook重写则没
有这个要求。Weave重写至少需要了解被重写代码所在闭包的位置——全局的或局部的。这是因为
Weave重写后将产生一个函数,而这个函数(默认)是全局的,例如:
当你需要它是某个局部的函数时,你不得不重新创建一个(当前闭包内的)scope。例如:
由于对闭包位置有显性的要求,因此Weave()重写事实上并不太适合于函数内的重写——当然如
果你总是确知这些信息的话,又另当别论了。所以,Weave()重写通常只用在全局的(匿名或具名
的)函数中——能较为方便地控制闭包的位置。
3. 模拟形式参数表(arugments)的问题
---------------------
当然,我们可以随时通过apply/call方法来传递一个参数表。——尽管我们看起来也可以通过对
象闭包来模拟参数表中的形式参数,例如:
但其中的一个严重的问题是,在通过Block()构造的这个函数f()内部,使用arguments时并不能访
问到对象o中的成员——而在正常情况下,arugments与形式参数是存在对应关系的。所以事实上在
使用Scope()方法时,我们无法通过对象闭包来模拟参数表。
六、基本的元类声明,与元类系统的实现
---------------------
1、Meta.js中的元类系统声明
---------------------
QoBean声明了基本的元类系统,它的声明非常简单:
也就是说,对于QoBean来说,元类和元对象都是函数——按照前面所讲述的,也就是说是“执行
体”。QoBean规定了这些执行体的返回结果,也就是:
======
MetaClass()将返回一个类类型(函数),它声明了一个“基于类的对象系统”的组织形式;
MetaObject()将返回一个构造器函数,它可以放在TMyObject.Create成员中,用于构建一个对象实例。
======
Meta.js中,上述两个声明只是抽象声明,并没有实现,也没有描述任务逻辑细节。这也是元语言系
统的一个特点:元语言是最基底的声明、描述或实现。它约定了范围与边界,但不一定去直接实现它。
这有点像架构师的工作。呵呵。
2、Class.js中的实现
---------------------
Class.js中实现了一个类注册函数,用于将一个普通的函数注册为一个“类类型”,或者说它是通过
类注册的方式,构建了基于类的对象系统。
类注册函数为Class(),它描述了类注册以及从类构建一个对象实例的基本方法。包括四个主干步骤:
======
1、通过MetaClass()取得一个新的类,即cls = MetaClass(AConstructor);
2、设定原构造器的原型继承关系,即AConstructor.prototype = Parent.Create.prototype;
3、初始化类,即Initializtion(cls);
4、重写原来的构造器,即AConstructor = cls.Create
======
在第3步的初始化类过程中,存在四个小的分支步骤:
======
1、填写用于类系统识别的类信息;
2、从MetaObject()中取得一个元对象构造器到cls.Create,以支持“对象创建”的行为;
3、重写上述构造器cls.Create的prototype属性,以支持“对象继承”的能力;
4、重写上述prototype的constructor属性,以支持对象的“构造器(外部)链回溯”。
======
QoBean中的Class.js代码也很简单,就如下几行:
类注册过程的更多说明可以参见QoBean项目发起时的一篇文章:
http://blog.csdn.net/aimingoo/archive/2007/12/31/2006534.aspx
3、Object.js中的实现
---------------------
我们看到,Meta.js定义了元语言级别的“类、对象”的抽象,而Class.js中则描述了类和对象的
逻辑关系。然而MetaClass()和MetaObject()并没有具体的实现——也就是说,到现在为止我们得
到的仍然只是“具有逻辑关系的抽象系统”。我们必须要说明“实体系统是怎样的”,也就是要
说明“元类如何创建类、元对象如何创建对象(构造器)”。
而这部分就是在Object.js中实现的。其结果则是完成了全部的类系统,在装载完Object.js之后,
QoBean的类、类类型系统也就构建完成了,这个类类型的基本使用与Qomo历来的版本是完全一致
的。也就是下面的基本模式:
QoBean中的Object.js代码也很简单,就如下几行:
七、QoBean中,从元系统开始的系统结构栈
---------------------
QoBean的元系统只有Meta.js一个文件,约70行代码。
QoBean的基本对象系统需要载入(参考QoBean代码包中的t_Object.html):
Meta.js
Class.js
Object.js
后两个文件不超过30行代码。整个的基本语言系统在100行JS代码以内。
如果更加增强的、完整的QoBean类类型系统,需要按如下栈载入JS文件:
Meta.js
Class.js
Namespace.js
ObjectEx.js
TObject.js
通过这个代码栈,可以支持Qomo 2.0版本中的全部对象特性。包括get/setter,
以及Inherted继承,以及匿名类类型等。此外,通过TObject.js,支持了Txxxx
风格的类类型继承描述。这些内容,可以参考QoBean代码包中的:
t_ObjectEx.html
t_ObjectEx2.html
QoBean当前版本已经支持了Qomo 2.0底层中的全部语言特性,包括接口、切面等等。
这些完整的特性可以通过如下栈来装载:
<!-- Qomo V2版本的JS增强和(切面的)切点
../trunk/Framework/RTL/JSEnhance.js
../trunk/Framework/RTL/JoPoints.js
-->
Intfs/QomoIntfs.js
Intfs/Interface.js
Meta.js
Class.js
Namespace.js
ObjectEx.js
Intfs/ClassIntf.js
TObject.js
<!-- Qomo V2版本中的切面
../trunk/Framework/RTL/Aspect.js
-->
这个示例可以参考QoBean代码包中的:
t_ObjectEx3.html
QoBean内部版本已经可以完全使用QoBean来替代Qomo V2的语言内核了。通过实测,
上述的新的内核,比Qomo V2旧的版本减少了1/3的代码,且同时提高了1/3的执行
性能。所以,我们在这个节点上发布了QoBean Beta 1.0。