Array

L'objet global Array est utilisé pour créer des tableaux. Les tableaux sont des objets de haut-niveau (en termes de complexité homme-machine) semblables à des listes.

Syntaxe

[element0, element1, ..., elementN]
new Array(element0, element1[, ...[, elementN]])
new Array(arrayLength)

Paramètres

element0, element1, ..., elementN

Un tableau est initialisé avec les éléments donnés, sauf dans le cas où un argument seul est passé au constructeur Array et que l'argument est un nombre. (Voir ci-après.) Notez que ce cas spécial s'applique aux tableaux créés avec le constructeur Array, pas avec des tableaux créés avec des littéraux qui utilisent les crochets.

arrayLength

Si le seul argument passé au constructeur Array est un entier entre 0 et 2³²-1 (inclus), un nouveau tableau sera créé avec ce nombre d'éléments (note : le tableau sera créé avec des éléments vides, il ne sera pas créé avec autant d'éléments qui valent undefined). Si l'argument est un autre nombre, une exception RangeError sera levée.

Description

Les tableaux JavaScript sont des objets semblables à une liste et possèdent plusieurs méthodes incorporées pour exécuter des opérations de parcours et de modification. Ni la taille d'un tableau ni les types de ses éléments n'est fixé. Puisque la dimension d'un tableau peut augmenter ou diminuer à tout moment, les tableaux ne sont pas garantis d'être compacts. En général, cela permet de couvrir plusieurs cas pratiques. En revanche si cette compacité est nécessaire pour votre cas d'utilisation, vous pourriez envisager d'utiliser les tableaux typés.

Notez que vous ne devriez pas considérer un tableau comme un tableau associatif (en anglais). Vous pouvez utiliser des objets classiques à la place pour obtenir ce comportements (cette approche n'est pas sans inconvénient non plus, mais c'est la plus pertinente). Voir le billet sur les dictionnaires légers en JavaScript avec des clés arbitraires par exemple. Si on utilise des clés qui sont des chaînes de caractères, on aura d'une part les éléments du tableaux (indexés avec des numéros) et d'autre part, un ensemble de propriétés qui ne seront pas utilisées dans les opérations de parcours du tableau.

Accéder aux éléments d'un tableau

Les tableaux sont indicés à partir de zéro ; le premier élément d'un tableau a 0 pour indice, et la position du dernier élément est donnée par length moins 1.

var arr = ["le premier élément", "le second élément"];  
console.log(arr[0]);             // affiche "le premier élément"    
console.log(arr[1]);             // affiche "le second élément"  
console.log(arr[arr.length - 1]);// affiche "le second élément"

Les éléments d'un tableau sont simplement des propriétés d'objets. Cependant, le code suivant renverra une erreur car le nom de la propriété utilise est invalide :

console.log(arr.0); // erreur de syntaxe

Ce comportement est tout à fait normal. En effet, il n'est pas possible d'accéder aux propriétés dont le nom commence par un chiffre avec cette notation (le point). Il est nécessaire d'utiliser la syntaxe avec les crochets pour accéder à ces propriétés. Ainsi, si pour un objet quelconque, on avait une propriété nommée '3d', on ne pourra y faire référence qu'en utilisant les crochets. Ainsi :

var années = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
// erreur de syntaxe
console.log(années.0);

// fonctionne correctement
console.log(années[0]);

renderer.3d.setTexture(model, "personnage.png");   // erreur de syntaxe
renderer["3d"].setTexture(model, "personnage.png");// fonctionne correctement 

Dans cet exemple, on utilise des doubles quotes autour de 3d. On peut aussi utiliser les doubles quotes pour accéder aux éléments d'un tableau (ex. : années["2"] au lieu de années[2]), mais ce n'est pas obligatoire. Dans l'instruction années[2], le nombre sera converti en une chaîne de caractères par le moteur JavaScript. Pour cette raison, si on utilise les noms de propriété "2" et "02", on fera référence à deux propriétés différentes, le fragment de code suivant renvoie donc true:

console.log(années["2"] != années["02"]); 

De façon semblable, les propriétés nommées avec des mots-clés réservés ne peuvent être consultées qu'en utilisant la syntaxe avec crochets :

var promise = {
  'var' : 'text',
  'array': [1, 2, 3, 4]
};

console.log(promise['var']);

Relation entre length et les propriétés numériques

La propriété length d'un tableau est liée aux propriétés numériques du tableau. Lorsqu'elles sont utilisées, plusieurs méthodes natives utilisent cette propriété : join, slice, indexOf, etc. D'autres méthodes comme push et splice modifient le tableau et la propriété length.

var fruits = [];  
fruits.push("banane", "pomme", "pêche");  
      
console.log(fruits.length); // 3

Lorsqu'on définit une nouvelle propriété numérique pour un tableau, que l'index utilisé est valide et que celui-ci est dehors des limites actuelles du tableau, le moteur JavaScript mettra à jour la propriété length :

fruits[5] = "mangue";  
console.log(fruits[5]);  // "mangue"
console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] 
console.log(fruits.length); // 6 

