(仅供参考)ActionScript 3.0之函数

ActionScript 3.0之函数
首先声明这不是我原创的教程。

以下内容来源于《殿堂之路》、官方帮助文档以及网上其他老师的教程，在此我只是根据我学习过程中对函数的理解加以归纳和整理，很多例子和解释文字都是对其他老师的代码和文字进行了原文的引用，在些也感谢黑羽老师及其它网络上的老师为 flash 动画所做出的贡献。

首先我们来看一个最简单的函数：
function greet():void {
trace("Hello!How are you?");
}
函数是什么？《殿堂之路》给出这样的解释：函数从外观上看，是一个语句块，包含着至少一条或数条语句；从逻辑上看，它是可以执行某个目标任务的代码块。

它可以接受外部传入的对象或值，还可以返回操作的结果。

函数（Function）的准确定义是：函数是执行特定任务并可以在程序中重用的代码块。

ActionScript3.0中函数为分两类：方法（Method）和函数闭包（Function closures）。

将函数称为方法还是函数闭包取决于定义函数的上下文。

如果您将函数定义为类定义的一部分或者将它附加到对象的实例，则该函数称为方法。

如果您以其它任何方式定义函数，则该函数称为函数闭包。

通过使用函数，就可以创建可重用的代码、可读的代码、灵巧的代码。

有了函数，就可以写出有效的、结构精巧的、维护得很好的代码，而不是冗长的、笨拙的代码。

一、理解用函数进行编程
函数是一种革新。

写代码没有函数，就像出版图书没有印刷机，出版业是如此没有生产力，如此没产量。

有了印刷机，只制一次版，就可以从那个版复制出许多副本了。

印刷机是一种革新。

同样地，如果编程序没有函数，就不得不一次一次地写出代码的每一行。

但是，当写出一个函数时，就可以将多条语句封装在一起，就可以重复地调用那个函数，而不用重复写相同的代码了，那就巧妙多了。

函数是一种组织起一个代码块的方法，该代码块直到从其主流程中调用(直接地或间接地)时才执行。

换句话说，函数是一种将调用时才执行(不调用不执行)某
个特殊任务的代码块包装在一起的方法。

函数比非结构化编程更具优势。

这些优势包括：
(1) 通过消除混乱和冗余的代码，使代码更具有可读性。

(2) 通过重复使用函数而不是每次重复输入整个代码块，使程序更加有效率。

(3) 函数成为了AS进行修改的中心点。

在函数中做个修改，该修改就能被应用到每个调用该函数的实例中。

(4) 编写成熟的函数可以在许多程序中重复使用。

因此，可以开发出一个可被用于建立各种程序的函数库，而不需要每次从打草稿开始写脚本。

(5) 包装在一个函数中的代码提供了进行用户交互的基础。

如果没有函数，应用程序就像一个单独的程序那样运行。

有了函数，一个用户发起的动作就可以调用一个函数。

二、调用函数
我们将术语“函数”定义为延迟执行的代码块。

这就是说，一个函数可以被定义，但直到访问或调用它之前什么也不会发生。

可以自己测试一下这一点，即在主时间轴的第1帧中，用如下代码创建一个新的Flash影片：
function greeting():void {
trace("Hello!How are you?");
}
当测试该影片时会看到，尽管在代码中有一个 trace() 动作，但什么也没发生。

为了调用一个函数，需要使用该函数的名字，并后跟一个圆括号(它被称为“函数调用运算符”)。

当调用一个函数时，对函数的调用本身就是一个语句。

因此，应该在该语句的后面使用一个分号。

下面的例子定义了一个函数，然后调用它。

如果想自己学习和测试它，只需将该代码放置在主时间轴的第1帧即可。

function greeting():void {
trace("Hello!How are you?");
}
greeting();//调用函数
当测试该影片时，在Output窗口中显示如下内容：
Hello!How are you?
要发送给函数的任何函数参数都括在小括号中。

例如，我们经常用到的trace() 函数，它是 Flash中的顶级函数：
trace("Use trace to help debug your script");
如果要调用没有参数的函数，则必须使用一对空的小括号。

例如，可以使用没有参数的 Math.random() 方法来生成一个随机数：
var randomNum:Number = Math.random();
三、定义自定义函数
现在，需要学习如何来写函数。

写一个函数也被称为“定义”或“声明”一个函数。

函数有两种定义方式。

一种是我们非常熟悉的函数语句定义法（Function statement）；另一种是ActionScript特有的函数表达式定义法(Function expression)。

