Eh bien je crois qu'on a tout vu... sauf l'essentiel
.
On sait accéder à un élément particulier, et on sait comment connaître la longueur de notre tableau...
Il ne nous reste plus qu'à accéder à
tous les éléments de notre tableau, un par un !
Lire un tableau
Commençons par le plus simple : que peut-on faire en parcourant un tableau ? Tout d'abord, le lire !
On va donc créer une fonction, qui prend en argument un tableau, et qui va nous "lire" le tableau dans une chaîne de caractères.
On va devoir parcourir tout notre tableau...
Mais comment faire ?
On doit en fait répéter une action sur chacun des éléments du tableau. On va donc utiliser... une
boucle.
Boucle "for" classique
Il est facile de parcourir un tableau numéroté à l'aide d'une boucle
for : en effet, on veut accéder à tous les
tableau[i], avec
i allant de
0 à
tableau.length -1 (ce qui nous fait bien nos
tableau.length éléments).
Voici donc une fonction qui retourne, sous forme de chaîne de caractères, le contenu du tableau :
Code : JavaScript1
2
3
4
5
6
7 | function lire1(tab)
{
var chaine = "Le tableau contient :"
for(var i=0; i<tab.length; i++)
chaine += "\n" + i + " -> " + tab[i];
return chaine;
}
|
Dans la pratique, on utilise généralement des boucles comme celle-ci (au moins, on est sûrs de n'avoir aucun problème de compatibilité, et c'est (souvent) aussi bien que la boucle que je vais vous présenter).
Une boucle "for" spéciale...
La boucle précédente est parfaite pour des tableaux numérotés, mais si vous avez fait l'essai avec un tableau associatif, vous avez pu vous rendre compte que ça n'affiche rien
.
Rassurez-vous, il existe une variante de la boucle
for qui nous permet de parcourir un tel tableau
.
La syntaxe de la boucle est la suivante :
Code : JavaScript1 | for(var indice in tableau)
|
Cette boucle va parcourir un par un tous les indices du tableau. Et une fois qu'on a les indices, on a les valeurs qui vont avec
.
De plus, si on laisse des cases vides (dans le cas d'un tableau numéroté), elle ne seront pas parcourues par cette boucle.
Voici donc une nouvelle fonction pour lire un tableau :
Code : JavaScript1
2
3
4
5
6
7 | function lire2(tab)
{
var chaine = "Le tableau contient :";
for(var indice in tab)
chaine += "\n" + indice + " -> " + tab[indice];
return chaine;
}
|
Au risque de me répéter, on utilise le plus souvent des tableaux numérotés.
Il est donc inutile d'utiliser cette boucle dans ce cas-là.
Exploiter un tableau
Maintenant que vous savez lire un tableau, vous n'aurez pas de mal à le parcourir pour y effectuer les opérations que vous voulez (comme mettre toutes les cases à zéro).
Parcours d'un tableau classique
La structure est exactement la même : on utilise une boucle
for (version 1 de préférence
) pour parcourir toute les cases du tableau, et on y fait ce que l'on veut.
Un petit exemple ?
On va créer une fonction qui calcule la moyenne d'un tableau contenant des nombres (et aucune case vide).
La moyenne de plusieurs nombres, c'est (la somme de ces nombres) divisée par (le nombre de nombres).
Avec deux nombres x et y, c'est donc (x+y) / 2.
Code : JavaScript1
2
3
4
5
6
7
8 | function moyenne(tableau)
{
var n = tableau.length; // nombre de valeurs
var somme = 0;
for(i=0; i<n; i++)
somme += tableau[i];
return somme/n; // somme divisee par le nombre de valeurs
}
|
Tableau à plusieurs dimensions
Maintenant, attaquons-nous à un peu plus dur (rassurez-vous, c'est aussi moins courant d'y avoir affaire)...
Il est possible de créer des tableaux à plusieurs dimensions
.
Un tableau à 2 dimensions : ce n'est en fait rien d'autre... qu'un tableau de tableaux !
Avec 3 dimensions, on se retrouve avec un tableau de (tableaux de tableaux)
.
Pour y voir plus clair : prenons l'exemple d'une grille de sudoku (une grille de 9 x 9 cases).
Ça illustre parfaitement un tableau à deux dimensions. Chaque ligne est un tableau de 9 cellules (en vert), et la grille elle-même est un tableau de lignes (en bleu).
Représentation sous forme de tableau d'une grille de sudoku.
En vert : tableau représentant une ligne.
En bleu : tableau contenant les lignes.
Pour accéder à la case (
1,
5) du schéma (ligne 1, colonne 5), c'est en fait très facile :
- on accède au tableau qui contient la ligne 1 avec grille[1] (c'est le tableau vert, qui est dans la case n°1 du tableau bleu)
- à l'intérieur de ce tableau (le vert, dont on vient de parler), on va accéder à la case n° 5 : grille[1][5].
La case (
1,
5) de notre grille est donc
grille[1][5].
Pour créer un tel tableau, on commence par créer celui qui va contenir les lignes (en bleu sur le schéma).
Ensuite, pour chaque ligne (dans chaque case de ce tableau), on crée un nouveau tableau (en vert).
Pour terminer, dans chaque ligne, on parcourt toutes les cellules pour leur mettre la valeur
0.
Code : JavaScript 1
2
3
4
5
6
7
8
9
10
11
12 | // on cree le tableau bleu, contenant les lignes
var grille = new Array();
// on cree les lignes (tableau vert) les unes après les autres
for(var i=0; i<9; i++)
grille[i] = new Array();
// on parcourt les lignes...
for(var i=0; i<9; i++)
// ... et dans chaque ligne, on parcourt les cellules
for(var j=0; j<9; j++)
grille[i][j] = 0;
|
Finalement, vous voyez, ça peut parfois servir, un tableau à deux dimensions
.
Mais je ne détaillerai pas plus le cas de tableaux à 3 ou 4 dimensions : si jamais un jour vous avez besoin d'en utiliser, prévenez-nous
(avec ça, je suis tranquille, la boîte à MP a encore de beaux jours devant elle
).
Les tableaux
)
), voici... euh... pour l'instant, appelons ça une fonction... qui permet de trier un tableau (par ordre croissant) grâce à monTableau.sort() (to sort signifie trier en anglais).
mbinette
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+