Geïndexeerde arrays

Flash Player 9 of hoger, Adobe AIR 1.0 of hoger

Geïndexeerde arrays slaan een reeks van een of meer waarden op, die op zo’n manier worden geordend dat elke waarde kan worden benaderd met een geheel-getalwaarde zonder teken. De eerste index is altijd het getal 0 en de index neemt met 1 toe voor elk achtereenvolgend element dat u toevoegt aan de array. In ActionScript 3.0 worden twee klassen als geïndexeerde arrays gebruikt: de klasse Array en de klasse Vector.

Geïndexeerde arrays gebruiken voor het indexnummer een 32-bits geheel getal zonder teken. De maximale grootte van een geïndexeerde array is 232 - 1 of 4.294.967.295. Een poging om een array te maken die groter is dan dit maximum, resulteert in een uitvoeringsfout.

Als u één element van een geïndexeerde array wilt benaderen, gebruikt u de operator voor arraytoegang ([]) om de indexpositie op te geven van het element dat u wilt benaderen. De volgende code bijvoorbeeld wijst het eerste element aan (het element op index 0) in de geïndexeerde array songTitles:

songTitles[0]

De combinatie van de naam van de arrayvariabele gevolgd door de index tussen vierkante haken werkt als één identificatie. (Met andere woorden, deze kan op dezelfde wijze als een variabelennaam worden gebruikt.) U kunt een waarde aan een geïndexeerd arrayelement toewijzen door de naam en index aan de linkerzijde van een toewijzingsinstructie te plaatsen:

songTitles[1] = "Symphony No. 5 in D minor";

Evenzo kunt u de waarde van een geïndexeerd arrayelement ophalen door de naam en index aan de rechterzijde van een toewijzingsinstructie te plaatsen:

var nextSong:String = songTitles[2];

U kunt ook een variabele tussen vierkante haken plaatsen in plaats van een expliciete waarde op te geven. (De variabele moet een niet-negatieve gehele waarde zijn, zoals een uint, een positieve int of een positieve gehele instantie van Number.) Deze techniek wordt veelvuldig gebruikt om de elementen in een geïndexeerde array te doorlopen en met enkele of alle elementen een bewerking uit te voeren. In het volgende stukje programmacode wordt deze techniek gedemonstreerd. In de code wordt een lus gebruikt om elke waarde in het Array-object oddNumbers te benaderen. De instructie trace() wordt gebruikt om elke waarde af te drukken in de vorm 'oddNumber[index] = waarde':

var oddNumbers:Array = [1, 3, 5, 7, 9, 11]; 
var len:uint = oddNumbers.length; 
for (var i:uint = 0; i < len; i++) 
{ 
    trace("oddNumbers[" + i.toString() + "] = " + oddNumbers[i].toString()); 
}

De klasse Array

Het eerste type geïndexeerde array is de klasse Array. Een Array-instantie kan een waarde van een willekeurig gegevenstype bevatten. Hetzelfde Array-object kan objecten van verschillende gegevenstypen bevatten. Zo kan een enkele Array-instantie een String-waarde op index 0 hebben, een Number-instantie op index 1 en een XML-object op index 2.

De klasse Vector

Een ander type geïndexeerde array in ActionScript 3.0 is de klasse Vector. Een Vector-instantie is een array met type. Dat betekent dat alle elementen in een Vector-instantie allemaal hetzelfde gegevenstype hebben.

Opmerking: De klasse Vector is beschikbaar vanaf Flash Player 10 en Adobe AIR 1.5.

Wanneer u een Vector-variabele declareert of een Vector-object instantieert, geeft u expliciet het gegevenstype op van de objecten die de vector kan bevatten. Het opgegeven gegevenstype wordt het basistype van de vector genoemd. Tijdens de runtime en het compileren (in strikte modus) wordt elke code gecontroleerd die de waarde van een Vector-element instelt of een waarde uit een vector ophaalt. Als het gegevenstype van het object dat wordt toegevoegd of opgehaald, niet overeenkomt met het basistype van de vector, treedt een fout op.

