Understanding "some" and "every" Array Methods in Javascript
Tags: arrays, javascript, typescript, cleancode
Published: 2023-06-12 19:30:15

## Introduction

In this post, we'll explore two powerful array methods in Javascript: **`some`** and **`every`**. These methods are inherited from JavaScript and can be used to test elements in an array against specified conditions. We'll dive into their syntax, usage, and provide concrete examples to demonstrate their functionality.  

### Array.some()
The **`Array.some()`** method tests if at least one element in an array passes the provided test function. If at least one element satisfies the condition, it returns **`true`**; otherwise, it returns **`false`**.

#### Example
Let's say we have an array of numbers and we want to check if any of them are greater than 10.
```ts
const numbers: number[] = [1, 5, 12, 8, 3];

const hasNumberGreaterThan10 = numbers.some((num) => num > 10);
console.log(hasNumberGreaterThan10); // Output: true

```  
In this example, the **`some`** method returns **`true`** because the number 12 is greater than 10.

### Array.every()
The **`Array.every()`** method tests if all elements in an array pass the provided test function. If all elements satisfy the condition, it returns **`true`**; otherwise, it returns **`false`**.  

#### Example
Using the same array of numbers, let's check if all of them are less than 20.   
```ts
const numbers: number[] = [1, 5, 12, 8, 3];

const areAllNumbersLessThan20 = numbers.every((num) => num < 20);
console.log(areAllNumbersLessThan20); // Output: true

```
In this example, the every method returns true because all numbers in the array are less than 20.

---

## Improving Code Readability with `some` and `every` Array Methods  

Now, let's look at an example of how using some and every can help us write cleaner and more readable code. We will keep the previous example in the article as well.

Consider a scenario where we have an array of users, and we want to check if all users are adults and if any of them are from a specific city.   

```ts
interface User {
  name: string;
  age: number;
  city: string;
}

const users: User[] = [
  { name: 'Alice', age: 25, city: 'New York' },
  { name: 'Bob', age: 30, city: 'Los Angeles' },
  { name: 'Charlie', age: 22, city: 'New York' },
];

 Without using 'some' and 'every'
function checkUsers(users: User[]): { allAdults: boolean; anyFromNewYork: boolean } {
  let allAdults = true;
  let anyFromNewYork = false;

  for (const user of users) {
    if (user.age < 18) {
      allAdults = false;
    }
    if (user.city === 'New York') {
      anyFromNewYork = true;
    }
  }

  return { allAdults, anyFromNewYork };
}

// Using 'some' and 'every'
function checkUsersWithSomeAndEvery(users: User[]): { allAdults: boolean; anyFromNewYork: boolean } {
  const allAdults = users.every((user) => user.age >= 18);
  const anyFromNewYork = users.some((user) => user.city === 'New York');

  return { allAdults, anyFromNewYork };
}

```

In the first **`checkUsers`** function, we use a **`for`** loop to iterate through the users array and manually update the **`allAdults`** and **`anyFromNewYork`** variables. This approach is more complex and harder to read.   

In the second **`checkUsersWithSomeAndEvery`** function, we use the **`every`** and **`some`** methods to achieve the same result. This version of the function is cleaner, more readable, and easier to understand. By using these methods, we can focus on the conditions we want to check, making the code more maintainable and less error-prone.

## Conclusion 

The **`some`** and **`every`** array methods in TypeScript are powerful tools for testing elements in an array against specified conditions. By understanding their syntax and usage, and following best practices, you can write clean and efficient code that's easy to read and maintain.