ActionScript 3.0 Language and Components Reference | All Packages | All Classes | Language Elements | Index | Appendixes | Conventions | Frames No Frames |
Vector

Package | Top Level
Class | public dynamic class Vector
Inheritance | Vector Object

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

The Vector class lets you access and manipulate a vector -- an array whose elements all have the same data type. The data type of a Vector's elements is known as the Vector's base type. The base type can be any class, including built in classes and custom classes. The base type is specified when declaring a Vector variable as well as when creating an instance by calling the class constructor.

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 (`.`), less than sign (`<`), class name, then a greater than sign (`>`), 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 or `unshift()` 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

[] array access
Vector() global function
Array class

Public Properties
Hide Inherited Public Properties
Show Inherited Public Properties

| Property | Defined By
--- | --- | ---
|  | constructor : Object A reference to the class object or constructor function for a given object instance. | Object
|  | fixed : Boolean Indicates if 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

Public Methods
Hide Inherited Public Methods
Show Inherited Public Methods

| Method | Defined By
--- | --- | ---
|  | Vector(length:uint = 0, fixed:Boolean = false) Creates a Vector with the specified base type. | Vector
|  | concat(... args):Vector Review Needed. Concatenates the elements specified in the parameters with the elements in the Vector and creates a new Vector. | Vector
|  | every(callback:Function, thisObject:Object = null):Boolean Executes a test function on each item in the Vector until an item is reached that returns false for the specified function. | Vector
|  | filter(callback:Function, thisObject:Object = null):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
|  | forEach(callback:Function, thisObject:Object = null):void Executes a function on each item in the Vector. | Vector
|  | hasOwnProperty(name:String):Boolean Indicates whether an object has a specified property defined. | Object
|  | indexOf(searchElement:T, fromIndex:int = 0):int Searches for an item in the Vector and returns the index position of the item. | Vector
|  | isPrototypeOf(theClass:Object):Boolean Indicates whether an instance of the Object class is in the prototype chain of the object specified as the parameter. | Object
|  | join(sep:String = ","):String Review Needed. Converts the elements in the Vector to strings, inserts the specified separator between the elements, concatenates them, and returns the resulting string. | Vector
|  | lastIndexOf(searchElement:T, fromIndex:int = 0x7fffffff):int Searches for an item in the Vector, working backward from the specified index position, and returns the index position of the matching item. | Vector
|  | map(callback:Function, thisObject:Object = null):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
|  | propertyIsEnumerable(name:String):Boolean Indicates whether the specified property exists and is enumerable. | Object
|  | push(... args):uint Adds one or more elements to the end of the Vector and returns the new length of the Vector. | Vector
|  | reverse():Vector Reverses the order of the elements in the Vector. | Vector
|  | setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void 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
|  | slice(startIndex:int = 0, endIndex:int = 16777215):Vector Review Needed. Returns a new Vector that consists of a range of elements from the original Vector, without modifying the original Vector. | Vector
|  | some(callback:Function, thisObject:Object = null):Boolean Executes a test function on each item in the Vector until an item is reached that returns true. | Vector
|  | sort(compareFunction:Function):Vector Sorts the elements in the Vector. | Vector
|  | splice(startIndex:int, deleteCount:uint, ... items):Vector Review Needed. Adds elements to and removes elements from the Vector. | Vector
|  | toLocaleString():String Returns a string that represents the elements in the specified Vector. | Vector
|  | toString():String Returns a string that represents the elements in the Vector. | Vector
|  | unshift(... args):uint Adds one or more elements to the beginning of the Vector and returns the new length of the Vector. | Vector
|  | valueOf():Object Returns the primitive value of the specified object. | Object

Property Detail

fixed | property

`fixed:Boolean` [read-write]

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

Indicates if 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 the `splice()` call changes the `length` of the Vector).

Implementation
`public function get fixed():Boolean`
`public function set fixed(value:Boolean):void`

length | property |

`length:uint` [read-write]

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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).

Constructor Detail

Vector | () | Constructor

`public function Vector(length:uint = 0, fixed:Boolean = false)`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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 (`.`), less than sign (`<`), class name, then a greater than sign (`>`), 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.

Parameters

| `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

Vector() global function
Method Detail

concat | () | method

`AS3 function concat(... args):Vector`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

## Review Needed

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.

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.

Returns

| `Vector` — 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

Player Version : | Flash Player 10

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, 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 `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 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.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>):void;
| `thisObject:Object` (default = `null`)`` — The object that the identifer `this` in the callback function refers to when the function is called.

