Tableaux indexés

Vous pouvez utiliser plusieurs techniques pour créer une occurrence de Array ou une occurrence de Vector. Cependant, les techniques de création de chaque type de tableau sont quelque peu différentes.

L’opérateur ( [] ) d’accès au tableau constitue le moyen le plus élémentaire d’ajouter un élément à un tableau indexé. Pour définir la valeur d’un élément de tableau indexé, utilisez le nom d’objet Array ou Vector et le numéro d’index du côté gauche d’une instruction d’affectation.

songTitles[5] = "Happy Birthday";

Si un élément ne se trouve pas déjà à cette position d’index du tableau ou du vecteur, l’index est créé et la valeur y est stockée. Si une valeur existe à cet index, la nouvelle valeur remplace l’ancienne.

Un objet Array vous permet de créer un élément pour tout index. Cependant, avec un objet Vector, vous pouvez affecter uniquement une valeur à un index existant ou à l’index disponible suivant. Celui-ci correspond à la propriété length de l’objet Vector. Utilisez du code comme celui qui est présenté ci-dessous pour ajouter un nouvel élément à un objet Vector de la façon la plus sûre :

myVector[myVector.length] = valueToAdd;

Trois méthodes des classes Array et Vector, push() , unshift() et splice() , vous permettent d’insérer des éléments dans un tableau indexé. La méthode push() ajoute un ou plusieurs éléments à la fin d’un tableau. Ainsi, le dernier élément inséré dans le tableau à l’aide de la méthode push() aura le numéro d’index le plus élevé. La méthode unshift() insère un ou plusieurs éléments au début d’un tableau, qui est toujours au numéro d’index 0. La méthode splice() insère des éléments au niveau d’un index spécifié dans le tableau.

L’exemple suivant illustre les trois méthodes. Un tableau appelé planets est créé pour trier les noms des planètes par ordre de proximité par rapport au soleil. La méthode push() est tout d’abord appelée pour ajouter l’élément initial, Mars . Deuxièmement, la méthode unshift() est appelée pour insérer l’élément Mercury au début du tableau. Pour finir, la méthode splice() est appelée pour insérer les éléments Venus et Earth après Mercury , mais avant Mars . Le premier élément envoyé à splice() , l’entier 1, indique à l’insertion de débuter à l’index 1. Le deuxième argument envoyé à splice() , l’entier 0, indique qu’aucun élément ne doit être supprimé. Pour finir, les troisième et quatrième arguments envoyés à splice() , Venus et Earth , sont les éléments à insérer.

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

Les méthodes push() et unshift() renvoient toutes les deux un entier non signé qui représente la longueur du tableau modifié. La méthode splice() renvoie un tableau vide lorsqu’elle est utilisée pour insérer des éléments, ce qui semble étrange mais compréhensible en raison de saversatilité. Vous pouvez utiliser la méthode splice() non seulement pour insérer des éléments dans un tableau, mais également pour en supprimer. Lorsque vous l’utilisez pour supprimer des éléments, la méthode splice() renvoie un tableau contenant les éléments supprimés.

Utilisez l’opérateur ( [] ) d’accès au tableau pour récupérer la valeur d’un élément de la façon la plus simple. Pour récupérer la valeur d’un élément de tableau indexé, utilisez le nom d’objet Array ou Vector et le numéro d’index du côté droit d’une instruction d’affectation.

var myFavoriteSong:String = songTitles[3];

Il est possible d’essayer de récupérer une valeur à partir d’un tableau ou d’un vecteur à l’aide d’un index où aucun élément n’existe. Dans ce cas, un objet Array renvoie la valeur non définie et un vecteur renvoie une exception RangeError.

Trois méthodes des classes Array et Vector, pop() , shift() et splice() , vous permettent de supprimer des éléments. La méthode pop() supprime un élément de la fin du tableau. En d’autres termes, elle supprime l’élément au niveau du numéro d’index le plus élevé. La méthode shift() supprime un élément du début du tableau, ce qui signifie qu’elle supprime toujours l’élément au numéro d’index 0. La méthode splice() , qui peut également être utilisée pour insérer des éléments, supprime un nombre arbitraire d’éléments en commençant au numéro d’index indiqué par le premier argument envoyé à la méthode.

L’exemple suivant utilise les trois méthodes pour supprimer des éléments d’une occurrence d’Array. Un tableau nommé oceans est créé pour stocker les noms des océans. Certains noms dans le tableau sont des noms de lacs plutôt que des noms d’océans. Ils doivent donc être supprimés.

