Licence CC BY-NC-SA

Les tableaux

Publié :

Pour clore cette première partie du cours, nous verrons les tableaux très utilisés en programmation !

Les variables de base, présentées dans un chapitre précédent, sont très utiles mais possèdent leurs limites lorsqu'il s'agit de gérer beaucoup de valeurs. Effectivement, à l'aide de variables nous pouvons associer une valeur à un nom. Or ceci peut être handicapant lors du traitement d'une grosse quantité de valeurs. C'est ici qu'entrent en jeu les tableaux ! Le principe des tableaux est de pouvoir stocker plusieurs valeurs sous un même nom. Ceci facilitera alors le traitement de ces données, puisque celles-ci seront enregistrées sous le même nom simplement différenciées par un indice à l'intérieur du tableau.

En Actionscript, nous avons plusieurs manières de créer et d'utiliser des tableaux. Dans ce chapitre nous verrons les deux types de tableaux : Array et Vector.

Le type Array

Le premier type de tableaux utilisé en Actionscript est Array. Ce qu'il faut savoir en Actionscript, c'est que les tableaux ne sont pas fixés en taille, ce qui permet une programmation plus souple. D'autre part en ce qui concerne le type Array, les tableaux ne sont pas typés, c'est-à-dire qu'ils ne sont pas réservés à un seul type de variable. Il est alors possible d'insérer dans un tableau des variables de type int, uint, Number, String ou encore tout ce qu'il vous passe par la tête.

Création

La création d'un tableau de type Array peut être réalisée de multiples façons. Cependant, les tableaux sont soumis aux mêmes règles que les variables. C'est pourquoi nous retrouverons donc la structure de base commune à toute variable :

1
var nomDuTableau:Array = ceQueJeMetsDedans;

C'est en revanche lorsqu’il s'agit d'initialiser un tableau que nous trouvons diverses méthodes. Voici quatre manières différentes d'initialiser une variable de type Array :

1
2
3
4
var monTableau:Array = new Array(3); // Création d'un tableau de 3 valeurs non renseignées
var monTableau:Array = new Array(); // Création d'un tableau vide
var monTableau:Array = new Array("Site", "du", "Zéro"); // Création d'un tableau contenant les 3 valeurs indiquées
var monTableau:Array = ["Site", "du", "Zéro"]; // Création du même tableau contenant les 3 valeurs indiquées

Dans beaucoup de langages, la longueur d'un tableau doit être définie lors de sa déclaration. Ceci n'est pas le cas en Actionscript, il est tout à fait possible de changer la longueur d'un tableau en cours de programme.

La fonction trace() permet également d'afficher le contenu d'un tableau. Vous pouvez ainsi à tout moment connaître l'état de votre tableau :

1
2
var monTableau:Array = ["Site", "du", "Zéro"];
trace(monTableau); // Affiche : Site,du,Zéro

Les éléments du tableau

Même si un tableau regroupe plusieurs valeurs, celles-ci doivent pouvoir être utilisées séparément. C'est ici qu'entre en jeu la notion d'indice à l'intérieur d'un tableau. Ces indices sont utilisés entre crochets [] pour préciser la position de l'élément désiré dans le tableau. Les valeurs peuvent alors être traitées comme n'importe quelle variable :

1
2
3
4
5
var monTableau:Array = new Array(3);
monTableau[0] = 4;
monTableau[1] = 5;
monTableau[2] = monTableau[0] + monTableau[1];
trace(monTableau[2]); // Affiche : 9

Attention, en programmation les indices des tableaux commencent toujours à 0. Ainsi le troisième élément du tableau se trouve à l'indice 2. Ce n'est pas très compliqué à comprendre, mais on a souvent tendance à l'oublier les premières fois.

Comme nous venons de le voir, les valeurs à l'intérieur d'un tableau se manipulent de la même manière que les variables. Toutefois, une valeur non initialisée dans le tableau aura une valeur par défaut, undefined :

1
2
var monTableau:Array = new Array();
trace(monTableau[0]); // Affiche : undefined

Propriétés du type Array

Enfin pour en finir avec le type Array, nous allons voir quelques méthodes et propriétés qui pourront vous être utiles. Tout d'abord lorsque vous utiliserez des tableaux, vous n'aurez pas besoin de connaître en permanence la taille de votre tableau. En revanche, vous pouvez à tout moment avoir besoin de connaître cette longueur de tableau. Pour cela, vous pouvez utiliser la propriété length associée aux tableaux de type Array. Voici comment l’utiliser :

