Indexerade arrayer

Du kan använda flera olika metoder när du skapar en Array-instans eller Vector-instans. Metoderna för de olika arraytyperna skiljer sig emellertid åt något.

Det vanligaste sättet att lägga till ett element i en indexerad array är att använda operatorn för arrayåtkomst ( [] ). Om du vill ställa in värdet för ett indexerat arrayelement ska du använda Array- eller Vector-objektnamnet och indexnumret på vänster sida i en tilldelningssats:

songTitles[5] = "Happy Birthday";

Om en Array eller Vector inte redan har ett element vid detta index, skapas indexet och värdet lagras där. Om det finns ett värde vid detta index, ersätter det nya värdet det befintliga.

Med ett Array-objekt kan du skapa ett element vid valfritt index. Med ett Vector-objekt kan du emellertid bara tilldela ett värde till ett befintligt index eller till nästa tillgängliga index. Nästa tillgängliga index motsvarar Vector-objektets length -egenskap. Det säkraste sättet att lägga till ett nytt element i ett Vector-objekt är att använda kod som den nedan:

myVector[myVector.length] = valueToAdd;

Tre av metoderna i klasserna Array och Vector – push() , unshift() och splice() – används för att infoga element i en indexerad array. Metoden push() lägger till ett eller flera element i slutet av en array. Detta innebär att det element som senast infogades i arrayen med metoden push() får det högsta indexvärdet. Med metoden unshift() infogas ett eller flera element i början av en array, vilket alltid är vid indexvärdet 0. Metoden splice() används för att infoga valfritt antal objekt vid ett angivet index i arrayen.

I följande exempel visas alla tre metoderna. En array med namnet planets skapas för att lagra namnen på planeterna i den ordning de ligger från solen. Till att börja med anropas metoden push() för att lägga till det första objektet, Mars . Därefter anropas metoden unshift() för att lägga till ett objekt, Mercury , som ska ligga först i arrayen. Slutligen anropas metoden splice() för att infoga objekten Venus och Earth efter Mercury , men före Mars . Det första argumentet som skickas till splice() , heltalet 1, anger att infogningen ska börja vid index 1. Det andra argumentet som skickas till splice() , heltalet 0, anger att inga objekt ska raderas. Det tredje och fjärde argumentet som skickas till splice() , Venus och Earth , är de objekt som ska infogas.

var planets:Array = new Array(); 
planets.push("Mars"); // array contents: Mars 
planets.unshift("Mercury"); // array contents: Mercury,Mars 
planets.splice(1, 0, "Venus", "Earth"); 
trace(planets); // array contents: Mercury,Venus,Earth,Mars

Metoderna push() och unshift() returnerar båda ett heltal utan tecken, som representerar längden på den ändrade arrayen. Metoden splice() returnerar en tom array när den används för att infoga element, vilket kan tyckas underligt, men blir mer begripligt i ljuset av den flexibilitet som metoden splice() uppvisar. Du kan använda metoden splice() både för att infoga element i en array och för att ta bort element från en array. När du använder metoden splice() för att ta bort element returneras en array som innehåller de borttagna elementen.

Det enklaste sättet att hämta värdet på ett element från en indexerad array är att använda operatorn för arrayåtkomst ( [] ). Om du vill hämta värdet för ett indexerat arrayelement ska du använda Array- eller Vector-objektnamnet och indexnumret på höger sida i en tilldelningssats:

var myFavoriteSong:String = songTitles[3];

Det går att försöka hämta ett värde från en Array eller Vector genom att använda ett index där det inte finns några element. I så fall returnerar ett Array-objekt värdet odefinierat och en Vector returnerar ett RangeError-undantag.

Tre metoder i klasserna Array och Vector – pop() , shift() och splice() – används för att ta bort element. Metoden pop() används för att ta bort ett element från slutet av arrayen. Den tar med andra ord bort elementet med det högsta indexvärdet. Metoden shift() används för att ta bort ett element från början av arrayen, vilket innebär att den alltid tar bort elementet vid indexvärdet 0. Metoden splice() , som också kan användas för att infoga element, tar bort ett godtyckligt antal element med början från det indexvärde som anges i det första argumentet som skickas till metoden.

I följande exempel används alla tre metoder för att ta bort element från en Array-instans. En array med namnet oceans skapas för att lagra namnen på de stora världshaven. Vissa av namnen i arrayen är sjöar och inte världshav, så dessa måste tas bort.

Först används metoden splice() för att ta bort objekten Aral och Superior och för att infoga Atlantic och Indian . Det första argumentet som skickas till splice() , heltalet 2, anger att åtgärden ska starta med det tredje objektet i listan, alltså vid index 2. Det andra argumentet, 2, anger att två objekt ska tas bort. De återstående argumenten, Atlantic och Indian , är värden som ska infogas vid index 2.

Därefter används metoden pop() för att ta bort det sista elementet i arrayen, Huron . Slutligen används metoden shift() för att ta bort det första elementet i arrayen, Victoria .

