ActionScript 3.0数组操作

  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中的所有元素没有改变
*/

三、排序:reverse、sort、sortOn

你可能感兴趣的:(ActionScript 3.0数组操作)