常青的JAVA视界

ActionScript 3 Cookbook 中文版

2007-02-03T14:42:00.000+08:00

ActionScript 3 Cookbook 中文版

本文未经同意，谢绝转载

第一章. ActionScript 语言基础

第六章. 可视化对象列表 (目录)

第七章. 绘图和遮罩 (目录)

第八章.位图 (目录)

第八章.位图

2007-02-03T00:00:00.000+08:00

第八章.位图

8.0.简介

8.1.创建BitmapData对象

8.2.添加位图到可视化对象列表

8.3.绘制可视化对象到位图上

8.4.载入外部图片到位图上

8.5.处理象素

8.6.创建矩形填充

8.7.创建一个充溢填充

8.8.拷贝象素

8.9.拷贝通道

8.10.创建噪波

8.11.创建布林噪波

8.12.使用阈值

8.13.在位图上应用滤镜

8.14.在两幅位图之间转换

8.15.滚动位图

第五章.数组

2007-01-22T22:20:00.001+08:00

第五章.数组

5.13.取得数组元素的最大值和最小值

5.14.比较数组

5.15.创建联合数组

5.16.读取联合数组

5.16.读取联合数组

2007-01-22T22:04:00.001+08:00

5.16. 读取联合数组

问题
我要怎样遍历联合数组
解决办法
使用 for . . . in 语句
讨论

基于整形下标的数组可以通过for 语句进行循环遍历，但是，用关键字作索引的联合数组就不能这样遍历了，还好，联合数组可以通过 for . . . in 语句进行遍历访问。该语句会访问指定对象所有可用的属性，语法如下：
for (key in object) {
// Actions
}
for . . . in 语句不需要循环变量更新语句，决定循环次数的是对象的属性个数。注意这key 就是存储每个属性名称的：
var members:Object = new Object( );
members.scribe = "Franklin";
members.chairperson = "Gina";
members.treasurer = "Sindhu";

// 使用 for . . . in 语句遍历所有元素
for (var sRole:String in members) {
// 显示:
// treasurer: Sindhu
// chairperson: Gina
// scribe: Franklin
trace(sRole + ": " + members[sRole]);
}

5.15.创建联合数组

2007-01-22T21:45:00.001+08:00

5.15. 创建联合数组

问题
我要创建用名称元素作为索引的数组
解决办法
创建联合数组
讨论

