FLEX程序设计--数组

数组Array

使用 Array 类可以访问和操作数组。 Array 索引从零开始，这意味着数组中的第一个元素为 [0]，第二个元素为 [1]，依此类推。要创建 Array 对象，可以使用 new Array() 构造函数。 Array() 还可以作为函数调用。此外，还可以使用数组访问 ([]) 运算符初始化数组或访问数组元素。

您可以在数组元素中存储各种各样的数据类型，包括数字、字符串、对象，甚至是其它数组。您可以创建一个多维数组，方法是创建一个索引数组，然后给它的每个元素分配不同的索引数组。这样的数组被视为是多维的，原因是它可用于表示表中的数据。

数组是稀疏数组，这意味着可能存在这样的情况：在索引 0 处有一个元素，在索引 5 处有另一个元素，而这两个元素之间的索引位置却是空的。在这种情况下，位置 1 至位置 4 的元素是未定义的，表示这些位置不存在元素，而不一定存在值为 undefined 的元素。

数组赋值是通过引用而不是通过值进行的。如果将一个数组变量赋值给另一个数组变量，则这两个变量引用同一个数组：

 var oneArray:Array = new Array("a", "b", "c");
 var twoArray:Array = oneArray; // Both array variables refer to the same array.
 twoArray[0] = "z";             
 trace(oneArray);               // Output: z,b,c.

请不要使用 Array 类创建关联数组（也称为哈希），关联数组是包含命名元素而不包含编号元素的数据结构。要创建关联数组，请使用 Object 类。虽然 ActionScript 允许使用 Array 类创建关联数组，但不能对关联数组使用 Array 类的任何方法或属性。

可以扩展 Array 类并覆盖或添加方法。但是，必须将子类指定为 dynamic，否则将无法在数组中存储数据。

查看示例

另请参见

[] (array access)
Object class
函数参数

公共属性

隐藏继承的公共属性

显示继承的公共属性

	属性		定义方
		constructor : Object 对类对象或给定对象实例的构造函数的引用。	Object
		length : uint 指定数组中元素数量的非负整数。	Array
		prototype : Object [static] 对类或函数对象的原型对象的引用。	Object

公共方法

隐藏继承的公共方法

显示继承的公共方法

	方法		定义方
		Array(numElements:int = 0) 允许创建指定元素数量的数组。	Array
		Array(... values) 允许创建包含指定元素的数组。	Array
		concat(... args):Array 将参数中指定的元素与数组中的元素连接，并创建新的数组。	Array
		every(callback:Function, thisObject:* = null):Boolean 对数组中的每一项执行测试函数，直到获得对指定的函数返回 false 的项。	Array
		filter(callback:Function, thisObject:* = null):Array 对数组中的每一项执行测试函数，并构造一个新数组，其中的所有项都对指定的函数返回 true。	Array
		forEach(callback:Function, thisObject:* = null):void 对数组中的每一项执行函数。	Array
		hasOwnProperty(name:String):Boolean 指示对象是否已经定义了指定的属性。	Object
		indexOf(searchElement:*, fromIndex:int = 0):int 使用全等运算符 (===) 搜索数组中的项，并返回该项的索引位置。	Array
		isPrototypeOf(theClass:Object):Boolean 指示 Object 类的实例是否在指定为参数的对象的原型链中。	Object
		join(sep:*):String 将数组中的元素转换为字符串、在元素间插入指定的分隔符、连接这些元素然后返回结果字符串。	Array
		lastIndexOf(searchElement:*, fromIndex:int = 0x7fffffff):int 使用全等运算符 (===) 搜索数组中的项（从最后一项开始向前搜索），并返回匹配项的索引位置。	Array
		map(callback:Function, thisObject:* = null):Array 对数组中的每一项执行函数并构造一个新数组，其中包含与原始数组中的每一项的函数结果相对应的项。	Array
		pop():Object 删除数组中最后一个元素，并返回该元素的值。	Array
		propertyIsEnumerable(name:String):Boolean 指示指定的属性是否存在、是否可枚举。	Object
		push(... args):uint 将一个或多个元素添加到数组的结尾，并返回该数组的新长度。	Array
		reverse():Array 在当前位置倒转数组。	Array
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void 设置循环操作动态属性的可用性。	Object
		shift():Object 删除数组中第一个元素，并返回该元素。	Array
		slice(startIndex:int = 0, endIndex:int = 16777215):Array 返回由原始数组中某一范围的元素构成的新数组，而不修改原始数组。	Array
		some(callback:Function, thisObject:* = null):Boolean 对数组中的每一项执行测试函数，直到获得返回 true 的项。	Array
		sort(... args):Array 对数组中的元素进行排序。	Array
		sortOn(fieldName:Object, options:Object = null):Array 根据数组中的一个或多个字段对数组中的元素进行排序。	Array
		splice(startIndex:int, deleteCount:uint, ... values):Array 给数组添加元素以及从数组中删除元素。	Array
		toLocaleString():String 返回一个字符串，它表示指定数组中的元素。	Array
		toString():String 返回一个字符串，它表示指定数组中的元素。	Array
		unshift(... args):uint 将一个或多个元素添加到数组的开头，并返回该数组的新长度。	Array
		valueOf():Object 返回指定对象的原始值。	Object

公共常量

	常量		定义方
		CASEINSENSITIVE : uint = 1 [static] 指定 Array 类排序方法为不区分大小写的排序。	Array
		DESCENDING : uint = 2 [static] 指定 Array 类排序方法为降序排序。	Array
		NUMERIC : uint = 16 [static] 指定 Array 类排序方法为数值（而不是字符串）排序。	Array
		RETURNINDEXEDARRAY : uint = 8 [static] 指定排序返回的数组包含数组索引。	Array
		UNIQUESORT : uint = 4 [static] 指定 Array 类排序方法的唯一排序要求。	Array

属性详细信息

length

属性

length:uint [read-write]

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