De vectorklasse heeft naast de gegevenstypebeperking ook andere beperkingen die deze van de klasse Array onderscheiden:

  • Een vector is een dichte array. Een Array-object kan waarden bevatten op de indices 0 en 7, zelfs als de indices 1 tot en met 6 geen waarde bevatten. Een vector moet echter op elke index een waarde (of null) hebben.

  • Een vector kan optioneel een vaste lengte hebben. Dat betekent dat het aantal elementen dat de vector kan bevatten, niet kan veranderen.

  • Toegang tot de elementen van een vector wordt met begrenzingen gecontroleerd. U kunt nooit een waarde lezen uit een index die groter is dan het laatste element (length - 1). U kunt nooit een waarde instellen met een index die hoger is dan de huidige laatste index. (Met andere woorden, u kunt alleen een waarde instellen op een bestaande index of op index [length].)

Een Vector-instantie heeft, door zijn beperkingen, drie belangrijke voordelen ten opzichte van een Array-instantie waarvan de elementen allemaal van één klasse zijn:

  • Prestatie: toegang tot en iteratie van arrayelementen zijn veel sneller wanneer u een Vector-instantie gebruikt dan met een Array-instantie.

  • Veiligheid van type: in de strikte modus kan de compiler gegevenstypefouten onderscheppen. Voorbeelden van dergelijke fouten zijn het toewijzen van een waarde van een verkeerd gegevenstype aan een vector, of het verwachten van het verkeerde gegevenstype wanneer een waarde uit een vector wordt gelezen. Tijdens de runtime worden gegevenstypen eveneens gecontroleerd wanneer ze worden toegevoegd aan of gelezen uit een Vector-object. Wanneer u echter de methode push() of unshift() gebruikt om waarden aan een vector toe te voegen, worden de gegevenstypen van het argument niet tijdens het compileren gecontroleerd. Bij gebruik van deze methoden worden de waarden wel tijdens de runtime gecontroleerd.

  • Betrouwbaarheid: door bereikcontroles tijdens de runtime (of vaste-lengtecontroles) is de betrouwbaarheid aanzienlijk groter dan bij arrays.

Op de extra beperkingen en voordelen na, lijkt de klasse Vector verder veel op de klasse Array. De eigenschappen en methoden van een Vector-object zijn vergelijkbaar - voornamelijk identiek - met de eigenschappen en methoden van een array. In de meeste gevallen waarin u een array zou gebruiken waarin alle elementen hetzelfde gegevenstype hebben, heeft een Vector-instantie de voorkeur.

Arrays maken

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.

Array-instanties maken

U kunt een Array-object maken door de Array()-constructor op te roepen of door de literale Array-syntaxis te gebruiken.

De constructorfunctie voor Array() kan op drie manieren worden gebruikt. Ten eerste: als u de constructor aanroept zonder argumenten, krijgt u een lege array. Met de eigenschap length van de klasse Array kunt u controleren of de array geen elementen heeft. Met de volgende code wordt bijvoorbeeld de Array ()-constructor opgeroepen zonder argumenten:

var names:Array = new Array(); 
trace(names.length); // output: 0

Ten tweede: als u als enige parameter voor de Array()-constructor een nummer gebruikt, wordt een array met die lengte gemaakt, waarbij de waarde van elk element is ingesteld op undefined. Het argument moet een geheel getal zonder teken zijn tussen de waarden 0 en 4.294.967.295. Met de volgende code wordt bijvoorbeeld de Array()-constructor opgeroepen met één numeriek argument:

var names:Array = new Array(3); 
trace(names.length); // output: 3 
trace(names[0]); // output: undefined 
trace(names[1]); // output: undefined 
trace(names[2]); // output: undefined