用联合数组其每个元素都有特定的含义，这一点原来的数组类型是做不到的。
var aMembers:Array = new Array("Franklin", "Gina", "Sindhu");
联合数组在其他的语言叫做哈希表，在 ActionScript 里它就是Object 类的一个实例，联合数组使用名称元素来代替数字下标，该名称也被称为关键字或属性，说关键字更好理解些，它关联了元素值，两者一一对应。
创建联合数组不是用Array 类而是Object类创建的，它就是 Object 类的一个实例，理论上 Object 类是任何类的基类。所有的对象都能作为联合数组，但是除非有特殊需要，最好还是用 Object 类创建。
用{ } ，而且用逗号分开每个键值对，键值对之间用：，像下面：
var memebers:Object = {scribe: "Franklin",
chairperson: "Gina",
treasurer: "Sindhu"};
也可以像下面那样创建联合数组：
var members:Object = new Object( );
members.scribe = "Franklin";
members.chairperson = "Gina";
members.treasurer = "Sindhu";
有两种方法访问联合数组内容，一种是通过访问属性名称（关键字）：
trace(members.scribe); // 显示: Franklin
另一种就像数组那样，把关键字作为下标来访问，用[ ] 符号：
trace(members["scribe"]); // 显示: Franklin
这种方式更加灵活，可以在数组中进行遍历，对于动态生成的关键值和内容这种访问方式是最好的，例如：
var members:Object = new Object();
members.councilperson1 = "Beatrice";
members.councilperson2 = "Danny";
members.councilperson3 = "Vladamir";
for (var i:int = 1; i <= 3; i++) {
trace(members["councilperson" + i];
}
数组访问方式在循环语句里经常用到：
var members:Object = new Object( );
members["councilperson"] = "Ruthie";
trace(members.councilperson); // 显示 Ruthie
members.councilperson = "Rebecca";
trace(members["councilperson"]); // 显示: Rebecca

5.14.比较数组

2007-01-22T20:52:00.000+08:00

5.14. 比较数组

问题
我该怎么知道两个数组是否相等呢
解决办法
循环数组，一一比较对应位置的每个元素
讨论

因为数组是引用类型，使用=操作符只能对比引用是否指向同一内存空间，如：
var letters:Array = ["a", "b", "c", "d"];
var lettersPointer:Array = letters;
trace(letters == lettersPointer); // 显示: true
但是如果数组内容相同，但是在不同的内存空间，=操作就会返回false：
var letters1:Array = ["a", "b", "c", "d"];
var letters2:Array = ["a", "b", "c", "d"];
trace(letters1 == letters2]; // 显示: false
因此，比较数组应该比较数组的每个元素是否相等：
var equivalent:Boolean = true;
for(var i:int = 0; i < letters1.length; i++) {
if(letters1[i] != letters2[i]) {
equivalent = false;
break;
}
}
trace(equivalent); // 显示: true
另外还可以用ArrayUtilities.equals( ) 方法，该方法需要两个参数：两个数组引用，返回布尔值说明是否相等：
var letters1:Array = ["a", "b", "c", "d"];
var letters2:Array = ["a", "b", "c", "d"];
trace(ArrayUtilities.equals(letters1, letters2));
// 显示: true
默认，两个不同排列的数组是不相等的，除非提供第3个参数为true表示忽略数组排列顺序：
var letters1:Array = ["a", "b", "c", "d"];
var letters2:Array = ["b", "a", "d", "c"];
trace(ArrayUtilities.equals(letters1, letters2));
// 显示: false
trace(ArrayUtilities.equals(letters1, letters2, true));
// 显示: true
equals( ) 方法用起来很简单，下面是它的代码：
public static function equals(arrayA:Array,
arrayB:Array,
bNotOrdered:Boolean):Boolean {

// 如果两个数组长度不同
if(arrayA.length != arrayB.length) {
return false;
}

// 创建拷贝，不影响原数组
var arrayACopy:Array = arrayA.concat( );
var arrayBCopy:Array = arrayB.concat( );

// 如果忽略排列顺序
if(bNotOrdered) {
arrayACopy.sort( );
arrayBCopy.sort( );
}

// 循环比较
// 如果不匹配，删除拷贝，返回false
for(var i:int = 0; i < arrayACopy.length; i++) {
if(arrayACopy[i] != arrayBCopy[i]) {
delete arrayACopy;
delete arrayBCopy;
return false;
}
}

// 否则相等，删除数组，返回true
delete arrayACopy;
delete arrayBCopy;
return true;
}

5.13.取得数组元素的最大值和最小值

2007-01-22T17:54:00.001+08:00

5.13. 取得数组元素的最大值和最小值

问题
我要获取数字数组的最大和最小元素
解决办法
经过数字排序，然后读取数组的第一个和最后一个元素
讨论

要想快速的取得最大值和最小值，先进行排序，看下面：
var scores:Array = [10, 4, 15, 8];
scores.sort(Array.NUMERIC);
trace("Minimum: " + scores[0]);
trace("Maximum: " + scores[scores.length - 1]);
如果不破坏原有数组顺序，可先复制数组：
也可使用 ArrayUtilities.min( ) 和 ArrayUtilities.max( ) 方法。

5.12.数组元素的随机排序

2007-01-22T17:49:00.001+08:00

5.12. 数组元素的随机排序

问题
我要打乱数组元素的顺序
解决办法
使用 sort( ) 方法和自定义比较函数返回随机的正数或负数
讨论

很多情况我们需要得到一个随机排列的数组，比如有个游戏需要产生随机的字母。
有很多种方法达到这个目的，但是最简单的办法就是创建自定义比较函数，返回随机的正数或负数，把该函数引用传递给sort( ) 方法：
下面的比较函数就能达到目的：
function randomSort(elementA:Object, elementB:Object):Number {
return Math.random( ) - .5
}
Math.random( ) 返回0.0 到 1.0. 减去0.5 ，正好有一半的几率是负数，一半为正数，因此这个数组经过随机排序
看下面的随机排序例子：
var numbers:Array = new Array( );
for(var i:int=0;i<20;i++) {
numbers[i] = i;
}
numbers.sort(randomSort);
for(var i:int=0;i<numbers.length;i++) {
trace(numbers[i]);
}

5.11.实现自定义排序

2007-01-22T17:35:00.001+08:00

5.11. 实现自定义排序

问题
我要自定义数组排序
解决办法
把自定义比较的函数引用传递给sort( ) 方法
讨论

如果要自定义排序，可用sort( ) 方法和自定义比较函数。sort( ) 方法重复调用比较函数对两个数组元素进行比较，比较函数接受两个参数即数组元素（我们称为a和b），根据具体的排序方式返回正数，负数或0。如果返回负数，a排在b前，如果返回0，位置不变，如果返回正数，a排在b后，直到所有元素对比完毕。
下面有个例子对字符串数组进行自定义排序，比如是一个歌曲名数组，在排序时忽略字符串中含有的"The" 字母，首先看看默认的排序：
var bands:Array = ["The Clash",
"The Who",
"Led Zeppelin",
"The Beatles",
"Aerosmith",
"Cream"];
bands.sort( );
for(var i:int = 0; i < bands.length; i++) {
trace(bands[i]);
/* 输出：
Aerosmith
Cream
Led Zeppelin
The Beatles
The Clash
The Who
*/
}
给 sort( ) 方法传递bandNameSort 比较函数：
var bands:Array = ["The Clash",
"The Who",
"Led Zeppelin",
"The Beatles",
"Aerosmith",
"Cream"];
bands.sort(bandNameSort);
for(var i:int = 0; i < bands.length; i++) {
trace(bands[i]);
/*输出
Aerosmith
The Beatles
The Clash
Cream
Led Zeppelin
The Who
*/
}

function bandNameSort(band1:String, band2:String):int
{
band1 = band1.toLowerCase( );
band2 = band2.toLowerCase( );
if(band1.substr(0, 4) == "the ") {
band1 = band1.substr(4);
}
if(band2.substr(0, 4) == "the ") {
band2 = band2.substr(4);
}
if(band1 < band2) {
return -1;
}
else {
return 1;
}
}
bandNameSort( ) 函数把字符串元素转换为小写，然后检测是否含有"The "，如果有则剪切掉，取剩余字符串进行比较

5.10.数组排序

2007-01-22T17:06:00.001+08:00

5.10. 数组排序

问题
我要进行数组排序
解决办法
使用 sort( ) 方法，对于对象数组可以用 sortOn( ) 方法
讨论

使用 sort( ) 方法就可以对数组进行排序，没有参数是进行升序排序，对于字符内容采用 Unicode 编码排序
var words:Array = ["tricycle", "relative", "aardvark", "jargon"];
words.sort( );
trace(words); // 显示: aardvark,jargon,relative,tricycle
如果要进行降序排序，需要传递参数Array.DESCENDING 常量：
var words:Array = ["tricycle", "relative", "aardvark", "jargon"];
words.sort(Array.DESCENDING);
trace(words); // 显示: tricycle,relative,jargon,aardvark
上面的例子没有考虑大小写问题，比如：
var words:Array = ["Tricycle", "relative", "aardvark", "jargon"];
words.sort( );
trace(words); // 显示: Tricycle,aardvark,jargon,relative
使用Array.CASEINSENSITIVE 常量忽略大小写进行排序：
var words:Array = ["Tricycle", "relative", "aardvark", "jargon"];
words.sort(Array.CASEINSENSITIVE);
trace(words); // 显示 aardvark,jargon,relative,Tricycle
如果对数字内容的数组排序，则根据第一个数字的ASCII 排序：
var scores:Array = [10, 2, 14, 5, 8, 20, 19, 6];
scores.sort( );
trace(scores); // 显示: 10,14,19,2,20,5,6,8
使用 Array.NUMERIC 常量才能正常对数字排序：
var scores:Array = [10, 2, 14, 5, 8, 20, 19, 6];
scores.sort(Array.NUMERIC);
trace(scores); // 显示：2,5,6,8,10,14,19,20
还有两个常量Array.UNIQUESORT 和 array.RETURNINDEXEDARRAY. ，如果你只是对含有唯一元素的数组排序就可以用Array.UNIQUESORT ，Flash只会对这样的数组排序，不满足条件 sort( ) 返回0，且不进行排序：
var ranking:Array = [2,5,6,3,1,1,4,8,7,10,9];
var sortedRanking:Object = ranking.sort(Array.UNIQUESORT);
trace(sortedRanking); // 显示: 0
trace(ranking); // 显示：2,5,6,3,1,1,4,8,7,10,9
Array.RETURNINDEXEDARRAY 得到排序后数组元素的下标顺序，但不改变原始数组：
var words:Array = ["tricycle", "relative", "aardvark", "jargon"];
var indices:Array = words.sort(Array.RETURNINDEXEDARRAY);
trace(words); // 显示: tricycle,relative,aardvark,jargon
trace(indices); // 显示: 2,3,1,0
for(var i:int = 0; i < words.length; i++) {
/* 显示
aardvark
jargon
relative
tricycle
*/
trace(words[indices[i]]);
}
可以用操作符(|)联合使用这些常量：
var words:Array = ["Tricycle", "relative", "aardvark", "jargon"];
words.sort(Array.CASEINSENSITIVE | Array.DESCENDING);
trace(words); // 显示: Tricycle,relative,jargon,aardvark
有时候你想反转数组该怎么办呢？sort( ) 方法并没这功能，这是可以用 reverse( ) 方法：
var words:Array = ["tricycle", "relative", "aardvark", "jargon"];
words.reverse( );
trace(words); // 显示: jargon,aardvark,relative,tricycle
上面的部分讨论了怎么对字符串和数字进行排序，对于对象数组可用 sortOn( ) 方法，该方法需要一个字符串参数指定名称属性对其排序：
var cars:Array = new Array();
cars.push({make: "Honda", year: 1997, color: "maroon"});
cars.push({make: "Chrysler", year: 2000, color: "beige"});
cars.push({make: "Mercedes", year: 1985, color: "blue"});
cars.push({make: "Fiat", year: 1983, color: "gray"});
// 对 year 属性进行排序 cars.sortOn("year")：
for (var i:int = 0; i < cars.length; i++) {
/* 显示:
gray 1983 Fiat
blue 1985 Mercedes
maroon 1997 Honda
beige 2000 Chrysler
*/
trace(cars[i].color + "\t" +
cars[i].year + "\t" +
cars[i].make);
}
sortOn( ) 方法也可以一次对多个字段进行排序，看下面的代码：
var cars:Array = new Array( );
cars.push({make: "Honda", year: 1997, color: "maroon"});
cars.push({make: "Chrysler", year: 2000, color: "beige"});
cars.push({make: "Mercedes", year: 1985, color: "blue"});
cars.push({make: "Fiat", year: 1983, color: "gray"});
cars.push({make: "Honda", year: 1992, color: "silver"});
cars.push({make: "Chrysler", year: 1968, color: "gold"});
cars.push({make: "Mercedes", year: 1975, color: "green"});
cars.push({make: "Fiat", year: 1983, color: "black"});
cars.push({make: "Honda", year: 2001, color: "blue"});
cars.push({make: "Chrysler", year: 2004, color: "orange"});
cars.push({make: "Mercedes", year: 2000, color: "white"});
cars.push({make: "Fiat", year: 1975, color: "yellow"});
// 对两个字段排序
cars.sortOn(["year", "make"]);
for (var i:int = 0; i < cars.length; i++) {
/* 显示:
gold 1968 Chrysler
yellow 1975 Fiat
green 1975 Mercedes
black 1983 Fiat
gray 1983 Fiat
blue 1985 Mercedes
silver 1992 Honda
maroon 1997 Honda
beige 2000 Chrysler
white 2000 Mercedes
blue 2001 Honda
orange 2004 Chrysler
*/
trace(cars[i].color + "\t" +
cars[i].year + "\t" +
cars[i].make);
}
下面的例子，先对 make, 再对year排序：
cars.sortOn(["make", "year"]);

for (var i:int = 0; i < cars.length; i++) {
/* 显示:
gold 1968 Chrysler
beige 2000 Chrysler
orange 2004 Chrysler
yellow 1975 Fiat
black 1983 Fiat
gray 1983 Fiat
silver 1992 Honda
maroon 1997 Honda
blue 2001 Honda
green 1975 Mercedes
blue 1985 Mercedes
white 2000 Mercedes
*/
trace(cars[i].color + "\t" +
cars[i].year + "\t" +
cars[i].make);
}
sortOn( ) 方法也可用那些数组常量完成降序，忽略大小写等排序：
cars.sortOn("year", Array.DESCENDING);

for (var i:int = 0; i < cars.length; i++) {
/* 显示:
beige 2000 Chrysler
maroon 1997 Honda
blue 1985 Mercedes
gray 1983 Fiat
*/
trace(cars[i].color + "\t" +
cars[i].year + "\t" +
cars[i].make);
}

5.9.存储多维数据

2007-01-22T15:24:00.000+08:00

5.9. 存储多维数据

问题
我要怎样存储多组相关的数据
解决办法
使用多维数组存储
讨论

除了一维数组，还可以创建多维数组，比如 beginGradientFill() 方法（在第7章讨论）使用三个平行数组表示colors, alphas, 和ratios ，每个数组都有相同的下标。
创建平行数组，然后操作同一下标的元素，使用平行数组，很容易访问同一下标的相关元素，比如：
var colors:Array = ["maroon", "beige", "blue", "gray"];
var years:Array = [1997, 2000, 1985, 1983];
var makes:Array = ["Honda", "Chrysler", "Mercedes", "Fiat"];

// 循环这些数组，因此数组的长度相同，可以用任何一个数组的length属性，下面的例子使用了 //makes.length.
for (var i:int = 0; i < makes.length; i++) {
trace("A " + colors[i] + " " +
years[i] + " " +
makes[i]);
// 显示:
// A maroon 1997 Honda
// A beige 2000 Chrysler
// A blue 1985 Mercedes
// A gray 1983 Fiat
}
需要注意的是，如果改变了数组长度，必须同时修改其他数组。
另一种方法就是创建多维数组，它是数组的数组：
// 创建数组 cars，然后用数组组装填充，每个元素都是数组包含3个元素 (color, year, make).
var cars:Array = new Array();
cars.push(["maroon", 1997, "Honda"]);
cars.push(["beige", 2000, "Chrysler"]);
cars.push(["blue", 1985, "Mercedes"]);
cars.push(["gray", 1983, "Fiat"]);
// 循环遍历数组
for (var i:int = 0; i < cars.length; i++) {
// 显示:
// A maroon 1997 Honda
// A beige 2000 Chrysler
// A blue 1985 Mercedes
// A gray 1983 Fiat
TRace("A " + cars[i][0] + " " +
cars[i][1] + " " +
cars[i][2]);
}
下面的代码用二重循环遍历二维数组：
for (var i:int = 0; i < cars.length; i++) {
for (var j:int = 0; j < cars[i].length; j++) {
TRace("Element [" + i + "][" + j + "] contains: " +
cars[i][j]);
}
}
从上面的例子来看,很难区别cars[i][0] 和 cars[i][j]。但如果任何数组的长度发生变化这时cars[i][0]这种表示就很被动，需要修改代码才行。
另外对象数组的使用也很类似，只是多了个名称属性。对象数组用名称属性代替数字下标来索引元素：
// 创建数组cars，填充对象
// 每个对象有个make 属性，year 属性和 color 属性
var cars:Array = new Array();
cars.push({make: "Honda", year: 1997, color: "maroon"});
cars.push({make: "Chrysler", year: 2000, color: "beige"});
cars.push({make: "Mercedes", year: 1985, color: "blue"});
cars.push({make: "Fiat", year: 1983, color: "gray"});

// 遍历数组
for (var i:int = 0; i < cars.length; i++) {
trace("A " + cars[i].color + " " +
cars[i].year + " " +
cars[i].make);
}

5.8.创建数组的拷贝

2007-01-21T23:40:00.001+08:00

5.8. 创建数组的拷贝

问题
我要复制一份数组，内容完全一样，只是不同的引用
解决办法
使用 concat( ) 方法或 slice( ) 方法，另外还可以使用ArrayUtilities.duplicate( ) 方法，duplicate( ) 方法可以创建递归复制
讨论

因为数组是复合类型，因此它的比较和复制都和基本类型不同。一个变量指向数组但是实际上它并不包含数组数据，它只是指向内存中存放数组数据的位置。从优化的角度考虑，基本类型的占用空间往往很小，但是符合类型如数组可以变得很大，如果我们在日常操作中经常复制整个数组是非常不明智的，因此当你要复制数组时，ActionScript 并不是生成独立的一份拷贝，看下面的例子：
首先我们看看基本类型是怎么复制的：
// 赋值数字5给变量
var quantity:int = 5;
// 拷贝 quantity的值给另一个变量 newQuantity.
var newQuantity:int = quantity;
// 改变 quantity的值
quantity = 29;
trace(quantity); // 显示: 29
trace(newQuantity); // 显示: 5
我们看到，两者是互不影响的，也就是说基本变量拷贝的是值
现在我们看看数组的操作，和上面的例子不同，两个变量实际上都指向了同一个数组存贮空间。当letters 变量改变数组内容时，也影响到newLetters变量：
// 赋值数组.
var letters:Array = ["a", "b", "c"];
// 拷贝 letters 到newLetters.
var newLetters:Array = letters;
// 两个数组包含相同内容
trace(letters); // 显示: "a,b,c"
trace(newLetters); // 显示: "a,b,c"
// 改变letters的值
letters = ["d", "e", "f"];
// 另一个数组也变了
trace(letters); // 显示: "d,e,f"
trace(newLetters); // 显示: "d,e,f" (而不是 "a,b,c")
其实这就像文件夹的两个快捷方式那样，两个快捷方式虽然名字不同，但是都指向同一个文件，无论哪个对文件夹操作，另一个快捷方式也发生变化。
如果真要复制数组，可以调用数组的 concat( ) 方法：
// 给数组赋值.
var letters:Array = ["a", "b", "c"];
//用concat( ) 创建新的数组
var newLetters:Array = letters.concat( );
// 两个数组内容一样
trace(letters); // 显示: "a,b,c"
trace(newLetters); // 显示: "a,b,c"
// 改变letters的值
letters = ["d", "e", "f"];
//不像上面的例子，这次两个数组内容不同了.
trace(letters); // 显示: "d,e,f"
trace(newLetters); // 显示: "a,b,c"
也可以用 slice( ) 方法代替 concat( )，例如：
var newLetters:Array = letters.slice(0);
concat( ) 或 slice( ) 方法复制一维整型下标的数组还可以，但是如果是多维的联合数组就不行了，对于联合数组,不能使用 concat( ) 或 slice( ) 方法，对于多维数组，用 concat( ) 或 slice( ) 只能复制顶层的数组，内部的就不能复制了，看下面的代码：
var coordinates:Array = new Array( );
coordinates.push([0,1,2,3]);
coordinates.push([4,5,6,7]);
coordinates.push([8,9,10,11]);
coordinates.push([12,13,14,15]);

// 复制
var coordinatesDuplicate:Array = coordinates.concat( );

// 替换元素
coordinatesDuplicate[0][0] = 20;
trace(coordinates[0][0]); //显示: 20

// 替换顶层元素.
coordinatesDuplicate[1] = [21,22,23,24];
trace(coordinates[1]); // 显示: 4,5,6,7
上面的代码coordinates 是个二维数组，coordinatesDuplicate 是coordinates的复制。但是，虽然是复制，有些元素仍然引用了原始数组元素，这就意味你改变了一个，会影响另一个数组的内容。实际上从上面的代码可以看出，只复制了顶层的数组，这一部分是互不关联的。
要想完全的复制数组，需要使用递归。ArrayUtilities.duplicate( ) 方法就是这样的做法，默认下它也只复制一层数组，当第2个参数设为true时则是递归复制：
// 创建二维数组
var coordinates:Array = new Array( );
for(var i:int = 0; i < 4; i++) {
coordinates[i] = new Array( );
for(var j:int = 0; j < 4; j++) {
coordinates[i].push(String(i) + "," + String(j));
}
}

// 复制coordinates.
var newCoordinates:Array = ArrayUtilities.duplicate(coordinates, true) as Array;
// 替换
newCoordinates[0][0] = "a";
// 使用toString() 方法输出
trace(ArrayUtilities.toString(coordinates));
trace(ArrayUtilities.toString(newCoordinates));
下面的例子演示用 duplicate( ) 方法复制联合数组：
var coordinatesMap:Object = new Object( );
coordinatesMap.a = [{a: 1},{b: 2}, {c: 3}, {d: 4}];
coordinatesMap.b = [{a: 1},{b: 2}, {c: 3}, {d: 4}];
coordinatesMap.c = [{a: 1},{b: 2}, {c: 3}, {d: 4}];
coordinatesMap.d = [{a: 1},{b: 2}, {c: 3}, {d: 4}];
var newCoordinatesMap:Object = ArrayUtilities.duplicate(coordinatesMap, true);
newCoordinatesMap.a[0] = {r: 5};
trace(ArrayUtilities.toString(coordinatesMap));
trace(ArrayUtilities.toString(newCoordinatesMap));
两个例子可以看到，复制的数组改变不会影响原始数组。

5.7.转换数组为字符串

2007-01-21T22:14:00.001+08:00

5.7. 转换数组为字符串

问题
我要把数组转换为字符串
解决办法
使用 join( ) 方法
讨论

ActionScript 提供内建的方法 join( ) 可以快速把数组转换为字符串（数组中的元素不管什么类型都将转换为字符串），该方法接受个参数作为分隔符：
var letters:Array = ["a", "b", "c"];
trace(letters.join("|")); // 显示: a|b|c
如果不指定分隔符，默认为逗号：
var letters:Array = ["a", "b", "c"];
trace(letters.join()); // 显示: a,b,c

当 join( ) 的分隔符为逗号，其效果和toString( ) 一样。实际上当我们直接输出数组时系统就是调用toString( ) 方法进行转换的，例如：
var letters:Array = ["a", "b", "c"];
trace(letters); // 显示: a,b,c

5.6.转换字符串为数组

2007-01-21T22:04:00.001+08:00

5.6. 转换字符串为数组

问题
我有一堆字符串，想把它转换为数组。
解决办法
使用String.split( ) 方法
讨论

String 类的split( ) 方法把字符串转换为数组，但前提是字符串中含有统一的分割符，比如 Susan,Robert,Paula 字符串分割符为逗号
split( ) 方法接受两个参数：
分割符
用分割符来分割字符串，如果没定义，则把整个字符串作为数组的第一个元素
数量
分割出的最大元素个数，如果没定义，则全部放入数组。
可以使用空格符作为分割符：
var list:String = "Peter Piper picked a peck of pickled peppers";
var words:Array = list.split(" ");
split( ) 方法在用URLLoader 对象读取数据时经常用到，比如你接受服务器的一些姓名字符串：
names=Michael,Peter,Linda,Gerome,Catherine
这是用split( ) 方法转换为数组：
// URLLoader 读取数据
var namesData:String = _loader.data;
var names:Array = namesData.split(",");

5.5.在数组中间插入元素

2007-01-21T21:35:00.001+08:00

5.5. 在数组中间插入元素

问题
我要在数组中间插入元素u
解决办法
使用splice( ) 方法
讨论

splice( ) 方法不仅可以删除元素，也可以插入元素，插入的元素放到第2个参数之后，当第2个参数为0代表插入元素：
var letters:Array = ["a", "b", "c", "d"];
//插入三个元素，起始位置为1
letters.splice(1, 0, "r", "s", "t");

// letters 现在包含的元素有：
// "a", "r", "s", "t", "b", "c", "d".
for (var i:int = 0; i < letters.length; i++) {
trace(letters[i]);
}
你也可以删除和插入同时执行：
var letters:Array = ["a", "b", "c", "d"];
//删除2个，插入3个
letters.splice(1, 2, "r", "s", "t");
// myArray 现在的元素
// "a", "r", "s", "t", and "d".
for (var i:int = 0; i < letters.length; i++) {
trace(letters[i]);
}

5.4.删除数组元素

2007-01-21T21:21:00.001+08:00

5.4. 删除数组元素

问题
我要删除一个或多个数组元素，或移动数组元素
解决办法
splice( ) 方法删除指定位置的元素，pop( ) 删除尾部元素，shift( ) 删除首部元素
讨论

删除指定位置的元素使用splice( ) 方法，它需要两个参数：
start
开始下标
deleteCount
删除的元素个数，如果没有定义，则从起始位置到末尾全部删除：
var letters:Array = ["a", "b", "c", "d"];
//从下标1开始删除1个元素
letters.splice(1, 1);
// 显示结果，现在只剩三个
// "a", "c", 和 "d".
for (var i:int = 0; i < letters.length; i++) {
trace(letters [i]);
}
splice( ) 方法也返回一个新的包含删除的元素数组：
var letters:Array = ["a", "b", "c", "d"];
//删除两个元素，从0位置开始
var deleted:Array = letters.splice(0, 2);
// 显示: "a"，"b".
for (var i:int = 0; i < deleted.length; i++) {
trace(deleted[i]);
}
删除首部和尾部的元素可用shift( ) 和pop( ) 方法。 shift( ) 方法删除首部第一个元素，然后返回该元素，pop( ) 方法删除尾部的元素并返回该值：
var letters:Array = ["a", "b", "c", "d"];
trace(letters.shift( ));
trace(letters.pop( ));

//显示剩下的元素
for (var i = 0; i < letters.length; i++) {
trace(letters[i]);
}
在for循环里删除原始，也要修改下标值，下面的代码演示不更新下标值变量出现的情况：
var numbers:Array = new Array(4, 10);
numbers[4] = 1;
trace(numbers); // 显示: 4,10,undefined,undefined,1
for(var i:int = 0; i < numbers.length; i++) {
if(numbers[i] == undefined) {
numbers.splice(i, 1);
}
}
trace(numbers); // 显示： 4,10,undefined,1
上面的代码本来是期望上出全部undefined 元素的，结果只删除一个，调试运行，看看发生了什么：
1。前两个循环什么都没做，因为都不是undefined.
2。第三次找到 undefined 然后删除它，这时，第4个和第5个元素下移变成了第3个和第4个元素
3。下一循环检测第4个元素，也就是最后一个，这时忽略了第3个元素也就是那个undefined 元素，因此，当删除元素，应该把小标变量-1，代码应该这样：
var numbers:Array = new Array(4, 10);
numbers[4] = 1;
trace(numbers); // 显示: 4,10,undefined,undefined,1
for(var i:int = 0; i < numbers.length; i++) {
if(numbers[i] == undefined) {
numbers.splice(i, 1);
i--;
}
}
trace(numbers); // 显示: 4,10,1

5.3.搜索匹配的数组元素

2007-01-21T20:28:00.001+08:00

5.3. 搜索匹配的数组元素

问题
我要找出指定值得数组元素
解决办法
用for 语句和break 语句就能找到匹配的元素。另外用ArrayUtilities.findMatchIndex( ), ArrayUtilities.findLastMatchIndex( ), 和ArrayUtilities.findMatchIndices( ) 方法
讨论

用for循环查找第一个匹配的元素后，用break立即返回，这样就实现功能了。
break应该在if语句里进行判断，是否找到匹配元素，找到则执行break推出循环，否则继续查找。
var letters:Array = ["a", "b", "c", "d", "a", "b", "c", "d"];

// 指定要搜索的内容
var match:String = "b";

for (var i:int = 0; i < letters.length; i++) {

// 检测当前元素是否匹配
if (letters[i] == match) {
trace("Element with index " + i +
" found to match " + match);
break;
}
}
也可以找到匹配的最后一个元素，这就需要倒序遍历数组：
var letters:Array = ["a", "b", "c", "d", "a", "b", "c", "d"];

var match:String = "b";
for (var i:int = letters.length - 1; i >= 0; i--) {
if (letters[i] == match) {
trace("Element with index " + i +
" found to match " + match);
break;
}
}
使用自定义类ArrayUtilities 类更简单，它在 ascb.util 包中，首先导入它：
import ascb.util.ArrayUtilities;
ArrayUtilities 类有三个方法来查找匹配的元素findMatchIndex( ), findLastMatchIndex( ), 和 findMatchIndices( )。 findMatchIndex( ) 方法至少需要两个参数：一个指向数组的引用和需要匹配的值，返回第一个匹配的元素下标，如果找不到返回-1：
var letters:Array = ["a", "b", "c", "d"];
trace(ArrayUtilities.findMatchIndex(letters, "b"));
// 显示: 1
trace(ArrayUtilities.findMatchIndex(letters, "r"));
// 显示: -1
也可以指定搜索的起始下标作为第三个参数：
var letters:Array = ["a", "b", "c", "d", "a", "b", "c", "d"];
trace(ArrayUtilities.findMatchIndex(letters, "a", 1));
// 显示: 4
如果第三个参数为true，则返回部分匹配的元素：
var words:Array = ["bicycle", "baseball", "mat", "board"];
trace(ArrayUtilities.findMatchIndex(words, "s", true));
// 显示: 1
如果你想部分匹配又想指定起始搜索下标，可以把起始下标作为第四个参数。
findLastMatchIndex( ) 方法返回最后一个匹配的元素下标
findMatchIndices( ) 方法返回所有匹配的元素下标数组：
var letters:Array = ["a", "b", "c", "d", "a", "b", "c", "d"];
trace(ArrayUtilities.findMatchIndices(letters, "b"));
// 显示: 1,5
也可以设定为部分匹配，指定第三个参数为true：
var words:Array = ["bicycle", "baseball", "mat", "board"];

trace(ArrayUtilities.findMatchIndices(words, "b", true));
// 显示: 0,1,3
ArrayUtilities 方法内部也是用for循环来实现的，现在我们看看代码，下面是findMatchIndex( ) 方法的代码：

public static function findMatchIndex(array:Array, element:Object):int {
// Use a variable to determine the index
// from which to start. Use a default value of 0.
var startingIndex:int = 0;

// By default don't allow a partial match.
var partialMatch:Boolean = false;

// If the third parameter is a number,
// assign it to nStartingIndex.
// Otherwise, if the fourth parameter is a number,
// assign it to nStartingIndex instead.
if(typeof arguments[2] == "number") {
startingIndex = arguments[2];
}
else if(typeof arguments[3] == "number") {
startingIndex = arguments[3];
}

// If the third parameter is a Boolean value,
// assign it to partialMatch.
if(typeof arguments[2] == "boolean") {
partialMatch = arguments[2];
}

// Assume no match is found.
var match:Boolean = false;

// Loop through each of the elements of the array
// starting at the specified starting index.
for(var i:int = startingIndex;
i < array.length; i++) {

// Check to see if the element either matches
// or partially matches.
if(partialMatch) {
match = (array[i].indexOf(element) != -1);
}
else {
match = (array[i] == element);
}

// If the element matches, return the index.
if(match) {
return i;
}
}

// The following return statement is only reached
// if no match was found. In that case, return -1.
return -1;
}

public static function findMatchIndices(array:Array,
element:Object, partialMatch:Boolean = false):Array {
var indices:Array = new Array( );
var index:int = findMatchIndex(array,
element,
partialMatch);
while(index != -1) {
indices.push(index);
index = findMatchIndex(array,
element,
partialMatch,
index + 1);
}
return indices;
}

5.2.遍历数组成员

2007-01-21T19:44:00.001+08:00

5.2. 遍历数组成员

问题
我要访问数组的每个元素
解决办法
利用 for 循环来遍历数组，使用下标返回元素。
讨论

for循环的初始变量从0开始，结束为array.length-1，因为是从下标0开始的：
var letters:Array = ["a", "b", "c"];
for (var i:int = 0; i < letters.length; i++) {
trace("Element " + i + ": " + letters[i]);
}
也可以降序遍历数组，循环变量从array.length-1开始到0：
var letters:Array = ["a", "b", "c"];
for (var i:int = letters.length - 1; i >= 0; i--){
trace("Element " + i + ": " + letters[i]);
}
有很多情况需要用循环遍历所有元素，比如，获得了包含sprite的数组, 然后把每个sprite的x坐标+1：
for (var i:int = 0; i < sprites.length; i++){
sprites[i].x++;
}
可以把数组长度存在变量中，免得每次循环都要重新计算：
var length:int = sprites.length;
for (var i:int = 0; i < length; i++){
sprites[i].x++;
}
这样做可以提高Flash性能，因为不用每次循环都去计算长度了，但是有个前提，就是没有进行插入删除操作来改变长度值，否则就要每次计算长度才行。

5.1.在数组首部和尾部添加元素

2007-01-21T19:23:00.001+08:00

5.1. 在数组首部和尾部添加元素

问题
我要再添加新元素到数组
解决办法
push( ) 方法在数组尾部添加元素，unshift( ) 方法在数组首部插入元素
讨论

Array.push( ) 方法把元素加在数组的尾部，也可以一次添加多个值：
var array:Array = new Array();
array.push("val 1", "val 2");
也可以在数组指定的下标位置设置值，下标位置在0到Array .length - 1之间：
array[array.length] = "val 3";
如果下标不存在，数组会自动扩充，扩充的空间当中，没有被赋值的自动以"undefined"填充：
var letters:Array = ["a", "b", "c"];
letters[5] = "f";
通过unshift( ) 方法在数组首部插入新元素：
// 创建四个元素的数组
// "a", "b", "c", "d".
var letters:Array = new Array( );
letters.push("a", "b", "c", "d");

// 添加"z" ，其他元素依次向下移动
letters.unshift("z");

for (var i:int = 0; i < letters.length; i++) {
trace(letters[i]);
}
到底把数据插入到哪里需要根据具体实际需要，比如要达到(LIFO) 目的，我们需要 Array.push( ) 和 Array.pop( ) 成对使用。

5.0.简介

2007-01-21T17:10:00.001+08:00

5.0. 简介

数组保存一组相关联的数据，组织和处理这些数据。数组概念在生活中是很常见的，比如菜谱，包含姓名，地址，生日等地址本都是数组原理。
在ActionScript中，有两种数组：整型下标和联合数组，都是组织相关数据，只是访问数据的方法不同而已。

整型下标数组：
数组的每个元素都用唯一的整数下标来索引。通过下标排序，起始值为0，每个元素保存在索引指定的位置，这就像抽屉一样。

联合数组：
用字符串关键字作为每个元素的索引。

首先创建数组，有两种构造方法，
// 创建空的数组
var array:Array = new Array();

// 创建数组时指定数组长度
var array:Array = new Array(elements);

//创建数组时加入多个元素
var array:Array = new Array(element0,...elementN);
直接用数组符号也可以创建一个数组，这是很简洁的方式创建数组：
var letters:Array = ["a", "b", "c"];
Array 类提供了一些方法修改数组内容或者返回新的数组
使用数组操作符（中括号加上下标索引）来读取和设置内容，如：
//设置第5个元素为"apples"
// (下标从0开始).
items[4] = "apples";

// 显示第5个元素
trace(items[4]); // 显示: apples
ActionScript 并不关心数组里存的是什么类型的数据，可以是字符串，数字，布尔值和引用的类型，而且不像其他语言，同一个数组可以存不同类型的数据，例如：
var data:Array = ["a", 2, true, new Object()];
还有点不同，数组在创建时可以不用指定数组长度。

第四章.数字和数学

2007-01-20T23:14:00.001+08:00

第四章.数字和数学

4.12.计算两点之间的距离

2007-01-20T22:18:00.000+08:00

4.12. 计算两点之间的距离

问题
我要计算两点之间的距离
解决办法
根据勾股定理，使用 Math.pow( ) 和 Math.sqrt( ) 联合计算
讨论

通过勾股定理可以计算出两点之间的距离（直线）。一个三角形，最长边的平方等于其他两边的平方和：
a2 + b2 = c2

根据这个公式可以计算出两点之间的距离，a 是两点X坐标的差值，b 是两点Y坐标的差值：
var c:Number = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));