指定数组中元素数量的非负整数。在向数组中添加新元素时，此属性会自动更新。当您给数组元素赋值（例如，my_array[index] = value）时，如果 index 是数字，而且 index+1 大于 length 属性，则 length 属性会更新为 index+1。

注意：如果您为 length 属性所赋的值小于现有长度，会将数组截断。

实现
public function get length():uint
public function set length(value:uint):void

示例
如何使用示例

下面的代码创建一个 Array 对象 names，其中包含字符串元素 Bill。然后它使用 push() 方法添加另外一个字符串元素 Kyle。数组的长度由 length 属性确定，在使用 push() 之前是一个元素，在调用 push() 之后是两个元素。添加另外一个字符串 Jeff 以使 names 的长度变为三个元素。然后，两次调用 shift() 方法以删除 Bill 和 Kyle，从而使最终数组的 length 变为一。

var names:Array = new Array("Bill");
names.push("Kyle");
trace(names.length); // 2

names.push("Jeff");
trace(names.length); // 3

names.shift();
names.shift();
trace(names.length); // 1

构造函数详细信息

Array

()

构造函数

public function Array(numElements:int = 0)

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

允许创建指定元素数量的数组。如果不指定任何参数，则创建包含 0 个元素的数组。如果指定多个元素，则创建包含 numElements 个元素的数组。

注意：此类显示了两个构造函数方法项，这是因为此构造函数接受的参数的类型和数量可变。根据传递的参数类型和数量的不同（由每一项详细定义），此构造函数具有不同的行为。 ActionScript 3.0 不支持方法或构造函数重载。

参数

numElements:int (default = 0) — 一个指定数组中元素数量的整数。

引发

RangeError — 该参数不是大于等于 0 的整数。

另请参见

[] array access
Array.length

示例
如何使用示例

下面的示例创建 Array 对象 myArr，该对象没有参数且初始长度为 0：

package {
    import flash.display.Sprite;

    public class Array_Array extends Sprite {

        public function Array_Array() {
            var myArr:Array = new Array();
            trace(myArr.length); // 0
        }
    }
}

下例创建一个 Array 对象，该对象包含 5 个初始元素，长度为 5，并用字符串 "one" 填充第一个元素，然后将字符串元素 "six" 添加到数组的末尾（使用 push() 方法）：

package {
    import flash.display.Sprite;

    public class Array_Array_2 extends Sprite {

        public function Array_Array_2() {
            var myArr:Array = new Array(5);
            trace(myArr.length); // 5
            myArr[0] = "one";
            myArr.push("six");
            trace(myArr);         // one,,,,,six
            trace(myArr.length); // 6
        }
    }
}

Array

()

构造函数

public function Array(... values)

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

允许创建包含指定元素的数组。您可以指定任何类型的值。数组中第一个元素的索引（或位置）始终为 0。

注意：此类显示了两个构造函数项，这是因为此构造函数接受的参数的类型和数量可变。根据传递的参数类型和数量的不同（由每一项详细定义），此构造函数具有不同的行为。 ActionScript 3.0 不支持方法或构造函数重载。

参数

... values — 一个以逗号分隔的列表，包含一个或多个任意值。

注意：如果传递给 Array 构造函数的只有一个单数值参数，则认为该参数指定数组的 length 属性。

引发

RangeError — 该参数不是大于等于 0 的整数。

另请参见

[] array access
Array.length

示例
如何使用示例

下例创建一个新的 Array 对象，该对象初始长度为 3，并用字符串元素 one、two 和 three 填充数组，然后将这些元素转换为字符串。

package {
    import flash.display.Sprite;

    public class Array_Array_3 extends Sprite {

        public function Array_Array_3() {
            var myArr:Array = new Array("one", "two", "three");
            trace(myArr.length); // 3
            trace(myArr);          // one,two,three
        }
    }
}

方法详细信息

concat

()

方法

AS3 function concat(... args):Array

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

将参数中指定的元素与数组中的元素连接，并创建新的数组。如果这些参数指定了一个数组，将连接该数组中的元素。

参数

... args — 要连接到新数组中的任意数据类型的值（如数字、元素或字符串）。如果未传递任何值，则新数组将是原始数组的副本。

Array — 一个数组，其中包含此数组中的元素，后跟参数中的元素。

示例
如何使用示例

以下代码创建四个 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 数组。

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

every

()

方法

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

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

对数组中的每一项执行测试函数，直到获得对指定的函数返回 false 的项。使用此方法可确定数组中的所有项是否满足某一条件，如具有的值小于某一特定数值。