(1)、首先我们来看一下函数语句定义法：
function 函数名(参数1:参数类型,参数2:参数类型,……):返回数据类型{ //函数体
}
例子：定义一个加法函数
function addition(a:int,b:int):int {
return a + b;
}
trace(addition(2,7));
在函数的语法中，要注意如下几个关键点：
◆function关键字告诉Flash，正在声明一个函数。

当定义一个函数时，必须像上面那样包括function关键字。

◆函数应该遵守变量的命名规则。

就像命名变量那样，给函数取一个能表示其功能的名字是一个好做法。

◆所有函数的定义都必须在函数名字后面包括一对圆括号。

在圆括号中的“参数”可以没有。

在后面我们会讲到有关参数的更详细的内容。

但是，无论一个函数是
否定义了参数，都必须在定义中包括一对圆括号。

◆圆括号后面接着就是冒号和一个有效的数据类型名字。

数据类型是函数将返回的数据的类型。

在后面会讲到如何返回数据。

使用void表示该函数不返回值。

◆函数体是由一对开始和结束波浪式大括号({})定义的。

(2)、接着我们再来看一下函数表达式定义法：
函数表达式定义法是ActionScript特有的一各定义方式。

定义格式如下：
var 函数名:Function=function(参数1:参数类型,参数2:参数类型,……): 返回数据类型{
//函数体
}
注意：“＝”号右边的内容 function 后面没有跟随函数名，这相当于创建了一个匿名函数对象，并将引用赋值给了左边的函数型变量。

这种方法经常被中、高级编程人员使用，对于初学者掌握住第一种方法就可以了。

例子：
var addition:Function=function(a:int,b:int):int {
return a+b
};
trace(addition(13,67))
平时，应当尽量使用函数语句定义法，这种方法更加标准，也更加简捷。

区别：函数表达式定义法需要先定义、后调用；函数语句定义法可以先调用，后定义。

函数语句定义法定义的函数在编译时会被提升到最前面，而函数表达式定义法只能先定义再使用，只有定义后面的语句才可以成功调用。

例子：
test1();//将这一行移以最后面就能编译成功
test2();
var test1:Function=function():void{
trace("这是函数表达式定义法！")
};
function test2():void {
trace("这是函数语句定义法！");
}
函数表达式是表达式，而不是语句。

这意味着函数表达式不能独立存在，而函数语句则可以。

函数表达式只能用作语句（通常是赋值语句）的一部分。

下面的例子显示了一个赋予数组元素的函数表达式：
var myArray:Array=new Array();
myArray[0]=function(string:String){
trace(string)
};
myArray[0]("My God");
除此之外，函数语句定义法和函数表达式定义法还体现在函数体中this关键字的记忆上。

使用函数语句定义法，则this关键字牢牢指向当前函数定义的域；而若使用函数表达式定义法，则随着函数附着的对象不同，this关键字也随之改变。

这里不做深入探讨，有兴趣的朋友中以看一下《殿堂之路》，里面有详细的介绍。

(3)、嵌套函数
您可以嵌套函数，这意味着函数可以在其它函数内部声明。

除非将对嵌套函数的引用传递给外部代码，否则嵌套函数将仅在其父函数内可用。

例如，下面的代码在 greeting() 函数内部声明两个嵌套函数：
function greeting():String {
function greet():String {
return"hello!";
}
function names():String {
return"新好男人!";
}
return (greet() + " " + names());
}
trace(greeting());
// 输出：hello! 新好男人!
在将嵌套函数传递给外部代码时，它们将作为函数闭包传递，这意味着嵌套函数保留在定义该函数时处于作用域内的任何定义。

有关例子后面会讲到。

四、传递参数
（1）、正常传递参数。

某些函数不需要给它们传递任何参数，而许多函数需要给它们传递参数。

例如，如果greeting() 函数可以使用不同的姓名来显示个性化的问候，就会使greeting()函数更加有趣了。

有了参数，实现这一点就简单了。

把上面的函数修改一下，如下所示：
function greeting(names:String):void {
trace("Hello!How are you?"+names);
}
一旦用这种方式定义了该函数，就可以调用它了，并给它传递不同的参数值。

例子如下所示：
greeting(" 张三"); //显示: Hello!How are you? 张三
greeting(" 李四"); //显示: Hello!How are you? 李四
在一个函数中，一个参数就是一个变量，当调用该函数时就给变量赋值。

