A non-negative integer specifying the number of elements in the array. This property is automatically updated when new elements are added to the array. When you assign a value to an array element (for example, my_array[index] = value), if index is a number, and index+1 is greater than the length property, the length property is updated to index+1.

Note: If you assign a value to the length property that is shorter than the existing length, the array will be truncated.

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

Lets you create an array of the specified number of elements. If you don't specify any parameters, an array containing 0 elements is created. If you specify a number of elements, an array is created with numElements number of elements.

Note: This class shows two constructor method entries because the constructor accepts variable types of arguments. The constructor behaves differently depending on the type and number of arguments passed, as detailed in each entry. ActionScript 3.0 does not support method or constructor overloading.

See also

package {
    import flash.display.Sprite;

	public class Array_Array extends Sprite {

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

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

Lets you create an array that contains the specified elements. You can specify values of any type. The first element in an array always has an index (or position) of 0.

Note: This class shows two constructor entries because the constructor accepts variable types of arguments. The constructor behaves differently depending on the type and number of arguments passed, as detailed in each entry. ActionScript 3.0 does not support method or constructor overloading.

See also

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

Concatenates the elements specified in the parameters with the elements in an array and creates a new array. If the parameters specify an array, the elements of that array are concatenated. If you don't pass any parameters, the new array is a duplicate (shallow clone) of the original array.

• The numbers array, which contains the numbers 1, 2, and 3.
• The letters array, which contains the letters a, b, and c.
• The numbersAndLetters array, which calls the concat() method to produce the array [1,2,3,a,b,c].
• The lettersAndNumbers array, which calls the concat() method to produce the array [a,b,c,1,2,3].

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

Executes a test function on each item in the array until an item is reached that returns false for the specified function. You use this method to determine whether all items in an array 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. Suppose you create a function in a movie clip called me:

     function myFunction(obj:Object):void {

        //your code here

     }

     

Suppose you then use the every() method on an array called myArray:

     myArray.every(myFunction, me);

     

Because myFunction is a member of the Timeline class, which cannot be overridden by me, the Flash runtime will throw an exception. You can avoid this runtime error by assigning the function to a variable, as follows:

     var myFunction:Function = function(obj:Object):void {

         //your code here

     };

     myArray.every(myFunction, me);

     

function callback(item:*, index:int, array:Array):Boolean;

See also

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

Executes a test function on each item in the array and constructs a new array for all items that return true for the specified function. If an item returns false, it is not included in the new array.

For this method, the second parameter, thisObject, must be null if the first parameter, callback, is a method closure. Suppose you create a function in a movie clip called me:

     function myFunction(obj:Object):void {

        //your code here

     }

     

Suppose you then use the filter() method on an array called myArray:

 

     myArray.filter(myFunction, me);

     

Because myFunction is a member of the Timeline class, which cannot be overridden by me, the Flash runtime will throw an exception. You can avoid this runtime error by assigning the function to a variable, as follows:

     var myFunction:Function = function(obj:Object):void {

         //your code here

         };

     myArray.filter(myFunction, me);

     

    function callback(item:*, index:int, array:Array):Boolean;

See also

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

Executes a function on each item in the array.

For this method, the second parameter, thisObject, must be null if the first parameter, callback, is a method closure. Suppose you create a function in a movie clip called me:

     function myFunction(obj:Object):void {

        //your code here

     }

     

Suppose you then use the forEach() method on an array called myArray:

     myArray.forEach(myFunction, me);

     

Because myFunction is a member of the Timeline class, which cannot be overridden by me, the Flash runtime will throw an exception. You can avoid this runtime error by assigning the function to a variable, as follows:

     var myFunction:Function = function(obj:Object):void {

         //your code here

         };

     myArray.forEach(myFunction, me);

     

    function callback(item:*, index:int, array:Array):void;

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

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

Checks whether the array 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 (array[i] == item)).

Searches for an item in an array by using strict equality (===) and returns the index position of the item.

See also

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

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

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

Converts the elements in an array to strings, inserts the specified separator between the elements, concatenates them, and returns the resulting string. A nested array is always separated by a comma (,), not by the separator passed to the join() method.

See also

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

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

Searches for an item in an array, working backward from the last item, and returns the index position of the matching item using strict equality (===).

See also

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

Executes a function on each item in an array, and constructs a new array of items corresponding to the results of the function on each item in the original array.

For this method, the second parameter, thisObject, must be null if the first parameter, callback, is a method closure. Suppose you create a function in a movie clip called me:

     function myFunction(obj:Object):void {

        //your code here

     }

     

Suppose you then use the map() method on an array called myArray:

     myArray.map(myFunction, me);

     

Because myFunction is a member of the Timeline class, which cannot be overridden by me, the Flash runtime will throw an exception. You can avoid this runtime error by assigning the function to a variable, as follows:

     var myFunction:Function = function(obj:Object):void {

         //your code here

         };

     myArray.map(myFunction, me);

     

    function callback(item:*, index:int, array:Array):String;

See also

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

Removes the last element from an array and returns the value of that element.

See also

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

Adds one or more elements to the end of an array and returns the new length of the array.

See also

var letters:Array = new Array();

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

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

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

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

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

Reverses the array in place.

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

Removes the first element from an array and returns that element. The remaining array elements are moved from their original position, i, to i-1.

See also

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

Returns a new array that consists of a range of elements from the original array, without modifying the original array. The returned array includes the startIndex element and all elements up to, but not including, the endIndex element.

If you don't pass any parameters, the new array is a duplicate (shallow clone) of the original array.

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

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

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

Executes a test function on each item in the array until an item is reached that returns true. Use this method to determine whether any items in an array 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. Suppose you create a function in a movie clip called me:

     function myFunction(obj:Object):void {

        //your code here

     }

     

Suppose you then use the some() method on an array called myArray:

     myArray.some(myFunction, me);

     

Because myFunction is a member of the Timeline class, which cannot be overridden by me, the Flash runtime will throw an exception. You can avoid this runtime error by assigning the function to a variable, as follows:

     var myFunction:Function = function(obj:Object):void {

         //your code here

         };

     myArray.some(myFunction, me);

     

    function callback(item:*, index:int, array:Array):Boolean;

See also

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

Sorts the elements in an array. This method sorts according to Unicode values. (ASCII is a subset of Unicode.)

By default, Array.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".

To sort an array by using settings that deviate from the default settings, you can either use one of the sorting options described in the sortOptions portion of the ...args parameter description, or you can create your own custom function to do the sorting. If you create a custom function, you call the sort() method, and use the name of your custom function as the first argument (compareFunction)

See also

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

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

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;
	}
}

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;
	}
}

