QoBean的元语言系统（二）

------------------------------------------------------------------------

第二部分：元语言下的编程基本方法

------------------------------------------------------------------------


 三、代码组织形式
---------------------
  1. 物理代码块(代码文本、代码行)
  ---------------------
代码到底应该如何组织？如果我们认为代码是由序列调用的例程构成的，那么我们可以把代码的
形式回溯到很“远古”的时代，例如：
====== function func1() { } function func2() { } function main() { func1(); func2(); } main(); ======<PRE>
简单地说，就是我们可以通过函数来组织代码块，并通过函数的连续调用完成运算。那么，函数
又是如何“组织成代码块”的呢？

这个过程被分解为三个部分，也就是：
  - body : 函数的代码体
  - name : 函数名
  - param : 函数参数表
其基本规则为：
====== function [name]([param]) { } ======<PRE>

QoBean中的Block()这个函数，用于从代码文本中分离上述三个部分。Block()可以处理任何一个
符合JavaScript语法的函数(的文本)。例如(param返回数组, 其它两种情况返回文本字符串)：
====== function foo(a,b,c) { // .. } alert( Block(foo, 'body') ); alert( Block(foo, 'name') ); alert( Block(foo, 'param') ); // 返回一个数组，可以直接用作字符串连接 ======<PRE>

Block的上述三种参数，用于获取一个函数（的文本格式）中三个部分的物理代码块。

  2. 逻辑代码块(闭包、全局闭包)
  ---------------------
一个函数如果不是局部的，就是全局的。局部的，就是指被物理上包含在其它函数内部的函数。
基于这样的规则，显然一个(全局的)语句中包括的函数会是全局的（而非局部的）。例如：
====== if (true) { // 下面的函数是全局的(或属于外一层函数闭包) function() { // ... } } ======<PRE>
由于逻辑代码块事实上就两种，因此Block()提供了两种方式来实现它：
====== // 得到一个匿名的全局函数 f1 = Scope(func, 'anonymous'); // 得到一个匿名的局部函数(在当前闭包内) f2 = eval( Scope(func, 'scope') ); ======<PRE>
这两种方式得到的新函数都以是func为参考的，也就是说复制了一个一模一样的函数——但改
变了它们的闭包作用域。如下例：
====== var msg = 'in global.'; var ff = function() { var msg = 'in ff.'; return function() { alert(msg); } }() // show 'in ff.' ff(); function myFunc() { var msg = 'in myFunc.'; // show 'in myFunc'; var f = eval( Scope(ff, 'scope') ); f(); // show 'in global.' var f = Scope(ff, 'anonymous'); f(); } // test myFunc(); ======<PRE>

  3. Scoped()，绑定到指定的作用域（全局或指定对象的闭包)
  ---------------------
原则上，Scope()的处理对象是函数，其结果或者是一个代码文本，或者是一个函数闭包。但如果
你试图将一个函数绑定到一个对象的闭包中，那么你需要用Scoped()这个函数，其含义是“作用
域化”。返回一个函数，该函数位于指定的对象或全局的闭包中。Scope()与Scoped()的区别在于：
　- Scope()用于根据函数func，返回新函数(或用于eval()的函数文本)；
   - Scoped()用于将函数绑定到目标对象obj，返回绑定后的函数；

绑定到指定作用域是一个有趣的功能，例如：
====== var aData = 'global data'; var obj = { aData: 'object data' } myFunc = function() { alert(aData); } myFunc2 = Scoped(obj, myFunc); myFunc(); // show: 'global data'; myFunc2(); // show: 'object data'; ======<PRE>


四、重写的基础技术与思想
---------------------
  1. 重写
  ---------------------
QoBean认为一个项目中的代码，是通过开发人员不断地在一个基础代码上繁殖衍生而得到的。这个所
谓的基础代码的最原始的、基底性的版本，就是下面这样一个函数：
====== function() { } ======<PRE>
其最终执行的方法为：
====== void function() { }(); ======<PRE>
其繁殖衍生的过程就称为“重写”。例如：
====== // 原始版本 x = function() { } // 重写1 old_x = x; x = function() { old_x(); ... } // 重写2 old_x = x; x = function() { ... old_x(); } ... // 执行 void x(); ======<PRE>

  2. JS中的重写方法
  ---------------------
JS中本身就具有多种重写的方法，例如编译期重写与执行期重写（注意，编译期的重写是由编译器根
据代码上下文中的标识符，及其出现的次序来决定的。它的效果不能由用户代码来改变)：
====== function func() { } // 下面的重新声明，其“重写”效果是在编译期发生的 function func() { } // 下面的赋值操作，是一种在执行期发生的“重写”效果 func = function() { } ====== <PRE>
  3. 保留旧有代码的两种基本方法
  ---------------------