就像在greeting() 函数中所看到的那样，参数被命名为“names”，在每次调用该函数的时候就给该参数设置值。

当用值“张三”调用该函数时，该变量就被赋予了“张三”；当用值“李四”调用该函数时，该变量就被赋予了“李四”。

参数(变量)是在函数定义的圆括号中声明的。

大家可能注意到了，参数的声明与常规变量的声明相似但略微不同。

首先，声明的相似性在于，需要给变量创建一个名字并定义一个数据类型。

但是，当声明一个参数时，不需要使用var关键字，也不需要使用分号。

下面的代码是不正确地声明参数的例子，将产生错误：
//不能使用 var 关键字。

function greeting(var names:String):void{
trace("Hello."+names)
}
//不能使用分号。

function greeting(names:String;):void{
trace("Hello."+names)
}
在 as3 中可以在圆括号中初始化变量，这是正确的写法，也是与 as2 最大不同之处。

function greeting(names:String="王麻子"):void {
trace("Hello！"+names);
}
如果想在函数中使用多个参数，该怎么办呢？很简单，当定义函数时，可以声明用逗号分隔开的多个参数。

同样地，当调用该函数时，可以给它传递多个值，只需简单地用逗号分隔这些值即可。

以下是具有多个参数的test()函数的例子function test(names:String,weight:Number):void {
trace(names+"的体重是:"+weight);
}
test("张三",50)//显示：张三的体重是:50
有的时候，当开始将越来越多的参数添加到一个函数定义的参数列表中时，代码就开始超出编辑器的边界了。

可以在Actions面板中启用自动换行功能。

还可以在定义函数时将每个参数(或参数组)放置到新的一行中。

这是一个通常采用的习惯，因为它能更容易地阅读一个由许多参数组成的函数的参数列表。

语法是相同的，区别仅在于：参数列表中的每个参数都放在新的一行中，以便使它更容易阅读。

例如：
function test(names:String,
weight:Number):void {
trace(names+"的体重是:"+weight);
}
test("张三",50);//显示：张三的体重是:50
注意：定义函数的参数个数与调用时传递的参数个数不一定要相同，当然，如果该有的参数没有的话，可能函数不会正常工作，多个参数是按先后顺序依次
“对号入座”的。

（2）、设置默认参数
在as3中可以设置函数默认参数，如果调用函数时没有写明参数，那么会调用该参数默认值代替。

格式如下：
function(参数1:类型＝默认值,参数2:类型＝默认值):{
//函数内部语句
}
具体例子如下：
function test(a:int=3,b:int=2,c:int=1):void {
trace(a+b+c,a,b,c);
}
test(); //输出：6 3 2 1 本处滑传参数，全部使用了默认值
test(9); //输出：12 9 2 1 本处传了一个参数，使用了后两个参数默认值
test(2,9); //输出：12 2 9 1 使用了最后一个参数默认值
test(1,2,3); //输出：6 1 2 3 参数齐全，没有使用默认值
（3）、访问参数和正确传入参数。

先来了解一下arguments 属性。

现在所看见过的函数要么不使用任何参数，要么参数被声明为圆括号中的参数列表。

但是，不管一个函数是否声明了任何参数，传递给函数的所有参数都被保存在一个函数自动生成的名为arguments的对象中。

arguments是一个特殊的数组。

每个函数都有一个arguments变量（对象），当调用函数的时候，就在该函数中创建该变量。

可以使用arguments[0]、arguments[1]访问传入的第一个参数、第二个参数，依次类推。

arguments有一个属性length，arguments.length表示传入参数的数目。

function test(a:int=3,b:String="hello",c:Number=1.5):void { for (var i:uint=0; i<arguments.length; i++) {
trace(arguments[i]);
}
}
test(); //没传参数，什么也不输出
test(2) //输出 2
test(2,"ok",32.4) //输出 2 ok 32.4
应避免将“arguments”字符串作为参数名，因为它将遮蔽 arguments 对象。

例如，写一个test()函数，添加 arguments 参数，那么，函数体内arguments 的引用所引用的将是该参数，而不是 arguments 对象。

下面的代码不生成输出结果：
function test(x:int, arguments:int):void {
for (var i:uint = 0; i < arguments.length; i++) {
trace(arguments[i]);
}
}
test(1,2);// 报错：访问可能未定义的属性 length (通过 static 类型 int 引用)
一个函数的arguments对象还有一个callee 属性，持有指向当前函数的引用，常用来创建递归。