Ten derde: als u de constructor oproept en een lijst met elementen doorgeeft als parameter, wordt een array gemaakt met elementen die overeenstemmen met de verschillende parameters. Met de volgende code worden drie argumenten aan de Array()-constructor doorgegeven:

var names:Array = new Array("John", "Jane", "David"); 
trace(names.length); // output: 3 
trace(names[0]); // output: John 
trace(names[1]); // output: Jane 
trace(names[2]); // output: David

U kunt ook arrays maken met Array-literalen. Array-literalen kunnen rechtstreeks aan een arrayvariabele worden toegewezen, zoals in het volgende voorbeeld wordt geïllustreerd:

var names:Array = ["John", "Jane", "David"];

Vector-instanties maken

U maakt een Vector-instantie door de constructorVector.<T>()-constructor. U kunt ook een vector maken door de globale functie Vector.<T>()-constructor. Deze functie converteert een opgegeven object in een Vector-instantie. In Flash Professional CS5 of hoger, Flash Builder 4 of hoger en Flex 4 of hoger kunt u ook een Vector-instantie maken door de letterlijke Vector-syntaxis te gebruiken.

Telkens wanneer u een Vector-variabele declareert (of een parameter voor de Vector-methode of een resultaattype voor de methode), geeft u het basistype van de Vector-variabele op. U geeft het basistype ook op wanneer u een Vector-instantie maakt door de constructor Vector.<T>()-constructor. Anders gezegd, telkens wanneer u de term Vector in ActionScript gebruikt, gaat deze vergezeld van een basistype.

U geeft het basistype van de vector op met de syntaxis voor de parameter type. Het parametertype staat direct achter het woord Vector in de code. Deze bestaat uit een punt (.), gevolgd door de naam van de basisklasse tussen vierkante haken (<>), zoals in dit voorbeeld:

var v:Vector.<String>; 
v = new Vector.<String>();

In de eerste regel van het voorbeeld is de variabele v gedeclareerd als een Vector.<String>-instantie. Met andere woorden, deze geeft een geïndexeerde array aan die alleen String-instanties kan bevatten. Op de tweede regel wordt de Vector()-constructor opgeroepen om een instantie van hetzelfde Vector-type te maken (dus een vector waarvan de elementen allemaal String-objecten zijn). Hier wordt dat object toegewezen aan v.

De Vector.<T>()-constructor gebruiken

Als u de constructor Vector.<T>() zonder argumenten gebruikt, wordt een lege Vector-instantie gemaakt. U kunt testen of een vector leeg is door de eigenschap length van de vector te controleren. Met de volgende code wordt bijvoorbeeld de constructor Vector.<T>() opgeroepen zonder argumenten:

var names:Vector.<String> = new Vector.<String>(); 
trace(names.length); // output: 0

Als u van tevoren weet hoeveel elementen een vector nodig heeft, kunt u het aantal elementen in de vector van tevoren definiëren. Als u een vector met een bepaald aantal elementen wilt maken, geeft u het aantal elementen als eerste parameter (de parameter length) door. Omdat Vector-elementen niet leeg mogen zijn, worden alle elementen gevuld met instanties van het basistype. Als het basistype een referentietype is dat null-waarden toestaat, bevatten de elementen allemaal null-waarden. Anders bevatten de elementen allemaal de standaardwaarde voor de klasse. Zo mag een uint-variabele niet null zijn. Daarom wordt de vector ages in de volgende voorbeeldcode gemaakt met zeven elementen, die allemaal de waarde 0 bevatten:

var ages:Vector.<uint> = new Vector.<uint>(7); 
trace(ages); // output: 0,0,0,0,0,0,0 

Tot slot kunt u met de constructor Vector.<T>() ook een vector met een vaste lengte maken door true als tweede parameter (de parameter fixed) door te geven. In dat geval wordt de vector met het opgegeven aantal elementen gemaakt en kan het aantal elementen niet worden gewijzigd. Let wel: in een vector met vaste lengte kunt u echter wel de waarden van de elementen wijzigen.

