package com.yoyo
{
/**
* 数组Array中的方法、属性、学习
* 注意： 每一个方法要分开测试，以免有影响 控制台打印，需要在Debug模式下运行才可以使用
*/
public class _Array_class
{
private var initArray:Array;
public function _Array_class()
{
initArray=new Array("ABC",123,"EFG","MNXO");
}
/**
* Array(numElements:int = 0) 允许创建指定元素数量的数组。
*/
public function array_Array():void{
var tempArray:Array=new Array();
trace("默认数组的长度："+tempArray.length+"默认数组的值"+tempArray[0]);
var tempArray2:Array=new Array(5);
trace("默认数组的长度："+tempArray2.length+"默认数组的值"+tempArray2[0]);
for each(var e:Object in tempArray2){ //只遍历数组中存在的值 ，像undefined的元素责不遍历
trace("数组中的每一个元素为："+e);
}
tempArray2[2]="第三个元素值 ";
for each(var e1:Object in tempArray2){
trace("数组中的每一个元素为："+e1);
}
}
/**
* Array(... values) 允许创建包含指定元素的数组。
*/
public function array_Array1():void{
var tempArray:Array=new Array("ABC",123,null,"",undefined,"EFG"); //此处为数组元数指定为undefined确遍历了
trace("数组的长度为："+tempArray.length);
for each(var e:Object in tempArray){
trace("数组中的每一个元素为："+e);
}
}
/*
* shift():* 删除数组中第一个元素，并返回该元素。
*/
public function array_shift():void{
trace("删除前数组中的元素："+"(长度："+initArray.length+")");
for each(var e:Object in initArray){
trace(e.toString());
}
trace("删除的元素元："+initArray.shift());
trace("删除后数组中的元素："+"(长度："+initArray.length+")");
for each(var e1:Object in initArray){
trace(e1.toString());
}
}
/*
* pop():* 删除数组中最后一个元素，并返回该元素的值。
*/
public function array_pop():void{
trace("删除前数组中的元素："+"(长度："+initArray.length+")");
for each(var e:Object in initArray){
trace(e.toString());
}
trace("删除的元素元："+initArray.pop());
trace("删除后数组中的元素："+"(长度："+initArray.length+")");
for each(var e1:Object in initArray){
trace(e1.toString());
}
}
/**
* unshift(... args):uint 将一个或多个元素添加到数组的开头，并返回该数组的新长度。
*/
public function array_unshift():void{
trace("数组的初始数据：长度：("+initArray.length+")");
for each(var e:Object in initArray){
trace(e.toString());
}
trace("数组新长度为："+initArray.unshift("增加元素1","增加元素2","增加元素3","增加元素4"));
for each(var e1:Object in initArray){
trace(e1.toString());
}
}
/*
* push(... args):uint 将一个或多个元素添加到数组的结尾，并返回该数组的新长度。
*/
public function array_push():void{
trace("添加前数组中的元素："+"(长度："+initArray.length+")");
for each(var e:Object in initArray){
trace(e.toString());
}
trace("新数组的长度："+initArray.push("再加一个"));
for each(var e1:Object in initArray){
trace(e1.toString());
}
}
/**
* slice(startIndex:int = 0, endIndex:int = 16777215):Array 返回由原始数组中某一范围的元素构成的新数组，而不修改原始数组。
*
* 返回由原始数组中某一范围的元素构成的新数组，而不修改原始数组。返回的数组包括 startIndex 元素以及从其开始到 endIndex 元素（但不包括该元素）的所有元素。
* 如果您没有传递任何参数，则创建原始数组的一个副本。
参数 : startIndex:int (default = 0) — 一个数字，指定片段起始点的索引。如果 startIndex 是负数，则起始点从数组的结尾开始，其中 -1 指的是最后一个元素。
endIndex:int (default = 16777215) — 一个数字，指定片段终点的索引。如果省略此参数，则片段包括数组中从开头到结尾的所有元素。如果 endIndex 是负数，则终点从数组的结尾指定，其中 -1 指的是最后一个元素。
返回 Array — 一个数组，由原始数组中某一范围的元素组成。
*/
public function array_slice():void{
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(1,3);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // b,c
}
/**
* 下面的代码创建一个 Array 对象 letters，其中包含元素 [a,b,c,d,e,f]。
* 然后创建数组 someLetters，方法是调用 slice() 方法（对元素 2 (c)），从而得到一个数组，其中包含元素 [c,d,e,f]。
*/
public function array_slice1():void{
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // c,d,e,f
}
/**
* 下面的代码创建一个 Array 对象 letters，其中包含元素 [a,b,c,d,e,f]。
* 然后创建数组 someLetters，方法是调用 slice() 方法（对倒数第二个元素 (e)），从而得到一个数组，其中包含元素 e 和 f。
*/
public function array_slice2():void{
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(-2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // e,f
}
public function array_splice():void{
//原始值 ："ABC",123,"EFG","MNXO"
var spliced:Array = initArray.splice(2, 2);
// trace("初始数组的数据：长度("+initArray.length+")");
// for each(var e:Object in initArray){
// trace(e);
// }
trace(initArray); // "ABC",123
// trace("操作后数组的数据：长度("+spliced.length+")");
// for each(var e1:Object in spliced){
// trace(e1);
// }
trace(spliced); // "EFG","MNXO"
initArray.splice(1, 0, spliced);
// trace("初始数组的数据：长度("+initArray.length+")");
// for each(var e2:Object in initArray){
// trace(e2);
// }
trace(initArray); // "ABC","EFG","MNXO",123
trace("初始数组的数据：长度("+initArray.length+")"); //注意，新添加进来的数据只是作为原数组中的一个元素
for each(var e2:Object in initArray){
trace(e2);
}
// ABC
// EFG,MNXO
// 123
}
/**
* 将参数中指定的元素与数组中的元素连接，并创建新的数组。如果这些参数指定了一个数组，将连接该数组中的元素。
* ... args — 要连接到新数组中的任意数据类型的值（如数字、元素或字符串）。如果未传递任何值，则新数组将是原始数组的副本。
* Array — 一个数组，其中包含此数组中的元素，后跟参数中的元素。
*
* •包含数字 1、2 和 3 的 numbers 数组。
* •包含字母 a、b 和 c 的 letters 数组。
* •调用 concat() 方法生成数组 [1,2,3,a,b,c] 的 numbersAndLetters 数组。
* •调用 concat() 方法生成数组 [a,b,c,1,2,3] 的 lettersAndNumbers 数组。
*/
public function array_concat():void{
var numbers:Array = new Array(1, 2, 3);
var letters:Array = new Array("a", "b", "c");
var numbersAndLetters:Array = numbers.concat(letters);
var lettersAndNumbers:Array = letters.concat(numbers);
trace(numbers); // 1,2,3
trace(letters); // a,b,c
trace(numbersAndLetters); // 1,2,3,a,b,c
trace(lettersAndNumbers); // a,b,c,1,2,3
}
/**
* 对数组中的每一项执行测试函数，直到获得对指定的函数返回 false 的项。
* 使用此方法可确定数组中的所有项是否满足某一条件，如具有的值小于某一特定数值
*/
public function array_every():void{
var numberArray:Array=new Array(1,2,3,4);
trace(numberArray.every(isNumber));
var objArray:Array=new Array(1,"b","c");
trace(objArray.every(isNumber));
}
private function isNumber(element:*,i:int,arr:Array):Boolean{
return (element is Number);
}
/**
* 对数组中的每一项执行函数。
*/
public function array_foreach():void{
var employees:Array = new Array();
employees.push({name:"Employee 1", manager:false});
employees.push({name:"Employee 2", manager:true});
employees.push({name:null, manager:null});
employees.push({name:undefined, manager:undefined});
employees.push({name:"", manager:""});
employees.push({name:"Employee 6", manager:false});
trace(employees);
employees.forEach(traceArrayElement);
}
private function traceArrayElement(element:*,index:int,arr:Array):void{
trace(element.name+"("+element.manager+")");
}
/**
* 对数组中的每一项执行函数并构造一个新数组，其中包含与原始数组中的每一项的函数结果相对应的项。
*/
public function array_map():void{
var arr:Array = new Array("aa","bb","cc","dd","ee","ff");
var newArray:Array=arr.map(toUpper);
trace(arr); //aa,bb,cc,dd,ee,ff
trace(newArray); //AA,BB,CC,DD,EE,FF
}
private function toUpper(element:*,i:int,arr:Array):String{
return String(element).toUpperCase();
}
/**
* 使用全等运算符 (===) 搜索数组中的项，并返回项的索引位置。
* searchElement:* — 要在数组中查找的项。
* fromIndex:int (default = 0) — 数组中的位置，从该位置开始搜索项。
*/
public function array_indexOf():void{
trace(initArray.indexOf(123,1));
trace(initArray.indexOf("123"));
}
public function array_lastIndexof():void{
var tempArray:Array=new Array("A","B","C","A","C","A");
trace(tempArray.indexOf("A")); //0
trace(tempArray.lastIndexOf("A")); //5
}
/**
* 将数组中的元素转换为字符串、在元素间插入指定的分隔符、连接这些元素然后返回结果字符串。
* 嵌套数组总是以逗号 (,) 分隔，而不使用传递给 join() 方法的分隔符分隔。
* 参数 sep:* (default = NaN) — 在返回字符串中分隔数组元素的字符或字符串。如果省略此参数，则使用逗号作为默认分隔符。
* 返回 String — 一个字符串，由转换为字符串并由指定参数分隔的数组元素组成。
*/
public function array_join():void{
var myArr:Array = new Array("one", "two", "three");
var myStr:String = myArr.join(" and ");
trace(myArr); // one,two,three
trace(myStr); // one and two and three
}
/**
* 字符串的分割成数组，将数组连接成字符串(目的：将字符串转换成指字的字符串)
*/
public function array_split():void{
var str:String="abcd,efg,hijk,,mno";
var arr:Array=str.split(",");//字符串分割成数组
trace(arr.length); //5
trace(arr); //abcd,efg,hijk,,mno
var str2:String=arr.join("");
trace(str2); //abcdefghijkmno
}
public function array_split1():void{
var strPhone:String="(8610)010-58022266-145";
var numberPhone:String=strPhone;
var specialChars:Array=new Array("(",")","-"," ");
for(var i:uint=0;i<specialChars.length;i++){
numberPhone=numberPhone.split(specialChars[i]).join("");
}
trace(strPhone); //(8610)010-58022266-145
trace(numberPhone); //861001058022266145
}
/**
* 在当前位置倒转数组。
*/
public function array_reverse():void{
trace(initArray); //ABC,123,EFG,MNXO
var newArray:Array=initArray.reverse();
trace(newArray); //MNXO,EFG,123,ABC
}
/**
* 对数组中的每一项执行测试函数，直到获得返回 true 的项。使用此方法确定数组中的所有项是否满足条件，如具有小于某一特定数值的值。
*/
public function array_some():void{
var isExist:Boolean=initArray.some(findValue);
if(isExist){
trace("数组中包含该值123："+initArray);
}else{
trace("数组中不包含该值123："+initArray);
}
}
private function findValue(ele:*,i:int,arr:Array):Boolean{
return (arr[i]=="123");
}
/**
* 下面的代码创建 Array 对象 vegetables，其中包含元素 [spinach, green pepper, cilantro, onion, avocado]。
* 然后，通过 sort() 方法对该数组进行排序，调用该方法时不带参数。
* 结果是 vegetables 按字母顺序排序 ([avocado, cilantro, green pepper, onion, spinach])。
*/
public function array_sort():void{
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
trace(vegetables); // spinach,green pepper,cilantro,onion,avocado
vegetables.sort();
trace(vegetables); // avocado,cilantro,green pepper,onion,spinach
}
/**
* 下面的代码创建 Array 对象 vegetables，其中包含元素 [spinach, green pepper, Cilantro, Onion, and Avocado]。
* 然后，通过 sort() 方法对该数组进行排序，第一次调用该方法时不带参数，其结果是 [Avocado,Cilantro,Onion,green pepper,spinach]。然后再次调用 sort()（对 vegetables），调用时将 CASEINSENSITIVE 常数作为参数。
* 结果是 vegetables 按字母顺序排序 ([Avocado, Cilantro, green pepper, Onion, spinach])。
*/
public function array_sort1():void{
var vegetables:Array = new Array("spinach",
"green pepper",
"Cilantro",
"Onion",
"Avocado");
vegetables.sort();
trace(vegetables); // Avocado,Cilantro,Onion,green pepper,spinach
//CASEINSENSITIVE : uint = 1 [静态] 指定 Array 类排序方法为不区分大小写的排序。
vegetables.sort(Array.CASEINSENSITIVE);
trace(vegetables); // Avocado,Cilantro,green pepper,Onion,spinach
}
public function array_sort2():void{
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
vegetables.sort();
trace(vegetables);
}
/**
* 按自定义的排序方式进行排序
*/
public function array_sort3():void{
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
vegetables.sort(sortOnPrice);
trace(vegetables);
}
private function sortOnPrice(a:Vegetable,b:Vegetable):int{
if(a.getPrice()>b.getPrice()){
return 1;
}else if(a.getPrice()==b.getPrice()){
return 0;
}else{
return -1;
}
}
/**
* 按数字进行排序
*/
public function array_sort4():void{
var numbers:Array = new Array(3,5,100,34,10);
trace(numbers); // 3,5,100,34,10
numbers.sort();
trace(numbers); // 10,100,3,34,5
numbers.sort(Array.NUMERIC); //按数字排序
trace(numbers); // 3,5,10,34,100
}
/**
* 根据数组中的一个或多个字段对数组中的元素进行排序。
*/
public function array_sortOn():void{
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sortOn("name");
//vegetables.sortOn(["name","price"]);
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
vegetables.sortOn("price", Array.NUMERIC | Array.DESCENDING);
trace(vegetables);
// asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29
}
/**
* 对数组的多个字段进行排序
*/
public function array_sortOn1():void{
var records:Array = new Array();
records.push({name:"john", city:"omaha", zip:68144});
records.push({name:"john", city:"kansas city", zip:72345});
records.push({name:"bob", city:"omaha", zip:94010});
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, omaha
// john, kansas city
// bob, omaha
trace("records.sortOn('name', 'city');");
records.sortOn(["name", "city"]);
for(var j:uint = 0; j < records.length; j++) {
trace(records[j].name + ", " + records[j].city);
}
// Results:
// bob, omaha
// john, kansas city
// john, omaha
trace("records.sortOn('city', 'name');");
records.sortOn(["city", "name"]);
for(var k:uint = 0; k < records.length; k++) {
trace(records[k].name + ", " + records[k].city);
}
// Results:
// john, kansas city
// bob, omaha
// john, omaha
}
public function array_sortOn2():void{
var users:Array = new Array();
users.push(new User("Bob", 3));
users.push(new User("barb", 35));
users.push(new User("abcd", 3));
users.push(new User("catchy", 4));
trace(users); // Bob:3,barb:35,abcd:3,catchy:4
users.sortOn("name");
trace(users); // Bob:3,abcd:3,barb:35,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE);
trace(users); // abcd:3,barb:35,Bob:3,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE | Array.DESCENDING);
trace(users); // catchy:4,Bob:3,barb:35,abcd:3
users.sortOn("age");
trace(users); // abcd:3,Bob:3,barb:35,catchy:4
users.sortOn("age", Array.NUMERIC);
trace(users); // Bob:3,abcd:3,catchy:4,barb:35
users.sortOn("age", Array.DESCENDING | Array.NUMERIC);
trace(users); // barb:35,catchy:4,Bob:3,abcd:3
var indices:Array = users.sortOn("age", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
var index:uint;
for(var i:uint = 0; i < indices.length; i++) {
index = indices[i];
trace(users[index].name, ": " + users[index].age);
}
// Results:
// Bob : 3
// abcd : 3
// catchy : 4
// barb : 35
}
/*
Array(numElements:int = 0)允许创建指定元素数量的数组。
Array(... values) 允许创建包含指定元素的数组。
push(... args):uint 将一个或多个元素添加到数组的结尾，并返回该数组的新长度。
shift():* 删除数组中第一个元素，并返回该元素。
*/
public function arrayAssignment():void{
trace("原来数组一的值：");
for each(var e:Object in initArray){
trace(e.toString());
}
var twoArray:Array=initArray;
trace("原来数组二的值：");
for each(var e1:Object in twoArray){
trace(e1.toString());
}
trace('向数组oneArray.push("aa","bb","ee")中添加新元素后返回新的数组长度：'+initArray.push("aa","bb","ee"));//将一个或多个元素添加到数组的结尾，并返回该数组的新长度。
trace("删除数组中第一个元素，并返回该元素："+initArray.shift());//shift():* 删除数组中第一个元素，并返回该元素
trace("数组一的值：");
for each(var e2:Object in initArray){
trace(e2.toString());
}
trace("数组二的值：");
for each(var e3:Object in twoArray){
trace(e3.toString());
}
}
public function getOneArray():uint{
var oneArray:Array=new Array();
return oneArray.length;
}
public function getTwoArray():uint{
var twoArray:Array=new Array(5);
return twoArray.length;
}
public function getThree():void{
var threeArray:Array =new Array(5);
for(var i:uint=0;i<threeArray.length;i++){
trace(threeArray[i]);
}
}
public function getFour():void{
var fourArray:Array=new Array(5);
trace("长度为："+fourArray.length);
for(var i:uint=0;i<fourArray.length;i++){
trace("循环中的第"+i+"个："+fourArray[i]);
}
fourArray[0]="第一个值";
fourArray.push("测试");
for(var j:uint=0;j<fourArray.length;j++){
trace("循环中的第"+j+"个："+fourArray[j]);
}
trace("长度为："+fourArray.length);
}
}
}
626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