var oceans:Array = ["Victoria", "Pacific", "Aral", "Superior", "Indian", "Huron"]; 
oceans.splice(2, 2, "Arctic", "Atlantic"); // replaces Aral and Superior 
oceans.pop(); // removes Huron 
oceans.shift(); // removes Victoria 
trace(oceans);// output: Pacific,Arctic,Atlantic,Indian

Metoderna pop() och shift() returnerar båda det objekt som togs bort. Datatypen för Array-instansens returnerade värde är Object eftersom arrayer kan innehålla värden av alla datatyper. För en Vector-instans är datatypen för det returnerade värdet bastypen för Vectorn. Metoden splice() returnerar en array eller vektor som innehåller de borttagna värdena. Du kan ändra arrayexemplet oceans så att anropet till splice() tilldelar den returnerade arrayen till en ny arrayvariabel, enligt följande:

var lakes:Array = oceans.splice(2, 2, "Arctic", "Atlantic"); 
trace(lakes); // output: Aral,Superior

Du kan träffa på kod där operatorn delete används på ett element i ett Array-objekt. Operatorn delete anger värdet för ett arrayelement som undefined , men elementet tas inte bort från arrayen. I följande exempel används operatorn delete på det tredje elementet i arrayen oceans , men längden på arrayen är fortfarande 5:

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Indian", "Atlantic"]; 
delete oceans[2]; 
trace(oceans);// output: Arctic,Pacific,,Indian,Atlantic 
trace(oceans[2]); // output: undefined 
trace(oceans.length); // output: 5

Du kan korta av en array eller vektor med hjälp av en arrays length -egenskap. Om du ställer in egenskapen length för en indexerad array på en längd som är mindre än den aktuella längden på arrayen, kortas arrayen av och de element som lagras vid indexnummer högre än det nya värdet på length minus 1 tas bort. Om till exempel arrayen oceans sorteras så att alla giltiga poster finns i början av arrayen, kan du använda egenskapen length för att ta bort posterna i slutet av arrayen, vilket visas i följande kod:

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Aral", "Superior"]; 
oceans.length = 2; 
trace(oceans); // output: Arctic,Pacific

Det finns tre metoder – reverse() , sort() och sortOn() – som används för att ändra ordningen i en indexerad array genom att sortera den på olika sätt. Alla dessa metoder används för att förändra en befintlig array. I tabellen nedan sammanfattas dessa metoder och deras beteende för Array- och Vector-objekt:

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

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

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

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

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 
*/

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 
*/

Fyra metoder i klasserna Array och Vector – concat() , join() , slice() och toString() – används för att ställa frågor mot arrayen och inte för att förändra den. Metoderna concat() och slice() returnerar båda nya arrayer, medan metoderna join() och toString() båda returnerar strängar. I metoden concat() tas en ny array eller lista med element som argument och kombinerar den med en befintlig array för att skapa en ny array. Metoden slice() har två parametrar med de passande namnen startIndex och endIndex . Den returnerar en ny array som innehåller en kopia av de element som delades upp från den befintliga arrayen. Uppdelningen börjar med elementet vid startIndex och slutar med elementet precis före endIndex . Detta kanske behöver upprepas: elementet vid endIndex ingår INTE i returvärdet.

I följande exempel används concat() och slice() för att skapa nya arrayer med hjälp av element från andra arrayer:

var array1:Array = ["alpha", "beta"]; 
var array2:Array = array1.concat("gamma", "delta"); 
trace(array2); // output: alpha,beta,gamma,delta 
 
var array3:Array = array1.concat(array2); 
trace(array3); // output: alpha,beta,alpha,beta,gamma,delta 
 
var array4:Array = array3.slice(2,5); 
trace(array4); // output: alpha,beta,gamma

Du kan använda metoderna join() och toString() för att ställa frågor mot arrayen och returnera dess innehåll som en sträng. De båda metoderna är identiska om inga parametrar används för metoden join() , eftersom de returnerar en sträng med en kommaseparerad lista med alla element i strängen. För metoden join() , till skillnad från metoden toString() , accepteras en parameter med namnet delimiter , vilket innebär att du kan välja vilken symbol som ska användas som avgränsare mellan elementen i den returnerade strängen.

I nästa exempel skapas en array med namnet rivers som anropar både join() och toString() för att returnera värdena i arrayen som en sträng. Metoden toString() används för att returnera kommaseparerade värden ( riverCSV ), medan metoden join() används för att returnera värden som separeras med tecknet + .

var rivers:Array = ["Nile", "Amazon", "Yangtze", "Mississippi"]; 
var riverCSV:String = rivers.toString(); 
trace(riverCSV); // output: Nile,Amazon,Yangtze,Mississippi 
var riverPSV:String = rivers.join("+"); 
trace(riverPSV); // output: Nile+Amazon+Yangtze+Mississippi

En sak som du bör tänka på när du använder metoden join() är alla kapslade Array- och Vector-instanser alltid returneras med kommaavgränsade värden, oavsett vilken avgränsare du anger för elementen i huvudarrayen, vilket framgår av följande exempel:

var nested:Array = ["b","c","d"]; 
var letters:Array = ["a",nested,"e"];  
var joined:String = letters.join("+"); 
trace(joined); // output: a+b,c,d+e