Tableaux indexés

Flash Player 9 et les versions ultérieures, Adobe AIR 1.0 et les versions ultérieures

Les tableaux indexés stockent une série d’une ou de plusieurs valeurs organisées de façon à ce que vous puissiez accéder à chaque valeur à l’aide d’une valeur d’entier non signé. Le premier index correspond toujours au nombre 0. L’index est ensuite incrémenté d’une unité pour chaque élément ajouté consécutivement au tableau. Dans ActionScript 3.0, deux classes sont utilisées comme tableaux indexés : la classe Array et la classe Vector.

Les tableaux indexés utilisent un entier 32 bits non signé pour le numéro d’index. La taille maximale d’un tableau indexé est 232 - 1 ou 4 294 967 295. Si vous tentez de créer un tableau plus grand que la taille maximale, une erreur d’exécution se produit.

Pour accéder à un élément particulier d’un tableau indexé, vous pouvez utiliser l’opérateur ([]) d’accès au tableau pour spécifier la position de l’index de l’élément visé. Par exemple, le code suivant représente le premier élément (l’élément à l’index 0) dans un tableau indexé appelé songTitles :

songTitles[0]

La combinaison du nom de la variable du tableau suivi de l’index entre crochets fonctionne comme un identifiant unique. En d’autres termes, elle peut être utilisée tout comme un nom de variable. Vous pouvez affecter une valeur à un élément du tableau indexé en utilisant le nom et l’index du côté gauche d’une instruction d’affectation :

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

Dans la même veine, vous pouvez récupérer une valeur à un élément du tableau indexé en utilisant le nom et l’index du côté droit d’une instruction d’affectation :

var nextSong:String = songTitles[2];

Vous pouvez aussi utiliser une variable entre crochets plutôt que de fournir une valeur explicite. Elle doit contenir une valeur entière non-négative telle qu’un uint, un int positif ou une occurrence de Number d’entier positif. Cette technique est utilisée couramment pour passer en boucle sur les éléments dans un tableau indexé et effectuer une opération sur un ou tous les éléments. Le code ci-dessous décrit cette technique. Le code utilise une boucle pour accéder à chaque valeur dans un objet Array appelé oddNumbers. Il utilise l’instruction trace() pour imprimer chaque valeur sous la forme “oddNumber[index] = value” :

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

Classe Array

La classe Array est le premier type de tableau indexé. Une occurrence de Array peut comporter une valeur de n’importe quel type de données. Le même objet Array peut comporter des objets qui sont de types de données différents. Par exemple, une occurrence de Array unique peut avoir une valeur String en index 0, une occurrence de Number en index 1 et un objet XML en index 2.

Classe Vector

La classe Vector est un autre type de tableau indexé qui est disponible dans ActionScript 3.0. Une occurrence de Vector est un tableau typé, ce qui signifie que tous les éléments d’une occurrence de Vector ont toujours le même type de données.

Remarque : la classe Vector est prise en charge à partir de Flash Player 10 et Adobe AIR 1.5.

Lorsque vous déclarez une variable Vector ou que vous instanciez un objet Vector, vous spécifiez explicitement le type de données des objets que le vecteur peut contenir. Le type de données spécifié est connu sous le nom de type de base du vecteur. Lors de l’exécution et de la compilation (en mode strict), tout code qui fixe la valeur d’un élément Vector ou récupère une valeur d’un élément Vector est contrôlé. Si le type de données de l’objet que l’on tente d’ajouter ou de récupérer ne correspond pas au type de base du vecteur, une erreur se produit.

Outre la restriction concernant le type de données, la classe Vector possède d’autres restrictions qui la distinguent de la classe Array :

  • Un vecteur est un tableau dense. Un objet Array peut comporter des valeurs dans les index 0 et 7 même si elle n’en a pas dans les positions 1 à 6. Cependant, un vecteur doit comporter une valeur (ou null) dans chaque index.

  • Un vecteur peut facultativement avoir une longueur fixe. Ceci signifie que le nombre d’éléments du vecteur est immuable.

  • L’accès aux éléments d’un vecteur est défini par ses limites. Vous ne pouvez jamais lire une valeur d’un index supérieur à celui de l’élément final (longueur - 1). Vous ne pouvez jamais définir une valeur avec un index supérieur à l’index final actuel. En d’autres termes, vous pouvez définir une valeur uniquement à l’index existant ou à une [longueur] d’index.