1
2
3
var monTableau:Array = new Array(5);
var taille:int = monTableau.length;
trace(taille); // Affiche : 5

Nous allons à présent voir différentes méthodes permettant d'insérer ou de supprimer des éléments dans un tableau. D'abord, la méthode push() permet d'ajouter un ou plusieurs éléments à la fin du tableau. À l'opposé, la méthode unshift() insère un ou plusieurs éléments au début du tableau, c'est-à-dire à l'indice 0. Pour finir, la méthode splice() est un compromis car elle permet d'insérer des éléments à un indice spécifié. Voici un exemple d'utilisation de ces méthodes :

1
2
3
4
5
var monTableau:Array = ["Site", "du", "Zéro"];
monTableau.unshift("Bienvenue");
monTableau.splice(1, 0, "sur","le");
monTableau.push("!");
trace(monTableau); // Affiche : Bienvenue,sur,le,Site,du,Zéro,!

La méthode splice() peut avoir des finalités différentes suivant les paramètres renseignés. Voici donc la signification de chacun de ses paramètres :

  • indice de départ où on se place pour effectuer les opérations
  • nombre d'éléments devant être supprimés à partir de l'indice de départ
  • série d'éléments qui doivent être insérés à la suite de l'indice de départ.

Ainsi la méthode splice() permet à la fois d'insérer des éléments mais également de supprimer ou remplacer des éléments. Dans le cas présent, la mise à zéro du deuxième paramètre permet uniquement d'insérer des éléments sans en supprimer.

Enfin, pour supprimer des éléments nous avons également trois méthodes : pop(), shift(), et splice(). Symétriquement à push() et unshift(), les méthodes pop() et shift() permettent de supprimer des éléments respectivement à la fin ou au début d'un tableau. Pour supprimer des éléments au milieu du tableau, il faut utiliser la méthode splice() présentée juste avant. Encore une fois, voici un exemple pour bien comprendre :

1
2
3
4
5
var monTableau:Array = ["Bienvenue", "sur", "le", "Site", "du", "Zéro", "!"];
monTableau.pop();
monTableau.splice(1, 2);
monTableau.shift();
trace(monTableau); // Affiche : Site,du,Zéro

Le type Vector

Le second type de tableaux utilisé en Actionscript est Vector. Vous verrez que ces tableaux sont très proches de ceux de type Array, notamment ils sont également non fixés en taille. La principale différence vient du fait que les tableaux de type Vector sont typés. C'est-à-dire qu'une fois déclaré pour un certain type de variables, il n'est pas possible d'y mettre autre chose. Voyons tout ceci plus en détails !

Déclaration

Ici encore la déclaration ressemble à celle d'une variable, mais à une nuance près. Étant donné que les tableaux de type Vector sont typés, il est nécessaire de préciser le type de variables qui sera utilisé à l'aide des chevrons « <> ». Voici donc comment déclarer un tel tableau :

1
var nomDuTableau:Vector.<Type> = ceQueJeMetsDedans;

Pour initialiser un tableau de type Vector, voici les méthodes proposées :

1
2
3
var monTableau:Vector.<String> = new Vector.<String>();
var monTableau:Vector.<int> = new Vector.<int>(3);
var monTableau:Vector.<String> = Vector.<String>(["Site", "du", "Zéro"]);

Étant donné que ces tableaux sont typés, vous ne pouvez pas insérer une valeur dont le type ne correspondrait pas à celui déclaré. En effet, ceci entrainerait des erreurs d'exécution ou de compilation.

Notez que la taille du tableau peut toutefois être fixée en utilisant un paramètre supplémentaire de type Boolean et valant true. Voici le code correspondant :

1
var monTableau:Vector.<int> = new Vector.<int>(3, true);

Gestion des éléments

Tout comme les tableaux Array, les valeurs internes peuvent être manipulées à l'aide d'indices mis entre crochets « [] ». Voici encore quelques exemples de manipulations de valeurs à l'intérieur d'un tableau :

1
2
3
4
5
6
7
8
var monTableau:Vector.<int> = new Vector.<int>(10);
monTableau[0] = 0;
monTableau[1] = 1;
for(var i:int = 2; i < monTableau.length; i++)
{
    monTableau[i] = monTableau[i-1] + monTableau[i-2];
}
trace(monTableau); // Affiche : 0,1,1,2,3,5,8,13,21,34