在此方法中，如果第一个参数 callback 为 closure 方法，则第二个参数 thisObject 必须为 null。假设在影片剪辑中创建了一个名为 me 的函数：

     function myFunction(){ // 在此处输入您的代码}

然后对名为 myArray 的数组使用 filter() 方法：

     myArray.filter(myFunction, me);

由于 myFunction 是 Timeline 类的成员，不能被 me 覆盖，因此 Flash Player 将引发异常。通过将该函数分配给某个变量（如下所示），可以避免这种运行时错误：

     var foo:Function = myFunction() { // 在此输入您的代码}; myArray.filter(foo, me);

参数

	`callback:Function` — 要对数组中的每一项运行的函数。该函数可以包含简单的比较操作（例如，`item < 20`）或者更复杂的操作，并用三个参数来调用，即项值、项索引和 Array 对象： function callback(item:*, index:int, array:Array):Boolean;

	`thisObject:*` (default = `null`) — 用作函数的 `this` 的对象。

Boolean — 如果数组中的所有项对指定的函数都返回 true，则为布尔值 true；否则为 false。

另请参见

Array.some()

示例
如何使用示例

下面的示例测试两个数组，以确定每个数组中的每一项是否都是数字。还输出了测试结果，说明对于第一个数组，isNumeric 是 true，对于第二个数组则是 false：

package {
    import flash.display.Sprite;
    public class Array_every extends Sprite {
        public function Array_every() {
            var arr1:Array = new Array(1, 2, 4);
            var res1:Boolean = arr1.every(isNumeric);
            trace("isNumeric:", res1); // true
 
            var arr2:Array = new Array(1, 2, "ham");
            var res2:Boolean = arr2.every(isNumeric);
            trace("isNumeric:", res2); // false
        }
        private function isNumeric(element:*, index:int, arr:Array):Boolean {
            return (element is Number);
        }
    }
}

filter

()

方法

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

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

对数组中的每一项执行测试函数，并构造一个新数组，其中的所有项都对指定的函数返回 true。如果某项返回 false，则新数组中将不包含此项。

在此方法中，如果第一个参数 callback 为 closure 方法，则第二个参数 thisObject 必须为 null。假设在影片剪辑中创建了一个名为 me 的函数：

     function myFunction(){ // 在此处输入您的代码}

然后对名为 myArray 的数组使用 filter() 方法：

     myArray.filter(myFunction, me);

     var foo:Function = myFunction() { // 在此输入您的代码}; myArray.filter(foo, me);

参数

	`callback:Function` — 要对数组中的每一项运行的函数。该函数可以包含简单的比较操作（例如，`item < 20`）或者更复杂的操作，并用三个参数来调用，即项值、项索引和 Array 对象： function callback(item:*, index:int, array:Array):Boolean;

	`thisObject:*` (default = `null`) — 用作函数的 `this` 的对象。

Array — 一个新数组，它包含原始数组中返回 true 的所有项。

另请参见

Array.map()

示例
如何使用示例

下面的示例创建一个数组，其中包括职务为经理的所有员工：

package {
    import flash.display.Sprite;
    public class Array_filter extends Sprite {
        public function Array_filter() {
            var employees:Array = new Array();
            employees.push({name:"Employee 1", manager:false});
            employees.push({name:"Employee 2", manager:true});
            employees.push({name:"Employee 3", manager:false});
            trace("Employees:");
            employees.forEach(traceEmployee);
            
            var managers:Array = employees.filter(isManager);
            trace("Managers:");
            managers.forEach(traceEmployee);
        }
        private function isManager(element:*, index:int, arr:Array):Boolean {
            return (element.manager == true);
        }
        private function traceEmployee(element:*, index:int, arr:Array):void {
            trace("\t" + element.name + ((element.manager) ? " (manager)" : ""));
        }
    }
}

forEach

()

方法

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

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

对数组中的每一项执行函数。

在此方法中，如果第一个参数 callback 为 closure 方法，则第二个参数 thisObject 必须为 null。假设在影片剪辑中创建了一个名为 me 的函数：

     function myFunction(){ // 在此处输入您的代码}

然后对名为 myArray 的数组使用 filter() 方法：

     myArray.filter(myFunction, me);

     var foo:Function = myFunction() { // 在此输入您的代码}; myArray.filter(foo, me);

参数

	`callback:Function` — 要对数组中的每一项运行的函数。此函数可以包含简单的命令（如 `trace()` 语句）或者更复杂的操作，并用三个参数来调用，即项值、项索引和 Array 对象： function callback(item:*, index:int, array:Array):void;

	`thisObject:*` (default = `null`) — 用作函数的 `this` 的对象。

示例
如何使用示例

下面的示例对数组中的每一项运行 traceEmployee() 函数中的 trace() 语句：

package {
    import flash.display.Sprite;
    public class Array_forEach extends Sprite {
        public function Array_forEach() {
            var employees:Array = new Array();
            employees.push({name:"Employee 1", manager:false});
            employees.push({name:"Employee 2", manager:true});
            employees.push({name:"Employee 3", manager:false});
            trace(employees);
            employees.forEach(traceEmployee);
        }
        private function traceEmployee(element:*, index:int, arr:Array):void {
            trace(element.name + " (" + element.manager + ")");
        }
    }
}

下面的示例也对数组中的每一项运行略有变化的 traceEmployee() 函数中的 trace() 语句：

package {
    import flash.display.Sprite;
    public class Array_forEach_2 extends Sprite {
        public function Array_forEach_2() {
            var employeeXML:XML = <employees>
                    <employee name="Steven" manager="false" />
                    <employee name="Bruce" manager="true" />
                    <employee name="Rob" manager="false" />
                </employees>;
            var employeesList:XMLList = employeeXML.employee;
            var employeesArray:Array = new Array();
            for each (var tempXML:XML in employeesList) {
                employeesArray.push(tempXML);
            }
            employeesArray.sortOn("@name");
            employeesArray.forEach(traceEmployee);
        }
        private function traceEmployee(element:*, index:Number, arr:Array):void {
            trace(element.@name + ((element.@manager == "true") ? " (manager)" : ""));
        }
    }
}

indexOf

()

方法

AS3 function indexOf(searchElement:*, fromIndex:int = 0):int

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

使用全等运算符 (===) 搜索数组中的项，并返回项的索引位置。

参数

	`searchElement:*` — 要在数组中查找的项。

	`fromIndex:int` (default = `0`) — 数组中的位置，从该位置开始搜索项。

int — 数组项的索引位置（从 0 开始）。如果未找到 searchElement 参数，则返回值为 -1。

另请参见

Array.lastIndexOf()
=== (strict equality)

示例
如何使用示例

下面的示例显示指定数组的位置：

package {
    import flash.display.Sprite;
    public class Array_indexOf extends Sprite {
        public function Array_indexOf() {
            var arr:Array = new Array(123,45,6789);
            arr.push("123-45-6789");
            arr.push("987-65-4321");
            
            var index:int = arr.indexOf("123");
            trace(index); // -1
            
            var index2:int = arr.indexOf(123);
            trace(index2); // 0
        }
    }
}

join

()

方法

AS3 function join(sep:*):String

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

将数组中的元素转换为字符串、在元素间插入指定的分隔符、连接这些元素然后返回结果字符串。嵌套数组总是以逗号 (,) 分隔，而不使用传递给 join() 方法的分隔符分隔。

参数

sep:* — 在返回字符串中分隔数组元素的字符或字符串。如果省略此参数，则使用逗号作为默认分隔符。

String — 一个字符串，由转换为字符串并由指定参数分隔的数组元素组成。

另请参见

String.split()

示例
如何使用示例

下面的代码创建一个 Array 对象 myArr，其中包含元素 one、two 和 three，然后创建一个包含 one and two and three 的字符串（使用 join() 方法）。

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

下面的代码创建一个 Array 对象 specialChars，其中包含元素 (、)、- 和一个空格，然后创建一个字符串，其中包含 (888) 867-5309。然后使用 for 循环，删除 specialChars 中列出的每种类型的特殊字符，以生成一个字符串 (myStr)，该字符串中仅包含剩余的电话号码数字：888675309。请注意，其它字符（如 +）可能已添加到了 specialChars 中，这样此例程即可处理国际电话号码格式。

var phoneString:String = "(888) 867-5309";

var specialChars:Array = new Array("(", ")", "-", " ");
var myStr:String = phoneString;

var ln:uint = specialChars.length;
for(var i:uint; i < ln; i++) {
    myStr = myStr.split(specialChars[i]).join("");
}

var phoneNumber:Number = new Number(myStr);

trace(phoneString); // (888) 867-5309
trace(phoneNumber); // 8888675309

lastIndexOf

()

方法

AS3 function lastIndexOf(searchElement:*, fromIndex:int = 0x7fffffff):int

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

搜索数组中的项（从最后一项开始向前搜索），并使用全等运算符 (===) 返回匹配项的索引位置。

参数

	`searchElement:*` — 要在数组中查找的项。

	`fromIndex:int` (default = `0x7fffffff`) — 数组中的位置，从该位置开始搜索项。默认为允许的最大索引值。如果不指定 `fromIndex`，将从数组中的最后一项开始进行搜索。

int — 数组项的索引位置（从 0 开始）。如果未找到 searchElement 参数，则返回值为 -1。

另请参见

Array.indexOf()
=== (strict equality)

示例
如何使用示例

下面的示例显示指定数组的位置：

package {
    import flash.display.Sprite;
    public class Array_lastIndexOf extends Sprite {
        public function Array_lastIndexOf() {
            var arr:Array = new Array(123,45,6789,123,984,323,123,32);
            
            var index:int = arr.indexOf(123);
            trace(index); // 0
            
            var index2:int = arr.lastIndexOf(123);
            trace(index2); // 6
        }
    }
}

map

()

方法

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

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

对数组中的每一项执行函数并构造一个新数组，其中包含与原始数组中的每一项的函数结果相对应的项。

在此方法中，如果第一个参数 callback 为 closure 方法，则第二个参数 thisObject 必须为 null。假设在影片剪辑中创建了一个名为 me 的函数：

     function myFunction(){ // 在此处输入您的代码}

然后对名为 myArray 的数组使用 filter() 方法：

     myArray.filter(myFunction, me);

     var foo:Function = myFunction() { // 在此输入您的代码}; myArray.filter(foo, me);

参数

	`callback:Function` — 要对数组中的每一项运行的函数。此函数可以包含简单的命令（如更改字符串数组的大小写）或更复杂的操作，并用 3 个参数来调用，即项值、项索引和 Array 对象： function callback(item:*, index:int, array:Array):void;

	`thisObject:*` (default = `null`) — 用作函数的 `this` 的对象。

Array — 一个新数组，其中包含此函数对原始数组中每一项的执行结果。

另请参见

Array.filter()

示例
如何使用示例

下面的示例将数组中的所有项更改为使用大写字母：

package {
    import flash.display.Sprite;
    public class Array_map extends Sprite {
        public function Array_map() {
            var arr:Array = new Array("one", "two", "Three");
            trace(arr); // one,two,Three

            var upperArr:Array = arr.map(toUpper);
            trace(upperArr); // ONE,TWO,THREE
        }
        private function toUpper(element:*, index:int, arr:Array):String {
            return String(element).toUpperCase();
        }
    }
}

pop

()

方法

AS3 function pop():Object

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

删除数组中最后一个元素，并返回该元素的值。

Object — 指定的数组中最后一个元素（可以为任意数据类型）的值。

另请参见

Array.push()
Array.shift()
Array.unshift()

示例
如何使用示例

下面的代码创建一个 Array 对象 letters，其中包含元素 a、b 和 c。然后使用 pop() 方法将最后一个元素 (c) 从数组中删除，并将该元素分配给 String 对象 letter。

var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
var letter:String = letters.pop();
trace(letters); // a,b
trace(letter);     // c

push

()

方法

AS3 function push(... args):uint

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

将一个或多个元素添加到数组的结尾，并返回该数组的新长度。

参数

... args — 要追加到数组中的一个或多个值。

uint — 一个表示新数组长度的整数。

另请参见

Array.pop()
Array.shift()
Array.unshift()

示例
如何使用示例

下面的代码创建一个空的 Array 对象 letters，然后用如下元素填充数组：a、b 和 c（使用 push() 方法）。

var letters:Array = new Array();

letters.push("a");
letters.push("b");
letters.push("c");

trace(letters.toString()); // a,b,c

下面的代码创建一个 Array 对象 letters，最初用以下元素填充：a。然后，使用一次 push() 方法将元素 b 和 c 添加到数组的末尾，使用 push 方法后数组中就有了 3 个元素。

var letters:Array = new Array("a");
var count:uint = letters.push("b", "c");

trace(letters); // a,b,c
trace(count);   // 3

reverse

()

方法

AS3 function reverse():Array

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

在当前位置倒转数组。

Array — 新数组。

示例
如何使用示例

下面的代码创建一个 Array 对象 letters，其中包含元素 a、b 和 c。然后逆转数组元素的顺序（使用 reverse() 方法）以生成数组 [c,b,a]。

var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
letters.reverse();
trace(letters); // c,b,a

shift

()

方法

AS3 function shift():Object

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

删除数组中第一个元素，并返回该元素。其余数组元素将从其原始位置 i 移至 i-1。

Object — 数组中的第一个元素（可以是任意数据类型）。

另请参见

Array.pop()
Array.push()
Array.unshift()

示例
如何使用示例

下面的代码创建 Array 对象 letters，其中包含元素 a、b 和 c。然后，使用 shift() 方法将第一个元素 (a) 从 letters 中删除，并将其分配给字符串 firstLetter。

var letters:Array = new Array("a", "b", "c");
var firstLetter:String = letters.shift();
trace(letters);     // b,c
trace(firstLetter); // a

slice

()

方法

AS3 function slice(startIndex:int = 0, endIndex:int = 16777215):Array

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

返回由原始数组中某一范围的元素构成的新数组，而不修改原始数组。返回的数组包括 startIndex 元素以及从其开始到 endIndex 元素（但不包括该元素）的所有元素。

如果您没有传递任何参数，则创建原始数组的一个副本。

参数

	`startIndex:int` (default = `0`) — 一个数字，指定片段起始点的索引。如果 `startIndex` 是负数，则起始点从数组的结尾开始，其中 -1 指的是最后一个元素。

	`endIndex:int` (default = `16777215`) — 一个数字，指定片段终点的索引。如果省略此参数，则片段包括数组中从开头到结尾的所有元素。如果 `endIndex` 是负数，则终点从数组的结尾指定，其中 -1 指的是最后一个元素。

Array — 一个数组，由原始数组中某一范围的元素组成。

示例
如何使用示例

下面的代码创建一个 Array 对象 letters，其中包含元素 [a,b,c,d,e,f]。然后创建数组 someLetters，方法是调用 slice() 方法（对元素 1 (b) 至元素 3 (d)），从而得到一个数组，其中包含元素 b 和 c。

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]。

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。

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

some

()

方法

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

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

对数组中的每一项执行测试函数，直到获得返回 true 的项。使用此方法确定数组中的所有项是否满足条件，如具有小于某一特定数值的值。

在此方法中，如果第一个参数 callback 为 closure 方法，则第二个参数 thisObject 必须为 null。假设在影片剪辑中创建了一个名为 me 的函数：

     function myFunction(){ // 在此处输入您的代码}

然后对名为 myArray 的数组使用 filter() 方法：

     myArray.filter(myFunction, me);

     var foo:Function = myFunction() { // 在此输入您的代码}; myArray.filter(foo, me);

参数

	`callback:Function` — 要对数组中的每一项运行的函数。此函数可以包含简单的比较操作（如 `item < 20`）或者更复杂的操作，并用三个参数来调用，即项值、项索引和 Array 对象： function callback(item:*, index:int, array:Array):Boolean;

	`thisObject:*` (default = `null`) — 用作函数的 `this` 的对象。

Boolean — 如果数组中的所有项对于指定的函数都返回 true，则为布尔值 true，否则为 false。

另请参见

every()

示例
如何使用示例

下面的示例显示未定义的值：

package {
    import flash.display.Sprite;
    public class Array_some extends Sprite {
        public function Array_some() {
            var arr:Array = new Array();
            arr[0] = "one";
            arr[1] = "two";
            arr[3] = "four";
            var isUndef:Boolean = arr.some(isUndefined);
            if (isUndef) {
                trace("array contains undefined values: " + arr);
            } else {
                trace("array contains no undefined values.");
            }
        }
        private function isUndefined(element:*, index:int, arr:Array):Boolean {
            return (element == undefined);
        }
    }
}

sort

()

方法

AS3 function sort(... args):Array

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

对数组中的元素进行排序。此方法按 Unicode 值排序。（ASCII 是 Unicode 的一个子集。）

默认情况下，Array。sort() 按以下方式进行排序：

排序区分大小写（Z 优先于 a）。
按升序排序（a 优先于 b）。
修改该数组以反映排序顺序；在排序后的数组中不按任何特定顺序连续放置具有相同排序字段的多个元素。
元素无论属于何种数据类型，都作为字符串进行排序，所以 100 在 99 之前，这是因为 "1" 的字符串值小于 "9" 的字符串值。

如果要使用与默认设置不同的设置对数组进行排序，可以使用 ...args 参数说明中 sortOptions 部分所描述的某种排序选项，也可以创建自定义函数来进行排序。如果创建自定义函数，请调用 sort() 方法，并将自定义函数的名称作为第一个参数 (compareFunction)。

参数

... args — 指定一个比较函数和确定排序行为的一个或多个值的参数。

此方法使用语法和参数顺序 Array.sort(compareFunction, sortOptions)，其参数定义如下：

compareFunction - 一个用来确定数组元素排序顺序的比较函数。此参数是可选的。比较函数应该用两个参数进行比较。给定元素 A 和 B，compareFunction 的结果可具有以下三个值之一：
- s-1，如果 A 应在排序后的序列中出现在 B 之前
- 0，如果 A 等于 B
- 1，如果 A 应在排序后的序列中出现在 B 之后
sortOptions - 一个或多个数字或定义的常数，相互之间由 |（按位 OR）运算符隔开，它们将排序的行为从默认行为更改为其它行为。此参数是可选的。下面是 sortOptions 可接受的值：
- 1 或 Array.CASEINSENSITIVE
- 2 或 Array.DESCENDING
- 4 或 Array.UNIQUESORT
- 8 或 Array.RETURNINDEXEDARRAY
- 16 或 Array.NUMERIC
有关详细信息，请参阅 Array.sortOn() 方法。

Array — 返回值取决于您是否传递任何参数，如以下列表中所述：

如果为 ...args 参数的 sortOptions 变量指定值 4 或 Array.UNIQUESORT，并且所排序的两个或更多个元素具有相同的排序字段，则 Flash 返回值 0 并且不修改数组。
如果为 ...args 参数的 sortOptions 变量指定值 8 或 Array.RETURNINDEXEDARRAY，则 Flash 返回排序后的索引数值数组以反映排序结果，并且不修改数组。
否则，Flash 不返回任何内容并修改该数组以反映排序顺序。

另请参见

| (bitwise OR)
Array.sortOn()

示例
如何使用示例

下面的代码创建 Array 对象 vegetables，其中包含元素 [spinach, green pepper, cilantro, onion, avocado]。然后，通过 sort() 方法对该数组进行排序，调用该方法时不带参数。结果是 vegetables 按字母顺序排序 ([avocado, cilantro, green pepper, onion, spinach])。

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])。

var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "Cilantro",
                 "Onion",
                 "Avocado");

vegetables.sort();
trace(vegetables); // Avocado,Cilantro,Onion,green pepper,spinach
vegetables.sort(Array.CASEINSENSITIVE);
trace(vegetables); // Avocado,Cilantro,green pepper,Onion,spinach

下面的代码创建空的 Array 对象 vegetables，然后通过五次调用如下方法来填充该数组：push()。每次调用 push() 时，都创建一个新的 Vegetable 对象（通过调用 Vegetable() 构造函数，该构造函数接受 String (name) 和 Number (price) 对象）。使用所显示的值调用 push() 五次，会生成下面的数组：[lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]。然后，使用 sort() 方法排序该数组，从而得到数组 [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44]。

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.sort();

trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44

//The following code defines the Vegetable class
class Vegetable {
    private var name:String;
    private var price:Number;

    public function Vegetable(name:String, price:Number) {
        this.name = name;
        this.price = price;
    }

    public function toString():String {
        return " " + name + ":" + price;
    }
}

下例与前一个示例几乎完全相同，唯一不同的是将 sort() 方法与自定义排序函数 (sortOnPrice) 一起使用，该函数按 price 排序，而不是按字母顺序排序。请注意，新函数 getPrice() 将提取 price。

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.sort(sortOnPrice);

trace(vegetables);
// celery:1.29, squash:1.44, lettuce:1.49, spinach:1.89, asparagus:3.99

function sortOnPrice(a:Vegetable, b:Vegetable):Number {
    var aPrice:Number = a.getPrice();
    var bPrice:Number = b.getPrice();

    if(aPrice > bPrice) {
        return 1;
    } else if(aPrice < bPrice) {
        return -1;
    } else  {
        //aPrice == bPrice
        return 0;
    }
}

// The following code defines the Vegetable class and should be in a separate package.
class Vegetable {
    private var name:String;
    private var price:Number;

    public function Vegetable(name:String, price:Number) {
        this.name = name;
        this.price = price;
    }

    public function getPrice():Number {
        return price;
    }

    public function toString():String {
        return " " + name + ":" + price;
    }
}

下面的代码创建 Array 对象 numbers，其中包含元素 [3,5,100,34,10]。调用 sort() 时如果不带任何参数，将按照字母顺序进行排序，生成不需要的结果 [10,100,3,34,5]。若要对数值进行排序，必须将常数 NUMERIC 传递给 sort() 方法，该方法按以下方式对 numbers 进行排序：[3,5,10,34,100]。

注意：sort() 函数的默认行为是将每个实体作为字符串处理。 Array.NUMERIC 参数实际上并没有将其它数据类型转换为 Number 数据类型，它只是允许排序算法识别数字。

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

sortOn

()

方法

AS3 function sortOn(fieldName:Object, options:Object = null):Array

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

根据数组中的一个或多个字段对数组中的元素进行排序。数组应具有下列特性：

该数组是索引数组，不是关联数组。
该数组的每个元素都包含一个具有一个或多个属性的对象。
所有这些对象都至少有一个公用属性，该属性的值可用于对该数组进行排序。这样的属性称为 field。

如果您传递多个 fieldName 参数，则第一个字段表示主排序字段，第二个字段表示下一个排序字段，依此类推。 Flash 根据 Unicode 值排序。（ASCII 是 Unicode 的一个子集。）如果所比较的两个元素中均不包含 fieldName 参数中指定的字段，则认为将该字段设置为 undefined，在排序后的数组中将连续放置这些元素，不必遵循任何特定顺序。

默认情况下，Array。sortOn() 按以下方式进行排序：

排序区分大小写（Z 优先于 a）。
按升序排序（a 优先于 b）。
修改该数组以反映排序顺序；在排序后的数组中不按任何特定顺序连续放置具有相同排序字段的多个元素。
数值字段按字符串方式进行排序，因此 100 优先于 99，因为 "1" 的字符串值比 "9" 的低。

Flash Player 7 添加了 options 参数，您可以使用该参数覆盖默认排序行为。若要对简单数组（例如，仅具有一个字段的数组）进行排序，或要指定一种 options 参数不支持的排序顺序，请使用 Array.sort()。

若要传递多个标志，请使用按位“或”(|) 运算符分隔它们：

  my_array.sortOn(someFieldName, Array.DESCENDING | Array.NUMERIC);

Flash Player 8 添加了按多个字段进行排序时为每个字段指定不同的排序选项的功能。在 Flash Player 8 和更高版本中，options 参数接受排序选项的数组，以便每个排序选项对应于 fieldName 参数中的一个排序字段。下例使用降序排序对主排序字段 a 排序，使用数字排序对第二个排序字段 b 排序，使用不区分大小写的排序对第三个排序字段 c 排序：

  Array.sortOn (["a", "b", "c"], [Array.DESCENDING, Array.NUMERIC, Array.CASEINSENSITIVE]);

注意：fieldName 和 options 数组必须具有相同数量的元素；否则，将忽略 options 数组。此外，Array.UNIQUESORT 和 Array.RETURNINDEXEDARRAY 选项只能用作数组中的第一个元素；否则，将忽略它们。

参数

fieldName:Object — 一个字符串，它标识要用作排序值的字段，或一个数组，其中的第一个元素表示主排序字段，第二个元素表示第二排序字段，依此类推。

options:Object (default = null) — 所定义常数的一个或多个数字或名称，相互之间由 bitwise OR (|) 运算符隔开，它们可以更改排序行为。 options 参数可接受以下值：

如果您使用标志的字符串形式（例如，DESCENDING），而不是数字形式 (2)，则启用代码提示。

Array — 返回值取决于您是否传递任何参数：

如果您为 options 参数指定值 4 或 Array.UNIQUESORT，并且要排序的两个或多个元素具有相同的排序字段，则返回值 0 并且不修改数组。
如果为 options 参数指定值 8 或 Array.RETURNINDEXEDARRAY，则返回反映排序结果的数组并且不修改数组。
否则，不返回任何结果并修改该数组以反映排序顺序。

另请参见

| (bitwise OR)
Array.sort()

示例
如何使用示例

下面的代码创建一个空的 Array 对象 vegetables，然后通过五次调用如下方法来填充该数组：push()。每次调用 push() 时，都创建一个新的 Vegetable 对象（通过调用 Vegetable() 构造函数，该构造函数接受 String (name) 和 Number (price) 对象）。使用所显示的值调用 push() 五次，会生成下面的数组：[lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]。然后，使用 sortOn() 方法（使用 name 参数）获得以下数组：[asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44]。然后，使用 price 参数及 NUMERIC 和 DESCENDING 常数再次调用 sortOn() 方法，以得到按数字降序排序的数组：[asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29]。

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");
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

class Vegetable {
    public var name:String;
    public var price:Number;

    public function Vegetable(name:String, price:Number) {
        this.name = name;
        this.price = price;
    }

    public function toString():String {
        return " " + name + ":" + price;
    }
}

下面的代码创建一个空的 Array 对象 records，然后通过三次调用如下方法来填充该数组：push()。每次调用 push() 时，将字符串 name 和 city 以及 zip 数字添加到 records。使用三个 for 循环输出数组元素。第一个 for 循环将按元素的添加顺序输出元素。第二个 for 循环在先按名称后按城市对 records 进行排序后运行，排序时使用 sortOn() 方法。第三个 for 循环生成不同的输出，因为 records 先按城市，再按名称重新排序。

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 i:uint = 0; i < records.length; i++) {
    trace(records[i].name + ", " + records[i].city);
}
// Results:
// bob, omaha
// john, kansas city
// john, omaha

trace("records.sortOn('city', 'name');");
records.sortOn(["city", "name"]);
for(var i:uint = 0; i < records.length; i++) {
    trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, kansas city
// bob, omaha
// john, omaha

下面的代码创建一个空的 Array 对象 users，然后通过四次调用如下方法来填充该数组：push()。每次调用 push() 时，都创建一个 User 对象（使用 User() 构造函数），同时将 name 字符串和 age uint 添加到用户。生成的数组集为 [Bob:3,barb:35,abcd:3,catchy:4]。

然后按以下方式对数组进行排序：

仅按姓名排序，得到数组 [Bob:3,abcd:3,barb:35,catchy:4]
按姓名排序并使用 CASEINSENSITIVE 常数，得到数组 [abcd:3,barb:35,Bob:3,catchy:4]
按姓名排序并使用 CASEINSENSITIVE 和 DESCENDING 常数，得到数组 [catchy:4,Bob:3,barb:35,abcd:3]
仅按年龄排序，得到数组 [abcd:3,Bob:3,barb:35,catchy:4]
按年龄排序并使用 NUMERIC 常数，得到数组 [Bob:3,abcd:3,catchy:4,barb:35]
按年龄排序并使用 DESCENDING 和 NUMERIC 常数，得到数组 [barb:35,catchy:4,Bob:3,abcd:3]

然后，创建一个名为 indices 的数组，并将按年龄排序并使用 NUMERIC 和 RETURNINDEXEDARRAY 常数的结果赋予该数组，从而得到数组 [Bob:3,abcd:3,catchy:4,barb:35]，然后使用 for 循环输出该数组。

class User {
    public var name:String;
    public var age:Number;
    public function User(name:String, age:uint) {
        this.name = name;
        this.age = age;
    }

    public function toString():String {
        return this.name + ":" + this.age;
    }
}

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

splice

()

方法

AS3 function splice(startIndex:int, deleteCount:uint, ... values):Array

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

给数组添加元素以及从数组中删除元素。此方法会修改数组但不制作副本。

注意：要在 Array 的子类中覆盖此方法，请使用 ...args 作为参数，如本例所示：

  public override function splice(...args) { // 在此处输入您的语句}

参数

	`startIndex:int` — 一个整数，它指定数组中开始进行插入或删除的位置处的元素的索引。您可以用一个负整数来指定相对于数组结尾的位置（例如，-1 是数组的最后一个元素）。

	`deleteCount:uint` — 一个整数，它指定要删除的元素数量。该数量包括 `startIndex` 参数中指定的元素。如果没有为 `deleteCount` 参数指定值，则该方法将删除从 `startIndex` 元素到数组中最后一个元素的所有值。如果该参数的值为 0，则不删除任何元素。

	`... values` — 用逗号分隔的一个或多个值的可选列表或数组，此列表或数组将插入到此数组中由 `startIndex` 参数指定的位置。

Array — 一个数组，包含从原始数组中删除的元素。

示例
如何使用示例

下面的代码创建 Array 对象 vegetables，其中包含元素 [spinach, green pepper, cilantro, onion, avocado]。然后，使用参数 2 和 2 调用 splice() 方法，以将 cilantro 和 onion 赋予 spliced 数组。 vegetables 数组中就包含 [spinach,green pepper,avocado]。再次调用 splice() 方法（使用参数 1、0 和 spliced 数组），以将 [cilantro,onion] 作为以下数组中的第二个元素：vegetables。

var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "cilantro",
                 "onion",
                 "avocado");

var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced);    // cilantro,onion

vegetables.splice(1, 0, spliced);
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado

请注意，cilantro 和 onion 输出时好像 vegetables 有 5 个元素，但它实际上只有 4 个元素（其中第二个元素是一个包含两个元素的数组）。若要单独添加 cilantro 和 onion，可使用：

 
var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "cilantro",
                 "onion",
                 "avocado");
 
 var spliced:Array = vegetables.splice(2, 2);
 trace(vegetables); // spinach,green pepper,avocado
 trace(spliced);    // cilantro,onion
 
 vegetables.splice(1, 0, "cilantro", "onion");
 trace(vegetables); // spinach,cilantro,onion,green pepper,avocado

toLocaleString

()

方法

public function toLocaleString():String

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

返回一个字符串，它表示指定数组中的元素。数组中的每一个元素（从索引 0 开始到最高索引结束）均会转换为一个连接字符串，并以逗号分隔。在 ActionScript 3.0 实现中，此方法与 Array.toString() 方法返回相同的值。

String — 数组元素的字符串。

另请参见

Array.toString()

toString

()

方法

public function toString():String

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

返回一个字符串，它表示指定数组中的元素。数组中的每一个元素（从索引 0 开始到最高索引结束）均会转换为一个连接字符串，并以逗号分隔。若要指定自定义的分隔符，请使用 Array.join() 方法。

String — 数组元素的字符串。

另请参见

String.split()
Array.join()

示例
如何使用示例

以下代码创建一个 Array 对象，将值转换为字符串，并将它们存储到 String 数据类型的 vegnums 变量中。

var vegetables:Array = new Array();
vegetables.push(1);
vegetables.push(2);
vegetables.push(3);
vegetables.push(4);
vegetables.push(5);
var vegnums:String = vegetables.toString();
trace(vegnums+",6");
// 1,2,3,4,5,6

unshift

()

方法

AS3 function unshift(... args):uint

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

将一个或多个元素添加到数组的开头，并返回该数组的新长度。数组中的其它元素从其原始位置 i 移到 i+1。

参数

... args — 一个或多个要插入到数组开头的数字、元素或变量。

uint — 一个整数，表示该数组的新长度。

另请参见

Array.pop()
Array.push()
Array.shift()

示例
如何使用示例

下面的代码创建空的 Array 对象 names。添加字符串 Bill 和 Jeff（通过 push() 方法），然后将字符串 Alfred 和 Kyle 添加到 names 的开头（通过两次调用 unshift() 方法）。

var names:Array = new Array();
names.push("Bill");
names.push("Jeff");

trace(names); // Bill,Jeff

names.unshift("Alfred");
names.unshift("Kyle");

trace(names); // Kyle,Alfred,Bill,Jeff

常量详细信息

CASEINSENSITIVE

常量

public static const CASEINSENSITIVE:uint = 1

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

指定 Array 类排序方法为不区分大小写的排序。您可以对 sort() 方法或 sortOn() 方法中的 options 参数使用此常数。

此常数的值为 1。

另请参见

Array.sort()
Array.sortOn()

DESCENDING

常量

public static const DESCENDING:uint = 2

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

指定 Array 类排序方法为降序排序。您可以对 sort() 方法或 sortOn() 方法中的 options 参数使用此常数。

此常数的值为 2。

另请参见

Array.sort()
Array.sortOn()

NUMERIC

常量

public static const NUMERIC:uint = 16

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

指定 Array 类排序方法为数值（而不是字符串）排序。在 options 参数中包括此常数会导致 sort() 方法和 sortOn() 方法将数字作为数值排序，而不是作为数字字符的字符串排序。如果不使用 NUMERIC 常数，则排序将每个数组元素视为一个字符串，并且按照 Unicode 顺序生成结果。

例如，以值为 [2005, 7, 35] 的数组为例，如果 NUMERIC 常数未包括在 options 参数中，则排序后的数组为 [2005, 35, 7]，但如果包括了 NUMERIC 常数，则排序后的数组为 [7, 35, 2005]。

此常数仅应用于数组中的数字；不应用于包含数值数据（如 ["23", "5"]）的字符串。

此常数的值为 16。

另请参见

Array.sort()
Array.sortOn()

RETURNINDEXEDARRAY

常量

public static const RETURNINDEXEDARRAY:uint = 8

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

指定排序返回的数组包含数组索引。可以将此常数用于 sort() 或 sortOn() 方法中的 options 参数，以便您能够访问数组元素的多个视图，同时又不修改原始数组。

此常数的值为 8。

另请参见

Array.sort()
Array.sortOn()

UNIQUESORT

常量

public static const UNIQUESORT:uint = 4

语言版本 :

ActionScript 3.0

Player 版本 :

Flash Player 9

指定 Array 类排序方法的唯一排序要求。您可以对 sort() 方法或 sortOn() 方法中的 options 参数使用此常数。如果任何两个要排序的元素或字段的值相同，唯一排序选项就会终止排序。

此常数的值为 4。

另请参见

Array.sort()
Array.sortOn()

示例如何使用示例

下面的示例创建一个新的 Array 对象 myArr，该对象没有参数且初始长度为 0：

package {
    import flash.display.Sprite;

    public class ArrayExample extends Sprite {
        public function ArrayExample() {
            var myArr:Array = new Array();
            trace(myArr.length); // 0
        }
    }
}

posted @ 2009-04-25 02:27 温景良(Jason) Views(4664) Comments(0) Edit 收藏举报

刷新页面返回顶部

我的程序人生

提供基于Lesktop的IM二次开发,联系QQ:76159179

FLEX程序设计--数组

公告