为了复习函数定义的两种方法，我们用函数表达式定义法来定义下面的函数，这是一个计算“阶乘”的函数，可以递归地调用自己：
var factorial:Function=function(n:Number):Number{
if(n>0){
return n*arguments.callee(n-1)
}else{
return 1
}
};
trace(factorial(5))
通过 callee 调用自身可以避免因为改动声明部分的函数名，但忘了改动函数体内的函数名而产生的错误。

在as2中可以不用管函数的定义格式，可以传入任意多个参数。

但在as3中，要严格遵守函数定义，定义两个参数就必须传入两个参数，定义三个参数必须传入有一个参数，参数类型必须匹配，否则就是非法的，就会报错。

function test(a:int,b:int,c:int):void {
trace(a+b+c,a,b,c);
}
test(); //输出：参数个数不正确。

应为3 个
test(9); //输出：参数个数不正确。

应为 3个
test(2,9); //输出：参数个数不正确。

应为 3个
test(1,2,3,5); //报错：参数个数不正确。

不应超过 3 个
test([3,4]); //报错：Array 类型值的隐式强制指令的目标是非相关类型 int 如果给参数设置了默认值，并且传入的实参少于或等于形参总数，不会报错。

如果实参比形参个数多，也会报错。

function test(a:int=3,b:int=2,c:int=1):void {
trace(a+b+c,a,b,c);
}
test(); //输出：6 3 2 1
test(9); //输出：12 9 2 1
test(2,9); //输出：12 2 9 1
test(1,2,3,5);//输出：参数个数不正确。

不应超过3 个
如果多个参数有的设置了默认值，有的没有设置默认值，那么没有设置默认值的参数必须放在参数列表的前面，设置了默认值的参数放在参数列表的后面，也就是说，没有设置默认值的参数是必选参数，设置了默认值的参数是可选参数，必选参数不得位于可选参数之后，否则会报错。

function test(a:int=2,b:int=5,c:int):void {
trace(a+b+c,a,b,c);
}
test(6);//报错：必选参数不得位于可选参数之后
function test(a:int,b:in t=2,c:int=1):void {
trace(a+b+c,a,b,c);
}
test(2);//不会报错
（4）、传入任意数量的参数
为了提供传入任意参数的灵活性，as3提供了一个新关键字...rest。

那么只要在参数中定义了...rest，那么就可以传入任意多的参数了。

这些参数以数组的形式保存在rest中。

rest 只是推荐的命名，我们可以改成其它的名字，比如paras。

另外要注意，一旦使用了...rest 关键字，那么arguments 就不能再使用了。

尽管... rest参数提供了与 arguments 数组和 arguments.length 属性相同的功能，但是它不提供与 arguments.callee 类似的功能。

使用...rest 参数之前，应确保不需要使用 arguments.callee。

看下面的例子：
function testA(...rest):void {
trace("参数的长度"+rest.length);
for (var i in rest) {
trace(rest[i]);
}
}
testA(1,[5,9],"新好男人");
输出：
参数的长度 3
1
5,9
新好男人
...rest 参数还可与其它参数一起使用，前提是它必须是最后一个列出的参数。

再看一个例子：
testB() 函数的第一个参数names 是String 类型，第二个参数使用...rest 参数。

输出结果将忽略第一个值，因为第一个参数不再属于由...rest 参数创建的数组。

function testB(names:String,...rest):void {
trace("参数的长度"+rest.length);
for (var i in rest) {
trace(rest[i]);
}
}
testB("新好男人",[50,3],534,"你好");
输出：
参数的长度 3
50,3
534
你好
可以看出：实际“新好男人”并没有输出，要想输出，只有再加上语句trace(names)。

五、按值还是按引用来传入参数
当给函数传入参数时，参数是用两种方式之一进行传递的：按值和按引用。

其区别与数据类型有关。

按值传入，那么参数对象会复制一份副本供函数内部操作，参数对象本身不会爱影响；按引用传入，则不复制副本，函数内操作参数对象的引用，那么会改变参数的状态。

实际上，在 AS3 中，所有的参数都是按引用来传入的，只不过，基元数据类型是不变对象，传引用还是传值的效果都一样。

所以，如果参数是基元数据类型，那么可以看成是传值；如果参数不是基元数据类型，那么就是传引用。

（1）、基元数据类型是按值传递的。

在AS3中，基元数据类型只有Boolean、String、int、uint 和Number。