Premièrement, la méthode splice() est utilisée pour supprimer les éléments Aral et Superior , et insérer les éléments Atlantic et Indian . Le premier argument envoyé à splice() , l’entier 2, indique que l’opération doit commencer par le troisième élément dans la liste, qui est à l’index 2. Le deuxième argument, 2, indique que deux éléments doivent être supprimés. Les arguments restants, Atlantic et Indian , sont des valeurs à insérer à l’index 2.

Deuxièmement, la méthode pop() est utilisée pour supprimer le dernier élément dans le tableau, Huron . Et troisièmement, la méthode shift() est utilisée pour supprimer le premier élément dans le tableau, 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

Les méthodes pop() et shift() renvoient toutes les deux l’élément qui a été supprimé. Pour une occurrence de Array, le type de données de la valeur renvoyée est Object car les tableaux peuvent contenir des valeurs de n’importe quel type de données. Pour une occurrence de Vector, le type de données de la valeur renvoyée est le type de base du vecteur. La méthode splice() renvoie un tableau ou un vecteur contenant les valeurs supprimées. Vous pouvez modifier l’exemple du tableau oceans de façon à ce que l’appel à splice() affecte le tableau renvoyé à une nouvelle variable de tableau, comme illustré dans l’exemple suivant :

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

Il se peut que vous rencontriez un code qui utilise l’opérateur delete sur un élément de l’objet Array. L’opérateur delete définit la valeur d’un élément de tableau sur undefined , mais il ne supprime pas l’élément du tableau. Par exemple, le code suivant utilise l’opérateur delete sur le troisième élément dans le tableau oceans , mais la longueur du tableau demeure à 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

Vous pouvez tronquer un tableau ou un vecteur à l’aide d’une propriété length de tableau. Si vous définissez la propriété length d’un tableau indexé sur une longueur qui est moindre que la longueur actuelle du tableau, celui-ci est tronqué : tous les éléments stockés à des numéros d’index supérieurs à la nouvelle valeur length , diminuée de 1, sont supprimés. Par exemple, si le tableau oceans était trié de telle façon que toutes les entrées valides se trouvaient au début du tableau, vous pourriez utiliser la propriété length pour supprimer les entrées de fin de tableau, comme l’indique le code ci-dessous :

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

Trois méthodes, reverse() , sort() et sortOn() , vous permettent de modifier l’ordre d’un tableau indexé, soit en triant, soit en inversant l’ordre. Toutes ces méthodes modifient le tableau existant. Le tableau ci-dessous résume ces méthodes et leurs comportements pour les objets Array et Vector :

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

Les quatre méthodes restantes des classes Array et Vector, concat() , join() , slice() , toString() , interrogent toutes le tableau sans le modifier. Les méthodes concat() et slice() renvoient toutes les deux de nouveaux tableaux, alors que les méthodes join() et toString() renvoient des chaînes. La méthode concat() prend un nouveau tableau ou une liste d’éléments comme arguments et le/la combine avec le tableau existant pour créer un tableau. La méthode slice() possède deux paramètres nommés startIndex et endIndex , et renvoie un nouveau tableau contenant une copie des éléments découpés du tableau existant. La découpe commence avec l’élément à startIndex et se termine avec l’élément juste avant endIndex . Il convient d’insister : l’élément à endIndex n’est pas compris dans la valeur renvoyée.

L’exemple suivant utilise concat() et slice() pour créer des tableaux à l’aide d’éléments d’autres tableaux :

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

Vous pouvez utiliser les méthodes join() et toString() pour interroger le tableau et renvoyer son contenu sous la forme d’une chaîne. Si aucun paramètre n’est utilisé pour la méthode join() , les deux méthodes se comportent de façon identique : elles renvoient une chaîne contenant une liste de tous les éléments du tableau, séparés par une virgule. La méthode join() , contrairement à la méthode toString() , accepte un paramètre nommé delimiter , qui permet de choisir le symbole à utiliser comme séparateur entre chaque élément de la chaîne renvoyée.

L’exemple suivant crée un tableau nommé rivers et appelle à la fois join() et toString() pour renvoyer les valeurs dans le tableau sous la forme d’une chaîne. La méthode toString() est utilisée pour renvoyer des valeurs séparées par une virgule ( riverCSV ), alors que la méthode join() est utilisée pour renvoyer des valeurs séparées par le caractère + .

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

Il existe un problème avec la méthode join() ; toutes les occurrences de tableau et de vecteur imbriquées sont toujours renvoyées avec des valeurs séparées par des virgules, quel que soit le séparateur que vous spécifiez pour les éléments de tableau principaux, comme illustré dans l’exemple suivant :

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