Array资料（方法总结）【转载】

数组方法大全

（一）

indexOf,lastindexOf用来直接查找目标元素在数组中的索引。

  

indexOf用法: 目标数组.indexOf(要查找的元素) 或者目标数组.indexOf(要查找的元素，查找的起始位置)  //按索引从小到大查找，找到返回索引值

  

lastindexOf用法:目标数组.lastindexOf(要查找的元素) 或者目标数组.lastindexOf(要查找的元素，查找的起始位置)//按索引从大到小查找，找到返回索引值

  

push用法:数组.push(元素);数组.push(元素1，元素2，…元素n) //在数组尾部新增一个或多个元素

  

unshift用法:数组.unshift(元素);数组.unshift(元素1，元素2，…元素n) //在数组头部新增一个或多个元素

  

  pop用法:数组.pop()  //将数组最后一个元素删除

  

shift用法:数组.shift()  //将数组第一个元素删除，剩余元素索引值自动减1

splice的四种用途:

  (1)数组.splice(删除点索引，要删除的元素数目，新元素1，新元素2,…新元素n)  //从数组某位置开始，删除被指定数目的元素，并插入一些新元素。

  (2)数组.splice(删除点索引，要删除的元素数目)  //删除数组中某位置之后的几个元素

  (3)数组.splice(删除点索引)  //删除数组中某位置之后的所有元素

  (4)数组.splice(删除点索引，0，新元素1,新元素2…新元素n)  //在数组某位置之后，插入新元素

  —-{删除点的索引可以是负值，表示数组从尾部倒数的位置。比如，索引为-3，指的是数组倒数第三个元素}

  

slice可以获取数组中一段连续的元素，而不改变原有数组的内容。也就是说从原有数组复制一部分数组出来组成一个新数组。

  用法：数组.slice(起始索引，终点索引)  //返回值是截取的元素组成的新数组，新中包括起点索引的元素，但不包括终点索引的元素。

       数组.slice（起始索引）  //返回的是从起始点索引开始到数组终点的这段元素

  —-{起始点和终点的索引可以是负值，表示数组从尾部倒数的位置。比如，索引为-3，指的是数组倒数第三个元素}

  

concat将多个元素或数组拼成一个新的数组。

  用法: 数组.concat(参数1，参数2，…参数n)  //concat会将数组分开成各个元素按顺序加入新数组中

  例子：

    var foo:Array=["a","b","c"]

    var bar1:int=1

    var bar2:Array=[2,3,4]

    var newarr=foo.concat(bar1,bar2)

    trace(newarr)

    //输出：a,b,c,1,2,3,4

    trace(newarr.length)

     //输出:7

   —-{concat与push的区别：concat不会改变原有数组内容，push直接改变原有数组内容。concat加入数组时会将数组打散再按顺序将元素加入到新数组中，push加入数组时会将整个数组当作一个元素加入到原数组的后面}

  reverse能将数组元素倒序

   用法:数组.reverse()  //返回的是新的数组

  

  sort对数组元素排序

   用法：

    (1)数组.sort()  //默认排序  按照字符串字母顺序排序，如果元素是数值，也会被当成字符串来排序

    (2)数组.sort(排序方式)  //使用“排序方式”参数来排序，排序方式是一些定义好的整数常量

    (3)数组.sort(比较函数)  //使用自定义的比较函数，注意此处只可写函数排序

  sortOn 当数组元素是复杂数据类型，且需要根据这种对象的某个属性值来排序时使用。比如说某俎元素都有一个属性值name，希望根据name来排序，那么使用的方法如下

   用法：

    (1)数组.sortOn(”name”)   //根据指定属性，默认排序

    (2)数组.sortOn(”name”,排序方式)  //根据指定属性，使用指定的“排序方式”来排序

    (3)数组.sortOn(”name”,比较函数)  //根据指定属性，使用自定义的函数排序

   排序方式，是指一些再Array类中定义好的整形常量，代表几种不同的排序方式

  (1)Array.CASEINSENSITIVE 值为1，表示大小写不敏感按字母顺序排序，如果是数字则从小到大。

  (2)Array.DESCENDING 值为2，表示按字母到序排序

  (3)Array.UNIQUESORT 值为4，表示必须是唯一性排序，如果比较值结果相同，则放弃排序返回值为 0

  (4)Array.RETURNINDEXEDARRAY 值为8，让sort()和sortOn()函数返回值返回排序后的索引列表，同时保持原数组不变

  (5)Array.NUMERIC or 16 值为16，强制sort()和sortOn()中对数值采用从小到大排序。

   比较函数的要求是，有两个参数，返回值是1，0，-1中的一个。

  function 函数名(参数A，参数B):int{}

   比较函数的作用是将数组里的元素一对对的取出来分别作为这个比较函数的两个参数，如果返回为1，那么作为A参数的元素就应该排在B的后面；如果返回为-1，那么A参数的元素就应该排在B前面，如果为0，表示结果一样。

  forEach用法：数组.forEach(callFunction:Function,thisObject:*=null):viod  //遍历操作：操作数组中的每一项元素。回调函数不需要返回任何值。

  filter用法：数组.every(callFunction:Function,thisObject:*=null):Array  //过滤器：将符合回调函数条件的元素提出来，构成一个新的数组并返回。

  every用法：数组.filter(callFunction:Function,thisObject:*=null):Boolean  //全员满足才为真：必须所有元素都让回调函数返回为true，every()才返回true，否则为false。回调函数返回单个元素比较结果，布尔值。

  map用法：数组.filter(callFunction:Function,thisObject:*=null):Array  //映射器：根据回调函数操作原数组每个元素，并利用回调函数返回的结果生成新的数组。回调函数返回的是单个新数组元素。

  some用法：数组.filter(callFunction:Function,thisObject:*=null):Boolean  //有一个满足为真：只要有一个元素能让回调函数返回true，则some（）返回true，否则为false。回调函数返回的是单个元素比较结果，布尔值。

 

