Geïndexeerde arrays

Er zijn diverse technieken waarmee u een Array- of een Vector-instantie kunt maken. De technieken voor het maken van elk type array verschillen echter enigszins.

De meest fundamentele manier om een element aan een geïndexeerde array toe te voegen, is middels de operator voor arraytoegang ( [] ). Als u de waarde van een geïndexeerd arrayelement wilt instellen, gebruikt u de naam en het indexnummer van het Array- of Vector-object aan de linkerzijde van een toewijzingsinstructie:

songTitles[5] = "Happy Birthday";

Als de array of vector nog geen element op die index heeft, wordt de index gemaakt en wordt de waarde daar opgeslagen. Als wel een waarde op die index bestaat, wordt de bestaande waarde door de nieuwe vervangen.

Met een Array-object kunt u een element op een willekeurige index maken. Met een Vector-object kunt u echter alleen waarden toewijzen aan een bestaande index of aan de volgende beschikbare index. De volgende beschikbare index komt overeen met de eigenschap length van het Vector-object. De veiligste wijze om een nieuw element aan een Vector-object toe te wijzen, is zoals in deze voorbeeldcode wordt geïllustreerd:

myVector[myVector.length] = valueToAdd;

Met drie van de methoden voor de klasse Array en Vector - push() , unshift() en splice() - kunt u elementen in een geïndexeerde array invoegen. De methode push() voegt een of meer elementen toe aan het einde van een array. Het element dat als laatste met de methode push() wordt toegevoegd, krijgt dus het hoogste indexnummer. De methode unshift() voegt een of meer elementen toe aan het begin van een array, altijd bij indexnummer 0. De methode splice() voegt het gewenste aantal items toe bij de opgegeven index in de array.

In het volgende voorbeeld wordt het gebruik van alle drie de methoden getoond. Er wordt een array met de naam planets gemaakt waarin de namen van de planeten worden opgeslagen in volgorde van hun nabijheid bij de zon. Ten eerste wordt de methode push() aangeroepen om het eerste item, Mars toe te voegen. Vervolgens wordt de methode unshift() aangeroepen om het item toe te voegen dat aan het begin van de array hoort, Mercury . Ten slotte wordt de methode splice() aangeroepen om de items Venus en Earth toe te voegen achter Mercury , maar vóór Mars . Het eerste argument dat aan splice() wordt doorgegeven, het gehele getal 1, geeft aan dat het invoegen moet beginnen bij index 1. Het tweede argument voor splice() , het gehele getal 0, geeft aan dat geen enkel item mag worden verwijderd. Het derde en vierde argument die aan splice() worden doorgegeven, Venus en Earth , zijn de items die moeten worden ingevoegd.

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

Met zowel de methode push() als de methode unshift() wordt een geheel getal zonder teken geretourneerd, dat de lengte van de gewijzigde array aangeeft. Wanneer de methode splice() wordt gebruikt om elementen in te voegen, wordt een lege array geretourneerd. Dit lijkt misschien vreemd, maar in het licht van de veelzijdigheid van de methode splice() klopt het wel. U kunt de methode splice() immers niet alleen gebruiken om elementen aan een array toe te voegen, maar ook om elementen uit een array te verwijderen. Wanneer elementen worden verwijderd met de methode splice() , wordt een array met daarin de verwijderde elementen geretourneerd.

De meest fundamentele manier om de waarde van een element uit een geïndexeerde array op te halen, is middels de operator voor arraytoegang ( [] ). Als u de waarde van een element uit een geïndexeerde array wilt ophalen, gebruikt u de naam en het indexnummer van het Array- of Vector-object aan de rechterzijde van een toewijzingsinstructie:

var myFavoriteSong:String = songTitles[3];

U kunt proberen een waarde uit een array of vector op te halen met een index waarop geen element bestaat. In dat geval retourneert een Array-object de waarde 'ongedefinieerd' en wordt een RangeError-uitzondering gegenereerd.

Met drie methoden van de klasse Array en Vector - pop() , shift() en splice() - kunt u elementen verwijderen. De methode pop() verwijdert een element aan het einde van een array. Het element met het hoogste indexnummer wordt dus verwijderd. De methode shift() verwijdert een element aan het begin van de array. Dit betekent dat altijd het element bij indexnummer 0 wordt verwijderd. De methode splice() , die ook kan worden gebruikt voor het invoegen van elementen, verwijdert een willekeurig aantal elementen, te beginnen bij het indexnummer dat in het eerste argument aan de methode wordt doorgegeven.

In het volgende voorbeeld wordt het gebruik van de drie methoden getoond om elementen uit een Array-instantie te verwijderen. Er wordt een array met de naam oceans gemaakt waarin de namen van de oceanen worden opgeslagen. Sommige namen in de array zijn een meer in plaats van een oceaan en moeten dus worden verwijderd.

