ActionScript高级技巧－－深入了解Function

Function究竟是什么？
我们习惯了function的存在，就像习惯了我们呼吸的空气却不去探究它的本质。看起来，似乎function和Number, Boolean, String一样都是ActionScript本来就有的类型

先看以下代码：

trace (aFunc);                     // 输出：[type Function]
trace (aFunc instanceof Function);  // 输出：true
trace (aFunc instanceof Object);     // 输出：true

function aFunc() {
  trace (“This  is  aFunc!Excuted!”);
}

第一行告诉我们aFunc的类型是Function, 第二行又证实了这一点aFunc确实是一个Function类型的实例，第三行更加有意思告诉我们aFunc是一个Object。

初学者可能很惊奇，其实AS2.0中除了原始数据类型Number, Boolean, String，undefined, null，其余全是Object. 而AS3.0中则更加极端，一切皆对象。包括原始数据类型也是Object,只不过是特殊的不变对象(immutable objects)类型。与主题扯远了，打住。
Function本质上到底是怎样的一种Object?
与其他编程语言不同，在AS中， Function是一个Object，可以有独立的属性甚至方法。比如arguments，callee,caller。在AS3.0中，Function还由更多的属性。
函数一旦执行，一个特殊的对象就建立了。我们称它为"active object"，它含有以上的属性和本地变量。这个对象我们是不可访问的，属于内建的机制。同时，每个Function都含有一个内置的范围链(scope chain)，这时也将被建立，以使Flash Player来检查所有的声明。函数可以层层嵌套，范围链也是如此。最大的范围链那当然是Global函数的范围链了，包括所有的全局变量和函数。


知道了Function 是Object又怎样？
会给我们带来极大的便利和编程思维的改变：
运用一：这是简单运用， 设立一个代理函数对象，根据条件的不同，将它指向不同的函数，实现动态改变。相信有经验的程序员都了解动态改变函数的便利性。而且由于AS提供了这种便利，运用这个特性可以衍生大量技巧。

var kingdaFunc:Function;
var sex:String  =   " male " ;
if  ( sex  ==   " male " ) {
    kingdaFunc  =  maleFunc;
}  else  {
    kingdaFunc  =  femailFunc;
}
kingdaFunc();   // 输出: I am a boy

function maleFunc() {
    trace ( " I am a boy " );
}
function femaleFunc() {
    trace ( " I am a girl " );
}

运用二：建立函数执行队列。
比如说，我有一个对象，我想根据不同的情况对它进行一系列的操作。但是有时需要所有的操作，有时又只需要一部分的操作。那么这个较高级的技巧，就能保证代码的高度重用性和简洁。

var funcAry:Array  =  new Array(); 

// 将需要的操作步骤加入队列
funcAry.push(aFunc);
funcAry.push(bFunc);
funcAry.push(cFunc);

// 供操作的对象
var originObject:Object  =  new Object();

// 需要执行几步由execQueue这个参数决定，在实际工程运用中这个数可能是动态决定的。
var execQueue:Number  =  funcAry.length;

/ 核心步骤： / 函数队列执行。实际运用中可以把它包装成一个函数，或者一个类的实例。
for  (var i:Number  = 0; i < execQueue; i ++ ) {
    funcAry[i](originObject);
}

// trace出执行操作后的originObject里面的内容
for  (var i  in  originObject) {
    trace ( i  +   " : "   +  originObject[i]);
}

// 操作步骤a,b,c
function aFunc(eO:Object) {
    eO.aFuncExected  =  true;
    trace ( " aFunc() " );
}
function bFunc(eO:Object) {
    eO.bFuncExected  =  true;
    trace ( " bFunc() " );
}
function cFunc(eO:Object) {
    eO.cFuncExected  =  true;
    trace ( " cFunc() " );
}

输出内容为：

aFunc()
bFunc()
cFunc()
cFuncExected:true
bFuncExected:true
aFuncExected:true

前三行表明a,b,c三个函数按顺序执行了。后三行表明orginObject确实经过了三步操作，多了三个为true的属性。

黑羽提醒：技巧可以再延深！
可以通过一个函数来管理队列里面各个元素的位置，达到改变操作函数的顺序。比如通过一个数组来安排调用顺序

var operationAry:Array  =  [ 2 , 1 ,0]
for (var i:Number  =  0; i < operationAry.length; i  ++ ) {
    funcAry[operationAry[i]](originObject);
}

这样函数就通过2,1,0这样的倒序来执行操作。

这个技巧还有很多可以延伸的地方，比如说动态控制操作函数的参数等等，供大家自己研究扩展。
（未完，继续更新中，下一节介绍Function更深层次的运用：动态属性的运用）


下接续，我直接收集放在下面：

呵呵，上篇帖子大家反映不错，短短几天被几家网站转载。
废话少说，这次继续上次话题。看看人气情况，如果大家喜欢我这个高级技巧专题，那么日后会陆续发布一些我自己这几年来项目开发笔记中的实用技巧。


利用函数返回函数：
有一个proxyObject对象，我们希望根据proxy对象的内容来确定一个方法，来处理myObject对象。
当proxyObject是字符串时，我们又希望根据它字符串的内容来确定返回不同的函数(或方法)。这些函数参数和类型是不完全相同的，有的可能是一个参数，有的可能是多个参数，不同类型。
那么传统的解决方法：在函数内部调用其他函数就显得力不从心。即使解决，也不如我下面chooseFuncBy()这个函数简洁。
缺点当然有，那就是比较灵活，你一定要清楚管理好每个目标函数和判断逻辑。因为这种灵活的编程方式编译器是无法检查，不能查出类型不匹配这种错误的。菜鸟慎用。