Pour les plus perspicaces, vous aurez vu apparaître les premiers termes de la Suite de Fibonacci qui sont en effet : 0,1,1,2,3,5,8,13,21,34. En augmentant la taille du tableau, vous pourrez ainsi avoir tous les termes de la suite que vous désirez !

Grâce à cet exemple nous commençons à cerner l'intérêt de l'utilisation des tableaux. Effectivement lorsque nous utilisons des boucles par exemple, il devient relativement simple de lier notre variable i de boucle avec les indices du tableau. Ceci avait déjà été dit précédemment mais nous allons le rappeler, les boucles sont extrêmement utiles et performantes pour parcourir des tableaux.

Pour allier tableaux et fonctions, nous allons transformer le code précédent pour créer une fonction renvoyant le énième terme de la suite de Fibonacci. Découvrons cette fonction :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
function suiteFibonacci(terme:int):uint
{
    var monTableau:Vector.<uint> = new Vector.<uint>(terme);
    monTableau[0] = 0;
    monTableau[1] = 1;
    for(var i:int = 2; i < monTableau.length; i++)
    {
        monTableau[i] = monTableau[i-1] + monTableau[i-2];
    }
    return (monTableau[terme-1]);
}
trace(suiteFibonacci(10)); // Affiche : 34
trace(suiteFibonacci(20)); // Affiche : 4181
trace(suiteFibonacci(30)); // Affiche : 514229

Enfin pour finir, vous noterez que les méthodes push(), pop(), shift, unshift() et splice() fonctionnent également avec les tableaux de type Vector.

Les tableaux multidimensionnels

Le concept

Nous allons maintenant découvrir les tableaux multidimensionnels : un nom barbare pourtant c'est une notion qui n'est pas si compliquée que ça ! Les tableaux multidimensionnels ne sont en réalité que des tableaux imbriqués dans d'autres tableaux. Certes c'est une notion qui fait peur aux premiers abords, cependant il n'y a rien de nouveau en matière de code. Pour mieux comprendre, nous allons illustrer tout ça d'un exemple. Nous pourrions créer une liste regroupant l'ensemble des livres de la collection « le Livre du Zéro », il serait alors possible de réaliser cela avec un tableau classique ou monodimensionnel. Imaginons maintenant qu'en plus de stocker le nom des livres, nous souhaitions y ajouter le nom de l'auteur et l'année de sortie. Dans ce cas nous avons besoin d'utiliser un tableau bidimensionnel de la manière suivante :

1
2
3
4
5
var livres:Array = new Array();
livres[0] = ["Réalisez votre site web avec HTML5 et CSS3", "Mathieu Nebra", 2011];
livres[1] = ["Apprenez à programmer en Java", "Cyrille Herby", 2011];
livres[2] = ["Débutez dans la 3D avec Blender", "Antoine Veyrat", 2012];
livres[3] = ["Rédigez des documents de qualité avec LaTeX", "Noël-Arnaud Maguis", 2010];

Sachant que les éléments du tableau principal sont des tableaux, vous obtiendrez donc un tableau en utilisant la notation avec indice vue précédemment :

1
trace(livres[0]); // Affiche : Réalisez votre site web avec HTML5 et CSS3,Mathieu Nebra,2011

Il est bien évidemment possible d'accéder à une valeur à l'intérieur du second tableau. Pour cela nous devrons utiliser une notation à double indice ; c'est ce qui rend le tableau multidimensionnel ! Regardez plutôt ce code :

1
trace(livres[0][0]); // Affiche : Réalisez votre site web avec HTML5 et CSS3

Pour bien comprendre, nous pouvons effectuer une analogie avec un tableau Excel par exemple où le premier indice correspondrait au numéro de la ligne et le second au numéro de la colonne. Pour vos besoins, sachez que vous pouvez réaliser des tableaux de la dimension que vous souhaitez.

Un peu de pratique

Dans cette section, nous allons réaliser plusieurs fonctions pour apprendre à bien manipuler les tableaux. Pour les tests nous reprendrons le tableau précédent :

1
2
3
4
5
var livres:Array = new Array();
livres[0] = ["Réalisez votre site web avec HTML5 et CSS3", "Mathieu Nebra", 2011];
livres[1] = ["Apprenez à programmer en Java", "Cyrille Herby", 2011];
livres[2] = ["Débutez dans la 3D avec Blender", "Antoine Veyrat", 2012];
livres[3] = ["Rédigez des documents de qualité avec LaTeX", "Noël-Arnaud Maguis", 2010];

Pour éviter de surcharger le code de ce cours, nous ne réécririons pas ces lignes avant chaque fonction. À vous de les copier si vous souhaitez réaliser des essais.

