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
,否则将无法在数组中存储数据。
另请参见
属性 | 定义方 | ||
---|---|---|---|
![]() |
constructor : Object
对类对象或给定对象实例的构造函数的引用。 |
Object | |
length : uint
指定数组中元素数量的非负整数。 |
Array | ||
![]() |
prototype : Object
[static] 对类或函数对象的原型对象的引用。 |
Object |
方法 | 定义方 | ||
---|---|---|---|
允许创建指定元素数量的数组。 |
Array | ||
允许创建包含指定元素的数组。 |
Array | ||
将参数中指定的元素与数组中的元素连接,并创建新的数组。 |
Array | ||
对数组中的每一项执行测试函数,直到获得对指定的函数返回 false 的项。 |
Array | ||
对数组中的每一项执行测试函数,并构造一个新数组,其中的所有项都对指定的函数返回 true。 |
Array | ||
对数组中的每一项执行函数。 |
Array | ||
![]() |
指示对象是否已经定义了指定的属性。 |
Object | |
使用全等运算符 (===) 搜索数组中的项,并返回该项的索引位置。 |
Array | ||
![]() |
指示 Object 类的实例是否在指定为参数的对象的原型链中。 |
Object | |
将数组中的元素转换为字符串、在元素间插入指定的分隔符、连接这些元素然后返回结果字符串。 |
Array | ||
使用全等运算符 (===) 搜索数组中的项(从最后一项开始向前搜索),并返回匹配项的索引位置。 |
Array | ||
对数组中的每一项执行函数并构造一个新数组,其中包含与原始数组中的每一项的函数结果相对应的项。 |
Array | ||
删除数组中最后一个元素,并返回该元素的值。 |
Array | ||
![]() |
指示指定的属性是否存在、是否可枚举。 |
Object | |
将一个或多个元素添加到数组的结尾,并返回该数组的新长度。 |
Array | ||
在当前位置倒转数组。 |
Array | ||
![]() |
设置循环操作动态属性的可用性。 |
Object | |
删除数组中第一个元素,并返回该元素。 |
Array | ||
返回由原始数组中某一范围的元素构成的新数组,而不修改原始数组。 |
Array | ||
对数组中的每一项执行测试函数,直到获得返回 true 的项。 |
Array | ||
对数组中的元素进行排序。 |
Array | ||
根据数组中的一个或多个字段对数组中的元素进行排序。 |
Array | ||
给数组添加元素以及从数组中删除元素。 |
Array | ||
返回一个字符串,它表示指定数组中的元素。 |
Array | ||
返回一个字符串,它表示指定数组中的元素。 |
Array | ||
将一个或多个元素添加到数组的开头,并返回该数组的新长度。 |
Array | ||
![]() |
返回指定对象的原始值。 |
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
示例
如何使用示例
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 的整数。 |
另请参见
示例
如何使用示例
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 } } }
"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 构造函数的只有一个单数值参数,则认为该参数指定数组的 |
引发
RangeError — 该参数不是大于等于 0 的整数。 |
另请参见
示例
如何使用示例
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 — 一个数组,其中包含此数组中的元素,后跟参数中的元素。 |
示例
如何使用示例
- 包含数字
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 。 |
另请参见
示例
如何使用示例
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);
由于 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 的对象。 |
返回
Array — 一个新数组,它包含原始数组中返回 true 的所有项。 |
另请参见
示例
如何使用示例
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);
由于 myFunction
是 Timeline 类的成员,不能被 me
覆盖,因此 Flash Player 将引发异常。 通过将该函数分配给某个变量(如下所示),可以避免这种运行时错误:
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。 |
另请参见
示例
如何使用示例
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 — 一个字符串,由转换为字符串并由指定参数分隔的数组元素组成。 |
另请参见
示例
如何使用示例
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
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。 |
另请参见
示例
如何使用示例
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);
由于 myFunction
是 Timeline 类的成员,不能被 me
覆盖,因此 Flash Player 将引发异常。 通过将该函数分配给某个变量(如下所示),可以避免这种运行时错误:
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 — 一个新数组,其中包含此函数对原始数组中每一项的执行结果。 |
另请参见
示例
如何使用示例
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 — 指定的数组中最后一个元素(可以为任意数据类型)的值。 |
另请参见
示例
如何使用示例
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 — 一个表示新数组长度的整数。 |
另请参见
示例
如何使用示例
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
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 — 新数组。 |
示例
如何使用示例
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 — 数组中的第一个元素(可以是任意数据类型)。 |
另请参见
示例
如何使用示例
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 — 一个数组,由原始数组中某一范围的元素组成。 |
示例
如何使用示例
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
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
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);
由于 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 。 |
另请参见
示例
如何使用示例
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 — 返回值取决于您是否传递任何参数,如以下列表中所述:
|
另请参见
示例
如何使用示例
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
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
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; } }
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 参数可接受以下值:
如果您使用标志的字符串形式(例如, |
返回
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; } }
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
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 — 一个数组,包含从原始数组中删除的元素。 |
示例
如何使用示例
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 — 数组元素的字符串。 |
另请参见
toString | () | 方法 |
public function toString():String
语言版本 : | ActionScript 3.0 |
Player 版本 : | Flash Player 9 |
返回一个字符串,它表示指定数组中的元素。 数组中的每一个元素(从索引 0 开始到最高索引结束)均会转换为一个连接字符串,并以逗号分隔。 若要指定自定义的分隔符,请使用 Array.join()
方法。
返回
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 — 一个整数,表示该数组的新长度。 |
另请参见
示例
如何使用示例
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。
另请参见
DESCENDING | 常量 |
public static const DESCENDING:uint = 2
语言版本 : | ActionScript 3.0 |
Player 版本 : | Flash Player 9 |
指定 Array 类排序方法为降序排序。 您可以对 sort()
方法或 sortOn()
方法中的 options
参数使用此常数。
此常数的值为 2。
另请参见
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。
另请参见
RETURNINDEXEDARRAY | 常量 |
public static const RETURNINDEXEDARRAY:uint = 8
语言版本 : | ActionScript 3.0 |
Player 版本 : | Flash Player 9 |
指定排序返回的数组包含数组索引。 可以将此常数用于 sort()
或 sortOn()
方法中的 options
参数,以便您能够访问数组元素的多个视图,同时又不修改原始数组。
此常数的值为 8。
另请参见
UNIQUESORT | 常量 |
public static const UNIQUESORT:uint = 4
语言版本 : | ActionScript 3.0 |
Player 版本 : | Flash Player 9 |
指定 Array 类排序方法的唯一排序要求。 您可以对 sort()
方法或 sortOn()
方法中的 options
参数使用此常数。 如果任何两个要排序的元素或字段的值相同,唯一排序选项就会终止排序。
此常数的值为 4。
另请参见
myArr
,该对象没有参数且初始长度为 0:
package { import flash.display.Sprite; public class ArrayExample extends Sprite { public function ArrayExample() { var myArr:Array = new Array(); trace(myArr.length); // 0 } } }