Array : méthode findLast() - JavaScript | MDN

Basculer la barre latérale

Thème

Automatique
Clair
Sombre

Français

Se souvenir de la langue En savoir plus

Array : méthode findLast()

Baseline Large disponibilité

Cette fonctionnalité est bien établie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis août 2022.

La méthode findLast() des instances de Array parcourt le tableau en ordre inverse et retourne la valeur du premier élément qui satisfait la fonction de test fournie. Si aucun élément ne satisfait la fonction de test, undefined est retourné.

Si vous souhaitez :

le premier élément correspondant, utilisez find().
l'indice du dernier élément correspondant dans le tableau, utilisez findLastIndex().
l'indice d'une valeur, utilisez indexOf(). (Cette méthode est semblable à findIndex(), mais compare chaque élément à la valeur indiquée au lieu d'utiliser une fonction de test.)
savoir si une valeur existe dans un tableau, utilisez includes(). Là encore, chaque élément est comparé à la valeur indiquée au lieu d'utiliser une fonction de test.
savoir si un élément satisfait la fonction de test fournie, utilisez some().

Dans cet article

Exemple interactif

const array = [5, 12, 50, 130, 44];

const found = array.findLast((element) => element > 45);

console.log(found);
// Résultat attendu : 130

Syntaxe

js
findLast(callbackFn)
findLast(callbackFn, thisArg)

Paramètres

callbackFn

La fonction à exécuter pour chaque élément du tableau. Elle doit renvoyer une valeur équivalente à true pour indiquer qu'un élément correspondant a été trouvé, et une valeur équivalente à false sinon. La fonction est appelée avec les arguments suivants :

element

La valeur de l'élément courant du tableau en cours de traitement.

index

L'indice de l'élément courant du tableau en cours de traitement.

array

Le tableau sur lequel la méthode findLast() a été appelée.

thisArg Facultatif

La valeur à utiliser comme this lors de l'exécution de callbackFn. Voir les méthodes itératives.

Valeur de retour

Le dernier élément du tableau (celui avec l'indice le plus élevé) qui satisfait la fonction de test fournie ; undefined si aucun élément correspondant n'est trouvé.

Description

La méthode findLast() est une méthode itérative. Elle appelle la fonction fournie callbackFn une fois pour chaque élément d'un tableau dans l'ordre décroissant des indices, jusqu'à ce que callbackFn retourne une valeur vrai. findLast() retourne alors cet élément et arrête l'itération du tableau. Si callbackFn ne retourne jamais de valeur vrai, findLast() retourne undefined. Lisez la section méthodes itératives pour plus d'informations sur le fonctionnement général de ces méthodes.

callbackFn est appelée pour chaque indice du tableau, pas seulement ceux ayant une valeur affectée. Les emplacements vides des tableaux creux se comportent comme undefined.

La méthode findLast() est générique. Elle attend uniquement que la valeur this possède une propriété length et des propriétés à clés entières.

Exemples

Trouver le dernier objet d'un tableau dont la propriété correspond

Dans cet exemple, on illustre comment créer un test manipulant les propriétés des éléments du tableau.

js
const inventaire = [
  { nom: "pommes", quantite: 2 },
  { nom: "bananes", quantite: 0 },
  { nom: "poissons", quantite: 1 },
  { nom: "cerises", quantite: 5 },
];

// Renvoie true si le stock est faible
function pasSuffisant(item) {
  return item.quantite < 2;
}

console.log(inventaire.findLast(pasSuffisant));
// { nom: "poissons", quantite: 1 }

En utilisant les fonctions fléchées et la décomposition

L'exemple précédent peut être écrit à l'aide d'une fonction fléchée et une décomposition d'objet :

js
const inventaire = [
  { nom: "pommes", quantite: 2 },
  { nom: "bananes", quantite: 0 },
  { nom: "poissons", quantite: 1 },
  { nom: "cerises", quantite: 5 },
];

const resultat = inventaire.findLast(({ quantite }) => quantite < 2);

console.log(resultat);
// { name: "poissons", quantite: 1 }

Trouver le dernier nombre premier d'un tableau

Dans l'exemple suivant, on trouve le dernier élément du tableau qui est un nombre premier (ou on renvoie undefined si le tableau ne contient pas de nombre premier) :

js
function estPremier(n) {
  if (n < 2) {
    return false;
  }
  if (n % 2 === 0) {
    return n === 2;
  }
  for (let diviseur = 3; diviseur * diviseur <= n; diviseur += 2) {
    if (n % diviseur === 0) {
      return false;
    }
  }
  return true;
}

console.log([4, 6, 8, 12].findLast(estPremier)); // undefined, aucun trouvé
console.log([4, 5, 7, 8, 9, 11, 12].findLast(estPremier)); // 11

Note : L'implémentation de estPremier() est uniquement à des fins de démonstration. Pour une application réelle, il est préférable d'utiliser un algorithme fortement mémoïsé comme le crible d'Ératosthène afin d'éviter les calculs répétés.

Trouver la tâche la plus récemment terminée

Cet exemple illustre un cas d'utilisation pratique de findLast() lorsqu'on travaille avec des données ordonnées par le temps. Il trouve la tâche la plus récemment terminée dans une liste déjà triée par timestamp.

js
const tasks = [
  {
    name: "Configuration du projet",
    completed: true,
    timestamp: 1609459200000,
  },
  { name: "Écrire des tests", completed: false, timestamp: 1609545600000 },
  { name: "Corriger le bug #42", completed: true, timestamp: 1609632000000 },
  {
    name: "Déployer en pré-production",
    completed: true,
    timestamp: 1609718400000,
  },
  { name: "Revoir la PR", completed: false, timestamp: 1609804800000 },
];

const lastCompletedTask = tasks.findLast((task) => task.completed);

console.log(lastCompletedTask.name); // Déployer en pré-production

Ceci est plus efficace que d'utiliser find() avec un tableau inversé, car cela évite de créer un nouveau tableau.

Utiliser le troisième argument de callbackFn

L'argument array est utile si vous souhaitez accéder à un autre élément du tableau, en particulier lorsque vous n'avez pas de variable existante qui fait référence au tableau. L'exemple suivant utilise d'abord filter() pour extraire les valeurs positives puis utilise findLast() pour trouver le dernier élément qui est inférieur à ses voisins.

js
const nombres = [3, -1, 1, 4, 1, 5, 9, 2, 6];
const dernierCreux = nombres
  .filter((num) => num > 0)
  .findLast((num, idx, arr) => {
    // Sans l'argument arr, il n'y a pas de moyen simple d'accéder
    // au tableau intermédiaire sans le stocker dans une variable.
    if (idx > 0 && num >= arr[idx - 1]) return false;
    if (idx < arr.length - 1 && num >= arr[idx + 1]) return false;
    return true;
  });
console.log(dernierCreux); // 2

Utiliser findLast() sur des tableaux creux

Les emplacements vides d'un tableau sont parcourus. Ils sont traités comme s'ils avaient la valeur undefined.

js
// On déclare un tableau sans élément pour les indices 2, 3, et 4
const tableau = [0, 1, , , , 5, 6];

// Le parcourt suivant montre tous les indices et pas uniquement
// ceux avec des valeurs affectées
tableau.findLast((valeur, index) => {
  console.log(`Parcours de l'index ${index} avec la valeur ${valeur}`);
});
// Parcours de l'index 6 avec la valeur 6
// Parcours de l'index 5 avec la valeur 5
// Parcours de l'index 4 avec la valeur undefined
// Parcours de l'index 3 avec la valeur undefined
// Parcours de l'index 2 avec la valeur undefined
// Parcours de l'index 1 avec la valeur 1
// Parcours de l'index 0 avec la valeur 0

// Tous les indices sont affichés, y compris ceux qui sont
// supprimés
tableau.findLast((value, index) => {
  // On supprime l'élément 5 à la première itération
  if (index === 6) {
    console.log(`Suppression de array[5] avec la valeur ${tableau[5]}`);
    delete tableau[5];
  }
  // L'élément 5 est toujours parcouru, même supprimé
  console.log(`Parcours de l'index ${index} avec la valeur ${value}`);
});
// Suppression de array[5] avec la valeur 5
// Parcours de l'index 6 avec la valeur 6
// Parcours de l'index 5 avec la valeur undefined
// Parcours de l'index 4 avec la valeur undefined
// Parcours de l'index 3 avec la valeur undefined
// Parcours de l'index 2 avec la valeur undefined
// Parcours de l'index 1 avec la valeur 1
// Parcours de l'index 0 avec la valeur 0

Appeler findLast() sur des objets qui ne sont pas des tableaux

La méthode findLast() lit la propriété length de this puis parcourt les propriétés dont les clés sont des nombres entiers.

js
const semblableTableau = {
  length: 3,
  0: 2,
  1: 7.3,
  2: 4,
  3: 3, // ignoré par findLast() car length vaut 3
};
console.log(
  Array.prototype.findLast.call(semblableTableau, (x) => Number.isInteger(x)),
); // 4

Guide des collections indexées
L'objet global Array
La méthode Array.prototype.find()
La méthode Array.prototype.findIndex()
La méthode Array.prototype.findLastIndex()
La méthode Array.prototype.includes()
La méthode Array.prototype.filter()
La méthode Array.prototype.every()
La méthode Array.prototype.some()
La méthode TypedArray.prototype.findLast()
Prothèse d'émulation pour Array.prototype.findLast dans la bibliothèque core-js (angl.)
Prothèse d'émulation es-shims pour Array.prototype.findLast (angl.)

Aider à améliorer MDN

Cette page vous a-t-elle été utile ?

Oui Non

Apprendre à contribuer

Cette page a été modifiée le 27 mars 2026 par les contributeur·ice·s du MDN.

Voir cette page sur GitHub • Signaler un problème avec ce contenu

Objets natifs standards
Array
Constructeur
1. Array()
Méthodes statiques
Propriétés statiques
1. [Symbol.species]
Méthodes d'instance
Propriétés d'instance
1. length
2. [Symbol.unscopables]
Héritage
Object/Function
Méthodes statiques
Propriétés statiques
Méthodes d'instance
Propriétés d'instance
1. Object.prototype.__proto__
2. Object.prototype.constructor