第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回调函数
回调函数,就是要对数组中的每一项运行的函数