De constructor voor de letterlijke Vector-syntaxis gebruiken

In Flash Professional CS5 of hoger, Flash Builder 4 of hoger en Flex 4 of hoger kunt u een lijst met waarden aan de Vector.<T>()-constructor doorgeven om de beginwaarden van de vector op te geven:

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

De volgende informatie is op deze syntaxis van toepassing:

  • De navolgende komma is optioneel.

  • Er is geen ondersteuning voor lege items in de array. Een instructie als var v:Vector.<int> = new <int>[0,,2,] genereert een compilatiefout.

  • U kunt geen standaardlengte voor de Vector-instantie opgeven. De lengte is in dit geval identiek aan het aantal elementen in de initialisatielijst.

  • U kunt niet opgeven of de Vector-instantie een vaste lengte heeft. Gebruik in dit geval de eigenschap fixed.

  • Gegevensverlies of fouten kunnen zich voordoen als de items die als waarden worden doorgegeven, niet overeenkomen met het opgegeven type. Bijvoorbeeld:
    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

De globale functieVector.<T>() gebruiken

Naast de constructor Vector.<T>() en de constructors voor de letterlijke Vector-syntaxis kunt u ook de globale functie Vector.<T>() gebruiken om een Vector-object te maken. De Vector.<T>() is een conversiefunctie. Als u de globale functie Vector.<T>() oproept, geeft u het basistype op van de vector die de methode retourneert. U geeft een enkele geïndexeerde array (Array- of Vector-instantie) als argument door. De methode retourneert vervolgens een vector van het opgegeven basistype, die de waarden in het argument voor de bronarray bevat. In de volgende voorbeeldcode wordt geïllustreerd hoe u de globale functie Vector.<T>() globale functie:

var friends:Vector.<String> = Vector.<String>(["Bob", "Larry", "Sarah"]);

De Vector.<T>() voert gegevenstypeconversie uit op twee niveaus. Wanneer een Array-instantie aan de functie wordt doorgegeven, wordt eerst een Vector-instantie geretourneerd. Afhankelijk van het feit of de bronarray een Array- of een Vector-instantie is, probeert de functie vervolgens de elementen van de bronarray te converteren naar waarden van het basistype. Voor de conversie worden de standaard conversieregels voor ActionScript-gegevenstypen gehanteerd. In de volgende voorbeeldcode worden String-waarden in de bronarray geconverteerd naar gehele getallen in de resulterende vector. Het decimale gedeelte van de eerste waarde ('1.5') wordt afgekapt, en de niet-numerieke derde waarde ('Waffles') is in het resultaat geconverteerd naar 0:

var numbers:Vector.<int> = Vector.<int>(["1.5", "17", "Waffles"]); 
trace(numbers); // output: 1,17,0

Als bepaalde bronelementen niet geconverteerd kunnen worden, treedt een fout op.

Als de code de globale functie Vector.<T>() oproept en een element in de bronarray een instantie is van een subklasse van het opgegeven basistype, wordt het element toegevoegd aan de resulterende vector (er treden geen fouten op). Het gebruik van de globale functie Vector.<T>() is de enige manier om een vector met basistype T te converteren naar een vector met een basistype dat een bovenliggende klasse is van T.

Arrayelementen invoegen

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.

Opmerking: Als de eigenschap fixed van een Vector-object true is, kan het totale aantal elementen in de vector niet veranderen. Als u met een van de hier beschreven technieken een nieuw element probeert toe te voegen aan een vector met vaste lengte, treedt een fout op.

Waarden ophalen en arrayelementen verwijderen

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
Opmerking: Als de eigenschap fixed van een Vector-object true is, kan het totale aantal elementen in de vector niet veranderen. Als u met een van de hier beschreven technieken een element probeert te verwijderen uit een vector met vaste lengte of een vector met vaste lengte probeert af te kappen, treedt een fout op.