// 通过A调用只有一个参数的aFunc():
chooseFuncBy( " A " )( " A func has only one parameter. " );
// 输出：aFunc():A func has only one parameter.

// 通过B调用有两个参数的bFunc():
chooseFuncBy( " B " )( " B func has two parameters. " , " No.2 parameter " );
// 输出：bFunc():B func has two parameters.  one more Parameter:No. 2  parameter

// 字符串不符，默认函数
chooseFuncBy( " wu lala " )( " I choose A function " );
// 输出：Welcome to Kingda.org! My blog

var withObj:Object  =  new Object();
var myObj:Object  =  {name: " 黑羽 " , blog: " http;//www.kingda.org " , hobby: " Starcraft " };
chooseFuncBy(withObj)(myObj);
/*  输出：
objectFunc():
name:黑羽
blog:http; // www.kingda.org
hobby:Starcraft
*/


function chooseFuncBy(inputString):Function {
    
     // 运用一：利用参数的种类来确定返回的函数
     if  (!(typeof(inputString)  ==   " string " )) {
         return  objectFunc;
    }
    
     // 运用二：根据参数内容来返回函数
    switch (inputString) {
        case  " A " :
             return  aFunc;
        case  " B " :
             return  bFunc;    
        default:
             return  kingdaFunc;
    }
     // 更多延伸运用：利用参数个数、instanceof确定不同Class的实例来选择函数等等
}

function aFunc(nS:String):Void {
    trace ( " aFunc(): "   +  nS);    
}

function bFunc(nS:String, nP:String):Void {
    trace ( " bFunc(): "   +  nS  +   "   one more Parameter: " +  nP);    
}

function kingdaFunc():Void {
    trace ( " Welcome to Kingda.org! My blog " );
}

function objectFunc(kingdaObj:Object):Void {
    trace ( " objectFunc(): " );
     for  (var i  in  kingdaObj) {
        trace ( i  +   " : "   +  kingdaObj[i]);
    }
}

如上次所说，函数也是一个Object，不仅如此，函数Object也可以动态添加属性和方法。
函数动态添加属性

运用一：利用函数动态属性来计算函数调用次数
当然你完全可以用这个技巧来干更多更有用的事，我只是抛砖引玉开个头。 ：）

一个游戏中有开火函数shot()。我想知道总共开火了多少次，那么可以使用shot函数的属性times。

总的来说，对于AS2.0来说，这是一个不太好的编程习惯，虽然很方便。但由于动态属性的使用使得编译器无法进行类型检查，也使的大项目的犯错可能性增加。
对于AS1.0来说，与其使用Global变量，如_root, _level1，那么我宁愿建议你使用这个编程技巧。总比Global变量来的安全，不易产生冲突和蛛网效应。

注意，引用shot函数动态属性时，在函数内不能使用this.times，那不会指向函数本身的属性。只能使用函数名加属性，例: shot.times

shot.times  =  0;   // 初始化times
shot(); // 输出：Shot(): times: 1
shot(); // 输出：Shot(): times: 2
shot(); // 输出：Shot(): times: 3

function shot():Void {
    shot.times  ++ ;
    trace ( " Shot(): times: " +  shot.times);    
     // shot的其他代码放在这儿
}

函数对象动态添加方法
对了，更有趣的就是添加方法了。
函数这么一摆弄之后，Function对象成了二不像：不像普通类实例，也不像一个函数。这个技巧可以让我们的函数变得很强大，也会让它更复杂难以管理。
双刃剑阿，自己掂量着办吧。
我的建议是AS1.0可以稍多一点借鉴这个技巧，AS2.0用户应当尽量使用标准解决方式。在小的范围内可以为了方便而运用，绝不赞成大范围大规模的使用。

shot.times  =  0;
shot.reload  =  function () {
        trace ( " reload： " +  this.times );
         if  (this.times  > 3 ) {
            this.times  =  0;
        }
    }
shot.reload();

shot();
shot();
shot();
shot();
shot();
shot();

function shot():Void {
    shot.times  ++ ;
    trace ( " Shot(): times: " +  shot.times);    
    shot.reload();
     // shot的其他代码放在这儿
}
/* 输出：
reload：0
Shot(): times: 1
reload： 1
Shot(): times: 2
reload： 2
Shot(): times: 3
reload： 3
Shot(): times: 4
reload： 4
Shot(): times: 1
reload： 1
Shot(): times: 2
reload： 2
*/

写在篇尾的话：
可以看出，运用动态添加属性和方法的技巧，可以使Function这个特殊的东西异常强大起来。而且其灵活程度更是空前，试想如果动态添加的方法可以返回函数（见第一个技巧）。不要忘了，动态添加的方法可以直接访问函数的输入参数，那么其衍生的技巧又有多少种呢？函数又可以变成怎样的一种强有力的编程对象呢？
只有想不到，没有做不到。这就是Function给我们展示的无穷灵活性。
但是，我还是要说，技巧终归是技巧，它有其两面性。灵活是它的优点，也是它的缺点。小范围的运用让你爽快无比；大项目中大范围的使用，除非你管理的很好，不然会让你头疼欲裂死而后快。
通读AS2.0所有公开的类的代码后，你会发现Macromedia的程序员也使用了上述的技巧。只要管理的好，这绝对是ActionScript的优点所在。
AS2.0 coder们，欢喜之余，慎之又慎！


（全文完）

P.S 有人问我为什么不写写argument, callee, caller等方面的技巧，我的想法是这些在帮助中写的很清楚，大家可以自己看。而这些相关的技巧，文章已经有不少，看看其普及程度已经不能算高级技巧了，所以不再赘述！ ^_^

转载于:https://www.cnblogs.com/savageworld/archive/2006/07/21/456396.html