(转)as3效率优化

1、改进算法
无论对于那一种程序，好的算法总是非常重要的，而且能够极大地提高程序性能，所以任何性能的优化第一步就是从算法或者说程序逻辑的优化开始，检查自己的程序是否有多余的运算，是否在没有必要的时候做了无用功，往往从这些方面就能找到那些导致性能低下的地方。

2、优化细节代码
针对细节总是好的，有一些小技巧比如：
用 var obj:Object = {}; 要比 var obj:Object = new Object();要好；
var arr:Array = []; 要比 var arr:Array = new Array(); 要好；
for (var i:int=0, len=arr.length; i 如果不是为了保存颜色值请不要适用uint这个类型，他的速度比起 int要慢多了；
Array的遍历要比Object或者Dictionary的枚举要快得多。
if (myObj != null) 要比 if (myObj) 的速度要快， for (var i:* in myObj) 比 for (var i:String in myObj) 要快；
Dictionary当 weak key设置为 true 的时候要比 false 慢；
var myText:String = “a” + “b” + “c”;
var myText2:String = [ "a", "b", "c" ].join(”");
在JavaScript里面在IE下后者要更快，但是在AS里面，前者更快！
在循环体内声明变量和在循环体外声明变量其实速度上不会有太大的区别。

3、权衡程序的结构
程序的架构也非常重要，良好的结构会带来性能和程序健壮性的提升，但是有的时候又是相互矛盾的，例如代码写得过于健壮，反而会影响性能，这个地方需要开发者自己去权衡。

4、小心Flash的重绘
如果你使用的是Flash Player 的Debugger版本，那么请在检查性能瓶颈的时候不要忘记打开显示重绘区域的功能，这将帮你迅速定位到舞台上有那些地方被重绘了，找出没有显示任何东 西却不断重绘的地方，这些地方肯定是有问题的。Flash Player很笨，不会说你把一个DisplayObject的visible设置成false就放弃重绘那个显示对象。所以请保证你的 MovieClip在visible=false的时候为停止状态。有一点很有意思，假设两个现实物体存在 hitTest = true 这样的关系，那么重绘的区域的面积很有可能 > 两者的面积总和！

5、以空间换时间
听起来挺虚，实则很简单，说白了就是以内存换CPU，例如将不变动的值进行保存，免去下次需要此数据的时候进行再次计算，虽然原理很简单，但是有的时候却很容易疏忽掉，而这个往往就造成你的算法效率低下的问题。

6、记得销毁你的对象
对于非常驻的对象使用完之后记得消除其引用，防止出现内存溢出的问题，往往要做到这一点需要有一个良好的编程习惯。

7、清除冗余的代码
有些代码可能你的程序一辈子也不会执行到，请把这些没有用的代码或者对象清理掉，否则内存会被偷偷的蚕食掉。

8、小心使用useBitmapCache = true
一般情况下除非你确定这个显示对象不可能发生变化那么用用也无妨，不过我更推荐自己手动的用BitmapData将该对象Draw一遍，然后让这个对象彻底消失。否则每次的变动都是巨大的性能消耗。

—————-

前几日跟小雷配合做了一个项目，访问量统计的，要处理海量数据（其实万级别而已）。做出来之后，从程序启动到画出来图形，要超过15秒的脚本执行限 制。这样肯定是不行的，于是我开始研究程序优化——当然我之前也会有所涉及，只不过没有系统的总结过，这次需求比较严峻，所以整理一下。

flash性能最低的地方依然在于图形渲染，所以各种循环之中如果可以不包含图形变化就不要包含。我把图形变换放到数据运算之后，渲染速度从9秒多降低到0.4秒不到。
循环的速度，有人测出来是for each最快，for其次，while最慢。这个姑且相信吧，因为和我测出来的差不多。
数字类型的效率，int最高，number其次，uint最低。这个和as3刚出现时大家说的，能uint就uint完全不一致，uint甚至无法超过number。所以，循环的时候应该是：
（1）如果要存储的东西是对象，可以放在一个数组里面进行处理，需要循环的时候，可以用数组方法比如说every；同时，如果存储的对象包含自己的方法，则可以用for each (var _obj:* in _arr){_obj.method();}这样的方法。
（2）如果存储的是普通数据，可以尽量用for(var i:int=0,len:int=_arr.length;i
+=1的效率大于++，也很难理解。
公共属性，能不用getter/setter方法就不用，直接公开给外部调用修改。当然这种做法很不符合面向对象思想，不过有些时候也可以这么用。
xml的效率并不高，数据存储简单格式还是object吧。
剩下的以后补充。

===========================
最近我研究了一些AS3代码优化的文章，一般都是集中在研究loops 和 Number types上的，本文不在重复类似的测试

下面是我的一些测试结果

Array & Object constructing
构造数组和对象的时候，new Array() and new Object()要比 [] and {}慢3倍的时间

Index Number type for Arrays
数组的数字索引类型

ist[int(0)] 比list[0]要快

Create Array vs. Updating Array
再循环语句中避免多次创建数组，最好创建一次用多次更新内容替换

Nulling Array vs. Splicing Array
对于庞大的数组而言就行splice操作是比较耗成本的，要尽量避免

When working with large Arrays splicing is obviously an expensive operation, you can avoid this by nulling the index and skipping it in a null scenario. If you need to splice in order to keep the Array length low. Then store these nulled indexes in another trash Array once the garbage count has reached a limit you’ve defined loop through the numerically sorted trash indexes deleting splices in bulk. This concept is demonstrated in Tweensy.

Nulling Object vs. Delete Object
delete一个对象的属性要比把该属性设置为null 更昂贵，所以对于对象的属性最好设置为null

Nesting Loops（嵌套循环）
多次嵌套循环效率差，所以最好保证循环在2层以内

Inline code vs. function references
如果在时间帧上的函数很长而且执行时间长，最好，把该函数分成多个小的函数执行。

这样可以缩短执行时间提高效率

Arguments vs. variable referencing
尽量最小化函数的参数个数

Function apply scoping do it or not?
Scoping function.apply is a little bit slower than not so if you don’t have to then don’t.

Array push vs. Array index
用设置index的方式来代替使用数组函数push

比如

list[list.length] = data; 要比直接用push快600%；

Array emptying – length 0 vs. A new Array
如果你需要设置一个空数组，有一个方便的办法去选择，就是通过设置它的length属性为0

或者你会认为这么做是不错的选择，原因是它能节省内存，但是事实上这样做的执行速度不如直接new array的效率高

当然，如果你需要在一次循环中清除多于510个数组为空时，用length设置为0的时候会更好

Var declarations on multiple lines vs. Var declarations on a single line
将变量声明在一行中，要比声明多行更好，效率更高

i.e.
var a:int=0, b:int=0, c:int=0;
vs.
var a:int=0;
var b:int=0;
var c:int=0;

Using Xor to swap variables
如果你想去交换变量，但是又不想创建新的变量的时候，可以用xor

如：

a = a^b;
b = a^b;
a = a^b;

Multiplication vs. Division
乘法的运算速率总是比出发快，比如5000/1000 要比 5000*0.001快130%；

Type casting comparison 强制转换类型对比
When type casting the keyword as is 250% more efficient than casting by Type(item); Though surprisingly not using either is about 1400% more efficient.

建议使用对应的类型的变量进行比较

同类型的比较效率高的多

Long vs Short variable names
尽量用短的变量名

===================
提高flash程序效率(as3)
提高flash程序效率，这里先举一个处理字符串的例子，后面转载其他开发人员的优化经验，欢迎补充！
———————————————————————————–
action程序员都知道action处理String的效率是非常低的,可是说低的可以,下面代码可以说明:
var str = “abcde”;
var tmp = “”;
var time1 = getTimer();
for(var i=0;i < 10000;i++){
tmp += str;
}
trace(getTimer() - time1);//1665
将10000个5个字母的字符串连接起来竟然需要1.5s以上的时间(cpu: pm1.4)
而改成10个字母就需要使用4s左右的时间,15个字母就需要5.5s左右的时间
随着字符串的变长,字符串处理的速度越来越低
那怎么能让字符串连接的更快呢?看一看下面这段代码:
time1 = getTimer();
var tmpA = new Array();
for(var i=0;i < 10000;i++){
tmpA[i] = str;
}
var tmp1 = tmpA.join("");
trace(getTimer() - time1);
trace(tmp1 == tmp);
这段代码是接在上面的代码后面的,这里思路有所不同的是,在这里先把字符串一个一个的付给数组,然后利用数组的join方面一下子将整个数组转换为字符 串,你也许会想,先付给数组,然后再有数组转换,肯定会更慢.但实际上不是这样的,因为赋值语句在as里面是很快的,所以将10000个字符串付给数组花 不了多长时间,而最后调用的数组的方法是as内部函数,完全由c实现的,因此肯定要比as实现快很多倍,因此整体速度跟上面的代码就相差很多了,而且随字 符串增长,效率也不会明显降低,下面是执行结果:
同样为10000个字符串连接,5个字符第二种方法只需要140ms,比直接连接字符串快10倍左右,而后面的比较输出true说明两个字符串是一样的
而且当字符串加置10个,15个甚至更多的时候,效率并没有降低,而仍然用时140ms左右,而当字符串长度达到40的时候,用时才超过了200ms.
-------------------------------下面是较全面的优化-------------------------------
第一章 AS3的一些优化计算方法
用乘法来代替除法（当除数可转化为有限数的时候）。比如var n:Number = value * 0.5;要比var n:Number = value / 2;快。但差别并不是很大。只有在需要大量计算情况下，比如3D引擎中差别才比较明显。
用位运算代替除2或乘2。比如10>>1要比10*2快，而10<<1要比10*2快。从测试来看位运算几乎比乘除快一 倍，但是一般情况下，我们不能选择位运算，比如我们就不能用13>>1来代替13/2，尽管前者比后者运算速度更快，但2者的运算结果却不一 样。所以还是要看具体情况。
用unit()或int()代替取整运算Math.floor()和Math.ceil()。比如var test:uint = uint(1.5);要比var test:Number = Math.floor(1.5);快；而var test:uint = uint(1.5)+1;要比var test:Number = Math.ceil(1.5);也快。如果是Math.floor()，还可以用位运算(>>0)来代替。比如var test:uint =1.5>>0，比unit()或int()更快。
用乘-1来代替Math.abs()方法。比如var nn:Number = -23;var test:Number= nn < 0 ? nn * -1 : nn;要比var nn:Number = -23;var test:Number = Math.abs(nn);快。当然还有更多的优化计算的方法。一般来说，低级运算要比高级运算速度；内部方法比调用其他方法速度快。另外要注意的是，这 些方法有的时候可能并一定适用。
第二章 Actionscript 优化指南
原著 Marco Lapi,alias Lapo, aw译
在这篇文章中，我们将讨论多种优化 Actionscript 代码的方法.此外我们也针对一些典型的游戏代码进行了系列测试，来最大限度的发掘、提高Flash播放器的性能。何时进行优化对现有程序进行优化的过程， 有时十分的冗长与困难，这与原始代码的非优化程度有关，所以在投入大量时间进行代码优化之前，最重要的是要估计出要在什么地方对代码做出修改或替换。
一个游戏代码的最重要的部分就是主循环体，通常情况下该循环体要在flash的每一帧上执行，并控制游戏中的角色属性和重要的数据参数。而对于主循环体以外的部分，也可能是次要循环部分，同样要注意是给其否分配了过多的资源，而没有分配给那些更需要资源的核心部分。
通过积累在各处节约出来的时间(可能每处仅仅是几个毫秒)，您会明显发现自己的swf运行得更加稳定，并且游戏感也大大加强。
简洁与高效的代码
书写出十分简洁、可以再次调用的代码(有时可能是面向对象的)是一项精细的工作，但这需要多年的编程经验。对于OOP(object oriented programming，面向对象的程序设计)，有些场合根本利用不到它的优势，这使得它显得十分奢侈。在有限的资源条件下(可能是flash播放器的原 因)，通过更先进的方法，像刚刚提到的OOP，就可能反而导致令人不满意的结果。
我们并不是说OOP对游戏编程不好，只是在某些场合它显得过于奢侈和多余。毕竟有时候“传统的方法”却能得到更好的结果。大体而言，用OOP是比较 好的，因为它让代码维护更加简单。但在后文中，你会看到有时为了充分发挥flashplayer性能，而不采用OOP技术。例如：处理快速滚动或者计算十 分复杂的数学问题。基本的优化一提及代码优化，我们马上会联想到执行速度的改进，而很少去考虑系统资源的分配。这是因为当今，即使是将被淘汰的计算机，都 有足够的内存来运行我们大部分的flash游戏(128M的内存足以满足大多数情况的需要，况且，512M的内存是当今新电脑的基本配置)
变量
在各种重要的代码优化手段中，有这么一条：在定义局部变量的时候，一定要用关键字var来定义，因为在Flash播放器中，局部变量的运行速度更快，而且在他们的作用域外是不耗占系统资源的。
aw附：var变量仅仅在花括号对中才有“生命”，个人认为没有系统学过编程的人容易出错的一个地方：
awMC.onLoad = function(){
var aw = 1;
}
awMC.onEnterFrame = function(){
//不存在aw这个变量
}
一段非优化代码:
function doSomething()
{
mx = 100
my = 100
arr = new Array()

for (y=0; y < my; y++)
{
for (x=0; x < mx; x++)
{
i = (y * mx) + x
arr[i] = i
}
}
return arr
}
这段代码中，并未声明函数体内的那些变量(那些仅仅在函数内使用的变量)为局部变量，这使得这些变量被播放器调用的速度更慢，并且在函数执行完毕的时候仍然耗占系统资源。
下面列出的是经过改进的同样功能的代码：
function doSomething()
{
var mx = 100
var my = 100
var arr = new Array()

for (var y=0; y < my; y++)
{
for (var x=0; x < mx; x++)
{
var i = (y * mx) + x
arr[i] = i
}
}
return arr
}
这样一来所有的变量均被定义为了局部变量，他们能够更快地被播放器调用。这一点在函数大量(10，000次)循环运行时显得尤为重要！当一个函数调用结束的时候，相应的局部变量都会被销毁，并且释放出他们占有的系统资源。
*********************************************************************************************************************************
onEnterFrame 事件
onEnterFrame事件对于游戏开发者而言是非常有用的，它使得我们能够快速、反复地按照预设帧频(fps)运行一段程序。回想在 Flash5的时代，这(onEnterFrame实时监控)是一种非常流行的技术，用这样的事件来控制机器游戏对手的逻辑，又或者我们可以在每一个子弹 上设置这样的事件来监测子弹的碰撞。
实际上，我们并不推荐给过多的MoveClip添加这样的事件，因为这样做会导致“无头绪码(spaghetti code)”的出现，并且容易导致程序效率明显降低。
大多数情况下，用单独一个onEnterFrame事件就可以解决问题了：用这一个主循环来执行你所需要的操作。
另一个简单的办法是设置一个合适的帧频：要知道帧频越高，CPU资源就越紧张。在帧频为25-35(fps)之间时，onEnterFrame足以很好地执行较复杂代码，哪怕你的计算机配置较低。因此，在没有特殊要求的场合，我们不推荐使用高于60(fps)的帧频。
矢量图与位图
在处理图形前，我们一定要做出正确的选择。Flash能对矢量图和位图进行完美的兼容，然而矢量图和位图在播放器中的表现实质却完全不同。在用到矢 量图的时候，我们要尽可能简化它们的形状，去除多余的端点。这样做将大大降低播放器用于呈现矢量图所要进行的计算量。另一个重要方面在于线条的运用，尽量 减少和避免冗陈的线条结构，因为它们会直接影响到flash的播放效率。
当某个实例透明度小于100时，也会对播放速率造成影响，所以如果你发现自己的Flash播放速率过慢，就去挑出这些透明的实例来吧！
那么，如果真的需要呈现比较复杂的场景时，你就最好考虑使用位图实现。虽然Flash在对位图的渲染效率上并不是最优越的(比如和Flash的“兄 长”Director比起来)，但丰富的视觉内容呈现只能靠位图(与位图同复杂度的矢量图形渲染速率非常低)了，这也是很多基于区块的游戏中广泛采用像素 图作为背景的原因。顺便要提到的是，Flash虽然对GIF,JPG和PNG都有所支持，但是渲染速度上PNG还是占有绝对优势，所
以我们建议flash中的位图都尽可能采用PNG格式。
影片剪辑(MovieClip)的可视性[下面将MovieClip简称为mc]
您可能会经常碰到这样一种情况：有大量不可见/屏幕外的mc等待出场(比如游戏中屏幕外的地图、人物等等)。
要知道，播放器仍然要消耗一定的资源来处理这些不可见/屏幕外的mc，哪怕他们是单帧，非播放的状态。
最好的解决办法之一是给这些mc一个空白帧，当他们不出现在屏幕上时，你能用gotoAndStop()语句跳转到这一帧，从而减少播放器对资源的需求。
请务必记住，这种情况下，简单的设置可见度属性为不可见( _visible = false )是无效的，播放器将继续按照这些mc所停留或播放的帧的复杂度来分配资源。
数组
数组在各种需要记录数据的应用程序和游戏中都被广泛的使用。
一个典型的例子就是基于区块的Flash游戏，在这样一类的游戏中，地图有时被存放成形如arr[y][x]的二维数组。虽然这是一种很常见的方 法，但是如果用一维数组的话，却能提高程序的运行效率。另一个重要的方法来提高数组效率是在数组遍历的时候使用for in 循环来代替传统的 for 或者while循环语法。
例如：
一段代码如下
for (var i in arr)
{
if (arr[i] > 50)
{
// 进行某些操作
}
}
它的执行速度明显高于这一段代码：
for (var i=0; i < 10000; i++)
{
if (arr[i] > 50)
{
// 进行某些操作
}
}
前者的效率比后者提高了30%，这个数字在你的游戏要逐帧执行这一段代码的时候显得更加宝贵！
=================
第一章 AS3的一些优化计算方法
1.用乘法来代替除法（当除数可转化为有限数的时候）。比如var n:Number = value * 0.5;要比var n:Number = value / 2;快。但差别并不是很大。只有在需要大量计算情况下，比如3D引擎中差别才比较明显。

2.用位运算代替除2或乘2。比如10>>1要比10*2快，而10<<1要比10*2快。从测试来看位运算几乎比乘除快 一倍，但是一般情况下，我们不能选择位运算，比如我们就不能用13>>1来代替13/2，尽管前者比后者运算速度更快，但2者的运算结果却不 一样。所以还是要看具体情况。

3.用unit()或int()代替取整运算Math.floor()和Math.ceil()。比如var test:uint = uint(1.5);要比var test:Number = Math.floor(1.5);快；而var test:uint = uint(1.5)+1;要比var test:Number = Math.ceil(1.5);也快。如果是Math.floor()，还可以用位运算(>>0)来代替。比如var test:uint =1.5>>0，比unit()或int()更快。

4.用乘-1来代替Math.abs()方法。比如var nn:Number = -23;var test:Number= nn < 0 ? nn * -1 : nn;要比var nn:Number = -23;var test:Number = Math.abs(nn);快。当然还有更多的优化计算的方法。一般来说，低级运算要比高级运算速度；内部方法比调用其他方法速度快。另外要注意的是，这 些方法有的时候可能并一定适用。

第二章 Actionscript 优化指南
原著 Marco Lapi,alias Lapo, aw译

在这篇文章中，我们将讨论多种优化 Actionscript 代码的方法.此外我们也针对一些典型的游戏代码进行了系列测试，来最大限度的发掘、提高Flash播放器的性能。何时进行优化对现有程序进行优化的过程， 有时十分的冗长与困难，这与原始代码的非优化程度有关，所以在投入大量时间进行代码优化之前，最重要的是要估计出要在什么地方对代码做出修改或替换。

一个游戏代码的最重要的部分就是主循环体，通常情况下该循环体要在flash的每一帧上执行，并控制游戏中的角色属性和重要的数据参数。而对于主循环体以外的部分，也可能是次要循环部分，同样要注意是给其否分配了过多的资源，而没有分配给那些更需要资源的核心部分。
通过积累在各处节约出来的时间(可能每处仅仅是几个毫秒)，您会明显发现自己的swf运行得更加稳定，并且游戏感也大大加强。

简洁与高效的代码

书写出十分简洁、可以再次调用的代码(有时可能是面向对象的)是一项精细的工作，但这需要多年的编程经验。对于OOP(object oriented programming，面向对象的程序设计)，有些场合根本利用不到它的优势，这使得它显得十分奢侈。在有限的资源条件下(可能是flash播放器的原 因)，通过更先进的方法，像刚刚提到的OOP，就可能反而导致令人不满意的结果。

我们并不是说OOP对游戏编程不好，只是在某些场合它显得过于奢侈和多余。毕竟有时候“传统的方法”却能得到更好的结果。大体而言，用OOP是比较 好的，因为它让代码维护更加简单。但在后文中，你会看到有时为了充分发挥flashplayer性能，而不采用OOP技术。例如：处理快速滚动或者计算十 分复杂的数学问题。基本的优化一提及代码优化，我们马上会联想到执行速度的改进，而很少去考虑系统资源的分配。这是因为当今，即使是将被淘汰的计算机，都 有足够的内存来运行我们大部分的flash游戏(128M的内存足以满足大多数情况的需要，况且，512M的内存是当今新电脑的基本配置)

变量

在各种重要的代码优化手段中，有这么一条：在定义局部变量的时候，一定要用关键字var来定义，因为在Flash播放器中，局部变量的运行速度更快，而且在他们的作用域外是不耗占系统资源的。

aw附：var变量仅仅在花括号对中才有“生命”，个人认为没有系统学过编程的人容易出错的一个地方：复制内容到剪贴板代码:
awMC.onLoad = function(){
var aw = 1;
}
awMC.onEnterFrame = function(){
//不存在aw这个变量
}
一段非优化代码:
function doSomething()
{
mx = 100
my = 100
ar = new Array()

for (y=0; y < my; y++)
{
for (x=0; x < mx; x++)
{
i = (y * mx) + x
arr[i] = i
}
}
return arr
}这段代码中，并未声明函数体内的那些变量(那些仅仅在函数内使用的变量)为局部变量，这使得这些变量被播放器调用的速度更慢，并且在函数执行完毕的时候仍然耗占系统资源。

下面列出的是经过改进的同样功能的代码：复制内容到剪贴板代码:
function doSomething()
{
var mx = 100
var my = 100
var ar = new Array()

for (var y=0; y < my; y++)
{
for (var x=0; x < mx; x++) { var i = (y * mx) + x arr[i] = i } } return arr }这样一来所有的变量均被定义为了局部变量，他们能够更快地被播放器调用。这一点在函数大量(10，000次)循环运行时显得尤为重要！当一个函数调用结 束的时候，相应的局部变量都会被销毁，并且释放出他们占有的系统资源。 onEnterFrame 事件 onEnterFrame事件对于游戏开发者而言是非常有用的，它使得我们能够快速、反复地按照预设帧频(fps)运行一段程序。回想在Flash5的时 代，这(onEnterFrame实时监控)是一种非常流行的技术，用这样的事件来控制机器游戏对手的逻辑，又或者我们可以在每一个子弹上设置这样的事件 来监测子弹的碰撞。 实际上，我们并不推荐给过多的MoveClip添加这样的事件，因为这样做会导致“无头绪码(spaghetti code)”的出现，并且容易导致程序效率明显降低。 大多数情况下，用单独一个onEnterFrame事件就可以解决问题了：用这一个主循环来执行你所需要的操作。 另一个简单的办法是设置一个合适的帧频：要知道帧频越高，CPU资源就越紧张。在帧频为25-35(fps)之间时，onEnterFrame足以很好地 执行较复杂代码，哪怕你的计算机配置较低。因此，在没有特殊要求的场合，我们不推荐使用高于60(fps)的帧频。 矢量图与位图 在处理图形前，我们一定要做出正确的选择。Flash能对矢量图和位图进行完美的兼容，然而矢量图和位图在播放器中的表现实质却完全不同。在用到矢量图的 时候，我们要尽可能简化它们的形状，去除多余的端点。这样做将大大降低播放器用于呈现矢量图所要进行的计算量。另一个重要方面在于线条的运用，尽量减少和 避免冗陈的线条结构，因为它们会直接影响到flash的播放效率。 当某个实例透明度小于100时，也会对播放速率造成影响，所以如果你发现自己的Flash播放速率过慢，就去挑出这些透明的实例来吧！ 那么，如果真的需要呈现比较复杂的场景时，你就最好考虑使用位图实现。虽然Flash在对位图的渲染效率上并不是最优越的(比如和Flash的“兄 长”Director比起来)，但丰富的视觉内容呈现只能靠位图(与位图同复杂度的矢量图形渲染速率非常低)了，这也是很多基于区块的游戏中广泛采用像素 图作为背景的原因。顺便要提到的是，Flash虽然对GIF,JPG和PNG都有所支持，但是渲染速度上PNG还是占有绝对优势，所 以我们建议flash中的位图都尽可能采用PNG格式。 影片剪辑(MovieClip)的可视性[下面将MovieClip简称为mc] 您可能会经常碰到这样一种情况：有大量不可见/屏幕外的mc等待出场(比如游戏中屏幕外的地图、人物等等)。 要知道，播放器仍然要消耗一定的资源来处理这些不可见/屏幕外的mc，哪怕他们是单帧，非播放的状态。 最好的解决办法之一是给这些mc一个空白帧，当他们不出现在屏幕上时，你能用gotoAndStop()语句跳转到这一帧，从而减少播放器对资源的需求。 请务必记住，这种情况下，简单的设置可见度属性为不可见( _visible = false )是无效的，播放器将继续按照这些mc所停留或播放的帧的复杂度来分配资源。 数组 数组在各种需要记录数据的应用程序和游戏中都被广泛的使用。 一个典型的例子就是基于区块的Flash游戏，在这样一类的游戏中，地图有时被存放成形如arr[y][x]的二维数组。虽然这是一种很常见的方法，但是 如果用一维数组的话，却能提高程序的运行效率。另一个重要的方法来提高数组效率是在数组遍历的时候使用for in 循环来代替传统的 for 或者while循环语法。 例如： 一段代码如下复制内容到剪贴板代码: for (var i in arr) { if (arr[i] > 50)
{
// 进行某些操作
}
}它的执行速度明显高于这一段代码：复制内容到剪贴板代码:
for (var i=0; i < 10000; i++) { if (arr[i] > 50)
{
// 进行某些操作
}
}前者的效率比后者提高了30%，这个数字在你的游戏要逐帧执行这一段代码的时候显得更加宝贵！

高级优化：

1) for循环 和 while循环
用while循环将会得到比for循环更好的效率。然而，从数组中读取数据，用for in循环式最好的选择！

所以我们不推荐使用：复制内容到剪贴板代码:
for (var i=0; i < 1000; i++)
{
//进行某些操作
}而推荐使用
var i=-1
while (++i < 1000)
{
//进行某些操作
}2) 从数组中读取数据
我们通过测试发现，for in循环的效率大大高于其他的循环方式。参看：复制内容到剪贴板代码:
arr = []
MAX = 5000
//数组赋值
for (i=0; i < MAX; i++)
{
arr[i] = i
}
var item = null
// For 循环
for (var i=0; i < MAX; i++)
{
item = arr[i]
}
// For 循环
for (var i in arr)
{
item = arr[i]
}
// While 循环
i = -1
while(++i < MAX)
{
item = arr[i]
}3) 向数组中写入数据(while , for)可以看到while循环稍占优势。

