Sorting an array

The reverse() method

The reverse() method takes no parameters and does not return a value, but allows you to toggle the order of your array from its current state to the reverse order. The following example reverses the order of the oceans listed in the oceans array:

var oceans:Array = ["Arctic", "Atlantic", "Indian", "Pacific"]; 
oceans.reverse(); 
trace(oceans); // output: Pacific,Indian,Atlantic,Arctic

Basic sorting with the sort() method (Array class only)

For an Array instance, the sort() method rearranges the elements in an array using the default sort order . The default sort order has the following characteristics:

• The sort is case-sensitive, which means that uppercase characters precede lowercase characters. For example, the letter D precedes the letter b.

• The sort is ascending, which means that lower character codes (such as A) precede higher character codes (such as B).

• The sort places identical values adjacent to each other but in no particular order.

• The sort is string-based, which means that elements are converted to strings before they are compared (for example, 10 precedes 3 because the string "1" has a lower character code than the string "3" has).

You may find that you need to sort your Array without regard to case, or in descending order, or perhaps your array contains numbers that you want to sort numerically instead of alphabetically. The Array class’s sort() method has an options parameter that allows you to alter each characteristic of the default sort order. The options are defined by a set of static constants in the Array class, as shown in the following list:

• Array.CASEINSENSITIVE : This option makes the sort disregard case. For example, the lowercase letter b precedes the uppercase letter D.

• Array.DESCENDING: This reverses the default ascending sort. For example, the letter B precedes the letter A.

• Array.UNIQUESORT: This causes the sort to abort if two identical values are found.

• Array.NUMERIC: This causes numerical sorting, so that 3 precedes 10.

The following example highlights some of these options. An Array named poets is created that is sorted using several different options.

var poets:Array = ["Blake", "cummings", "Angelou", "Dante"]; 
poets.sort(); // default sort 
trace(poets); // output: Angelou,Blake,Dante,cummings 
 
poets.sort(Array.CASEINSENSITIVE); 
trace(poets); // output: Angelou,Blake,cummings,Dante 
 
poets.sort(Array.DESCENDING); 
trace(poets); // output: cummings,Dante,Blake,Angelou 
 
poets.sort(Array.DESCENDING | Array.CASEINSENSITIVE); // use two options 
trace(poets); // output: Dante,cummings,Blake,Angelou

Custom sorting with the sort() method (Array and Vector classes)

In addition to the basic sorting that’s available for an Array object, you can also define a custom sorting rule. This technique is the only form of the sort() method that is available for the Vector class. To define a custom sort, you write a custom sort function and pass it as an argument to the sort() method.

For example, if you have a list of names in which each list element contains a person’s full name, but you want to sort the list by last name, you must use a custom sort function to parse each element and use the last name in the sort function. The following code shows how this can be done with a custom function that is used as a parameter to the Array.sort() method:

var names:Array = new Array("John Q. Smith", "Jane Doe", "Mike Jones"); 
function orderLastName(a, b):int 
{ 
    var lastName:RegExp = /\b\S+$/; 
    var name1 = a.match(lastName); 
    var name2 = b.match(lastName); 
    if (name1 < name2) 
    { 
        return -1; 
    } 
    else if (name1 > name2) 
    { 
        return 1; 
    } 
    else 
    { 
        return 0; 
    } 
} 
trace(names); // output: John Q. Smith,Jane Doe,Mike Jones 
names.sort(orderLastName); 
trace(names); // output: Jane Doe,Mike Jones,John Q. Smith

The custom sort function orderLastName() uses a regular expression to extract the last name from each element to use for the comparison operation. The function identifier orderLastName is used as the sole parameter when calling the sort() method on the names array. The sort function accepts two parameters, a and b , because it works on two array elements at a time. The sort function’s return value indicates how the elements should be sorted:

• A return value of -1 indicates that the first parameter, a , precedes the second parameter, b .

• A return value of 1 indicates that the second parameter, b , precedes the first, a .

• A return value of 0 indicates that the elements have equal sorting precedence.

The sortOn() method (Array class only)

The sortOn() method is designed for Array objects with elements that contain objects. These objects are expected to have at least one common property that can be used as the sort key. The use of the sortOn() method for arrays of any other type yields unexpected results.

The following example revises the poets Array so that each element is an object instead of a string. Each object holds both the poet’s last name and year of birth.

var poets:Array = new Array(); 
poets.push({name:"Angelou", born:"1928"}); 
poets.push({name:"Blake", born:"1757"}); 
poets.push({name:"cummings", born:"1894"}); 
poets.push({name:"Dante", born:"1265"}); 
poets.push({name:"Wang", born:"701"});

You can use the sortOn() method to sort the Array by the born property. The sortOn() method defines two parameters, fieldName and options . The fieldName argument must be specified as a string. In the following example, sortOn() is called with two arguments, " born" and Array.NUMERIC . The Array.NUMERIC argument is used to ensure that the sort is done numerically instead of alphabetically. This is a good practice even when all the numbers have the same number of digits because it ensures that the sort will continue to behave as expected if a number with fewer or more digits is later added to the array.

poets.sortOn("born", Array.NUMERIC); 
for (var i:int = 0; i < poets.length; ++i) 
{ 
    trace(poets[i].name, poets[i].born); 
} 
/* output: 
Wang 701 
Dante 1265 
Blake 1757 
cummings 1894 
Angelou 1928 
*/

Sorting without modifying the original array (Array class only)

Generally, the sort() and sortOn() methods modify an Array. If you wish to sort an Array without modifying the existing array, pass the Array.RETURNINDEXEDARRAY constant as part of the options parameter. This option directs the methods to return a new Array that reflects the sort and to leave the original Array unmodified. The Array returned by the methods is a simple Array of index numbers that reflects the new sort order and does not contain any elements from the original Array. For example, to sort the poets Array by birth year without modifying the Array, include the Array.RETURNINDEXEDARRAY constant as part of the argument passed for the options parameter.

The following example stores the returned index information in an Array named indices and uses the indices array in conjunction with the unmodified poets array to output the poets in order of birth year:

var indices:Array; 
indices = poets.sortOn("born", Array.NUMERIC | Array.RETURNINDEXEDARRAY); 
for (var i:int = 0; i < indices.length; ++i) 
{ 
    var index:int = indices[i]; 
    trace(poets[index].name, poets[index].born); 
} 
/* output: 
Wang 701 
Dante 1265 
Blake 1757 
cummings 1894 
Angelou 1928 
*/