Indicates whether the length property of the Vector can be changed. If the value is true, 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).

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.

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

When calling the Vector() constructor, use brackets to specify the base type as a string using type parameter syntax. Type parameter syntax is a a string consisting of a left angle bracket (<), class name, then a right angle bracket (>), as shown in this example:

     var v = new air.Vector["<String>"]();
     

To create a Vector instance from an Array or another Vector (such as one with a different base type), use the Vector() global function.

To create a pre-populated Vector instance, use the following syntax instead of using the parameters specified below:

     // var v:Vector.<T> = new <T>[E0, ..., En-1 ,];
     // For example: 
     var v:Vector.<int> = new <int>[0,1,2,];
     

The following information applies to this syntax:

• It is supported in Flash Professional CS5 and later, Flash Builder 4 and later, and Flex 4 and later.
• The trailing comma is optional.
• Empty items in the array are not supported; a statement such as var v:Vector.<int> = new <int>[0,,2,] throws a compiler error.
• You can't specify a default length for the Vector instance. Instead, the length is the same as the number of elements in the initialization list.
• You can't specify whether the Vector instance has a fixed length. Instead, use the fixed property.
• Data loss or errors can occur if items passed as values don't match the specified type. For example:

     var v:Vector.<int> = new <int>[4.2]; // compiler error when running in strict mode
     trace(v[0]); //returns 4 when not running in strict mode
     

See also

Concatenates the Vectors specified in the parameters list with the elements in this Vector and creates a new Vector. The Vectors in the parameters list must have the same base type, or subtype, as this Vector. If you do not pass any parameters, the returned Vector is a duplicate (shallow clone) of the original Vector.

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 file, it cannot be executed in a different this context. Flash runtimes throw 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);
    

function callback(item:T, index:int, vector:Vector.<T>):Boolean {
       // your code here
    }
    

See also

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 file, it cannot be executed in a different this context. Flash runtimes throw 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);
     

function callback(item:T, index:int, vector:Vector.<T>):Boolean;

See also

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 file, it cannot be executed in a different this context. Flash runtimes throw 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);
     

function callback(item:T, index:int, vector:Vector.<T>):void;

Checks whether the vector includes the item that is passed in. Each element is checked in turn to see if it matches the item that is passed in, using the standard comparison operator (i.e. similar to if (vector[i] == item)).

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

See also

Insert a single element into the Vector. This method modifies the Vector without making a copy.

Checks whether the vector is empty. An alternative to calling a comparison vector.length == 0.

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.

See also

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

See also

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 runtimes throw 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);
     

function callback(item:T, index:int, vector:Vector.<T>):T;

See also

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.

See also

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.

See also

Remove a single element from the Vector. This method modifies the Vector without making a copy.

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

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.

See also

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, the new Vector is a duplicate (shallow clone) of the original Vector. If you pass a value of 0 for both parameters, a new, empty Vector is created of the same type as the original Vector.

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 runtimes throw 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);
     

function callback(item:T, index:int, vector:Vector.<T>):Boolean

See also

Sorts the elements in the Vector object, and also returns a sorted Vector object. This method sorts according to the parameter sortBehavior, which is either a function that compares two values, or a set of sorting options.

The method takes one parameter. The parameter is one of the following:

• a function that takes two arguments of the base type (T) of the Vector and returns a Number:

  function compare(x:T, y:T):Number {}

  The logic of the 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

• a number which is a bitwise OR of the following values:
  • 1 or Array.CASEINSENSITIVE
  • 2 or Array.DESCENDING
  • 4 or Array.UNIQUESORT
  • 8 or Array.RETURNINDEXEDARRAY
  • 16 or Array.NUMERIC

  If the value is 0, the sort works in the following way:

  • Sorting is case-sensitive (Z precedes a).
  • Sorting is ascending (a precedes b).
  • The array is modified to reflect the sort order; multiple elements that have identical sort fields are placed consecutively in the sorted array in no particular order.
  • All elements, regardless of data type, are sorted as if they were strings, so 100 precedes 99, because "1" is a lower string value than "9".

See also

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
     }
     

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.

See also

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.

See also

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.

See also