Qui est-ce ?

La fonction présentée ci-dessous permet de retrouver l'auteur d'un livre. Pour cela nous réaliserons donc une boucle à l'intérieur de laquelle nous rechercherons le livre spécifié en paramètre. Une fois le livre trouvé, il ne reste plus qu'à retenir l'indice correspondant dans le tableau et de renvoyer le nom de l'auteur. Voici la fonction en question :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
function auteur(monTableau:Array, monLivre:String):String
{
    var i:int = 0;
    var continuer:Boolean = true;
    do
    {
        if(monTableau[i][0] == monLivre)
            continuer = false;
        i++;
    } while(continuer);
    return monTableau[i-1][1]
}
trace(auteur(livres, "Apprenez à programmer en Java")); // Affiche : Cyrille Herby
trace(auteur(livres, "Réalisez votre site web avec HTML5 et CSS3")); // Affiche : Mathieu Nebra

Vous remarquerez que dans cet exemple, nous combinons à la fois : condition, boucle, fonction et tableau. Si vous avez bien compris cet exemple c'est que vous êtes au point sur la première partie et donc fin prêt pour entamer la deuxième ! ;)

Trions par chronologie

Comme cela est dit dans le titre, nous allons dans cette fonction trier le tableau en fonction de l'année de sortie des livres. Pour faire ceci, nous allons devoir créer un nouveau tableau que nous allons remplir au fur et à mesure. Nous prendrons donc chaque livre du premier tableau, puis nous chercherons où l'insérer dans le second. Pour réaliser cela, nous devrons utiliser deux boucles, une pour chaque tableau. Cette fonction est plus complexe que la précédente :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function tri(monTableau:Array):Array
{
    var nouveauTableau:Array = new Array();
    nouveauTableau[0] = monTableau[0];
    for(var i:int = 1; i < monTableau.length; i++)
    {
        var j:int = 0;
        var continuer:Boolean = true;
        while(continuer)
        {
            if(j >= nouveauTableau.length || monTableau[i][2] <= nouveauTableau[j][2])
                continuer = false;
            j++;
        }
        nouveauTableau.splice(j-1, 0, monTableau[i]);
    }
    return nouveauTableau
}
livres = tri(livres);
trace(livres[0]); // Affiche : Rédigez des documents de qualité avec LaTeX,Noël-Arnaud Maguis,2010
trace(livres[1]); // Affiche : Apprenez à programmer en Java,Cyrille Herby,2011
trace(livres[2]); // Affiche : Réalisez votre site web avec HTML5 et CSS3,Mathieu Nebra,2011
trace(livres[3]); // Affiche : Débutez dans la 3D avec Blender,Antoine Veyrat,2012

Prenez le temps de bien comprendre ces deux exemples qui reprennent la quasi-totalité des concepts de la première partie.

Parcourir un tableau

Il existe plusieurs manières de parcourir un tableau, que ce soit un Array ou un Vector. Il faut savoir que certaines sont plus rapides que d'autres, et il faut savoir choisir laquelle utiliser en fonction des possibilités. Nous utiliserons à chaque fois la boucle for que nous avons déjà vue précédemment, néanmoins l'Actionscript en propose quelques « variantes » encore plus efficaces.

La boucle for classique

Comme nous l'avons vu, la boucle for est particulièrement bien adaptée au parcours d'un tableau. Pour rappel, voici un exemple de manipulation de ce type de boucle :

1
2
3
4
5
var monTableau:Array = ["élément n°1", "élément n°2", "élément n°3", "élément n°4"];
for(var i:int = 0; i < monTableau.length; i++)
{
    trace(monTableau[i]);
}

Ce qui affichera :

1
2
3
4
élément n°1
élément n°2
élément n°3
élément n°4

Dans une boucle for classique, nous nous basons donc sur l'indice, ou la position, des différents éléments à l'intérieur du tableau. Pour cela, nous avons alors besoin de connaître la longueur de celui-ci, que nous pouvons d'ailleurs stocker dans une variable :

1
2
3
4
5
6
var monTableau:Array = ["élément n°1", "élément n°2", "élément n°3", "élément n°4"];
var longueur:int = monTableau.length;
for(var i:int = 0; i < longueur; i++)
{
    trace(monTableau[i]);
}

Cependant il est également possible d'utiliser d'autres boucles, où la connaissance de la longueur d'un tableau devient superflue ; j'ai nommé les boucles for...in et for each !

La boucle for…in