这就是说，这些值被传递给函数后，任何被用于传递的变量就独立了。

下面是一个例子：
值类型的例子
function test(a:Number):Number {
a++;
return a;
}
var a:Number=5;
var c:Number=test(a);
trace(a);
trace(c);
//trace(test(a))
Output 窗口会显示如下内容：
5
6
在这个例子中，尽管变量a的值被传递给了函数，并且那个值在函数中被增加了1，但a仍然保持它的值5。

为什么？因为a的“值”被传递给了函数，而不是变量“自己”。

然后，那个值在函数中被赋予了一个名为a的参数，被增加、被返回。

然后，返回的值被赋予了一个新的名为c的变量。

这就是值类型的特点：直接存值。

每个变量不因为其它变量的值的改变而改变。

即使形参 a的命名与变量a的命名完全相同也是如此，因为函数内部的a将指向内存中的新位置，这些位置不同于函数外部同名的变量a所在的位置。

（2）、当复杂数据类型被作为参数传递时，它们是按引用进行传递。

这就是说，一个被传递给函数的对象是对该实际对象的一个引用。

其结果是，在函数中对对象引用所做的任何事情都会影响到该对象本身，没有产生该对象的副本。

除了基元数据类型外，其余都是复杂数据类型，如Array、Date、 Function、MovieClip 等等。

下面看一下复杂数据类型作为参数传递时的情况。

例 1：以 Array 为例：
function test(num:int,myArray:Array):void {
num=100;
myArray[0]=15;
myArray.push(100);
}
var a:int=5;
var b:Array=[1,2,3];
test(a,b);
trace(a);//输出：5 a没有变成100，保持不变
trace(b);//输出：输出：15,2，3,100 b 被改变了
例 2：以 Object 为例：
function test(obj:Object):void {
obj.x++;
obj.y++;
trace(obj.x, obj.y);
}
var myObj:Object = {x:10, y:15};
trace(myObj.x, myObj.y); // 10 15
test(myObj); // 11 16
trace(myObj.x, myObj.y); // 11 16
myObj对象具有两个属性：x 和 y。

该对象作为参数传递给 test() 函数。

因为该对象不是基元类型，所以它不但按引用传递，而且还保持同一个引用。

这意味着对函数内部的参数的更改将会影响到函数外部的对象属性。

六、从函数返回值
到目前为止，主要介绍了函数如何作为子程序进行应用。

也就是说，函数可以将主程序分解为更小的、更易管理的片段。

有时，当函数作为一个子程序时，函数并不需要返回一个值。

而有些时候想创建一个函数，用它进行某些计算或操作，函数就需要一个返回值。

可以在一个函数中使用return 语句来返回一个特定的值。

return语句的语法如下所示：
return value;
当使用return语句从一个函数返回一个值时，应该指定要被返回的数据类型（在函数定义的圆括号后面指定）。

在此之前的例子中，返回类型是void（表示无返回）。

但是，当返回一个字符串时，就应该将返回的数据类型设置成String；当返回一个数字时，就应该将返回的数据类型设置成Number，等等。

下面是一个计算矩形面积的函数的例子，其返回值是数字：
function rectArea(Width:Number,Height:Number):Numbe r {
var Area:Number=Width*Height;
return Area;
}
//trace(rectArea(3,5))
如果您选择指定返回类型，则必须返回相应类型的值。

例如，下面的代码在严格模式下会生成错误，因为它们不返回有效值：
function rectArea(Width:Number,Height:Number):Number {
var Area:String=String(Width*Height);
return Area;
}
trace(rectArea(3,5));//报错： String 类型值的隐式强制指令的目标是非相关类型 Number。

只要用到 return 语句，Flash 就退出该函数。

因此，如果在return语句后面还有其它剩余代码，就不会再执行它们了。

例如：
function rectArea(Width:Number,Height:Number):Number { var Area:Number=Width*Height;
return Area;
trace("The area is:"+Area);
}
trace(rectArea(3,5));
在上面的例子中，trace("The area is:"+Area)语句总是不会被执行。

这是因为在函数中return语句后面的代码是执行不到的。

下是一个使用几个return 语句的例子。