En raison de ses restrictions, un vecteur présente trois avantages principaux par rapport à une occurrence d’Array dont les éléments sont tous des occurrences d’une classe unique :

  • Performance : l’accès à l’élément de tableau et son itération sont beaucoup plus rapides lorsque vous utilisez une occurrence de Vector que lorsque vous utilisez une occurrence d’Array.

  • Sécurité des types : en mode strict, le compilateur peut identifier les erreurs de type de données. Parmi ces erreurs, il y a l’affectation d’une valeur du type de données incorrect à un vecteur ou l’attente d’un type de données incompatible lors de la lecture d’une valeur à partir du vecteur. A l’exécution, les types de données sont également contrôlés lors de l’ajout de données à un objet Vector ou la lecture de données qui en provient. Notez cependant que lorsque vous utilisez la méthode push() ou unshift() pour ajouter des valeurs à un vecteur, les types de données des arguments ne sont pas vérifiés au moment de la compilation. Lorsque vous utilisez ces méthodes, les valeurs sont toujours contrôlées à l’exécution.

  • Fiabilité : le contrôle de gamme à l’exécution (ou contrôle de longueur fixe) assure une fiabilité nettement supérieure à celle des objets Array.

A part les contraintes et les avantages supplémentaires, la classe Vector est très proche de la classe Array. Les propriétés et les méthodes d’un objet Vector sont similaires, voire dans certains cas identiques, aux propriétés et aux méthodes d’un objet Array. Au lieu d’utiliser un objet Array dont tous les éléments possèdent le même type de données, il est généralement préférable de faire appel à une occurrence de l’objet Vector.

Création de tableaux

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.

Création d’une occurrence de Array