4) _global(全局)变量同Timeline(时间轴)变量
我们猜测采用全局变量能提高变量调用速度，然而效果并不像预计的那样明显。

5) 单行、多行变量赋值
我们发现单行变量赋值效率大大高于多行。比如：
a = 0
b = 0
c = 0
d = 100
e = 100

效率就不如：
a = b = c = 0
d = e = 100

6) 变量名寻址
这个测试反映了变量名的预寻址是非常重要的，尤其是在循环的时候，一定要先给丁一个指向。这样大大节约了寻址时间。

比如：复制内容到剪贴板代码:
var num = null
t = getTimer()
for (var i=0; i < MAX; i++)
{
num = Math.floor(MAX) – Math.ceil(MAX)
}
t1.text = “Always lookup: ” + (getTimer() – t)就不如：复制内容到剪贴板代码:
t = getTimer()
var floor = Math.floor
var ceil = Math.ceil
for (var i=0; i < MAX; i++)
{
num = floor(MAX) – ceil(MAX)
}7) 短变量名和长变量名
变量名越短，效率越高。考虑到长变量名也有它的好处（比如，便于维护等），因此建议在关键部位（比如大量循环出现的时候）使用短变量名，最好就1-2个字符。

循环前、后声明变量
在测试前，我们认为循环前声明变量会更加节约时间，不料测试结果并不明显，甚至还恰恰相反！复制内容到剪贴板代码:
// 内部声明
t = getTimer()
for (var i=0; i < MAX; i++)
{
var test1 = i
}
t1.text = “Inside:” + (getTimer() – t)
// 外部声明
t = getTimer()
var test2
for (var i=0; i < MAX; i++) { test2 = i }9) 使用嵌套的if结构 当用到复杂的条件表达式时。把他们打散成为嵌套的独立判断结构是最佳方案。下面的代码我们进行了测试，发现这种效果改进明显！复制内容到剪贴板代码: MAX = 20000 a = 1 b = 2 c = -3 d = 4 var i=MAX while(–i > -1)
{
if (a == 1 && b == 2 && c == 3 && d == 4)
{
var k = d * c * b * a
}
}
//下面的判断更加节省时间
var i=MAX
while(–i > -1)
{
if (a == 1)
{
if (b == 2)
{
if (c == 3)
{
if (d == 4)
{
var k = d * c * b * a
}
}
}
}
}10) 寻找局部变量(this方法同with方法比较)
局部变量的定位方法很多。我们发现用with比用this更加有优势！复制内容到剪贴板代码:
obj = {}
obj.a = 1
obj.b = 2
obj.c = 3
obj.d = 4
obj.e = 5
obj.f = 6
obj.g = 7
obj.h = 8
obj.test1 = useThis
obj.test2 = useWith
MAX = 10000
function useThis()
{
var i = MAX
while(–i > -1)
{
this.a = 1
this.b = 2
this.c = 3
this.d = 4
this.e = 5
this.f = 6
this.g = 7
this.h = 8
}
}
function useWith()
{
var i = MAX
while(–i > -1)
{
with(this)
{
a = 1
b = 2
c = 3
d = 4
e = 5
f = 6
g = 7
h = 8
}
}
}11) 循环监听键盘事件
同刚才所提到的寻址一样，我们实现给一个指向会得到更好的效率，比如：
keyDown = Key.isDown
keyLeft = Key.LEFT

