第12章 数组Array.docx
《第12章 数组Array.docx》由会员分享，可在线阅读，更多相关《第12章 数组Array.docx（19页珍藏版）》请在冰豆网上搜索。
第12章数组Array
第十二章数组：
Array
12.1数组的介绍2
12.1.1访问数组元素2
12.1.2数组的长度2
12.1.3多维数组2
12.2数组（Array）的基本操作2
12.2.1查找：
indexOf、lastIndexOf2
12.2.2在数组首位新增元素：
push、unshift3
12.2.3删除数组首位元素：
pop、shift3
12.2.4在数组当中插入或者删除元素：
灵活多变的splice4
12.2.5获取数组中的部分元素：
slice5
12.2.6Concat6
12.2.7*浅复制与深复制6
12.2.8排序：
reverse、sort、sortOn9
12.3操作数组每个元素：
forEach、every、filter、map、some10
12.3.15个方法的共同点10
12.3.2回调函数11
12.3.3代码示例11
12.1数组的介绍
12.1.1访问数组元素
数组的第一个元素的索引值是0，第二个是1，以此类推。
12.1.2数组的长度
我们可以通过length属性来访问和设置数组的长度。
实现的方式如下，注意length是uint型，即非负整数。
publicfunctiongetlength（）:
uint
publicfunctionsetlength（value:
uint）
示例：
varfoo:
Array=[“one”,”two”,”three”];
trace（foo.length）;
//输出：
3
//设定foo的长度为5
foo.length=5;
trace（foo）;
//输出：
one,two,three,,
//可以看到，多出了两个空的元素
//使用超过length的索引来设定元素
foo[7]=“outranged”;
trace（foo）;
//输出：
one,two,three,,,,,,,outranged
trace（foo.length）;
//输出：
8
//强行设定foo的length为3
foo.length=3;
trace（foo）;
//输出：
one,two,three
//结果foo将3个元素以后的所有元素全部扔掉了
12.1.3多维数组
多维数组本质和数组没有不同。
不同之处在于，多维数组元素仍然是数组。
12.2数组（Array）的基本操作
12.2.1查找：
indexOf、lastIndexOf
indexOf按索引从小到大查找lastIndexOf按索引从大到小
<找到返回索引值，找不到返回-1>
目标数组.indexOf（要查找的元素，查找的起始位置）
目标数组.lastIndexOf（要查找的元素，查找的起始位置）
示例：
varfoo:
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））;
输出：
按索引从小到大查：
1
按索引从大到小查：
5
从第三个元素开始，按索引从小到大查：
5
从第五个元素开始，按索引从大到小查：
1
12.2.2在数组首位新增元素：
push、unshift
push方法：
在数组尾部新增一个或多个元素。
unshift方法：
在数组头部新增一个或多个元素。
push和unshift方法都有返回值。
返回值是增加元素后的数组长度。
数组.push（元素）;
数组.push（元素1,元素2,元素3,…元素n）;
数组.unshift（元素）;
数组.unshift（元素1,元素2,元素3,…元素n）;
示例：
varbookList:
Array=["BookI","BookII","BookIII"];
trace（bookList.push（"A"））;//数组尾部加入A，并用trace输出push方的返回值
trace（bookList.push（"B","C","D"））;//可以同时加入多个元素
trace（bookList）;
输出：
4
7
BookI,BookII,BookIII,A,B,C,D
trace（bookList.unshift（"1"））;//数组头部加入1，并用输出unshift方法的返回值
trace（bookList.unshift（"2","3","4"））;//可以同时加入多个元素
trace（bookList）;
输出：
8
11
2,3,4,1,BookI,BookII,BookIII,A,B,C,D
12.2.3删除数组首位元素：
pop、shift
pop方法用于将数组最后一个元素删除。
Shift方法用于将数组第一个元素删除，剩余元素索引自动减1
pop和shift不需要参数。
数组.pop（）
数组.shift（）
示例：
varbookList:
Array=["BookI","BookII","BookIII"];
//下句执行了pop，并输出被删除的元素
trace（"被pop删掉的书是:
"+bookList.pop（））;
//下句执行了shift，并输出被删除的元素
trace（"被shift删掉的书是:
"+bookList.shift（））;
trace（"原书单变成:
"+bookList）;
被pop删掉的书是:
BookIII
被shift删掉的书是:
BookI
原书单变成:
BookII
12.2.4在数组当中插入或者删除元素：
灵活多变的splice
Splice方法可以删除数组当中的一个或多个连续的元素。
splice用法灵活，用途广泛。
它的各种不同用法都有其专门的用途，请读者留意。
一般有以下4种用途。
（1）从数组某位置开始，删除指定数目的元素，并插入一些新元素。
这是splice的标准用法。
用法格式如下。
数组.splice（删除点的索引,要删除的元素数目,新元素1,新元素2，…新元n）;
删除点的索引可以是负值，表示数组从尾部倒数的位置。
比如，索引为-3，指的是数组倒数第三个元素，素引为-1，则是倒数第一个元素。
（2）删除数组中某位置之后几个元素。
数组.splice（删除点的索引,要删除的元素数目）;
（3）删除数组中某位置之后所有元素。
数组.splice（删除点索引）;
（4）在数组中某位置之后，插入新元素。
数组.splice（删除点索引,0,新元素1,新元素2,…新元素n）;
splice有返回值，返回的是一个数组，包含的就是删除的那些元素。
splice改变了原数组的内容。
如果只是想得到数组中的一段内容而不想改变原数组，那么应该使用slice方法。
Slice方法不改变原数组内容。
示例：
varfoo:
Array=["BookI","BookII","BookIII","BookIV","BookV"];
//从索引为2的元素开始删除两个元素，并插入3个元素
//从索引为1的元素开始删除两个元素
//删除索引为3的元素后面的所有元素
//在索引为2的元素后面插入两个新元素
trace（foo.splice（2,2,"book1","book2","book3"））;
trace（foo）;
//输出：
BookIII,BookIV
//BookI,BookII,book1,book2,book3,BookV
trace（foo.splice（1,2））;
trace（foo）;
//输出：
BookII,book1
//BookI,book2,book3,BookV
trace（foo.splice（3））;
trace（foo）;
//输出：
BookV
//BookI,book2,book3
trace（foo.splice（2,0,"书1","书2"））;
trace（foo）；
//输出：
//BookI,book2,书1,书2,book3
12.2.5获取数组中的部分元素：
slice
slice可以获取数组中一段连续的元素，而不改变原有数组内容。
有两个参数：
一个是截取范围的起点索引，另一个是截取范围的终点索引。
slice的起点和终点索引值都可以是负值。
负值就是倒数的索引，-1就是最后一个元素，-2是倒数第二个，以此类推。
返回值是截取的元素组成的新数组，而且不改变原有数组的内容。
新数组中包括起点索引的元素，而不包括终点索引的元素。
数组.slice（起点索引,终点索引）;
如果输入时，不慎将输入的起点索引设置为大于终点索引值，那么slice只会返回一个空数组。
当起点、终点中有一个是负值时，容易产生这种误操作。
如果只传一个参数给slice，那么将把这个参数当成起始索引值，截取从这个索引值开始，到数组终点这一段元素，生成新数组。
用法如下。
数组.slice（起点索引）
当不传任何参数给slice方法时，将生成原数组的一个浅复制。
示例：
varfoo:
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））;
//输出：
D,E
trace（foo.slice（3））;
//输出：
D,E,F
trace（foo.slice（-2））;
//输出：
E,F
trace（foo）;
//输出：
A,B,C,D,E,F
slice和splice的区别：
一、slice不改变原有的数组内容，splice改变。
二、slice根据指定起点和终点确定截取范围，splice根据指定起点和截取数量确定截取范围。
12.2.6Concat
concat可将多个元素或数组拼成一个新的数组，并通过返回值返回，不改变原有数组内容：
不传任何参数给concat方法时，将生成原数组的一个浅复制。
数组.concat（参数1,参数,参数3…参数n）
concat和push的相同之处在于，都是将参数中的元素按顺序加到数组的后面。
concat和push的不同点是：
一、concat不改变原有数组内容，而是生成一个新数组返回。
push直接改变原数组内容。
二、当参数是数组时，concat和push的行为不同。
concat会将数组分开成各个元素按顺序加入，而push则把这个是数组的参数当成一个元素加入原数组后面。
示例：
varfoo:
Array=["A","B","C"];
varbar1:
int=1;
varbar2:
Array=[2,3,4];
varbar3:
Array=["a","b","c"];
varnew_foo=foo.concat（bar1,bar2,bar3）;
trace（new_foo.length）;
//输出：
10
trace（new_foo）;
//输出：
A,B,C,1,2,3,4,a,b,c
trace（foo）;
//输出：
A,B,C
foo.push（bar1,bar2,bar3）;
trace（foo.length）;
//输出：
6
trace（foo）;
//输出：
A,B,C,1,2,3,4,a,b,c
trace（foo[4]）;
//输出：
2,3,4
12.2.7*浅复制与深复制
复制一个数组，是指生成一个新的数组，内容和原有数组一样。
1.何时用浅复制？
何时用深复制？
数组元素全部是基元数据类型，即全部是指类型，不分浅复制和深复制。
数组元素全部是复杂数据类型，即引用类型，有浅复制和深复制两种选择。
2.浅复制
生成数组浅复制的方法很简单，只需要调用原数组的slice方法或者concat方法，不传任何参数，即可生成原数组的浅复制。
用法示例如下:
varcopy:
Array=originalArray.concat（）;
varcopy:
Array=originalArray.slice（）;
注意点：
使用浅复制生成的新数组，其各个元素存放的只是引用。
两个数组中相同位置的元素存放的引用指向同一个对象。
那么，如果对该元素操作，等于就是操作引用指向的对象。
如果该对象状态发生变化，那么也会影响到另一个数组中相应位置的元素。
示例：
varobjectElement:
Object={name:
"kingda",web:
"www.kingda.org"};
vararrayElement:
Array=[1,2,3];
varfoo:
Array=["astringelememnt",arrayElement,objectElement]
trace（foo）;
//输出：
astringelememnt,1,2,3,[objectObject]
//1.使用slice/concat方法生成foo的潜复制
varbar:
Array=foo.concat（）;
trace（bar）;
//输出：
astringelememnt,1,2,3,[objectObject]
//2.比较foo和bar
trace（bar==foo）;//输出：
false
trace（bar[0]==foo[0]）;//输出：
true
trace（bar[1]==foo[1]）;//输出：
true
trace（bar[2]==foo[2]）;//输出：
true
bar[0]="anewstringinbar";
bar[1][0]=1000;
bar[2].web="www.ActoionS"
trace（foo）;
//输出:
astringelememnt,1000,2,3,[objectObject]
trace（bar）;
//输出:
anewstringinbar,1000,2,3,[objectObject]
trace（foo[2].web）;
//输出:
www.ActoionS
trace（bar[2].web）;
//输出:
www.ActoionS
3.深复制
使用深复制生成的新数组，其所有元素都是真正的原数组元素的备份。
这时两个数组中相同位置的元素，存放的是不同的引用，指向不同的对象。
但是这两个对象的状态是完全一致的。
示例：
ByteArray的运用
varobjectElement:
Object={name:
"kingda",web:
"www.kingda.org"};
vararrayElement:
Array=[1,2,3];
varfoo:
Array=["astringelement",arrayElement,objectElement];
//以下4行深复制数组foo
varfooBA:
ByteArray=newByteArray（）;
fooBA.writeObject（foo）;
fooBA.position=0;
varbar:
Array=fooBA.readObject（）asArray;
trace（bar）;
//输出：
astringelement,1,2,3,[objectObject]
trace（foo==bar）;
//输出：
false
//表明foo和bar持有的是两个不同对象的引用
trace（foo[0]==bar[0]）;
//输出：
true
//由于第一个元素是String型，因此“==”判断值相等，返回真
trace（foo[1]==bar[1]）;
//输出：
false
//第二个元素是Array型，因此“==”判断引用是否相同，若不同，返回假
trace（foo[2]==bar[2]）;
//输出：
false
//第三个元素是Object型，因此“==”判断引用是否相同，若不同，返回假
//以下3行改变bar的元素
bar[0]="anewstringinbar";
bar[1][0]=1000;
bar[2].web="";
//再看foo是否受影响
trace（foo）;
//输出：
astringelement,1,2,3,[objectObject]
trace（bar）;
//输出：
anewstringinbar,1000,2,3,[objectObject]
trace（foo[2].web）;
//输出：
www.kingda.org
trace（bar[2].web）;
//输出：
//可以看出，bar的改变并没有影响foo。
确确实实把所有的元素都真正复制了
/*传值传引用区别*/
vara:
Array=[1,2,3];
varb:
Array=a;
b[0]=1000;
trace（b）;//输出:
1000,2,3
trace（a）;//输出:
1000,2,3
varc:
int=1;
vard:
int=c;
d=5;
trace（d）;//输出：
5
trace（c）;//输出：
1
12.2.8排序：
reverse、sort、sortOn
reverse方法能将数组元素倒序，返回值是新的数组。
数组.reverse（）;
示例：
varary:
Array=[“a”,”b”,”c”];
trace（ary.reverse（））;//输出：
c,b,a
sort方法是对数组元素排序。
有3种使用方式，如下:
数组.sort（）;//默认排序
数组.sort（排序方式）;//使用“排序方式”参数来排序，排序方式是一些定义好的整数常量
数组.sort（比较函数）;//使用自定义的比较函数，注意此处只写函数名即可
sortOn方法是对当数组原算是复杂数据类型时，且需要根据这种对象的某个属性值来排序。
比如说，某数组元素都有一个属性值name，希望根据name来排序，那么使用方法如下。
数组.sortOn（“name”）;//根据指定属性，默认排序
数组.sortOn（“name”,排序方式）;//根据指定属性，使用制定的“排序方式”来排序
数组.sortOn（“name”,比较函数）;//根据指定属性，使用自定义函数排序
1.默认排序sort（）
当sort不加任何参数时，说明使用默认排序。
默认排序是按照字符串字母顺序排序的，返回值是排序后的数组。
varary:
Array=[“US”,”CHN”,”KOR”];
trace（ary.sort（））;//输出：
CHN,KOR,US
注意，如果数组中的元素是数值，默认排序也会把它当成字符串来排序，而不是按照数值大小，切记。
见下例。
varnumberAry:
Array=[2005,12,1000];
//默认排序
trace（numberAry.sort（））;//输出：
1000,12,2005
//想按数值排序，必须要用排序方式。
指定使用NUMERIC方式排序
trace（numberAry.sort（Array.NUMERIC））;//输出：
12,1000,2005
2.排序方式
所谓排序方式，实际上是一些在Array类中定义好的整形常量，代表几种不同的排序方式。
一共有5种，如下:
Array.CASEINSESITIVES值为：
1，表示大小写不敏感按字母顺序排序，如果是数字则从小到大
Array.DESCENDING值为：
2，表示按字母倒序排列
Array.UNIQUESORT值为：
4，表示必须是唯一性排序，如果比较值结果相同，则放弃排序
Array.RETURNINDEXEDARRAY值为：
8，让sort（）和sortOn（）函数返回值排序后的索引列表，同时保持原数组不变
Array.NUMERIC值为：
16，强制sort（）和sortOn（）中对数值采用从小到大排序，否则，不设方式，sort（）和sortOn（）将把数字当成字符串来排序
3.比较函数
比较函数的要求是，有两个参数，返回值只能是1、0、-1中的一个。
为了指代方便，放在第一位的参数，我们称为参数A，放在第二位的称为参数B。
格式如下：
function函数名（参数A:
类型,参数B:
类型）:
int{…}
返回值为1，那么作为A参数的数组元素应当排在B后面；
返回值为-1，那么A参数元素应当排在B前面；
返回值为0，表示比较结果一样，不分先后。
当返回值为0时，且指定排序方式是Array.UNIQUESORT的话，数组排序就会认为失败并返回返回值0。
示例：
vara:
Object={price:
20,number:
3};
varb:
Object={price:
10,number:
7};
varc:
Object={price:
50,number:
1};
varamountAry:
Array=[a,b,c];
//比较函数:
compare
functioncompare（paraA:
Object,paraB:
Object）:
int{
varresultA=paraA.price*paraA.number;
varresultB=paraB.price*paraB.number;
if（resultA>resultB）return1;
if（resultBreturn0;
}
//按比较函数排序
amoutAry.sort（compare）;
trace（amoutAry[0].price）;//输出：
50
trace（amoutAry[1].price）;//输出：
20
trace（amoutAry[1].price）;//输出：
10
12.3操作数组每个元素：
forEach、every、filter、map、some
12.3.15个方法的共同点
第一个参数用来传入一个回调函数（callbackfunction），第二个参数传入一个thisObject。
第二个参数不太常用，主要用来指定回调函数的this指向，只有回调函数是由函数表达式定义法定义的，才可能使用这个参数。
12.3.2回调函数
回调函数，就是要对数组中的每一项运行的函数
升级会员 