Array.prototype.findLast()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since August 2022.
ThefindLast() method ofArray instances iterates the array in reverse order and returns the value of the first element that satisfies the provided testing function.If no elements satisfy the testing function,undefined is returned.
If you need to find:
- thefirst element that matches, use
find(). - theindex of the last matching element in the array, use
findLastIndex(). - theindex of a value, use
indexOf().(It's similar tofindIndex(), but checks each element for equality with the value instead of using a testing function.) - whether a valueexists in an array, use
includes().Again, it checks each element for equality with the value instead of using a testing function. - if any element satisfies the provided testing function, use
some().
Try it
const array = [5, 12, 50, 130, 44];const found = array.findLast((element) => element > 45);console.log(found);// Expected output: 130Syntax
findLast(callbackFn)findLast(callbackFn, thisArg)Parameters
callbackFnA function to execute for each element in the array. It should return atruthy value to indicate a matching element has been found, and afalsy value otherwise. The function is called with the following arguments:
thisArgOptionalA value to use as
thiswhen executingcallbackFn. Seeiterative methods.
Return value
The last (highest-index) element in the array that satisfies the provided testing function;undefined if no matching element is found.
Description
ThefindLast() method is aniterative method. It calls a providedcallbackFn function once for each element in an array in descending-index order, untilcallbackFn returns atruthy value.findLast() then returns that element and stops iterating through the array. IfcallbackFn never returns a truthy value,findLast() returnsundefined. Read theiterative methods section for more information about how these methods work in general.
callbackFn is invoked forevery index of the array, not just those with assigned values. Empty slots insparse arrays behave the same asundefined.
ThefindLast() method isgeneric. It only expects thethis value to have alength property and integer-keyed properties.
Examples
Find last object in an array matching on element properties
This example shows how you might create a test based on the properties of array elements.
const inventory = [ { name: "apples", quantity: 2 }, { name: "bananas", quantity: 0 }, { name: "fish", quantity: 1 }, { name: "cherries", quantity: 5 },];// return true inventory stock is lowfunction isNotEnough(item) { return item.quantity < 2;}console.log(inventory.findLast(isNotEnough));// { name: "fish", quantity: 1 }Using arrow function and destructuring
The previous example might be written using an arrow function andobject destructuring:
const inventory = [ { name: "apples", quantity: 2 }, { name: "bananas", quantity: 0 }, { name: "fish", quantity: 1 }, { name: "cherries", quantity: 5 },];const result = inventory.findLast(({ quantity }) => quantity < 2);console.log(result);// { name: "fish", quantity: 1 }Find the last prime number in an array
The following example returns the last element in the array that is a prime number, orundefined if there is no prime number.
function isPrime(n) { if (n < 2) { return false; } if (n % 2 === 0) { return n === 2; } for (let factor = 3; factor * factor <= n; factor += 2) { if (n % factor === 0) { return false; } } return true;}console.log([4, 6, 8, 12].findLast(isPrime)); // undefined, not foundconsole.log([4, 5, 7, 8, 9, 11, 12].findLast(isPrime)); // 11Note:TheisPrime() implementation is for demonstration only. For a real-world application, you would want to use a heavily memoized algorithm such as theSieve of Eratosthenes to avoid repeated calculations.
Using the third argument of callbackFn
Thearray argument is useful if you want to access another element in the array, especially when you don't have an existing variable that refers to the array. The following example first usesfilter() to extract the positive values and then usesfindLast() to find the last element that is less than its neighbors.
const numbers = [3, -1, 1, 4, 1, 5, 9, 2, 6];const lastTrough = numbers .filter((num) => num > 0) .findLast((num, idx, arr) => { // Without the arr argument, there's no way to easily access the // intermediate array without saving it to a 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(lastTrough); // 2Using findLast() on sparse arrays
Empty slots in sparse arraysare visited, and are treated the same asundefined.
// Declare array with no elements at indexes 2, 3, and 4const array = [0, 1, , , , 5, 6];// Shows all indexes, not just those with assigned valuesarray.findLast((value, index) => { console.log(`Visited index ${index} with value ${value}`); return false;});// Visited index 6 with value 6// Visited index 5 with value 5// Visited index 4 with value undefined// Visited index 3 with value undefined// Visited index 2 with value undefined// Visited index 1 with value 1// Visited index 0 with value 0// Shows all indexes, including deletedarray.findLast((value, index) => { // Delete element 5 on first iteration if (index === 6) { console.log(`Deleting array[5] with value ${array[5]}`); delete array[5]; } // Element 5 is still visited even though deleted console.log(`Visited index ${index} with value ${value}`); return false;});// Deleting array[5] with value 5// Visited index 6 with value 6// Visited index 5 with value undefined// Visited index 4 with value undefined// Visited index 3 with value undefined// Visited index 2 with value undefined// Visited index 1 with value 1// Visited index 0 with value 0Calling findLast() on non-array objects
ThefindLast() method reads thelength property ofthis and then accesses each property whose key is a nonnegative integer less thanlength.
const arrayLike = { length: 3, 0: 2, 1: 7.3, 2: 4, 3: 3, // ignored by findLast() since length is 3};console.log( Array.prototype.findLast.call(arrayLike, (x) => Number.isInteger(x)),); // 4Specifications
| Specification |
|---|
| ECMAScript® 2026 Language Specification # sec-array.prototype.findlast |
Browser compatibility
See also
- Polyfill of
Array.prototype.findLastincore-js - es-shims polyfill of
Array.prototype.findLast - Indexed collections guide
ArrayArray.prototype.find()Array.prototype.findIndex()Array.prototype.findLastIndex()Array.prototype.includes()Array.prototype.filter()Array.prototype.every()Array.prototype.some()TypedArray.prototype.findLast()