Note: The default behavior of the sort() function is to handle each entity as a string. If you use the Array.NUMERIC argument, the Flash runtime attempts to convert any non-numeric values to integers for sorting purposes. If it fails, the runtime throws an error. For example, the runtime can successfully convert a String value of "6" to an integer, but will throw an error if it encounters a String value of "six".

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

Sorts the elements in an array according to one or more fields in the array. The array should have the following characteristics:

• The array is an indexed array, not an associative array.
• Each element of the array holds an object with one or more properties.
• All of the objects have at least one property in common, the values of which can be used to sort the array. Such a property is called a field.

If you pass multiple fieldName parameters, the first field represents the primary sort field, the second represents the next sort field, and so on. Flash sorts according to Unicode values. (ASCII is a subset of Unicode.) If either of the elements being compared does not contain the field that is specified in the fieldName parameter, the field is assumed to be set to undefined, and the elements are placed consecutively in the sorted array in no particular order.

By default, Array.sortOn() 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.
• Numeric fields are sorted as if they were strings, so 100 precedes 99, because "1" is a lower string value than "9".

Flash Player 7 added the options parameter, which you can use to override the default sort behavior. To sort a simple array (for example, an array with only one field), or to specify a sort order that the options parameter doesn't support, use Array.sort().

To pass multiple flags, separate them with the bitwise OR (|) operator:

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

     