Vous créez un objet Array par l’appel au constructeur Array( ou par l’utilisation d’une syntaxe de littéral de tableau.

Vous pouvez utiliser la fonction de constructeur Array() de trois façons différentes. Premièrement, si vous appelez le constructeur sans arguments, vous obtenez un tableau vide. Vous pouvez utiliser la propriété length de la classe Array pour vérifier que le tableau ne contient aucun élément. Par exemple, le code suivant appelle le constructeur Array() sans arguments :

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

Deuxièmement, si vous utilisez un nombre comme unique paramètre pour le constructeur Array(), un tableau de cette longueur est créé, avec chaque valeur d’élément définie sur undefined. L’argument doit être un entier non signé compris entre les valeurs 0 et 4 294 967 295. Par exemple, le code suivant appelle le constructeur Array() avec un seul argument numérique :

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

Troisièmement, si vous appelez le constructeur et transmettez une liste d’éléments comme paramètres, un tableau est créé avec des éléments correspondant à chacun des paramètres. Le code suivant transmet trois arguments au constructeur Array() :

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

Vous pouvez aussi créer des tableaux avec des littéraux de tableau. Un littéral de tableau peut être affecté directement à une variable de tableau, comme illustré dans l’exemple suivant :

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

Création d’une occurrence de Vector

Vous créez une occurrence de Vector par l’appel du constructeur Vector.<T>().  Vous pouvez aussi créer un vecteur par l’appel à la fonction globale Vector.<T>(). Cette fonction convertit un objet spécifié en une occurrence de Vector. Dans Flash Professional CS5 et les versions ultérieures, Flash Builder 4 et les versions ultérieures et Flex 4 et les versions ultérieures, vous pouvez également créer une occurrence de Vector à l’aide de la syntaxe de littéral correspondante.

Toutes les fois que vous déclarez une variable Vector (ou de la même façon, un paramètre de la méthode Vector ou un type de renvoi de la méthode Vector), vous spécifiez le type de base de la variable Vector. Vous spécifiez également le type de base lorsque vous créez une occurrence de Vector par l’appel au constructeur Vector.<T>().  Autrement dit, toutes les fois que vous utilisez le terme Vector dans ActionScript, il est accompagné d’un type de base.

Vous spécifiez le type de base du vecteur à l’aide de la syntaxe de paramètres de type. Le paramètre de type suit immédiatement le mot Vector dans le code. Il est formé d’un point (.), puis du nom de classe de base entouré de parenthèses en chevron (<>), comme l’indique cet exemple :

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

Dans la première ligne de cet exemple, la variable v est déclarée comme une occurrence de Vector.<Chaîne>. En d’autres termes, il représente un tableau indexé qui ne peut comporter que des occurrences de String. La deuxième ligne appelle le constructeur Vector() pour créer une occurrence du même type Vector, c’est-à-dire un vecteur dont les éléments sont tous des objets String. Il affecte cet objet à v.

Utilisation du constructeur Vector.<T>()

Si vous utilisez le constructeur Vector.<T>() sans arguments, il crée une occurrence de Vector vide. Vous pouvez contrôler qu’un vecteur est vide en vérifiant sa propriété length. Par exemple, le code ci-dessus appelle le constructeur Vector.<T>() sans arguments :

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

Si vous savez d’avance de combien d’éléments un vecteur a besoin initialement, vous pouvez prédéfinir ce nombre dans le vecteur. Pour créer un vecteur avec un certain nombre d’éléments, transmettez le nombre d’éléments comme premier paramètre (le paramètre length). Comme les éléments du vecteur ne peuvent pas être vides, ils sont remplis d’occurrences du type de base. Si ce type est un type de référence qui autorise les valeurs null, les éléments contiennent tous null. Autrement, ils contiennent tous la valeur par défaut pour la classe. Par exemple, une variable uint ne peut pas être null. Par conséquent, dans le code ci-dessous, le vecteur appelé ages est créé avec sept éléments, chacun contenant la valeur 0.

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

Enfin, à l’aide du constructeur Vector.<T>(), vous pouvez également créer un vecteur de longueur fixe en transmettant true comme deuxième paramètre (le paramètre fixed). Dans ce cas, le vecteur est créé avec le nombre spécifié d’éléments et celui-ci ne peut pas être modifié. Notez cependant que vous pouvez quand même changer les valeurs des éléments d’un vecteur de longueur fixe.

Utilisation du constructeur de syntaxe de littéral Vector

Dans Flash Professional CS5 et les versions ultérieures, Flash Builder 4 et les versions ultérieures et Flex 4 et les versions ultérieures, vous pouvez transmettre une liste de valeurs au constructeur Vector<T>() pour stipuler les valeurs initiales du vecteur :

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

Cette syntaxe possède les caractéristiques suivantes :

  • La virgule de fin de ligne est facultative.

  • La syntaxe ne gère pas la présence d’éléments vides dans le tableau. Une instruction telle que var v:Vector.<int> = new <int>[0,,2,] renvoie une erreur de compilation.

  • Il est impossible de stipuler la longueur par défaut de l’occurrence de Vector. La longueur correspond au nombre d’éléments qui composent la liste d’initialisation.

  • Il est impossible de spécifier si l’occurrence de Vector possède une longueur fixe. Utilisez à cet effet la propriété fixed.

  • Il risque de se produire des pertes de données ou des erreurs si les éléments transmis en tant que valeurs ne correspondent pas au type indiqué. Exemple :
    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

Utilisation du constructeur Vector. <T>()

Outre le constructeur Vector.<T>() et le constructeur de syntaxe de littéral Vector, vous disposez également de la fonction globale Vector. <T>() pour créer un objet Vector. La fonction globale Vector.<T>() est une fonction de conversion. Lorsque vous appelez la fonction globale Vector.<T>(), vous spécifiez le type de base du vecteur que la méthode renvoie. Vous transmettez un tableau indexé unique (occurrence de Array ou Vector) comme argument. La méthode renvoie alors un vecteur avec le type de base spécifié, contenant les valeurs dans l’argument du tableau source. Le code ci-dessous montre la syntaxe nécessaire pour appeler la fonction globale Vector.<T>().

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

La fonction globale Vector.<T>() exécute une conversion de type de base sur deux niveaux. D’abord, lorsqu’une occurrence de Array est transmise à la fonction, une occurrence de Vector est renvoyée. Ensuite, que le tableau source soit une occurrence de Array ou Vector, la fonction tente de convertir les éléments du tableau source en valeurs du type de base. La conversion utilise des règles standard de conversion des types de données ActionScript. Par exemple, le code suivant convertit les valeurs String du tableau source en nombres entiers dans le vecteur résultant. La partie décimale de la première ("1.5") est tronquée et la troisième valeur non numérique ("Waffles") est convertie en 0 dans le résultat :

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

S’il n’est pas possible de convertir un élément source quelconque, une erreur se produit.

Lorsque le code appelle la fonction globale Vector.<T>(), si un élément du tableau source est une occurrence d’une sous-classe du type de base spécifié, l’élément est ajouté au vecteur résultant (aucune erreur ne se produit). L’utilisation de la fonction globale Vector.<T>() est en fait le seul moyen de convertir un vecteur avec un type de base T en un vecteur avec un type de base qui est une superclasse de T.

Insertion d’éléments de tableau

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.

Remarque : si une propriété fixed de l’objet Vector est définie sur true, le nombre total d’éléments du vecteur reste immuable. Si vous tentez d’ajouter un nouvel élément à un vecteur de longueur fixe à l’aide des techniques décrites ici, une erreur se produit.

Récupération des valeurs et suppression des éléments du tableau

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
Remarque : si une propriété fixed de l’objet Vector est définie sur true, le nombre total d’éléments du vecteur reste immuable. Si vous essayez de supprimer un élément d’un vecteur de longueur fixe ou de tronquer celui-ci à l’aide des techniques décrites ici, une erreur se produit.

Tri d’un tableau

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 :

Méthode

Comportement d’Array

Comportement de Vector

reverse()

Modifie l’ordre des éléments de telle sorte que le dernier élément devient le premier élément, le pénultième le deuxième, etc.

Identique au comportement d’Array

sort()

Vous permet de trier les éléments du tableau de diverses façons prédéfinies, comme l’ordre alphabétique ou numérique. Vous pouvez également spécifier un algorithme de tri personnalisé.

Trie les éléments suivant l’algorithme de tri personnalisé que vous spécifiez

sortOn()

Vous permet de trier des objets qui ont une ou plusieurs propriétés en commun en spécifiant la ou les propriétés à utiliser comme critères de tri.

Non disponible dans la classe Vector

Méthode reverse()

La méthode reverse() ne prend aucun paramètre et ne renvoie aucune valeur mais vous permet de faire basculer l’ordre de votre tableau de son état actuel à l’ordre inverse. L’exemple suivant inverse l’ordre des océans répertoriés dans le tableau oceans :

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

Tri de base avec la méthode sort() (classe Array uniquement)

Pour une occurrence d’Array, la méthode sort() réorganise les éléments dans un tableau à l’aide de l’ordre de tri par défaut. L’ordre de tri par défaut possède les caractéristiques suivantes :

  • Le tri est sensible à la casse, ce qui signifie que les majuscules précédent les minuscules. Par exemple, la lettre D précède la lettre b.

  • Le tri est croissant, ce qui signifie que les codes de caractère bas (A, par exemple) précédent les codes de caractère élevés (B, par exemple).

  • Le tri place les valeurs identiques les unes à côté des autres mais sans ordre particulier.

  • Le tri est basé sur des chaînes, ce qui signifie que les éléments sont convertis en chaînes avant d’être comparés (par exemple, 10 précède 3 car la chaîne "1" a un code de caractère inférieur à celui de la chaîne "3").

Vous pouvez trier votre tableau en ignorant la casse ou par ordre décroissant. Vous pouvez également trier les nombres de votre tableau par ordre numérique plutôt que par ordre alphabétique. La méthode sort() de la classe Array possède un paramètre options qui vous permet de modifier chaque caractéristique de l’ordre de tri par défaut. Les options sont définies par un ensemble de constantes statiques dans la classe Array, comme indiqué dans la liste suivante :

  • Array.CASEINSENSITIVE : cette option permet d’ignorer la casse lors du tri. Par exemple, la lettre minuscule b précède la lettre majuscule D.

  • Array.DESCENDING : cette option inverse le tri croissant par défaut. Par exemple, la lettre B précède la lettre A.

  • Array.UNIQUESORT : cette option permet d’arrêter le tri si deux valeurs identiques sont repérées.

  • Array.NUMERIC : cette option permet d’effectuer un tri numérique, de façon à ce que 3 précède 10.

L’exemple suivant met en évidence certaines de ces options. Un tableau appelé poets est créé. Il est trié à l’aide de plusieurs 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

Tri personnalisé avec la méthode sort() (classes Array et Vector)

En plus du tri de base qui est disponible pour un objet Array, vous pouvez également établir une règle de tri personnalisée. Cette technique est la seule forme de méthode sort() disponible pour la classe Vector. Pour définir un tri personnalisé, vous rédigez une fonction de tri personnalisée et la transmettez comme argument à la méthode sort().

Par exemple, si vous avez une liste de noms dans laquelle chaque élément de liste contient le nom entier d’une personne mais que vous souhaitez trier la liste par nom de famille, vous devez utiliser une fonction de tri personnalisé pour analyser chaque élément et utiliser le nom de famille dans la fonction de tri. Le code suivant indique comment procéder avec une fonction personnalisée utilisée comme paramètre pour la méthode 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

La fonction de tri personnalisé orderLastName() utilise une expression régulière pour extraire le nom de famille de chaque élément à utiliser pour l’opération de comparaison. L’identifiant de fonction orderLastName est l’unique paramètre utilisé lors de l’appel à la méthode sort() sur le tableau names. La fonction de tri accepte deux paramètres, a et b, car elle fonctionne sur deux éléments de tableau à la fois. La valeur renvoyée de la fonction de tri indique la manière dont les éléments doivent être triés :

  • Une valeur renvoyée de -1 indique que le premier paramètre, a, précède le second paramètre, b.

  • Une valeur renvoyée de 1 indique que le second paramètre, b, précède le premier, a.

  • Une valeur renvoyée de 0 indique que les éléments ont une précédence de tri équivalente.

Méthode sortOn() (classe Array uniquement)

La méthode sortOn() est conçue pour des objets Array avec des éléments contenant des objets. Ces objets doivent avoir au moins une propriété en commun pouvant être utilisée comme clé de tri. L’utilisation de la méthode sortOn() pour des tableaux d’autres types provoque des résultats inattendus.

Remarque : la classe Vector ne contient pas de méthode sortOn(). Cette méthode n’est disponible que pour les objets Array.

L’exemple suivant modifie le tableau poets de façon à ce que chaque élément soit un objet plutôt qu’une chaîne. Chaque objet contient à la fois le nom de famille du poète et sa date de naissance.

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

Vous pouvez utiliser la méthode sortOn() pour trier le tableau par la propriété born. La méthode sortOn() définit deux paramètres, fieldName et options. L’argument fieldName doit être spécifié en tant que chaîne. Dans l’exemple suivant, la méthode sortOn() est appelée avec deux arguments, "born" et Array.NUMERIC. L’argument Array.NUMERIC est utilisé pour vérifier que le tri est effectué par ordre numérique plutôt que par ordre alphabétique. Ceci est utile même lorsque tous les nombres ont le même nombre de chiffres car vous êtes certain que le tri se fera comme prévu si un nombre comportant un nombre inférieur ou supérieur de chiffres est ensuite ajouté au tableau.

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

Tri sans modification du tableau d’origine (classe Array uniquement)

Généralement, les méthodes sort() et sortOn() modifient un tableau. Si vous souhaitez trier un tableau sans modifier le tableau existant, transmettez la constante Array.RETURNINDEXEDARRAY avec le paramètre options. Cette option indique aux méthodes de renvoyer un nouveau tableau qui reflète le tri et laisse le tableau d’origine inchangé. Le tableau renvoyé par les méthodes est un tableau simple de numéros d’index qui reflète le nouvel ordre de tri et ne contient aucun élément du tableau d’origine. Par exemple, pour trier le tableau poets par année de naissance sans le modifier, incluez la constante Array.RETURNINDEXEDARRAY dans l’argument transmis pour le paramètre options.

L’exemple suivant stocke les informations d’index renvoyées dans un tableau nommé indices et utilise le tableau indices avec le tableau poets inchangé pour trier les poètes dans l’ordre de leur année de naissance :

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

Interrogation d’un tableau

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