（二）

首先值得一提的是AS3的 Array 有了像 String 一样的 indexOf() 和 lastIndexOf() 。另外增加了几个很有用的 Method。

every(callback:Function, thisObject:* =null):Boolean

检测是否数组所有元素都满足 callback 方法指定的条件。

 

some(callback:Function, thisObject:* =null):Boolean

检测数组中是否有元素满足 callback 方法指定的条件。

 

filter(callback:Function, thisObject:* =null):Array

根据 callback 方法指定的条件过滤数组，返回由符合条件的元素组成的新数组

 

map(callback:Function, thisObject:* =null):Array

数组的每一个元素执行 callback 方法，返回由对应的结果组成的新数组

 

forEach(callback:Function, thisObject:* =null):void

数组的每一个元素执行 callback 方法，不返回任何值

　　第二个参数 thisObject 是第一个参数 callback 的执行范围，即方法内部的this ，一般不需指定。callback 的参数也都是一样的

 

function callback(item:*, index:int,array:Array)

　　item 就是数组的每一个元素，如果数组元素类型统一就指明该类型，否则用 * 。index是数组当前元素的索引，array是操作的数组。参数名称可以任意起。如果只使用第一个参数这些方法都不改变原数组，使用后两个参数则可对原数组进行操作。不推荐这样做。

 

public function TestArray(){

   var arr1:Array = [1,3,5,7,

9,11];

   //是否所有元素是两位数(false)

   trace(arr1.every(isDoubleDigit));

   //是否有两位数的元素(true)

   trace(arr1.some(isDoubleDigit));

   //arr1数组元素执行doubleObject方法的返回值组成新的arr2数组

   var arr2:Array = arr1.map(doubleObject);

   //arr3是arr2中满足 bigDouble 条件的元素组成的新数组

   var arr3:Array = arr2.filter(bigDouble);

   trace("arr1:",arr1);

   trace("arr2 double :");

   arr2.forEach(traceDouble);

   trace("arr3 double :");

   arr3.forEach(traceDouble);

   //double方法使用了后两个参数，直接修改了原数组

   arr1.forEach(double);

   trace("arr1:",arr1);

}

private function isDoubleDigit(n

:int,i:int,a:Array):Boolean{

   return n > 10;

}

private functiondoubleObject(n:int,i:int,a:Array):Object{

   return {double:n * 2};

}

private function bigDouble(o:Object,i:int,a:Array):Boolean{

   return o.double > 10;

}

private functiontraceDouble(o:Object,i:int,a:Array):void{

   trace(o.double);

}

private functiondouble(n:int,i:int,a:Array):Object

{

   a *= 2;

}

输出：

 

false

true

arr1: 1,3,5,7,9,11

arr2 double :

2

6

10

14

18

22

arr3 double :

14

18

22

arr1: 2,6,10,14,18,22

 

//随机取数

var ar:Array=[];

for(var i:int=0;i<54;++i){

         ar.push(i);

         }

ar.forEach(function(e:*,i:int,a:Array):void{

                                                                                      var temp:*=e;

                                                                                     var index:int=int(Math.random()*53);

                                                                                      a=ar[index];

                                                                                      ar[index]=temp;

                                                                                      },null)

trace(ar)

 

（三）