Returns

| `Boolean` — A Boolean value of `true` if the specified function returns `true` when called on all items in the Vector; otherwise, `false`.

See also

Vector.some()

filter | () | method |

`AS3 function filter(callback:Function, thisObject:Object = null):Vector`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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, 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.

Returns

| `Vector` — A new Vector that contains all items from the original Vector for which the `callback` function returned `true`.

See also

Vector.map()

forEach | () | method |

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

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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, 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

Player Version : | Flash Player 10

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.

Returns

| `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

Vector.lastIndexOf()
=== (strict equality)

join | () | method |

`AS3 function join(sep:String = ","):String`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

## Review Needed

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.

Returns

| `String` — A string consisting of the elements of the Vector converted to strings and separated by the specified string.

See also

String.split()

lastIndexOf | () | method |

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

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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 `length + fromIndex`, meaning the search starts `-fromIndex` items from the end and searches from that position backward to index 0.

Returns

| `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

Vector.indexOf()
=== (strict equality)

map | () | method |

`AS3 function map(callback:Function, thisObject:Object = null):Vector`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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, 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, 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.

Returns

| `Vector` — 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

Vector.filter()

pop | () | method |

`AS3 function pop():T`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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.

Returns

| `T` — The value of the last element in the specified Vector.

Throws

| `RangeError` — If this method is called while `fixed` is `true`.

See also

Vector.push()
Vector.shift()
Vector.unshift()

push | () | method |

`AS3 function push(... args):uint`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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.

Returns

| `uint` — The length of the Vector after the new elements are added.

Throws

| `TypeError` — If any of the arguments are not instances of the base type `T` of the Vector.
| `RangeError` — If this method is called while `fixed` is `true`.

See also

Vector.pop()
Vector.shift()
Vector.unshift()

reverse | () | method |

`AS3 function reverse():Vector`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

Reverses the order of the elements in the Vector. This method alters the Vector on which it is called.

Returns

| `Vector` — The Vector with the elements in reverse order.

shift | () | method |

`AS3 function shift():T`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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.

Returns

| `T` — The first element in the Vector.

Throws

| `RangeError` — If `fixed` is `true`.

See also

Vector.pop()
Vector.push()
Vector.unshift()

slice | () | method |

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

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

## Review Needed

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.

Returns

| `Vector` — 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

Player Version : | Flash Player 10

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, 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;
| `thisObject:Object` (default = `null`)`` — The object that the identifer `this` in the callback function refers to when the function is called.

Returns

| `Boolean` — A Boolean value of `true` if any items in the Vector return `true` for the specified function; otherwise `false`.

See also

every()

sort | () | method |

`AS3 function sort(compareFunction:Function):Vector`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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 (`T`) of the Vector and return a Number:
    function compare(x:T, y:T):Number {}
The logic of the `compareFunction` function is that, given two elements `x` and `y`, the function returns one of the following three values: a negative number, if `x` should appear before `y` in the sorted sequence 0, if `x` equals `y` a positive number, if `x` should appear after `y` in the sorted sequence

Returns

| `Vector` — This Vector, with elements in the new order.

splice | () | method |

`AS3 function splice(startIndex:int, deleteCount:uint, ... items):Vector`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

## Review Needed

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, or a Vector, to insert into the Vector at the position specified in the `startIndex` parameter.

Returns

| `Vector` — 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

Player Version : | Flash Player 10

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.

Returns

| `String` — A string of Vector elements.

See also

Vector.toString()

toString | () | method |

`public function toString():String`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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.

Returns

| `String` — A string of Vector elements.

See also

String.split()
Vector.join()

unshift | () | method |

`AS3 function unshift(... args):uint`

Language Version : | ActionScript 3.0

Player Version : | Flash Player 10

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.

Returns

| `uint` — An integer representing the new length of the Vector.

Throws

| `TypeError` — If any of the arguments are not instances of the base type `T` of the Vector.
| `RangeError` — If this method is called while `fixed` is `true`.

See also

Vector.pop()
Vector.push()
Vector.shift()

Submit Feedback on LiveDocs
© 2004-2008 Adobe Systems Incorporated. All rights reserved.
Tue May 20 2008, 04:02 AM -07:00