4.11.转换角度计算

2007-01-20T21:51:00.001+08:00

4.11. 转换角度计算

问题
我要计算角度及转换为合适的单位
解决办法
使用 Unit 和 Converter 类
讨论

影片剪辑的_rotation 属性使用角度计算的。如果用弧度而不是角度就有些麻烦了。首先要把弧度值转换为角度值，再赋值给 _rotation 属性，而且，大多数人喜欢用角度计算。还好，把弧度转换为角度挺容易，只要180/Math.PI.，角度转换为弧度就反一下，Math.PI/180. ，而且使用自定义的Unit 和Converter 类更简单。
这两个类都是自定义类，在ascb.unit 包中，首先创建Unit 实例，然后描述需要转换的单位类型， Unit.DEGREE, Unit.RADIAN, 和 Unit.GRADIAN 常量返回新的Unit 对象表示各种单位。Unit 对象有些属性，包括name, category, label, 和labelPlural:
var degree:Unit = Unit.DEGREE;
trace(degree.name); // 显示: degree
trace(degree.category); // 显示: angle
trace(degree.label); // 显示: degree
trace(degree.labelPlural); // 显示: degrees
使用getConverterTo( ) 方法，传递 Unit 对象作为，得到converter对象，看下面的代码得到弧度向角度转换的对象：
var converter:Converter = Unit.DEGREE.getConverterTo(Unit.RADIAN);
一旦得到Converter 实例，运行convert( ) 方法，指定值进行转换：
trace(converter.convert(90));
convertWithLabel( ) 方法输出字符串：
var converterToRadians:Converter = Unit.DEGREE.getConverterTo(Unit.RADIAN);
var converterToDegrees:Converter = Unit.RADIAN.getConverterTo(Unit.DEGREE);
trace(converterToRadians.convertWithLabel(1));
trace(converterToRadians.convertWithLabel(57.2957795130823));
trace(converterToDegrees.convertWithLabel(1));
trace(converterToDegrees.convertWithLabel(0.0174532925199433));