Een array sorteren

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:

Methode

Arraygedrag

Vectorgedrag

reverse()

Deze methode wijzigt de volgorde van de array zo dat het laatste element het eerste wordt. Het op één na laatste element wordt het tweede element enzovoort.

Identiek aan arraygedrag

sort()

Met deze methode kunt u de elementen in de array op diverse, vooraf gedefinieerde manieren sorteren, bijvoorbeeld in alfabetische of numerieke volgorde. U kunt ook een aangepaste sorteeralgoritme opgeven.

Deze methode sorteert elementen volgens de aangepaste sorteeralgoritme die u opgeeft.

sortOn()

Met deze methode kunt u objecten sorteren die een of meer gemeenschappelijke eigenschappen hebben, door de eigenschap(pen) als sorteersleutel op te geven.

Niet beschikbaar in de klasse Vector

De methode reverse()

De methode reverse() gebruikt geen parameters en retourneert geen waarde, maar maakt het mogelijk om de volgorde van de array om te wisselen van de huidige toestand naar de omgekeerde volgorde. In het volgende voorbeeld wordt de volgorde van de oceanen in de array oceans omgekeerd:

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

Basissortering met de methode sort() (alleen klasse Array)

Voor een Array-instantie rangschikt de methode sort() de elementen van de array opnieuw in de standaard sorteervolgorde. De standaardvolgorde heeft de volgende kenmerken:

  • Bij het sorteren wordt onderscheid gemaakt tussen hoofdletters en kleine letters (hoofdletters komen voor de kleine letters). De letter D komt dus voor de letter b.

  • Er wordt oplopend gesorteerd. Een lagere tekencode (zoals de A) komt voor de hogere tekencodes (zoals de B).

  • Identieke waarden worden bij het sorteren naast elkaar geplaatst, maar niet in een bepaalde volgorde.

  • Voor het sorteren worden tekenreeksen gebruikt. Dit wil zeggen dat elementen eerst worden omgezet in een tekenreeks, voordat ze met elkaar worden vergeleken (dus 10 komt voor 3 omdat de tekenreeks "1" een lagere tekencode heeft dan de tekenreeks "3").

Misschien wilt u een array sorteren zonder rekening te houden met de hoofdletters en kleine letters, of in aflopende volgorde, of misschien bevat uw array getallen die u numeriek wilt sorteren in plaats van alfabetisch. Bij de methode sort() van de klasse Array hoort de parameter options, waarmee u de verschillende kenmerken van de standaardvolgorde kunt aanpassen. De opties worden gedefinieerd met een set statische constanten in de klasse Array, zoals wordt getoond in de volgende lijst:

  • Array.CASEINSENSITIVE: hiermee wordt bij het sorteren niet gekeken naar de hoofdletters en kleine letters. De kleine letter b komt dus voor de hoofdletter D.

  • Array.DESCENDING: hiermee wordt de standaardvolgorde waarmee wordt gesorteerd, omgekeerd. De letter B komt dus voor de letter A.

  • Array.UNIQUESORT: hiermee wordt het sorteren afgebroken als twee identieke waarden worden aangetroffen.

  • Array.NUMERIC: hiermee wordt numeriek gesorteerd, dus 3 komt voor 10.

In het volgende voorbeeld worden enkele van deze opties toegepast. Er wordt een array met de naam poets gemaakt, die vervolgens wordt gesorteerd met behulp van verschillende opties.

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

Aangepaste sortering met de methode sort() (klassen Array en Vector)

Naast de basissortering die voor een Array-object beschikbaar is, kunt u ook een aangepaste sorteerregel definiëren. Deze techniek is de enige vorm van de methode sort() die beschikbaar is voor de klasse Vector. Als u een aangepaste sortering wilt opgeven, schrijft u een aangepaste sorteerfunctie en geeft u deze als argument door aan de methode sort().