//我们再用 if (keyDown(keyLeft))
附：我们测试了按键代码和键值常量的效率发现并无太大差别。

12) Math.floor()方法与int()
这个问题曾在Flashkit的论坛被提出讨论过。测试表明，旧的int方法反而效率更高。我们的测试结果也反映了这一点。

13)eval表达式与中括号语法
我们并没有发现明显的差别，并不像刚才所述那样，旧的eval表达式比起中括号方法并没有太大的优势
var mc = eval(”_root.myMc” + i)
var mc = _root["myMc" + i]
//两者效率差不多16) 涉及MC的循环：ASBroadcaster 同欢同循环的差别

结论

我们从这些测试结果中发现，对于不同的需求，采用不同的代码，我们可以大大提高脚本的执行效率。虽然我们在这里罗列了许多的优化代码的方法，需要大家自己测试、实验的还有很多(考虑到每个人的需求不同).如果你想更加深入地讨论这类问题。可以来我们的论坛。

aw附:
终于翻译完了，自己也学到很多好东西，大家又什么问题可以去gotoAndPlay的官方，也可以来我的Blog提出！

第三章 黑羽AS心得:浅释ActionScript的代码优化
本机函数要比用户定义的函数运行速度更快。本机函数即Flash中内有的一些函数(intrinsic)，比如hitTest()，你没必要自己写一个类似的。