La boucle for...in est très proche de la boucle for classique, et s'utilise quasiment de la même manière. Toutefois ici, il n'est pas nécessaire de connaître le nombre d'éléments contenus dans un tableau pour parcourir l'intégralité de ce dernier. Voici un exemple d'utilisation de cette boucle :

1
2
3
4
5
var monTableau:Array = ["élément n°1", "élément n°2", "élément n°3", "élément n°4"];
for(var i:String in monTableau)
{
    trace(monTableau[i]);
}

Ce qui nous affichera comme précédemment :

1
2
3
4
élément n°1
élément n°2
élément n°3
élément n°4

Ainsi vous pouvez considérer que dans une boucle for...in la variable se comporte comme un indice qui s'incrémente automatiquement et qui parcourt l'intégralité du tableau.

Il est fort probable que certains d'entre vous se demandent alors, pourquoi diable, la variable i est-elle de type String et non de type int ?

Pour comprendre cela, nous allons devoir brièvement sortir du cadre de ce chapitre. En réalité la boucle for...in n'est pas propre aux tableaux, mais peut être utilisée pour parcourir d'autres types d'éléments ou objets… Pour cerner le problème par un exemple, nous allons imaginer l'objet ou la variable suivante :

1
var monObjet:Object = {a:"élément A", b:"élément B", c:"élément C"};

Nous avons donc ici une sorte de tableau contenant trois éléments. Néanmoins, ces éléments ne sont pas rangés à l'aide d'un indice, mais plutôt grâce à une étiquette ou propriété et ne sont donc pas disposés suivant un ordre particulier. La seule manière de faire référence à un élément à l'intérieur de cette variable est donc d'utiliser les étiquettes associées à chacun de ces éléments.

L'utilisation de la boucle for...in prend alors tout son sens :

1
2
3
4
for(var i:String in monObjet)
{
    trace(i + ": " + monObjet[i]);
}

Voici le résultat :

1
2
3
a: élément A
b: élément B
c: élément C

Pour utiliser correctement la boucle for...in, vous devez vous rappeler qu'à l'intérieur de celle-ci nous travaillons non pas à l'aide d'un indice numérique mais bien avec une étiquette sous forme de chaîne de caractères. Dans le cas d'un tableau de type Array ou Vector, la variable utilisée représente néanmoins l'indice, mais toujours sous la forme d'une chaîne de caractères de type String !

La boucle for each

La dernière boucle permettant de parcourir un tableau est la boucle for each. Contrairement à ses congénères, la variable utilisée à l'intérieur de celle-ci ne fait pas référence à l'indice, ou l'étiquette, associé aux éléments d'un tableau, mais aux éléments eux-mêmes.

La manipulation des éléments devient alors beaucoup plus simple :

1
2
3
4
5
var monTableau:Array = [12, 42, 10, 3];
for each(var nombre:int in monTableau)
{
    trace(nombre);
}

Comme vous l'imaginez, dans ce cas, le type de la variable devra s'adapter suivant la nature des éléments contenus à l'intérieur du tableau :

1
2
3
4
5
var monTableau:Array = [2.3, 24567673, 42, 3.14, 276.54];
for each(var nombre:Number in monTableau)
{
    trace(nombre);
}

Ou encore :

1
2
3
4
5
var monTableau:Array = ['Hello', 'world', '!'];
for each(var chaine:String in monTableau)
{
    trace(chaine);
}

Notez toutefois qu'en utilisant cette boucle vous perdez la notion de repérage à l'intérieur du tableau, et vous n'êtes alors plus en mesure de relier l'élément au tableau.

Bien évidemment ce qui est faisable avec un tableau de type Array, l'est aussi avec un autre tableau de type Vector :

1
2
3
4
5
var monVecteur:Vector.<String> = Vector.<String>(['Hello', 'world', '!']);
for each(var chaine:String in monVecteur)
{
    trace(chaine);
}

En résumé

  • Grâce aux tableaux, nous pouvons stocker plusieurs valeurs sous un même nom de variable.
  • Les éléments d'un tableau sont accessibles via un indice qui démarre à 0.
  • Les tableaux de type Array ne sont ni fixés, ni typés.
  • Les tableaux de type Vector ne sont pas fixés, mais en revanche ils sont typés.
  • Différentes méthodes permettent de manipuler des tableaux à la fois de Array et de type Vector.
  • On utilise généralement les boucles for, for...in ou for each pour parcourir un tableau.
  • Il est possible de créer des tableaux multidimensionnels en utilisant une notation à double indice.