Méthodes de tableau JavaScript

En JavaScript, il existe une grande variété de méthodes de tableau. Pour vous donner une information plus détaillée et plus complète, nous allons les diviser en groupes.

Méthodes d'ajout/suppression

Dans le chapitre Tableaux, nous avons déjà parlé de ce groupe de méthodes. Parmi celles-ci :

  • arr.push(...items) - aide à ajouter des éléments à la fin ;
  • arr.pop() - extrait un élément de la fin ;
  • arr.shift() - extrait un élément du début ;
  • arr.unshift(...items) - ajoute des éléments au début.

Dans ce chapitre, nous parlerons de plusieurs autres méthodes.

Epissure

La première méthode est la arr.splice. Elle est utilisée pour ajouter ou supprimer des éléments dans/du tableau, ainsi que pour retourner ceux qui ont déjà été supprimés. Ainsi, avec cette méthode, vous pouvez faire n'importe quoi : insérer, supprimer, remplacer des éléments.

La syntaxe ressemble à ceci :

arr.splice(index[, deleteCount, elem1, ..., elemN])

Il est plus facile de comprendre par l'exemple.

Dans le premier exemple, la suppression est démontrée comme suit :

javascript array splice
let arr = ["Welcome", "to", "W3Docs"]; arr.splice(1, 1); // from index 1 remove 1 element console.log(arr); // ["Welcome", "W3docs"]

Dans l'exemple suivant, nous allons supprimer trois éléments et les remplacer par deux autres :

javascript array splice javascript array splice
let arr = ["Welcome", "to", "W3Docs", "Javascript", "book"]; // remove 3 first elements and replace them with another arr.splice(0, 3, "Starts", "read"); console.log(arr) // now ["Starts", "read", "Javascript", "book"]

Maintenant, vous pouvez remarquer que splice retourne le tableau des éléments supprimés, comme suit :

javascript array splice
let arr = ["Welcome", "to", "W3Docs", "Javascript", "book"]; // remove 2 first elements let removed = arr.splice(0, 2); console.log(removed); // "Welcome", "to" <-- array of removed elements

Il est essentiel de savoir qu'avec cette méthode, vous pouvez également insérer des éléments sans aucune suppression. Pour cela, il est nécessaire de définir deleteCount à 0 , comme ceci :

javascript array splice
let arr = ["Welcome", "to", "W3Docs"]; // from index 2, delete 0 // then insert "Javascript" and "book" arr.splice(4, 0, "Javascript", "book"); console.log(arr); // "Welcome", "to", " W3Docs", "Javascript", "book"

Tranche

arr.slice est une méthode simple, beaucoup plus simple que arr.splice.

Sa syntaxe est la suivante :

arr.slice([start], [end])

Cette méthode renvoie un nouveau tableau en copiant tous les éléments de l'index start à end (mais elle ne comprend pas la fin). Si les deux start et end sont une position négative du tableau, la fin sera supposée.

C'est beaucoup comme la méthode end, mais elle crée des sous-tableaux au lieu de sous-chaînes.

Voici un exemple :

Javascript slice method, make subarray javascript
let arr = ["W", "3", "D", "o", "c", "s"]; console.log(arr.slice(1, 3)); // 3,D (copy from 1 to 3) console.log(arr.slice(-2)); // c,s (copy from -2 till the end)

Vous pouvez l'appeler sans argument : str.slice créera une copie de arr.

Concaténation

La méthode arr.concat est utilisée pour créer un nouveau tableau, incluant des valeurs provenant d'autres tableaux, ainsi que des éléments supplémentaires. La syntaxe ressemblera à ceci :

arr.concat(arg1, arg2...)

Elle acceptera des arguments en toute quantité (tableaux ou valeurs).

Le résultat sera un nouveau tableau avec les éléments de arr, puis arg1, arg2, et plus encore.

Si un argument argN représente un tableau, tous ses éléments seront copiés. Dans d'autres cas, l'argument sera copié.

Par exemple :

