Package | Top Level |
Class | public dynamic class Vector |
Inheritance | Vector Object |
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Like with an Array, you can use the array access ([]
) operator to
set or retrieve the value of a Vector element. Several Vector methods also
provide mechanisms for setting and retrieving element values. These include
push()
, pop()
, shift()
, unshift()
,
and others. The properties
and methods of a Vector object are similar — in most cases identical — to
the properties and methods of an Array. In any case where you would use
an Array in which all the elements have the same data type, a Vector instance
is preferable.
The Vector's base type is specified using postfix
type parameter syntax. Type parameter syntax is a sequence consisting of
a dot (.
), left angle bracket (<
), class name,
then a right angle bracket (>
), as shown in this example:
var v:Vector.<String>; v = new Vector.<String>();
In the first line of the example, the variable v
is declared as a
Vector.<String> instance. In other words, it represents a Vector (an array)
that can only hold String instances and from which only String instances can be retrieved.
The second line constructs an instance of the same Vector type (that is, a
Vector whose elements are all String objects) and assigns it to v
.
A variable declared with the Vector.<T> data type can only store
a Vector instance that is constructed with the same base type
T
. For example, a Vector that's constructed by calling
new Vector.<String>()
can't be assigned to a variable
that's declared with the Vector.<int> data type. The base types must match exactly.
For example, the following code doesn't compile because the object's base type isn't
the same as the variable's declared base type (even though Sprite is a subclass of
DisplayObject):
// This code doesn't compile even though Sprite is a DisplayObject subclass var v:Vector.<DisplayObject> = new Vector.<Sprite>();
To convert a Vector with base type T
to a Vector of a superclass of
T
, use the Vector()
global function.
In addition to the data type restriction, the Vector class has other restrictions that distinguish it from the Array class:
- A Vector is a dense array. Unlike an Array, which may have values in indices
0 and 7 even if there are no values in positions 1 through 6, a Vector must have
a value (or
null
) in each index. - A Vector can optionally be fixed-length, meaning the number of elements it contains can't change.
- Access to a Vector's elements is bounds-checked. You can never read a value
from an index greater than the final element (
length - 1
). You can never set a value with an index more than one beyond the current final index (in other words, you can only set a value at an existing index or at index[length]
).
As a result of its restrictions, a Vector has two primary benefits over an Array instance whose elements are all instances of a single class:
- Performance: array element access and iteration are much faster when using a Vector instance than when using an Array.
- Type safety: in strict mode the compiler can identify data type errors such as
assigning a value of the incorrect data type to a Vector or expecting the wrong data
type when reading a value from a Vector. Note, however, that when using the
push()
method orunshift()
method to add values to a Vector, the arguments' data types are not checked at compile time but are checked at run time.
See also
Property | Defined By | ||
---|---|---|---|
constructor : Object
A reference to the class object or constructor function for a given object instance. | Object | ||
fixed : Boolean
Indicates whether the length property of the Vector can
be changed. | Vector | ||
length : uint
The range of valid indices available in the Vector. | Vector | ||
prototype : Object [static]
A reference to the prototype object of a class or function object. | Object |
Method | Defined By | ||
---|---|---|---|
Creates a Vector with the specified base type. | Vector | ||
Concatenates the elements specified in the parameters with the elements
in the Vector and creates a new Vector. | Vector | ||
Executes a test function on each item in the Vector until an item is
reached that returns false for the specified function. | Vector | ||
Executes a test function on each item in the Vector and returns
a new Vector containing all items that return true for the
specified function. | Vector | ||
Executes a function on each item in the Vector. | Vector | ||
Indicates whether an object has a specified property defined. | Object | ||
Searches for an item in the Vector and returns the index position of the item. | Vector | ||
Indicates whether an instance of the Object class is in the prototype chain of the object specified
as the parameter. | Object | ||
Converts the elements in the Vector to strings, inserts the specified separator between the
elements, concatenates them, and returns the resulting string. | Vector | ||
Searches for an item in the Vector, working backward from the specified
index position, and returns the index position of the matching item. | Vector | ||
Executes a function on each item in the Vector, and returns a new Vector
of items corresponding to the results of calling the function on
each item in this Vector. | Vector | ||
pop():T
Removes the last element from the Vector and returns that element. | Vector | ||
Indicates whether the specified property exists and is enumerable. | Object | ||
Adds one or more elements to the end of the Vector and returns
the new length of the Vector. | Vector | ||
Reverses the order of the elements in the Vector. | Vector | ||
Sets the availability of a dynamic property for loop operations. | Object | ||
shift():T
Removes the first element from the Vector and returns that element. | Vector | ||
Returns a new Vector that consists of a range of elements from
the original Vector, without modifying the original Vector. | Vector | ||
Executes a test function on each item in the Vector until an
item is reached that returns true. | Vector | ||
Sorts the elements in the Vector. | Vector | ||
Adds elements to and removes elements from the Vector. | Vector | ||
Returns a string that represents the elements in the specified Vector. | Vector | ||
Returns a string that represents the elements in the Vector. | Vector | ||
Adds one or more elements to the beginning of the Vector and returns
the new length of the Vector. | Vector | ||
Returns the primitive value of the specified object. | Object |
fixed | property |
fixed:Boolean
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Indicates whether the length
property of the Vector can
be changed. If the value is false
, the length
property can't be changed. This means the following operations are not
allowed when fixed
is true
:
- setting the
length
property directly - assigning a value to index position
length
- calling a method that changes the
length
property, including:pop()
push()
shift()
unshift()
splice()
(if thesplice()
call changes thelength
of the Vector).
Implementation
public function get fixed():Boolean
public function set fixed(value:Boolean):void
length | property |
length:uint
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
The range of valid indices available in the Vector.
A Vector instance has index positions up to but not including
the length
value.
Every Vector element always has a value that is either an
instance of the base type or null
. When the
length
property is set to a value
that's larger than its previous value, additional elements are
created and populated with the default value appropriate to
the base type (null
for reference types).
When the length
property is set to a value
that's smaller than its previous value, all the elements
at index positions greater than or equal to the new length
value are removed from the Vector.
Implementation
public function get length():uint
public function set length(value:uint):void
Throws
RangeError — If this property is changed
while fixed is true .
| |
RangeError — If this property is set to a value larger
than the maximum allowable index (232).
|
Vector | () | Constructor |
public function Vector(length:uint = 0, fixed:Boolean = false)
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Creates a Vector with the specified base type.
When calling the Vector.<T>()
constructor, specify the
base type using type parameter syntax. Type parameter syntax is a
sequence consisting of a dot (.
), left angle bracket
(<
), class name, then a right angle bracket
(>
), as shown in this example:
var v:Vector.<String> = new Vector.<String>();
Unlike with the Array class, you can't use the Vector.<T>()
constructor to create a pre-populated Vector instance. To create a Vector
instance from an Array or another Vector (such as one with a different base
type), use the Vector()
global function.
length:uint (default = 0 ) — The initial length (number of elements) of the Vector. If
this parameter is greater than zero, the specified number of Vector elements
are created and populated with the default value appropriate to
the base type (null for reference types).
| |
fixed:Boolean (default = false ) — Whether the Vector's length is fixed (true ) or
can be changed (false ). This value can also be set using
the fixed property.
|
See also
concat | () | method |
AS3 function concat(... args):Vector.<T>
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Concatenates the elements specified in the parameters with the elements in the Vector and creates a new Vector. If the parameters specify a Vector, the elements of that Vector are concatenated.
hello world
Parameters
... args — One or more values of the base type of this Vector
to be concatenated in a new Vector. If you don't
pass any values, the new Vector is a duplicate of the original Vector.
|
Vector.<T> — A Vector with the same base type as this Vector that contains
the elements from this Vector followed by elements from the parameters.
|
Throws
TypeError — If any argument is not an instance of the base type
and can't be converted to the base type.
|
every | () | method |
AS3 function every(callback:Function, thisObject:Object = null):Boolean
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Executes a test function on each item in the Vector until an item is
reached that returns false
for the specified function.
You use this method to determine whether all items in a Vector meet
a criterion, such as having values less than a particular number.
For this method, the second parameter,
thisObject
, must be null
if the
first parameter, callback
, is a method closure. That is
the most common way of using this method.
However, suppose you create a function on a frame on the main timeline using Flash Professional,
but you want it to be called in a different this
context:
function myFunction(item:T, index:int, vector:Vector.<T>):Boolean { // your code here }
Suppose you then use the every()
method on a Vector called myVector
:
myVector.every(myFunction, someObject);
Because myFunction
is a member of the
main class of the SWF, it cannot be executed in a different this
context. Flash
Player or AIR throws an exception when this code runs. You can avoid this runtime error
by assigning the function to a variable, as follows:
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):Boolean { //your code here }; myVector.every(myFunction, someObject);
Parameters
callback:Function — The function to run on each item in the Vector.
This function is invoked
with three arguments: the current item from the Vector, the index of the item,
and the Vector object:
function callback(item:T, index:int, vector:Vector.<T>):Boolean { // your code here } The callback function should return a Boolean value. | |
thisObject:Object (default = null ) — The object that the identifer this in the
callback function refers to when the function is called.
|
Boolean — A Boolean value of true if the specified function returns
true when called on all items in the Vector; otherwise, false .
|
See also
filter | () | method |
AS3 function filter(callback:Function, thisObject:Object = null):Vector.<T>
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Executes a test function on each item in the Vector and returns
a new Vector containing all items that return true
for the
specified function. If an item returns false
,
it is not included in the result Vector. The base type of the return
Vector matches the base type of the Vector on which the method is called.
For this method, the second parameter,
thisObject
, must be null
if the
first parameter, callback
, is a method closure. That is
the most common way of using this method.
However, suppose you create a function on a frame on the main timeline using Flash Professional,
but you want it to be called in a different this
context:
function myFunction(item:T, index:int, vector:Vector.<T>):Boolean { // your code here }
Suppose you then use the filter()
method on a Vector called myVector
:
var result:Vector.<T> = myVector.filter(myFunction, someObject);
Because myFunction
is a member of the
main class of the SWF, it cannot be executed in a different this
context. Flash
Player throws an exception when this code runs. You can avoid this runtime error
by assigning the function to a variable, as follows:
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):Boolean { //your code here }; myVector.filter(myFunction, someObject);
Parameters
callback:Function — The function to run on each item in the Vector.
This function is invoked
with three arguments: the current item from the Vector, the index of the item,
and the Vector object:
function callback(item:T, index:int, vector:Vector.<T>):Boolean; | |
thisObject:Object (default = null ) — The object that the identifer this in the
callback function refers to when the function is called.
|
Vector.<T> — A new Vector that contains all items from the original Vector
for which the callback function returned true .
|
See also
forEach | () | method |
AS3 function forEach(callback:Function, thisObject:Object = null):void
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Executes a function on each item in the Vector.
For this method, the second parameter,
thisObject
, must be null
if the
first parameter, callback
, is a method closure. That is
the most common way of using this method.
However, suppose you create a function on a frame on the main timeline using Flash Professional,
but you want it to be called in a different this
context:
function myFunction(item:T, index:int, vector:Vector.<T>):void { // your code here }
Suppose you then use the forEach()
method on a Vector called myVector
:
myVector.forEach(myFunction, someObject);
Because myFunction
is a member of the
main class of the SWF, it cannot be executed in a different this
context. Flash
Player throws an exception when this code runs. You can avoid this runtime error
by assigning the function to a variable, as follows:
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):void { //your code here }; myVector.forEach(myFunction, someObject);
Parameters
callback:Function — The function to run on each item in the Vector.
This function is invoked
with three arguments: the current item from the Vector, the index of the item,
and the Vector object:
function callback(item:T, index:int, vector:Vector.<T>):void; Any return value from the function call is discarded. | |
thisObject:Object (default = null ) — The object that the identifer this in the
callback function refers to when the function is called.
|
indexOf | () | method |
AS3 function indexOf(searchElement:T, fromIndex:int = 0):int
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Searches for an item in the Vector and returns the index position of the item.
The item is compared to the Vector elements using strict equality (===
).
Parameters
searchElement:T — The item to find in the Vector.
| |
fromIndex:int (default = 0 ) — The location in the Vector from which to start searching
for the item. If this parameter is negative, it is treated as length
+ fromIndex , meaning the search starts -fromIndex items
from the end and searches from that position forward to the end of the Vector.
|
int — A zero-based index position of the item in the Vector.
If the searchElement argument is not found,
the return value is -1.
|
See also
join | () | method |
AS3 function join(sep:String = ","):String
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Converts the elements in the Vector to strings, inserts the specified separator between the
elements, concatenates them, and returns the resulting string. A nested Vector is always
separated by a comma (,), not by the separator passed to the join()
method.
Parameters
sep:String (default = ", ") — A character or string that separates Vector elements in
the returned string. If you omit this parameter, a comma is used as the default
separator.
|
String — A string consisting of the elements of the Vector
converted to strings and separated by the specified string.
|
See also
lastIndexOf | () | method |
AS3 function lastIndexOf(searchElement:T, fromIndex:int = 0x7fffffff):int
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Searches for an item in the Vector, working backward from the specified
index position, and returns the index position of the matching item. The
item is compared to the Vector elements using strict equality (===
).
Parameters
searchElement:T — The item to find in the Vector.
| |
fromIndex:int (default = 0x7fffffff ) — The location in the Vector from which to start searching
for the item. The default is the maximum allowable index value, meaning
that the search starts at the last item in the Vector.
If this parameter is negative, it is treated as
|
int — A zero-based index position of the item in the Vector.
If the searchElement argument is not found,
the return value is -1.
|
See also
map | () | method |
AS3 function map(callback:Function, thisObject:Object = null):Vector.<T>
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Executes a function on each item in the Vector, and returns a new Vector
of items corresponding to the results of calling the function on
each item in this Vector. The result Vector has the same base
type and length
as the original Vector.
The element at index i
in the result Vector is the result of
the call on the element at index i
in the original Vector.
For this method, the second parameter,
thisObject
, must be null
if the
first parameter, callback
, is a method closure. That is
the most common way of using this method.
However, suppose you create a function on a frame on the main timeline, using Flash Professional
but you want it to be called in a different this
context:
function myFunction(item:Object, index:int, vector:Vector.<T>):T { // your code here }
Suppose you then use the map()
method on a Vector called myVector
:
myVector.map(myFunction, someObject);
Because myFunction
is a member of the
main class of the SWF file, it cannot be executed in a different this
context. Flash
Player throws an exception when this code runs. You can avoid this runtime error
by assigning the function to a variable, as follows:
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):void { //your code here }; myVector.map(myFunction, someObject);
Parameters
callback:Function — The function to run on each item in the Vector.
This function is invoked
with three arguments: the current item from the Vector, the index of the item,
and the Vector object:
function callback(item:T, index:int, vector:Vector.<T>):T; | |
thisObject:Object (default = null ) — The object that the identifer this in the
callback function refers to when the function is called.
|
Vector.<T> — A new Vector that contains the results of calling the function
on each item in this Vector. The result Vector has the same base type
and length as the original.
|
See also
pop | () | method |
AS3 function pop():T
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Removes the last element from the Vector and returns that element. The
length
property of the Vector is decreased by one when
this function is called.
T — The value of the last element in the specified Vector.
|
Throws
RangeError — If this method is called while fixed is true .
|
See also
push | () | method |
AS3 function push(... args):uint
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Adds one or more elements to the end of the Vector and returns the new length of the Vector.
Because this function can accept multiple arguments, the data type of the arguments is not checked at compile time even in strict mode. However, if an argument is passed that is not an instance of the base type, an exception occurs at run time.
Parameters
... args — One or more values to append to the Vector.
|
uint — The length of the Vector after the new elements are added.
|
Throws
TypeError — If any argument is not an instance of the
base type T of the Vector.
| |
RangeError — If this method is called while fixed is true .
|
See also
reverse | () | method |
AS3 function reverse():Vector.<T>
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Reverses the order of the elements in the Vector. This method alters the Vector on which it is called.
ReturnsVector.<T> — The Vector with the elements in reverse order.
|
shift | () | method |
AS3 function shift():T
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Removes the first element from the Vector and returns that element. The remaining Vector elements are moved from their original position, i, to i - 1.
ReturnsT — The first element in the Vector.
|
Throws
RangeError — If fixed is true .
|
See also
slice | () | method |
AS3 function slice(startIndex:int = 0, endIndex:int = 16777215):Vector.<T>
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Returns a new Vector that consists of a range of elements from
the original Vector, without modifying the original Vector. The
returned Vector includes the startIndex
element and
all elements up to, but not including, the endIndex
element.
If you don't pass any parameters, a duplicate of the original Vector is created.
Parameters
startIndex:int (default = 0 ) — A number specifying the index of the starting point
for the slice. If startIndex is a negative number, the starting
point begins at the end of the Vector, where -1 is the last element.
| |
endIndex:int (default = 16777215 ) — A number specifying the index of the ending point for
the slice. If you omit this parameter, the slice includes all elements from the
starting point to the end of the Vector. If endIndex is a negative
number, the ending point is specified from the end of the Vector, where -1 is the
last element.
|
Vector.<T> — a Vector that consists of a range of elements from the original Vector.
|
some | () | method |
AS3 function some(callback:Function, thisObject:Object = null):Boolean
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Executes a test function on each item in the Vector until an
item is reached that returns true
. Use this method
to determine whether any items in a Vector meet a criterion, such as
having a value less than a particular number.
For this method, the second parameter,
thisObject
, must be null
if the
first parameter, callback
, is a method closure. That is
the most common way of using this method.
However, suppose you create a function on a frame on the main timeline,
but you want it to be called in a different this
context:
function myFunction(item:Object, index:int, vector:Vector.<T>):Boolean { // your code here }
Suppose you then use the some()
method on a Vector called myVector
:
myVector.some(myFunction, someObject);
Because myFunction
is a member of the
main class of the SWF file, it cannot be executed in a different this
context. Flash
Player throws an exception when this code runs. You can avoid this runtime error
by assigning the function to a variable, as follows:
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):Boolean { //your code here }; myVector.some(myFunction, someObject);
Parameters
callback:Function — The function to run on each item in the Vector.
This function is invoked
with three arguments: the current item from the Vector, the index of the item,
and the Vector object:
function callback(item:T, index:int, vector:Vector.<T>):Boolean The callback function should return a Boolean value. | |
thisObject:Object (default = null ) — The object that the identifer this in the
callback function refers to when the function is called.
|
Boolean — A Boolean value of true if any items in the Vector return
true for the specified function; otherwise, false .
|
See also
sort | () | method |
AS3 function sort(compareFunction:Function):Vector.<T>
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Sorts the elements in the Vector. This method sorts according to the function
provided as the compareFunction
parameter.
Parameters
compareFunction:Function — A comparison method that determines
the behavior of the sort.
The specified method must take two arguments of the base type ( function compare(x:T, y:T):Number {} The logic of the
|
Vector.<T> — This Vector, with elements in the new order.
|
splice | () | method |
AS3 function splice(startIndex:int, deleteCount:uint, ... items):Vector.<T>
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Adds elements to and removes elements from the Vector. This method modifies the Vector without making a copy.
Note: To override this method in a subclass of Vector,
use ...args
for the parameters, as this example shows:
public override function splice(...args) { // your statements here }
Parameters
startIndex:int — An integer that specifies the index of the element
in the Vector where the insertion or deletion begins. You can use a
negative integer to specify a position relative to the end of the Vector
(for example, -1 for the last element of the Vector).
| |
deleteCount:uint — An integer that specifies the number of elements
to be deleted. This number includes the element specified in the
startIndex parameter. If you do not specify a value for the
deleteCount parameter, the method deletes all of the values
from the startIndex element to the last element in the Vector.
If the value is 0, no elements are deleted.
| |
... items — An optional list of one or more comma-separated values
to insert into the Vector at the position specified in the startIndex parameter.
|
Vector.<T> — a Vector containing the elements that were removed from the original Vector.
|
Throws
RangeError — If the startIndex and deleteCount
arguments specify an index to be deleted that's outside the Vector's bounds.
| |
RangeError — If this method is called while fixed is true and the
splice() operation changes the length of the Vector.
|
toLocaleString | () | method |
public function toLocaleString():String
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Returns a string that represents the elements in the specified Vector.
Every element in the Vector, starting with index 0 and ending with the
highest index, is converted to a concatenated string and separated by
commas. In the ActionScript 3.0 implementation, this method returns
the same value as the Vector.toString()
method.
String — A string of Vector elements.
|
See also
toString | () | method |
public function toString():String
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Returns a string that represents the elements in the Vector. Every element in the
Vector, starting with index 0 and ending with the highest index, is converted to a
concatenated string and separated by commas. To specify a custom separator,
use the Vector.join()
method.
String — A string of Vector elements.
|
See also
unshift | () | method |
AS3 function unshift(... args):uint
Language Version: | ActionScript 3.0 |
Runtime Versions: | Flash Player 10, AIR 1.5 |
Adds one or more elements to the beginning of the Vector and returns the new length of the Vector. The other elements in the Vector are moved from their original position, i, to i + the number of new elements.
Because this function can accept multiple arguments, the data type of the arguments is not checked at compile time even in strict mode. However, if an argument is passed that is not an instance of the base type, an exception occurs at run time.
Parameters
... args — One or more instances of the base type of the Vector
to be inserted at the beginning of the Vector.
|
uint — An integer representing the new length of the Vector.
|
Throws
TypeError — If any argument is not an instance of the
base type T of the Vector.
| |
RangeError — If this method is called while fixed is true .
|
See also
Fri Mar 19 2010, 02:45 AM -07:00