On peut également modifier la propriété directement (cela n'ajoutera pas de nouveaux éléments) :

fruits.length = 10;  
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']         
console.log(fruits.length);  // 10

En revanche, si on diminue la valeur de length, cela supprimera des éléments :

fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2

Pour plus d'informations sur le comportement de cette propriété, voir la page Array.length.

Création d'un tableau utilisant le résultat d'une correspondance

Le résultat d'une correspondance entre une expression rationnelle et une chaîne peut créer un tableau. Ce tableau possède des propriétés et des éléments qui fournissent des informations sur cette correspondance. Il est possible d'obtenir un tableau grâce aux méthodes RegExp.prototype.exec, String.match, and String.replace. Pour mieux comprendre le fonctionnement de ces propriétés et de ces éléments, on pourra utiliser l'exemple et le tableau qui suivent :

var maRegexp = /d(b+)(d)/i;
var monTableau = maRegexp.exec("cdbBdbsbz");

Les propriétés et les éléments retournés depuis cette correspondance sont les suivants :

Propriétés

Array.length

La propriété de longueur pour le constructeur Array, elle vaut 1.

get Array[@@species]

La fonction de construction utilisée pour créer les objets dérivés.

Array.prototype

Cette propriété permet d'ajouter des propriétés à tous les tableaux.

Méthodes

Array.from()

Cette méthode permet de créer une nouvelle instance d'Array à partir d'un objet semblable à un tableau ou d'un itérable.

Array.isArray()

Cette méthode renvoie true si la variable est un tableau, false sinon.

Array.of()

Cette mtéhode permet de créer une nouvelle instance d'Array à partir d'un nombre variable d'arguments (peu importe la quantité ou le type des arguments utilsés).

Instances d'Array

Toutes les instances d'Array héritent de Array.prototype. Le prototype du constructeur Array peut être modifié afin d'affecter l'ensemble des instances grâce à l'héritage.

Les propriétés

Les méthodes

Les mutateurs

Les accesseurs

Les méthodes d'itération

Les méthodes génériques de manipulation de tableaux

Parfois, on peut vouloir appliquer des méthodes pour les tableaux sur des chaînes ou d'autres objets semblables aux tableaux (ex. : l'objet arguments). Une chaîne sera donc traitée comme un tableau de caractères. Ainsi, si on souhaite vérifier que chaque caractère d'une chaîne str est bien une lettre comprise entre 'a' et 'z', on pourra utiliser :

function estUneLettre(caractère) {
  return caractère >= 'a' && caractère <= 'z';
}

if (Array.prototype.every.call(str, estUneLettre)) {
  console.log("La chaîne '" + str + "' ne contient que des lettres entre a et z!");
}

Cette notation étant plutôt verbeuse, une notation raccourcie a été introduite avec JavaScript 1.6 :

if (Array.every(str,estUneLettre)) {
  console.log("La chaîne '" + str + "' ne contient que des lettres entre a et z !");
}

Des méthodes génériques sont également disponibles pour les String.

Cette fonctionnalité ne fait pas partie du standard ECMAScript et n'est pas prise en charge par les navigateurs qui sont basés sur Gecko. Pour disposer d'une méthode standard alternative, on peut en revanche convertir la valeur dans un vrai tableau grâce à la méthode Array.from() (attention, celle-ci peut être absente des anciens navigateurs) :

if (Array.from(str).every(estUneLettre)) {
  console.log("La chaîne '" + str + "' contient uniquement des lettres !");
}

Exemples

Créer un tableau

Dans l'exemple suivant, on crée un tableau tableauMsg, d'une longueur nulle. Ensuite, on lui affecte des valeurs pour tableauMsg[0] et tableauMsg[99], ce qui aura pour effet de modifier la propriété length (qui vaudra alors 100).

var tableauMsg = [];
tableauMsg[0] = 'Coucou';
tableauMsg[99] = 'monde';

if (tableauMsg.length === 100) {
  console.log('La longueur du tableau vaut 100.');
}

Créer un tableau à deux dimensions

Dans l'exemple qui suit, on crée un plateau d'échec grâce à un tableau de chaînes de caractères sur deux dimensions. Le premier mouvement est effectué en copiant 'p' de (6,4) vers (4,4). La position anciennement occupée par le pion (6,4) devient vide.

var plateau = [ 
  ['T','C','F','R','K','F','C','T'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['t','c','f','k','r','f','c','t'] ];

console.log(plateau.join('\n') + '\n\n');

// On déplace le pion de deux cases en avant 2
plateau[4][4] = plateau[6][4];
plateau[6][4] = ' ';
console.log(plateau.join('\n'));

Voici le résultat affiché :

T,C,F,R,K,F,C,T
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
p,p,p,p,p,p,p,p
t,c,f,k,r,f,c,t

T,C,F,R,K,F,C,T
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , ,p, , , 
 , , , , , , , 
p,p,p,p, ,p,p,p
t,c,f,k,r,f,c,t

Spécifications

Compatibilité des navigateurs

Voir aussi

• Guide JavaScript : indexer les propriétés d'un objet
• Guide JavaScript : Les objets natifs : l'objet Array
• Les compréhensions de tableau
• Émulation pour les méthodes génériques et autres fonctionnalités ECMAScript 5 pour les tableaux (en anglais)
• Les tableaux typés