Javascript concat method, create a new array javascript
let arr = ["a", "b"]; // create an array from: arr and ["c", "d"] console.log(arr.concat(["c", "d"])); // a,b,c,d // create an array from: arr and ["c", "d"] and [e,f] console.log(arr.concat(["c", "d"], ["e", "f"])); // a,b,c,d,e,f // create an array from: arr and ["c", "d"], then add values e and f console.log(arr.concat(["c", "d"], "e", "f")); // a,b,c,d,e,f

Itération : forEach

La méthode arr.forEach permet d'exécuter une fonction pour chaque élément du tableau.

Voici la syntaxe :

arr.forEach(function (item, index, array) {
  // ... do something with item
});

Dans l'exemple suivant, chaque élément du tableau est affiché :

// for each element call alert
["dog", "cat", "mouse"].forEach(alert);

Recherche dans le tableau

Dans cette partie, nous aborderons les méthodes de recherche dans un tableau.

javascript épissure de tableau

indexOf/lastIndexOf et includes

Ces méthodes ont la même syntaxe que leurs homologues de chaîne. La différence est qu'elles opèrent sur des éléments, et non sur des caractères.

Ce qu'elles font :

  • arr.indexOf(item, from) recherche un item à partir de l'index from et le renvoie à l'endroit où il a été trouvé, sinon -1.
  • arr.lastIndexOf(item, from) est similaire, mais cherche de droite à gauche.
  • arr.includes(item, from) recherche un item, en commençant par l'index from, et renvoie true, s'il a été trouvé.

Voyons l'exemple suivant :

Javascript indexOf, includes, last index arrays
let arr = [1, 0, false]; console.log(arr.indexOf(0)); // 1 console.log(arr.indexOf(false)); // 2 console.log(arr.indexOf(null)); // -1 console.log(arr.includes(1)); // true

Prenez en compte que ces méthodes utilisent la comparaison ===. Ainsi, lorsque vous cherchez false, elle trouvera false et non zéro.

Trouver et TrouverIndex

Supposons que vous ayez un tableau d'objets et que vous vouliez trouver un objet répondant à une condition spécifique. Alors, vous devez utiliser la méthode arr.find(fn) en utilisant cette syntaxe :

let result = arr.find(function (item, index, array) {
  // if true is returned,the item is returned, and iteration is stopped
  // for falsy scenario returns undefined
});

La fonction sera appelée pour les éléments du tableau, l'un après l'autre, comme ceci :

  • Un item est un élément.
  • L'index sera son index.
  • Le array sera le tableau lui-même.

En cas de retour de true, la recherche sera stoppée, et l'item retourné.

Par exemple :

Javascript find index in array
let animals = [{ id: 1, name: "dog" }, { id: 2, name: "cat" }, { id: 3, name: "mouse" } ]; let animal = animals.find(item => item.id == 1); console.log(animal.name); // dog

Filtre

Cette méthode recherche le premier élément qui fait renvoyer la fonction true.

S'il y a de nombreux éléments, vous pouvez utiliser la méthode arr.filter(fn). Sa syntaxe ressemble à celle de find, mais filter renverra un tableau avec tous les éléments correspondants :

let results = arr.filter(function (item, index, array) {
  // if true item is pushed to results and the iteration continues
  // returns empty array if nothing found
});

Voici un exemple :

Javascript filter method
let animals = [{ id: 1, name: "dog" }, { id: 2, name: "cat" }, { id: 3, name: "mouse" } ]; // returns array of the first two animals let someAnimals = animals.filter(item => item.id < 3); console.log(someAnimals.length); // 2

Transformation d'un tableau

Dans cette partie, nous aborderons les méthodes ciblant la transformation et le réarrangement d'un tableau.

carte

Cette méthode est l'une des plus utiles et des plus fréquemment utilisées. Voici la syntaxe :

let result = arr.map(function (item, index, array) {
  // returns the new value instead of item
});

Dans cet exemple, chaque élément est transformé en sa longueur :

Javascript map method
let lengths = ["dog", "cat", "mouse"].map(item => item.length); console.log(lengths); // 3,3,5

sort(fn)

Cette méthode est utilisée pour trier le tableau sur place, en changeant l'ordre des éléments.

Jetons un coup d'œil à l'exemple suivant :