Flash Player 8 added the ability to specify a different sorting option for each field when you sort by more than one field. In Flash Player 8 and later, the options parameter accepts an array of sort options such that each sort option corresponds to a sort field in the fieldName parameter. The following example sorts the primary sort field, a, using a descending sort; the secondary sort field, b, using a numeric sort; and the tertiary sort field, c, using a case-insensitive sort:

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

     

Note: The fieldName and options arrays must have the same number of elements; otherwise, the options array is ignored. Also, the Array.UNIQUESORT and Array.RETURNINDEXEDARRAY options can be used only as the first element in the array; otherwise, they are ignored.

See also

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;
	}
}

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

The array is then sorted in the following ways:

1. By name only, producing the array [Bob:3,abcd:3,barb:35,catchy:4]
2. By name and using the CASEINSENSITIVE constant, producing the array [abcd:3,barb:35,Bob:3,catchy:4]
3. By name and using the CASEINSENSITIVE and DESCENDING constants, producing the array [catchy:4,Bob:3,barb:35,abcd:3]
4. By age only, producing the array [abcd:3,Bob:3,barb:35,catchy:4]
5. By age and using the NUMERIC constant, producing the array [Bob:3,abcd:3,catchy:4,barb:35]
6. By age and using the DESCENDING and NUMERIC constants, producing the array [barb:35,catchy:4,Bob:3,abcd:3]

An array called indices is then created and assigned the results of a sort by age and using the NUMERIC and RETURNINDEXEDARRAY constants, resulting in the array [Bob:3,abcd:3,catchy:4,barb:35], which is then printed out using a for loop.

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

Adds elements to and removes elements from an array. This method modifies the array without making a copy.

Note: To override this method in a subclass of Array, use ...args for the parameters, as this example shows:

     public override function splice(...args) {

       // your statements here

     }

     

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

 
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

Returns a string that represents the elements in the specified array. Every element in the array, 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 Array.toString() method.

See also

Returns a string that represents the elements in the specified array. Every element in the array, 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 Array.join() method.

See also

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

Adds one or more elements to the beginning of an array and returns the new length of the array. The other elements in the array are moved from their original position, i, to i+1.

See also

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

Specifies case-insensitive sorting for the Array class sorting methods. You can use this constant for the options parameter in the sort() or sortOn() method.

The value of this constant is 1.

See also

Specifies descending sorting for the Array class sorting methods. You can use this constant for the options parameter in the sort() or sortOn() method.

The value of this constant is 2.

See also

Specifies numeric (instead of character-string) sorting for the Array class sorting methods. Including this constant in the options parameter causes the sort() and sortOn() methods to sort numbers as numeric values, not as strings of numeric characters. Without the NUMERIC constant, sorting treats each array element as a character string and produces the results in Unicode order.

For example, given the array of values [2005, 7, 35], if the NUMERIC constant is not included in the options parameter, the sorted array is [2005, 35, 7], but if the NUMERIC constant is included, the sorted array is [7, 35, 2005].

This constant applies only to numbers in the array; it does not apply to strings that contain numeric data such as ["23", "5"].

The value of this constant is 16.

See also

Specifies that a sort returns an array that consists of array indices. You can use this constant for the options parameter in the sort() or sortOn() method, so you have access to multiple views of the array elements while the original array is unmodified.

The value of this constant is 8.

See also

Specifies the unique sorting requirement for the Array class sorting methods. You can use this constant for the options parameter in the sort() or sortOn() method. The unique sorting option terminates the sort if any two elements or fields being sorted have identical values.

The value of this constant is 4.

See also