function test(myArray:Array,string:String):Number {
for (var i:Number=0; i<myArray.length; i++) {
//如果成员之一匹配 string 的值，就返回相应的索引。

这会导致该函数停止执行
if (myArray[i]==string) {
return i;
}
}
//如果没有发现匹配，就会遇到这条语句
return myArray.length;
}
var array:Array=[1,"ab",34,"efg",28.5];
var num:Number=test(array,"efg");
//var num:Number=test(array,"a")
trace(num);
很明显，在任何对该函数的调用中，只可能遇到其中的一个return语句。

而在这个例子中，一个return语句是在条件满足时遇到的，其它return语句是在条件不满足时遇到的。

该函数接受两个参数：一个（字符串）数组、一个字符串值。

该函数用个for语句在搜索遍历该数组，直到遇到一个与该字符串匹配的成员为止。

一旦发现，它就返回相应的索引。

如果没有发现匹配，该函数就返回数组长度。

不管函数做什么，只要它返回一个值，就完全可以将其作为表达式的一部分来调用。

例如，可以用下面的方法来使用“求面积”函数：
Var area:Numbe r=rectArea(6,3)；//返回值存入变量
也可以：
var area:Number=rectArea(6,3)*5;//函数参与计算
从本质上说，该函数就变成一个类似字符串、数字、变量的值。

因此，尽管下面的内容是有效的，然而却是不太有用的ActionScript语句
6；
下面也一样：
rectArea(6,3);
因为我们希望按某些有意义的方法来使用返回的值，也就是可以像使用变量那样来使用一个会返回值的函数。

我们已经见过用于赋值语句中的“求面积”函数了，下面是另外一个例子，在该例子中，函数作为条件表达式的一部分使用：function rectArea(Width:Number,Height:Number):Number {
return Width*Height;
}
if (rectArea(4,5)>18) {
trace("面积大于 18.");
} else {
trace("面积小于 18.");
}
注意：函数的返回值不但可以是数值、字符串等，也可以是对象，如数组、MovieClip、Function 等等。

七、引用函数
可以用函数的名字来引用一个函数。

当将函数名与函数调用运算符（圆括号）结合起来使用时，函数就被调用了，但是名字本身只是作为对函数的引用。

这就是说，实际上可以使用函数的名字来将一个引用赋予一个变量。

例如，一旦将一个函数的引用赋予给一个变量，就可以将那个变量名与调用运算符结合调用那个函数。

下面是一个例子：
function rectArea(Width:Number,Height:Number):Number {
var Area:Number=Width*Height;
return Area;
}
var fArea:Function=rectArea;
trace(fArea(6,4));//输出：24
八、理解函数作用域
“作用域”是在ActionScript中定义的某些标识符的作用范围。

有些标识符仅在一个时间轴中被定义，有些标识符在整个影片的范围中被定义，有些标识符仅在一个函数中被定义。

在函数中，有两种作用域需要解释一下：变量的作用域、函数的作用域。

（1）、变量的作用域
变量的“作用域”是指可在其中通过引用词汇来访问变量的代码区域。

“全
局”变量是指在代码的所有区域中定义的变量，而“局部”变量是指仅在代码的某个部分定义的变量。

在 ActionScript 3.0 中，始终为变量分配声明它们的函数或类的作用域。

当在一个函数中适当地声明一个变量时，该变量就被称为“局部变量”。

局部变量表示当在一个函数中声明一个变量时，它的定义在该函数调用之后就不再保留。

可定义局部变量的最小代码区域就是函数定义。

在函数内部声明的局部变量仅存在于该函数中。

例如，下面是一个函数的例子，它声明并初始化了一个名为greet的本地变量。

该变量在该函数中被定义。

但是，如果想使用trace()在该函数之外来显示该变量的值，结果将是未定义的，也就是局部变量在该函数外部将不可用。

function test():void {
var greet:String="hello!how are you?";
trace(greet)
}
test();
trace(greet);//输出：访问的属性 greet 未定义
使用局部变量可以更好地管理内存。

尽管它可能并不是真的很大，但在程序中定义的每个变量都会占用内存。

如果不用一个变量做什么事了，但它仍被定义，就会浪费内存。

通过使用局部变量，当函数结束之后内存就会被释放。

参数被看做局部变量，即其作用域在该函数中，不在函数之外。

从下面的例子就可以看出这一点：
function test(string:String):void {
trace(string);
}
test("hello!"); //输出：hello!
trace(string); //输出：访问的属性 string未定义
与局部变量不同的是, 全局变量是在任何函数或类定义的外部定义的变量。

在该函数外面声明的变量(但在定义该函数的相同时间轴中)是可以在该函数中使用的，是全局变量。

例如：。