在执行期的重写中，可以保留旧有的代码。例如：
====== func = function(foo) { //<-- 2. 使用形式参数foo来持有旧的函数 return function() { //<-- 3. 返回的匿名函数将重写func()，且仍可以通过foo来访问旧函数 // ... } }(func); //<-- 1. 传入旧的func函数引用 ======<PRE>
这种技术非常类似于桌面软件开发中的HOOK(钩子)技术，因此在这里我们将它使为“Hook重写”。

还有一种重写技术，也可以做到上述的“保留旧有代码”的效果。他利用了JS代码可以序列化的特性：
====== function attach_code(func, code) { var _r_codebody = /[^{]*/{([/d/D]*)/}$/; func = func.toString().replace(_r_codebody, '$1') return new Function(func + code); } func = attach_code(func, '...'); ======<PRE>
上述代码的基本思想在于通过"new Function()"来得到新的函数，而旧的函数被序列化为一个字符串，
作为新的代码的一部分。这个过程中，_r_codebody的作用是获取一个函数的body区——函数代码块。
从这个视角来看，下面的函数：
====== function hi() { alert('hi'); } ======<PRE>
其实相当于如下代码重写过程（给一个空函数内部attach一行代码)：
====== hi = new Function; hi = attach_code(hi, "alert('hi');"); ======<PRE>

  4. 通过链接代码来组织更大的代码块(或函数)
  ---------------------
源于函数可以被序列化的特性。attach_code()第二个参数的代码文本，也可以视为第一个函数的body
区。也就是说：
====== a_func = function() { //... }; hi = attach_code(hi, _get_code_body(a_func)); ======<PRE>

而从这里，我们也得到一个启发，如下代码：
====== function func1() { // func1 ... } function func2() { // func2 ... } func1(); func2(); ======<PRE>
其实执行效果相当于把func1()与func2()合并起来，而合并的效果也就是：
====== func = func1 + func2; // <-- attach_func(func1, func2); func(); ======<PRE>
如果attach_func()函数可以联合足够多的函数，我们也就可以拼合足够多的代码块——并让他足够复杂。

attach_func()的实现思想与上述过程是直接相关的：
====== function getCodeBody(func) { var _r_codebody = /[^{]*/{([/d/D]*)/}$/; return func.toString().replace(_r_codebody, '$1') } function attach_code(f1, f2) { return getCodeBody(f1) + (f2 ? attach_code.apply(null, [].slice.call(arguments, 1)) : ''); } function attach_func() { return new Function(attach_code.apply(null, arguments)); } // sample func = attach_func(func1, func2); alert(func); ======<PRE>

五、QoBean中的重写技术
---------------------

  1. QoBean所面临的更复杂的问题
  ---------------------
QoBean提供了Block()函数来取得一个function中的各个部分，同时也提供了Scoped()函数来产生指定
闭包环境下的函数。这也就意味着，我们可以在任意位置，通过上述的方法来“重写出”一个新的函
数——这个函数是象打补丁的过程一样，一次次增量叠加起来的。

有趣的是，如同上面所分析的，QoBean认为开发人员在书写原始代码的过程中的行为，的确就是这样
一个过程：不断地改写一个函数代码块的内部，或创建新的函数代码块——然后连接它们。所以，我
们可以写出任意大的程序来，本质上也就是我们在不停地用Block、Scope、Scope、Block……

这个过程在QoBean来说，叫做“编织(weave)”。Weave()这个函数用于简化“不停地Block、Scope”
这一过程。该过程首先包括了一个简单的逻辑：
====== function Weave(where, code) { var source = Block(this); code = source.replace(where, code); return Function.apply(null, Block(this, 'param').concat(code)); } ======<PRE>
也就是说，你可以为任何一个函数使用Weave()功能，以使得它可以在指定位置“where”增加一段代
码。这个指定位置可以是一个正则表达式、或者一个字符串。所以上一小节中的例子可以这样实现：
====== func = Weave.call(func1, /$/, Block(func2, 'body')); alert(func); ======<PRE>

同时，QoBean对这个过程进行了扩展，使得它可以支持：
  - 在Weave()处理的函数中，支持函数形式参数；
  - 在代码中可以使用'$&'等正则表达式中允许的替换匹配。
这个过程，通过Weave()函数自身的一些编织过程来实现——也就是Weave()自身其实被重写过一次。

  2. 两种重写方法的选择
  ---------------------
“Weave重写”与“Hook重写”各有应用的场合。一般来说，Hook重写更简洁也更容易让人接受，因
为它毕竟是JS自身支持的一种重写方法。但是它存在一个致命的问题——改变了调用栈：
====== function func() { f(); } function f() { alert(arguments.callee.caller); //显示调用栈上的函数 } // 1. 正常情况：显示调用者函数func() func(); // 重写1次 f = function(foo) { return function() { return foo.apply(this, arguments); } }(f); /* 重写n次 f = function(foo) { ... }(f); */ // 2. 异常情况：重写后，显示Hook程序，而不是调用者函数func() func(); ====== <PRE>
“Weave重写”的确没有这个问题，但它要求重写时对被重写代码有充分的了解——Hook重写则没
有这个要求。Weave重写至少需要了解被重写代码所在闭包的位置——全局的或局部的。这是因为
Weave重写后将产生一个函数，而这个函数（默认）是全局的，例如：
====== f = 'global'; function X() { var f = function() { }; f = Weave.call(f, /$/, 'alert(f)'); f(); } X(); ======<PRE>
当你需要它是某个局部的函数时，你不得不重新创建一个（当前闭包内的）scope。例如：
====== f = 'global'; function X() { var f = function() { }; f = eval(Block(Weave.call(f, /$/, 'alert(f)'), 'scope')); f(); } X(); ======<PRE>

由于对闭包位置有显性的要求，因此Weave()重写事实上并不太适合于函数内的重写——当然如
果你总是确知这些信息的话，又另当别论了。所以，Weave()重写通常只用在全局的(匿名或具名
的)函数中——能较为方便地控制闭包的位置。

  3. 模拟形式参数表(arugments)的问题
  ---------------------
当然，我们可以随时通过apply/call方法来传递一个参数表。——尽管我们看起来也可以通过对
象闭包来模拟参数表中的形式参数，例如：
====== function func(x, y) { alert(x + y) } o = {x:100, y:100}; f = new Function(Block(func, 'body')); func = Scope(o, f); func(); ======<PRE>
但其中的一个严重的问题是，在通过Block()构造的这个函数f()内部，使用arguments时并不能访
问到对象o中的成员——而在正常情况下，arugments与形式参数是存在对应关系的。所以事实上在
使用Scope()方法时，我们无法通过对象闭包来模拟参数表。


六、基本的元类声明，与元类系统的实现
---------------------
  1、Meta.js中的元类系统声明
  ---------------------
QoBean声明了基本的元类系统，它的声明非常简单：
====== // Constructors-Meta, return TMyObject.Create. It's abstracted define. MetaObject = Function; // Classes-Meta, return TMyObject. It's abstracted define. MetaClass = Function; ======<PRE>
也就是说，对于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代码也很简单，就如下几行：
====== // class register util function Class(Parent, Name) { var Constructor = eval(Name); var cls = new MetaClass(Constructor); // parent-class link and prototype set. Parent && (Constructor.prototype = Parent.Create.prototype); // the qomo classes system. // Initializtion --> ((Constructor = cls(Constructor), // step one cls.Create = new MetaObject(cls) // step two ).prototype = Constructor // step three ).constructor = cls.Create; // step four // rewrite constructor by 'Name' (Name instanceof Function) || eval(Name + '= cls.Create'); return cls; } ======<PRE>
类注册过程的更多说明可以参见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历来的版本是完全一致
的。也就是下面的基本模式：
====== // 声明(类似普通构造器函数) function MyObject() { } // 注册 TMyObject = Class(TObject, 'MyObject'); // 使用 obj = TMyObject.Create(); // or obj = new MyObject(); ======<PRE>

QoBean中的Object.js代码也很简单，就如下几行：
====== // rewrite meta system MetaClass = Meta(function(fromSource) { return new Function('Base', 'return new Base'); }, MetaClass); MetaObject = Meta(function(fromSource) { var atom = {}; return function() { if (this instanceof Function) return new arguments.callee(atom, arguments); if (this.Create) this.Create.apply(this, arguments[0]===atom ? arguments[1] : arguments); } }, MetaObject); ======<PRE>


七、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。