DEV Community


Posted on

Mastering Array Validation with JavaScript's array.every() method

Arrays are an essential data structure in JavaScript, and they often require validation to ensure that the data they hold meets specific criteria. The array.every() method is a less popular, but still powerful tool that allows you to determine whether all elements in an array satisfy a given condition. In this article, we'll explore the ins and outs of array.every() through practical examples.

Understanding the Basics

The array.every() method is a member of JavaScript's array prototype, and it checks whether all elements in an array meet a specific condition. The basic syntax for array.every() is as follows:

array.every(callback(element, index, array[, thisArg]))
Enter fullscreen mode Exit fullscreen mode
  • array: The array you want to check.
  • callback: A function that tests each element.
  • element: The current element being processed.
  • index (optional): The index of the current element.
  • array (optional): The array being processed.
  • thisArg (optional): An object that can be used as this when executing the callback function.

My IDE gives the following definition:

Definition from IDE

Now let's go through the examples and see how it works in practice!

Example 1: Validating Numeric Values

Let's start with a simple example where we have an array of numbers and we want to check if all of them are greater than 10:

const numbers = [15, 20, 25, 30, 35];

const allGreaterThanTen = numbers.every((element) => element > 10);

console.log(allGreaterThanTen); // Output: true
Enter fullscreen mode Exit fullscreen mode

In this example, the array.every() method iterates through the numbers array, and since all elements are greater than 10, it returns true.

Example 2: Validating Email Addresses

Now, consider a case where you have an array of email addresses, and you want to verify that each email follows a valid format:

const emails = ['', 'john.doe@', 'invalid-email'];

const allValidEmails = emails.every((element) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(element));

console.log(allValidEmails); // Output: false
Enter fullscreen mode Exit fullscreen mode

In this example, we use a regular expression to validate the format of each email address. Since one of the email addresses is not valid, the array.every() method returns false.

Example 3: Checking for Empty Array

array.every() can also be handy for checking if an array is empty or contains only falsy values. Here's how you can do that:

const emptyArray = [];

const isEmpty = emptyArray.every((element) => !element);

console.log(isEmpty); // Output: true
Enter fullscreen mode Exit fullscreen mode

In this case, the array.every() method checks that all elements are falsy (in this case, there are no elements), and it returns true.

Example 4: Custom Validation Function

You can create custom validation functions to use with array.every(). For instance, suppose you have an array of user objects and you want to validate that all users are active:

const users = [
  { name: 'Alice', isActive: true },
  { name: 'Bob', isActive: true },
  { name: 'Charlie', isActive: false },

const allActiveUsers = users.every((user) => user.isActive);

console.log(allActiveUsers); // Output: false
Enter fullscreen mode Exit fullscreen mode

In this example, the custom callback function checks if the isActive property is true for all user objects. Since one user is inactive, the array.every() method returns false.

Comparing array.every() with Other Array Methods

While array.every() is an excellent choice for certain types of array validation, it's essential to understand how it compares to other commonly used array methods like array.filter() and

array.filter(): This method is primarily used to create a new array containing elements that meet a specific condition. It is ideal when you need to extract valid elements and operate on them separately. In contrast, array.every() is focused on determining if all elements meet a condition and returns a boolean result. If you want to extract valid elements, use array.filter(), but if your goal is to validate the entire array, array.every() is the better choice. is used to transform each element in an array based on a provided function, creating a new array with the transformed values. It's not designed for validation but for data transformation. While you can technically use for validation by mapping to boolean values and then checking if they're all true, this approach lacks the clarity and simplicity of array.every() for validation tasks.


In summary, array.every() is tailored for the specific purpose of array-wide validation. It offers a more direct and clear way to check if all elements meet a condition, making it an excellent choice when your goal is to ensure the entire array meets specific criteria. Understanding the strengths and weaknesses of different array methods allows you to choose the most appropriate tool for your specific task, ensuring efficient and readable code in your JavaScript projects.

Happy coding!

NB: This article has been written with a bit of touch from ChatGPT. Mostly grammar and composition :)

Top comments (2)

18xdeveloper profile image
Sheikh Abdur Rohit

This is informative, I have been doing most of the traversal with and array.reduce.

hugaidas profile image

I am glad that it helped, happy coding!