Stel dat u een lijst met namen hebt waarbij elk element van de lijst bestaat uit de volledige naam van een persoon, maar u wilt de lijst sorteren op achternaam. In dit geval moet u een aangepaste sorteerfunctie gebruiken om de elementen te parseren en de achternaam te gebruiken in de sorteerfunctie. In de volgende code wordt getoond hoe u dit kunt doen met een aangepaste functie die wordt gebruikt als parameter voor de methode Array.sort():

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

De aangepaste sorteerfunctie orderLastName() gebruikt een reguliere expressie om uit elk element de achternaam te extraheren voor de vergelijking. De functie-id orderLastName wordt als enige parameter gebruikt bij het aanroepen van de methode sort() voor de array names. De sorteerfunctie accepteert twee parameters (a en b), omdat de functie met twee arrayelementen tegelijk aan het werk is. De geretourneerde waarde van de sorteerfunctie geeft aan hoe de elementen moeten worden gesorteerd:

  • Wanneer -1 wordt geretourneerd, wil dit zeggen dat de eerste parameter (a) voor de tweede parameter (b) komt.

  • Wanneer 1 wordt geretourneerd, wil dit zeggen dat de tweede parameter (b) voor de eerste parameter (a) komt.

  • Wanneer 0 wordt geretourneerd, wil dit zeggen dat de elementen dezelfde sorteerprioriteit hebben.

De methode sortOn() (alleen klasse Array)

De methode sortOn() is bedoeld voor Array-objecten met elementen die objecten bevatten. Deze objecten worden geacht ten minste één gemeenschappelijke eigenschap te hebben voor gebruik als sorteersleutel. Het gebruik van de methode sortOn() voor arrays van een ander type geeft onverwachte resultaten.

Opmerking: De klasse Vector kent geen methode sortOn(). Deze methode is alleen beschikbaar voor Array-objecten.

In het volgende voorbeeld wordt de array poets zo aangepast dat elk element een object is in plaats van een tekenreeks. Elk object bevat de achternaam en het geboortejaar van de dichter.

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

U kunt de methode sortOn() gebruiken om de array te sorteren op de eigenschap born. De methode sortOn() definieert twee parameters: fieldName en options. Het argument fieldName moet worden opgegeven als tekenreeks. In het volgende voorbeeld wordt sortOn() aangeroepen met twee argumenten ("born" en Array.NUMERIC). Het argument Array.NUMERIC dient om ervoor te zorgen dat numeriek in plaats van alfabetisch wordt gesorteerd. Dit is een goede manier van werken, zelfs wanneer alle getallen uit hetzelfde aantal cijfers bestaan, omdat de sorteeropdracht altijd zoals verwacht werkt als later een getal met minder of meer cijfers aan de array wordt toegevoegd.

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

Sorteren zonder de oorspronkelijke array te wijzigen (alleen klasse Array)

Over het algemeen wordt met de methoden sort() en sortOn()= de array gewijzigd. Als u een array wilt sorteren zonder de bestaande array te wijzigen, moet u de constante Array.RETURNINDEXEDARRAY doorgeven als onderdeel van de parameter options. Deze optie geeft de methoden de opdracht om een nieuwe array met de gewenste sorteervolgorde te retourneren en om de oorspronkelijke array ongewijzigd te laten. De array die door deze methoden wordt geretourneerd, is een eenvoudige array met indexnummers die de nieuwe sorteervolgorde in acht neemt en geen elementen van de oorspronkelijke array bevat. Als u bijvoorbeeld de array poets op geboortejaar wilt sorteren zonder de array te wijzigen, voegt u de constante Array.RETURNINDEXEDARRAY toe als onderdeel van het argument dat wordt doorgegeven voor de parameter options.

In het volgende voorbeeld wordt de geretourneerde indexinformatie opgeslagen in de array indices en wordt de array indices samen met de ongewijzigde array poets gebruikt om de dichters in volgorde van geboortejaar te krijgen:

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

Zoeken in een array

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