Eerst wordt de methode splice() gebruikt om de items Aral en Superior te verwijderen en de items Atlantic en Indian in te voegen. Het eerste argument dat aan splice() wordt doorgegeven (het gehele getal 2), geeft aan dat de bewerking moet beginnen bij het derde item van de lijst (bij index 2). Het tweede argument (2) geeft aan dat twee items moeten worden verwijderd. De overige argumenten ( Atlantic en Indian ) zijn de waarden die bij index 2 moeten worden ingevoegd.

Vervolgens wordt de methode pop() gebruikt om het laatste element van de array ( Huron ) te verwijderen. Ten slotte wordt met de methode shift() het eerste item van de array ( Victoria ) verwijderd.

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

Zowel de methode pop() als de methode shift() retourneert het item dat is verwijderd. Voor een Array-instantie is het gegevenstype van de resultaatwaarde Object omdat arrays waarden van elk willekeurig gegevenstype kunnen bevatten. Voor een Vector-instantie is het gegevenstype van de resultaatwaarde het basistype van de vector. De methode splice() retourneert een array of vector met daarin de verwijderde elementen. U kunt het Array-voorbeeld met oceans bijvoorbeeld zo wijzigen dat de geretourneerde array door het oproepen van splice() wordt toegewezen aan een nieuwe Array-variabele, zoals in het volgende voorbeeld wordt getoond:

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

U kunt code tegenkomen waarin de operator delete wordt gebruikt voor een Array-objectelement. Met de operator delete wordt de waarde van een Array-element op undefined ingesteld, maar wordt het element niet uit de array verwijderd. De volgende code gebruikt de operator delete bijvoorbeeld voor het derde element in de array oceans , maar de lengte van de array blijft 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

U kunt een array of vector afkappen door de eigenschap length van de array te gebruiken. Als u de eigenschap length van een geïndexeerde array instelt op een lengte die kleiner is dan de huidige lengte van de array, wordt de array afgekapt en worden alle elementen verwijderd die zijn opgeslagen op indexnummers hoger dan de nieuwe waarde van length min 1. Als de array oceans bijvoorbeeld zo was gesorteerd dat alle geldige vermeldingen zich aan het begin van de array bevonden, zou u de eigenschap length kunnen gebruiken om de vermeldingen aan het einde van de array te verwijderen, zoals in de volgende voorbeeldcode wordt geïllustreerd:

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

Er bestaan drie methoden - reverse() , sort() en sortOn() - om de volgorde van een geïndexeerde array te wijzigen, ofwel door te sorteren ofwel door de volgorde om te keren. Al deze methoden wijzigen de bestaande array. De volgende tabel bevat een overzicht van deze methoden en hun gedrag voor Array- en Vector-objecten:

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

Vier methoden van de klassen Array en Vector - concat() , join() , slice() en toString() - dienen allemaal om in een array te zoeken naar informatie. De array wordt niet gewijzigd. Met de methoden concat() en slice() wordt een nieuwe array geretourneerd, terwijl zowel de methode join() als de methode toString() een tekenreeks oplevert. De methode concat() neemt een nieuwe array of lijst met elementen als argumenten en maakt hier in combinatie met de bestaande array een nieuwe array van. De methode slice() heeft twee parameters met de toepasselijke naam startIndex en endIndex en retourneert een nieuwe array met daarin een kopie van de elementen uit de bestaande array. Dit begint bij het element dat zich bevindt bij startIndex en eindigt bij het element net voor endIndex . Dus: het element bij endIndex zit niet in de geretourneerde waarde.

In het volgende voorbeeld worden concat() en slice() gebruikt om nieuwe arrays te maken met elementen uit een andere array:

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

Met de methode join() en toString() kunt u zoeken in de array en de inhoud ervan retourneren als tekenreeks. Als geen parameters worden gebruikt voor de methode join() , gedragen beide methoden zich op dezelfde manier: ze retourneren een tekenreeks bestaande uit een door komma’s gescheiden lijst van alle elementen in de array. In tegenstelling tot de methode toString() accepteert de methode join() een parameter die delimiter heet. Met deze parameter kunt u het symbool kiezen dat u wilt gebruiken als scheidingsteken tussen de verschillende elementen in de geretourneerde tekenreeks.

In het volgende voorbeeld wordt de array rivers gemaakt. Hierbij wordt zowel join() als toString() opgeroepen om de waarden in de array te retourneren als een tekenreeks. De methode toString() wordt gebruikt om door komma’s gescheiden waarden te retourneren ( riverCSV ), terwijl met de methode join() waarden worden geretourneerd die door het teken + van elkaar worden gescheiden.

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

Iets om rekening mee te houden bij de methode join() is dat geneste Array- of Vector-instanties altijd worden geretourneerd met waarden die met een komma van elkaar gescheiden zijn, ongeacht het scheidingsteken dat u hebt opgegeven voor de elementen van de hoofdarray. Dit wordt getoond in het volgende voorbeeld:

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