ActionScript 3.0中的数组是以非零整数为索引的稀疏数组。不要求所有元素同一类型，不支持类型化数组。
一、基本操作
1.获取长度
var array:Array = ["apple", "banana", "pear", "berry", "orange", "litchi", ];
trace(array.length)
// 输出
// 6
2.查找：indexOf、lastIndexOf
- indexOf：从左到右查找，也就是按索引从小到大查找，找不到则返回 -1。
- lastIndexOf：从右到左查找，也就是按索引从大到小查找，找不到则返回 -1.
// 格式：
// 目标数组.indexOf(要查找的元素)
// 目标数组.lastIndexOf(要查找的元素)
// 目标数组.indexOf(要查找的元素， 查找的起始位置)
// 目标数组.lastIndexOf(要查找的元素， 查找的起始位置)
var array:Array = ["apple", "banana", "pear", "berry", "orange", "litchi", ];
trace("从左到右查找：" + array.indexOf("pear"));
trace("从右到左查找：" + array.lastIndexOf("pear"));
trace("从第三个元素开始，按索引从小到大查：" + array.indexOf("litchi", 2));
trace("从第五个元素开始，按索引从大到小查：" + array.lastIndexOf("banana", 4));
// 输出
// 从左到右查找：2
// 从右到左查找：2
// 从第三个元素开始，按索引从小到大查：5
// 从第五个元素开始，按索引从大到小查：1
注意：数组的查找判断的满足条件是，带查找的元素与数组中的元素全等，即使用“===”来判断是否全等，不会执行类型转换
3.在数组首位新增元素：push、unshift
- push：在数组尾部新增一个或多个元素
- unshift：在数组头部新增一个或多个元素
push和unshift方法都会返回值。所返回的值是新增元素后的数组长度
// 格式：
// 目标数组.push(元素)
// 目标数组.push(元素1, 元素2, ...元素n)
// 目标数组.shift(元素)
// 目标数组.shift(元素1, 元素2, ...元素n)
var array:Array = ["apple", "banana", "pear", "berry", "orange", "litchi", ];
// 头部新增多个元素，用逗号隔开
trace(array.unshift("apple", "banana"));
// 尾部新增多个元素，用逗号隔开
trace(array.push("orange", "litchi"));
// 打印数组
trace(array);
// 输出
// 8
// 10
// apple,banana,apple,banana,pear,berry,orange,litchi,orange,litchi
4.删除数组首位元素：pop、shift
- pop：将数组最后一个元素删除
- shift：将数组的第一个元素删除，剩余元素索引值减1
pop、shift每次只能删除一个元素，而都有返回值，返回值是被删除的元素。若要一次性删除多个元素，则需要使用splice方法。下述
// 格式，无需参数：
// 目标数组.pop()
// 目标数组.shift()
var array:Array = ["apple", "banana", "pear", "berry", "orange", "litchi", ];
// 头部新增多个元素，用逗号隔开
trace(array.unshift("apple", "banana"));
// 尾部新增多个元素，用逗号隔开
trace(array.push("orange", "litchi"));
// 打印数组
trace(array);
// 连续两次删除头部元素
trace("第一次删除头部元素" + array.shift());
trace("第二次删除头部元素" + array.shift())
trace(array);
// 连续两次删除尾部元素
trace("第一次删除尾部元素" + array.pop());
trace("第二次删除尾部元素" + array.pop());
trace(array);
// 输出
// 8
// 10
// apple,banana,apple,banana,pear,berry,orange,litchi,orange,litchi
// 第一次删除头部元素apple
// 第二次删除头部元素banana
// apple,banana,pear,berry,orange,litchi,orange,litchi
// 第一次删除尾部元素litchi
// 第二次删除尾部元素orange
// apple,banana,pear,berry,orange,litchi
5.在数组中插入或者删除多个元素：splice
-从数组某位置开始，删除指定书目的元素，并插入一些新元素。
数组.splice(删除点的索引， 要删除的元素数目， 新元素1， 新元素2， ...新元素n);
- 删除数组中某位置之后几个元素。
数组.splice(删除点的索引， 要删除的元素数目);
- 删除数组中某位置之后所有元素。
数组.splice(删除点索引);
- 在数组中某位置之后，插入新元素。
数组.splice(删除点索引， 0， 新元素1， 新元素2， ...新元素n);
注意：
删除点的索引可以是负值，表示数组从尾部倒数的位置。比如索引为-3，指的是数组倒数第三个元素，索引为-1，则是倒数第一个元素。
splice方法有返回值，返回一个包含删除的那些元素的数组。splice改变了原数组的内容，如果只是想获取数组中的一些内容而不想改变原数组，则应该使用slice方法。
var array:Array = ["apple", "banana", "pear", "berry", "orange", "litchi"];
// 从索引为 2 开始，删除 1 个元素，再添加新元素 fruit01, fruit02
trace("被删除的元素 " + array.splice(2, 1, "fruit01", "fruit02"));
trace(array);
// 输出
// 被删除的元素 pear
// apple,banana,fruit01,fruit02,berry,orange,litchi
trace("*******************************************************");
// 从索引为 -3 也就是倒数第三个元素开始，删除3个元素
trace("被删除的元素 " + array.splice(-3, 2));
trace(array);
// 输出
// 被删除的元素 berry,orange
// apple,banana,fruit01,fruit02,litchi
trace("*******************************************************");
// 从索引索引为 2 开始，删除之后所有元素
trace("被删除的元素 " + array.splice(1));
trace(array);
// 输出
// 被删除的元素 banana,fruit01,fruit02,litchi
// apple
trace("*******************************************************");
// 从索引索引为 2 开始，添加新元素 fruit03, fruit04, fruit05
trace("被删除的元素 " + array.splice(1, 0, "fruit03", "fruit04", "fruit05"));
trace(array);
// 输出
// 被删除的元素
// apple,fruit03,fruit04,fruit05
6.获取数组中的部分元素：slice
slice的作用是获取数组中的一段连续的元素，并且不改变原数组内的数据。该方法有两个参数：一个是截取范围的起始点索引，一个是截取范围的终止点索引。这两个参数一样也可以使用负值，用法同splice方法。返回值是截取的元素组成的新数组，其中包括起始点索引的元素而不包括终止点索引的元素。
// 格式
数组.slice(起始点索引, 终止点索引);
注意：如果在输入参数时，不慎将输入的起始点索引值设置为大于终止点索引值，那么slice只会返回一个空数组。当起始点、终止点中有一个是负值时，容易产生这种错误操作。如果只传一个参数，那么将把这个参数当成起始点索引值，截取从这个索引值开始，到数组终点这一段元素。当不传任何参数，那么将生成原数组的一个浅复制。
slice和splice的区别：
- slice不改变原有数组内容，splice改变。
- slice根据指定起点和终点确定截取范围，splice根据指定起始点和截取数量确定截取范围。
var array:Array = ["apple", "banana", "pear", "berry", "orange", "litchi"];
// 截取从索引值 2到4 的元素
trace("返回的数组 " + array.slice(2, 4));
// 输出 返回的数组 pear,berry
trace("**********************************************************");
// 起始索引大于终止索引，返回空数组
trace("返回的数组" + array.slice(4, 2));
// 输出 返回的数组
trace("**********************************************************");
// 使用负值参数
trace("返回的数组 " + array.slice(-2, -1));
// 输出 返回的数组 orange
trace("**********************************************************");
// 使用一个正值参数
trace("返回的数组 " + array.slice(3));
// 输出 返回的数组 berry,orange,litchi
trace("**********************************************************");
// 使用一个一个负值参数
trace("返回的数组 " + array.slice(-3));
// 输出 返回的数组 berry,orange,litchi
trace("**********************************************************");
// 不使用参数
trace("返回的数组 " + array.slice())
// 输出 返回的数组 apple,banana,pear,berry,orange,litchi
7.将多个元素或数组拼合成新的数组：concat
concat的作用是将多个元素或数组拼成一个新的数组，并通过返回值返回而不改变原数组内容。当不传任何参数时，将生成原数组的一个浅复制。
数组.concat(参数1， 参数2， 参数3...参数n);
concat和push的相同之处都是讲参数中的元素按顺序加到数组后面。
concat和push的不同点是：
- concat不改变原数组内容，而是生成一个新数组返回。push直接改变原数组内容，
- 当参数是数组时，concat会将数组分开成各个元素按顺序加入，而push则把这个数组当成一个元素加入到原数组后面。
var array:Array = ["apple", "banana", "pear", "berry", "orange", "litchi"];
var data01:Number = 2;
var data02:Array = [2, 3, 4];
var data03:Array = ["a", "b", "c"];
var newArray01:Array = array.concat(data01, data02, data03);
trace(newArray01);
// 输出 apple,banana,pear,berry,orange,litchi,2,2,3,4,a,b,c
trace(newArray01.length);
// 输出13
// 说明 data02, data03 被拆分成元素再添加
trace(array);
// 输出 apple,banana,pear,berry,orange,litchi
// 原数组内容不变
array.push(data01, data02, data03);
trace(array);
// 输出 apple,banana,pear,berry,orange,litchi,2,2,3,4,a,b,c
trace(array.length);
// 输出9
// 看似数组内容与 newArray01一样，实际上 push 是把data01, data02, data03各自当成一个元素
二、数组的浅复制与深复制
1.何时使用浅复制？何时使用深复制？
当数组元素全部是基元数据类型时，即全部都是值类型时，复制是没有浅复制和深复制之分。
当数组元素全部是复杂数据类型时，及引用类型，或者一部分是基元数据类型一部分是复杂数据类型时，才需要考虑浅复制和深复制。
比如数组A[1, "String", {A:"a", B:"b"}]，其中第三个元素是Object类型，属于复杂数据类型，如果要复制该数组，则需要考虑两种复制方式。
2.浅复制
生成数组浅复制的方法有两种：
var copy:Array = originalArray.concat();
var copy:Array = originalArray.slice();
使用浅复制生成的新数组，其各个元素存放的只是引用。两个数组中相同位置的元素存放的引用指向同一个对象。如果在操作元素时，等于操作引用指向的对象。
var data01:Object = {A:"a",B:"b"};
var data02:Array = [2, 3, 4];
var array:Array = ["helloWorld", data01, data02];
trace(array);
// 输出array: helloWorld,[object Object],2,3,4
// 1.使用slice方法生成 array的浅复制
var newArray01:Array = array.slice();
trace(newArray01);
// 输出 helloWorld,[object Object],2,3,4
// 内容与array一样
// 2.比较array 和 newArray01
trace(array == newArray01);
// 输出 false
/*
因为对于Array这个引用类型，“==”判断的是变量持
有对象的引用是否相同，而不是内容相同。由于slice（concat）1
是返回一个新数组，肯定不和原数组的引用相同
*/
trace(array[1] == newArray01[1]);
trace(array[2] == newArray01[2]);
/*
true
true
这两个元素是引用类型，所以其引用是相同的
*/
// 3.修改 newArray01 中的值
newArray01[0] = "hey";
newArray01[2][0] = 1000;
newArray01[1].A = "aaaa"
trace(array);
trace(newArray01)
trace(array[1].A);
trace(newArray01[1].A);
trace(array[2]);
trace(newArray01[2]);
/*
helloWorld,[object Object],1000,3,4
hey,[object Object],1000,3,4
aaaa
aaaa
1000,3,4
1000,3,4
可以看出 newArray01中的引用类型元素改变时，array中的引用类型元素也跟着改变
*/
3.深复制
使用深复制生成的新数组，其所有元素都是真正的原数组元素备份。这是两个数组中相同位置的元素，存放的是不同的引用，指向不同的对象。生成深复制时需要用到 ByteArray类。
var data01:Object = {A:"a",B:"b"};
var data02:Array = [2, 3, 4];
var array:Array = ["helloWorld", data01, data02];
trace(array);
// 输出array: helloWorld,[object Object],2,3,4
// 1.生成深复制
var arrayBA:ByteArray = new ByteArray();
arrayBA.writeObject(array);
arrayBA.position = 0;
var newArray01:Array = arrayBA.readObject() as Array;
trace(newArray01);
// 输出 helloWorld,[object Object],2,3,4
// 内容与array一样
// 2.比较array 和 newArray01
trace(array == newArray01);
// 输出 false
/*
因为对于Array这个引用类型，“==”判断的是变量持
有对象的引用是否相同，而不是内容相同。由于slice（concat）1
是返回一个新数组，肯定不和原数组的引用相同
*/
trace(array[1] == newArray01[1]);
trace(array[2] == newArray01[2]);
/*
false
false
因为是深复制，各个元素引用指向的对象都不同
*/
// 3.修改 newArray01 中的值
newArray01[0] = "hey";
newArray01[2][0] = 1000;
newArray01[1].A = "aaaa"
trace(array);
trace(newArray01)
trace(array[1].A);
trace(newArray01[1].A);
trace(array[2]);
trace(newArray01[2]);
/*
helloWorld,[object Object],2,3,4
hey,[object Object],1000,3,4
a
aaaa
2,3,4
1000,3,4
可以看出 newArray01中的引用类型元素改变时，array中的所有元素没有改变
*/