/*
显示:
0.0174532925199433 radians
1 radian
57.2957795130823 degrees
1 degree
*/
如果执行相反操作，使用getConverterFrom( ) 方法：
var converter:Converter = Unit.DEGREE.getConverterFrom(Unit.GRADIAN);
trace(converter.convert(100));
trace(converter.convert(23));

4.10.产生唯一的随机数

2007-01-20T21:12:00.001+08:00

4.10. 产生唯一的随机数

问题
我要产生唯一数
解决办法
使用 NumberUtilities.getUnique( ) 方法
讨论

唯一随机数经常在产生唯一的URL 时用到。就是在URL后加上个唯一的数字，以区别于使用过的URL，因此浏览器总是会去调用远程服务器而不是访问缓存
NumberUtilities.getUnique( ) 返回基于毫秒的数字
trace(NumberUtilities.getUnique( ));
下面的代码产生一组唯一的随机数：
for(var i:Number = 0; i < 100; i++) {
trace(NumberUtilities.getUnique( ));

4.9.模拟骰子

2007-01-20T20:58:00.001+08:00

4.9. 模拟骰子

问题
我要模仿掷骰子
解决办法
用NumberUtilities.random( ) 方法产生指定范围的随机数
讨论

用 random( ) 方法产生整数来模拟掷骰子，这在很多游戏中经常用到，这次我们在ActionScript中实现

一般我们产生随机数然后保存它在使用，如果要重新使用存在的随机数，应保存它而不是再产生新的随机数。注意下面两种情况，第一种，dice总是die1和die2的之和：
var die1:uint = NumberUtilities.random(1, 6);
var die2:uint = NumberUtilities.random(1, 6);
var dice:uint = die1 + die2;
下面的情况，dice和die1和die2没有关系，换句话说，即使die1和die2加起来等于7，dice也不会等于它：
var die1:uint = NumberUtilities.random(1, 6);
var die2:uint = NumberUtilities.random(1, 6);
var dice:uint = NumberUtilities.random(1, 6) + NumberUtilities.random(1, 6);
NumberUtilities.random( ) 还可以模拟多边的骰子：
var die1:uint = NumberUtilities.random(1, 15);
下面的例子模拟了一个骰子

package {

import flash.display.Sprite;
import flash.text.TextField;
import flash.events.MouseEvent;
import ascb.util.NumberUtilities;

public class NumbersAndMath extends Sprite {

var _die:Sprite;
var _value:uint;

public function NumbersAndMath( ) {
_die = new Sprite( );
addChild(_die);
_die.addEventListener(MouseEvent.CLICK, rollDie);
rollDie(null);
}

private function rollDie(event:MouseEvent):void {
_value = NumberUtilities.random(1, 6);
_die.graphics.clear( );
_die.graphics.lineStyle( );
_die.graphics.beginFill(0xFFFFFF);
_die.graphics.drawRect(0, 0, 50, 50);
_die.graphics.endFill( );
_die.graphics.beginFill(0x000000);
if(_value == 1 || _value == 3 || _value == 5) {
_die.graphics.drawCircle(25, 25, 4);
}
if(_value == 2 || _value == 3 || _value == 4 ||
_value == 5 || _value == 6)
{
_die.graphics.drawCircle(11, 11, 4);
_die.graphics.drawCircle(39, 39, 4);
}
if(_value == 4 || _value == 5 || _value == 6) {
_die.graphics.drawCircle(11, 39, 4);
_die.graphics.drawCircle(39, 11, 4);
}
if(_value == 6) {
_die.graphics.drawCircle(11, 25, 4);
_die.graphics.drawCircle(39, 25, 4);
}
}

}
}