3.不要过多使用 Object 类型。
数据类型注释应力求精确，这样可以提高性能。只有在没有适当的备选数据类型时，才使用 Object 类型。同时也便于代码管理，时刻知道对象的类型和作用。同时也有利于编译器编译时优化。

4.避免使用 eval() 函数或数据访问运算符。
通常，较为可取且更有效的做法是只设置一次局部引用。不得已时才用eval，比如转换_droptarget为MovieClip时。

5.在开始循环前将 Array.length 赋予变量，尤其是大的循环。
在开始循环前将 Array.length 赋予变量(比如var iLength:Number)，将其作为条件使用，而不是使用myArr.length 本身。
原因，在循环中，iLength是Number变量，会被放入寄存器使用，效率远比访问Array再得到length高。例如，应使用复制内容到剪贴板代码:
var fontArr:Array = TextField.getFontList();
var arrayLen:Number = fontArr.length;
for (var i:Number = 0; i < arrayLen; i++) {
trace(fontArr[i]);
}来代替：复制内容到剪贴板代码:
var fontArr:Array = TextField.getFontList();
for (var i:Number = 0; i < fontArr.length; i++) {
trace(fontArr[i]);
}6.注重优化循环及所有重复动作。
Flash Player 花费许多时间来处理循环(如使用 setInterval() 函数的循环)。

7.在局部变量够用时，不要使用全局变量。类静态变量也要少用。
全局变量是开发者的恶梦。实在需要全局变量的话，我建议使用singleton设计模式来进行管理。

8.声明变量时，添加 var 关键字。
这是为了编译时让编译器知道你的变量类型，优化编译。

黑羽补充一点：对关键字的使用要谨慎。
不赞成使用关键字作为自己的method和属性名，除非你确认后续开发不会用到相同的事件名和属性名。
但你怎么知道flash使用了多少隐藏关键字？太多了！比如说 className, invalidate, refresh, mouseOver等等不常用的关键词。好的方法是使用SEPY编辑器来写代码，那里面加亮了所有公布的和没有公布的关键词。而且因为很有可能和 start,load,等这些常用的事件名重复，带来代码不必要的修改和麻烦。

9.对涉及到调用绘图资源的函数时，尽量先多判断再调用。
所有渐变，位置变化，创建删除MC，组件等函数都涉及到绘图资源的调用。在很多情况下，尽量先用逻辑判断变量或者对象的属性，必要时再调用这些函数。这样可以节省较多的计算资源。

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