Javascript sort method
let arr = [1, 3, 25]; // the method reorders the content of arr arr.sort(); console.log(arr); // 1, 25, 3

Vous trouverez quelque chose de assez étrange dans le résultat. L'ordre ressemblait à 1, 25, 3

La raison est que les éléments sont triés comme des chaînes.

Tous les éléments sont convertis en chaînes pour les comparaisons. L'ordre lexicographique est utilisé pour les chaînes ( "3" > "25").

Pour utiliser votre ordre de tri, vous devez fournir une fonction comme argument de arr.sort().

Voici un exemple :

Javascript sort method
function compareNumeric(a, b) { if (a > b) return 1; if (a == b) return 0; if (a < b) return -1; } let arr = [1, 3, 25]; arr.sort(compareNumeric); console.log(arr); // 1, 3, 25

inverse

Cette méthode vise à inverser l'ordre des éléments dans arr.

Par exemple :

Javascript reverse method
let arr = ["a", "b", "c", "d", "e"]; arr.reverse(); console.log(arr); // e,d,c,b,a

Elle peut aussi retourner le tableau arr après l'avoir inversé.

split et join

La méthode str.split(delim) est utilisée pour diviser la chaîne en un tableau par un délimiteur particulier delim.

Dans l'exemple suivant, elle est divisée par une virgule suivie d'un espace :

Javascript split method
let animals = 'dog, cat, mouse'; let arr = animals.split(', '); for (let animal of arr) { console.log(`A message to ${animal}.`); // A message to dog (and other names) }

En passant, cette méthode a un argument numérique alternatif qui est une limite sur la longueur d'un tableau. Si elle est fournie, les éléments supplémentaires seront ignorés. De toute façon, les développeurs ne l'utilisent pas souvent.

L'exemple ressemblera à ceci :

Javascript split method
let arr = 'dog, cat, mouse, lion'.split(', ', 2); console.log(arr); // dog, cat

Si vous voulez inverser le split, appelez arr.join(glue). Il créera une chaîne d'éléments arr avec glue entre eux. Voici un exemple :

Javascript join method
let animalsArr = ['dog', 'cat', 'mouse']; let str = animalsArr.join(';'); // glue the array into a string using ; console.log(str); // dog;cat;mouse

réduire/réduireRight

Pour itérer sur un tableau, vous pouvez utiliser forEach, for, ou for..of.

Si vous souhaitez itérer et renvoyer les données pour chaque élément, le map peut être utilisé.

Les méthodes arr.reduce et arr.reduceRight font des actions similaires mais sont un peu plus complexes. Vous pouvez l'utiliser pour calculer une valeur basée sur le tableau.

La syntaxe est la suivante :

let value = arr.reduce(function (accumulator, item, index, array) {
  // ...
}, [initial]);

Les arguments sont :

  • l'accumulateur représente le résultat de l'appel de la fonction précédente, égal à initial la première fois ;
  • l'item peut être décrit comme l'élément du tableau courant.
  • l'index est sa position.
  • le array est le tableau.

Dans cet exemple, vous pouvez trouver une somme d'un tableau en une seule ligne :

Javascript reduce method
let sumArr = [1, 2, 3, 4, 5]; let result = sumArr.reduce((sum, current) => sum + current, 0); console.log(result); // 15

Array.isArray

Les tableaux sont basés sur des objets.

Par conséquent, le typeof ne vous permettra pas de distinguer un objet ordinaire d'un tableau :

Javascript typeof method
console.log(typeof {}); // object console.log(typeof []); // same

Mais les développeurs utilisent tellement les tableaux qu'il existe une méthode spéciale pour le faire : Array.isArray(value). Elle renvoie true si la valeur est un tableau et false sinon.

L'exemple est le suivant :

Javascript isArray method
console.log(Array.isArray({})); // false console.log(Array.isArray([])); // true

Heure du Quiz : Testez Vos Compétences!

Prêt à relever le défi de ce que vous avez appris ? Plongez dans nos quiz interactifs pour approfondir votre compréhension et renforcer vos connaissances de manière ludique.

Trouvez-vous cela utile?