ActionScript3.0中的数组是以非零证书为索引的洗漱数组(sparse array)。不要求所
有元素统一类型，不支持类型化数组(typed array).
1.数组的声明和访问：
//新建一个数组
var foo:Array = ['one','two','three'];
//使用索引访问第二个元素，数组索引从0开始，所以第二个的索引是1
Trace(foo[1]);
2.取数组的长度
var foo:Array = ['one','two','three'];
trace(foo.length);
//输出:3
foo.length = 5;
trace(foo);
//输出ne,two,three,,
//可以看到输出了两个空元素
//使用超过length的索引来设定元素
foo[7] = "out ranged";
trace(foo);
//输出ne,two,three,,,,,outrange
trace(foo.length);
//输出:8
//强行设定foo的length为3
foo.length = 2;
trace(foo);
//输出ne,two
//结果把第二个以后的元素都丢弃了
3.取数组的基本操作
var language:Array = ['php','java','C++'];
1.查找某个元素: indexOf、lastIndexOf
indexOf和lastIndexOf都可以用来查询目标元素在数组中的索引。不同的是，
indexOf用于在索引中从小到大查找，lastIndexOf用于在索引中从大到小查。如果查得到
就返回索引值，查不到就返回-1.
语法：
目标数组.indexOf(要查找的元素)
目标数组.lastIndexOf(要查找的元素)
除了上面的用法外，还可以定义查找的起始位置：
完整语法：
目标数组.indexOf(要查找的元素，[查找的起始位置])
目标数组.lastIndexOf(要查找的元素，[查找的起始位置])
实例：
数组indexOf和lastIndexOf的用法
var foo:Array =['apple','banana','pear','berry','apple','banana'];
trace("按索引从小到大查:"+foo.indexOf('banana'));
trace("按索引从大到小查:"+foo.lastIndexOf("banana"));
trace("从第三个元素开始,按索引从小到大查:"+foo.indexOf("banana",2));
trace("从第五个元素开始,按索引从大到小查:"+foo.lastIndexOf("banana",4));
2.在数组首尾新增元素:push,unshift
push:在数组尾部新增元素
unshift:在数组头部新增元素
注意：push和unshift都有返回值,返回值是增加元素后的数组长度.
语法：
数组.push(元素...)
数组.unshift(元素...)
push()和unshift()一次可以增加多个元素，元素之间用逗号隔开。
var language:Array =["A","B","C"];
trace(language.push("D"));
trace(language.push("E","F","G"));
trace(language);
trace(language.unshift("1"));
trace(language.unshift("2","3","4"));
trace(language);
3.删除数组首尾元素：
pop:删除数组的最后一个元素。
shift:删除数组的第一个元素，剩余的元素索引会自动减1。
语法：
数组.pop();
数组.shift();
注意：pop和shift都有返回值，返回值就是那个被删除的元素值。
pop和shift每次只能删除一个元素，如果需要一次删除多个元素,
可以使用splice方法。
实例：
var language:Array = ['A','B',"C"];
//下句执行了pop方法，并输出被删除的元素
trace("被pop删掉的元素是:"+language.pop());
trace("被shift删掉的元素是:"+language.shift());
trace("剩下的元素是:"+language);
4.在数组中插入或者删除元素:灵活多变的splice
Splice方法可以删除数组当中的一个或多个连续的元素。
语法：
1.从数组某位置开始，删除指定数目的元素，并插入一些新元素。这是
splice的标准用法。
数组.splice(删除点的索引，要删除的元素数目，新元素....)
注意：删除点的索引可以是负值，表示从数组尾部倒数的位置。
2.删除数组中某位置后的几个元素
数组.splice(删除点的索引，要删除的元素数目)
3.删除数组中某位置后的所有元素
数组.splice(删除点的索引)
4.在数组某位置开始，插入新的元素
数组.splice(删除点索引,0,新元素...)
注意: splice的返回值是一个数组，包含被删除的元素。
另外，splice改变了原数组的内容，如果只是想得到数组中的一段内容而不想改
变  原数组，可以使用slice方法。
实例：
用法1：
var arr:Array =["A","B","C","D","E"];
//从索引为2的位置之后，删除两个元素，并插入3个新元素
trace(arr.splice(2,2,"1","2","3"));
//输出splice改变后的数组
trace(arr);
用法2:
//从索引为1的位置之后删除两个元素
trace(arr.slice(1,2));
//输出splice改变后的数组
trace(arr);
用法3：
//从索引为2的元素开始删除所有元素
trace(arr.slice(2));
//输出splice改变后的数组
trace(arr);
用法4：
//不删除任何元素，在第2个元素后插入元素
trace(arr.slice(2,0,"abc","www"));
//输出splice改变后的数组
trace(arr);
5.获取数组中的部分元素:slice
slice可以获取数组中一段连续的元素，而不改变原有数组内容。它只有两个
参数，一个是截取范围的起始索引，另一个是截取范围的终点索引。
注意：起始索引和终点索引都可以是负值，表示倒数第几个元素
返回值是截取的元素组成的新数组，不改变原有数组的内容，新数组中包括启动
索引的元素，不包括终点索引的元素。
语法：
数组.slice(起点索引,终点索引);
注意：如果输入的起点索引比终点索引大时，返回值会返回一个空数组。
如果只有一个参数时，slice会截取从这个元素开始到结尾的所有元素。
数组.slice(起点索引)
slice与splice的区别：
1.slice不改变原有数组内容，splice却是在原有数组上进行操作
2.slice根据指定的起点和终点确定截取范围，splice根据起点和截取数来确
定截取范围。
实例：
var foo:Array =["A","B","C","D","E","F"];
trace(foo.slice(2,4));
//输出:C,D
trace(foo.slice(4,2));
//输出为空,因为起点索引大于终点索引，所以slice之后返回一个空数组
trace(foo.slice(-3,-1));
//输出,E
trace(foo.slice(3));
//输出,E,F
trace(foo.slice(-2));
//输出:E,F
trace(foo);
//输出:A,B,C,D,E,F
6.将多个元素或者数组拼合成新的数组:concat
类似于PHP中的array_merge,
concat可以将多个元素或者数组拼合成一个新的数组。
如果concat方法的参数为空，则返回一个原数组的"浅复制"。
语法：
数组.concat(参数...);
concat和push的区别:
1.concat生成的是一个新的数组，而push是改变原有数组。
2.如果concat的其中一个参数是数组，concat会把它拆分成元素，然后逐个
加入，而push如果有一个参数是数组，会将这个数组作为一个元素直接加入。
实例：
var foo:Array =["A","B","C"];
var bar1:int = 1;
var bar2:Array = [2,3,4];
var bar3:Array =["a","b","c"];
var newFoo:Array = foo.concat(bar1,bar2,bar3);
trace(newFoo);
//输出:A,B,C,1,2,3,4,a,b,c
trace(newFoo.length);
//输出:10
trace(foo);
//输出:A,B,C
foo.push(bar1,bar2,bar3);
trace(foo);
//输出:A,B,C,1,2,3,4,a,b,c
trace(foo.length);
//输出:6
trace(foo[4]);
//输出:2,3,4 说明第4个元素是个数组。
7.数组排序:reverse,sort,sortOn
reverse方法能将数组元素倒序，返回一个新的数组。
语法:
数组.reverse();
var arr:Array =["a","b","c"];
trace(arr.reverse());
//输出:c,b,a
sort方法是对数组元素进行排序，有三种方式:
语法:
1.数组.sort(); //默认排序
2.数组.sort(排序方式)；//使用指定的排序方式来排序，排序方式是一些定义
好的整数常量
3.数组.sort(比较函数)；//使用自定义的比较函数，这里的参数是函数名
实例：
1.默认排序:
var arr:Array = ["US","CHN","KOR"];
trace(arr.sort());
注意，如果数组中的元素是数值，默认排序也会把它当成字符串来排序，而不
是按照数值大小，切记。
//输出:CHN,KOR,US
var numberArr:Array = [2005,12,1000];
trace(numberArr.sort());
//输出:1000,12,2005
2.排序方式
//如果想按数值排序，需要用排序方式
trace(numberArr.sort(Array.NUMERIC));
//输出:12,1000,2005
所谓排序方式，实际上是在Array类中定义好的整型常量，代表几种不同的
排序方式。
Array.CASEINSESITIVE  值为: 1 //表示大小写不敏感，按照字母排序，如
果是数字则从小到大。
Array.DESCENDING 值为: 2  //表示按字母倒序排列
Array.UNIQUESORT 值为: 4  //表示必须是唯一性排序，如果比较结果相
同，则放弃排序
Array.RETURNINDEXEDARRAY 值为: 8  //表示让sort()和sortOn()函数返
回值排序后的索引表，同时保持原数组不变
Array.NUMERIC 值为: 16  //表示按数字强制从小到大排序
排序方式可以同时用多个，使用"|"隔开，以下是一些例子
//唯一性倒序排列
数组.sort(Array.DESCENDING|Array.UNIQUESORT);
//返回唯一性倒序排列的索引值数组
数组.sort
(Array.DESCENDING|array.UNIQUESORT|Array.RETURNINDEXEDARRAY);
实例:
var arr:Array =["US","CHINA","china","korea","KOREA"];
//字母倒序排列(默认大小写敏感)
trace(arr.sort(Array.DESCENDING));
//输出:korea,china,US,KOREA,CHINA
//字母倒序排列(默认大小写不敏感)
trace(arr.sort(Array.DESCENDING|Array.CASEINSESITIVE));
//输出:US,KOREA,korea,china,CHINA
//大小写不敏感,按默认字母顺序排列,且指定唯一性排序
trace(arr.sort(Array.CASEINSESITIVE|array.UNIQUESORT));
//输出:0,这表示排序失败，因为大小写不敏感后，china和CHINA结果一样，
导致失去了唯一性
trace(arr);
//输出:US,KOREA,korea,china,CHINA，数组没变，排序失败
//去掉大小写不敏感，再按唯一性排序
trace(arr.sort(array.UNIQUESORT));
trace(arr);
//输出:korea,china,US,KOREA,CHINA排序成功
//输出:korea,china,US,KOREA,CHINA数组改变
8.遍历数组：
首先，说明一下：
这5个方法的参数相同，第一个参数用来传一个回调函数(callback function),
第二个参数传入一个thisObject:*=null,主要是用来指定回调函数的this指向。
功能  说明
遍历操作  forEach(callback:Function,thisObject:*=null):void
操作数组中的每一项元素。回调函数不需要返回值。
过滤器  filter(callback:Function,thisObject:*=null):Array
将符合回调函数条件的元素提取出来，构成一个新数
组返回。
映射器  map(callback:Function,thisObject:*=null):Array
根据回调函数操作原数组的每个元素，并利用回调
函数的结果产生新的数组。
回调函数返回单个新数组的元素
有一个满足则为真  some(callback:Function,thisObject:*=null):Boolean
只要有一个元素能让回调函数返回true，则some()返
回true，否则为false。
回调函数返回单个元素比较结果，布尔值
全满足则为真  every(callback:Function,thisObject:*=null):Boolean
必须所有元素都让回调函数返回true,every()才返回true,
否则为false。
回调函数返回单个元素比较结果，布尔值
回调函数的格式:
function 回调函数名(元素标识符:类型,索引:int,要操作数组对
象:Array):返回值{}
实例  functioncallback(item:*,index:int,array:Array):void;
调用：拿forEach来说，如果是面向过程的，则语法为：
数组.forEach(回调函数);
如果是面向对象的，则语法为;
数组.forEach(回调函数,thisObject);
var book1:Object = {name:"ActionScript3",author:"kingda"};
var book2:Object = {name:"Flex3",author:"kingda"};
var book3:Object ={name:"AIR",author:"kingda"};
var book4:Object = {name:"Flash5",author:"kingda"};
var book5:Object = {name:"ActionScript 3Parttern",author:"kingda"};
var booklist:Array =[book1,book2,book3,book4,book5];
var price:Array = [100,200,300,400,500];
//every 用法: 如果发现有Flash 5这本书，就表示这套书有过时书。
trace(booklist.every(noFlash5));
functionnoFlash5(item:*,index:int,arr:Array):Boolean{
if(item.name.indexOf("Flash 5") !=-1){
return true;
}
trace("第"+(index+1)+"本书过时了!");
return false;
}
//map 用法: 生成一个书单，将price数组中的价格加入
var newBookList:Array =booklist.map(mapNewList);
trace(newBookList[0].price);
//输出:100
functionmapNewList(item:*,index:int,arr:Array):Object{
var newBook:Object = {};
newBook.name = item.name;
newBook.author = item.author;
newBook.price = price[index];
return newBook;
}
//some 用法: 如果发现有作者是Kingda,就标识这套书选了Kingda的书
trace(newBookList.some(isKingda));
//输出:true
functionisKingda(item:*,index:int,arr:Array):Boolean{
if(item.author == "Kingda")returntrue;
return false;
}
//filter 用法: 将作者为kingda的书挑出来，生成新的书单
var kingdaBookList:Array = newBookList.filter(isKingda);
trace(kingdaBookList.length);
//输出:5
//forEach 用法: 给每个书名都加上"RIA 系列"几个字，并把作者名是Kingda的，
改成"黑羽"
kingdaBookList.forEach(addBookHead);
//回调函数
functionaddBookHead(item:*,index:int,arr:Array):void{
item.bookname ="RIA 系列:"+item.bookname;
item.author = "黑羽";
}
for each{var I in kingdaBookList}
trace("* Book:" + i.bookname +"Author" + i.author);