• 12 heures
  • {0} Facile|{1} Moyenne|{2} Difficile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Mis à jour le 30/04/2014

Les tableaux

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Pour clore cette première partie du cours, nous verrons les tableaux qui sont 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. Ceci peut être handicapant lors du traitement d'une quantité de valeurs importante. 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 et seront 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 tableau utilisé en Actionscript est Array. En Actionscript, les tableaux ne sont pas fixés en taille ce qui permet une programmation plus souple. De plus, 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 qui 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 :

var nomDuTableau:Array = ceQueJeMetsDedans;

En revanche, lorsqu’il s'agit d'initialiser un tableau, nous avons le choix entre diverses méthodes. Voici quatre manières différentes d'initialiser une variable de type Array :

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

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

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 :

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

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 :

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 :

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 :

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,!

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 :

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, ils sont notamment é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 :

var nomDuTableau:Vector.<Type> = ceQueJeMetsDedans;

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

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

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 :

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 :

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

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 :

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, 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, cette notion 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 de quoi il s'agit, nous allons illustrer cette notion par 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 :

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 :

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 ce tableau multidimensionnel !
Regardez plutôt ce code :

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

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 :

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 :

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 annoncé dans le titre, cette fonction va nous permettre de trier le tableau en fonction de l'année de sortie des livres. Pour faire cela, 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 ceci, nous devrons utiliser deux boucles, une pour chaque tableau.
Cette fonction est plus complexe que la précédente :

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 assimiler 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, 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 :

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 :

é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 :

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, 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 :

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 :

é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 mieux cerner le problème, nous allons imaginer l'objet ou la variable suivante :

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 bouclefor...in prend alors tout son sens :

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

Voici le résultat :

a: élément A
b: élément B
c: élément C

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 :

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 :

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

Ou encore :

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

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

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.

Exemple de certificat de réussite
Exemple de certificat de réussite