JavaScript Array Methods - Some & Every
Tags: javascript, webdev, beginners
Published: 2022-04-03 19:29:19

Today, I will tell you about `.some()` and `.every()`. Double knowledge. I don't use these as often as `.map()` or `.filter()` but they do come in quite handy in certain scenarios. I have grouped these methods together because they both return a **Boolean** value as a result, so it made sense (in my mind) to learn them together. Plus they are very short.

## Array.prototype.some()

Just like the other methods I have talked about so far, `.some()` also take a function as its argument (a.k.a callback). The `.some()` method returns `true` for the first value/element in the array which passes the test and `false` otherwise.

I will use the `typeof` operator in my example, this operator returns a string telling you what the data type is.

Example: 

```javascript
let stoppingIndex;

const arrOfDataTypes = ["this is a string", 
  93, 
  false, 
  72n, 
  true,
  false,
  {
    name: "Tanwa", 
    hobby: ["coding", "gaming"]
  }
]

function callbackCheckBool(a) {
  return typeof a === 'boolean';
}

console.log(arrOfDataTypes.some( (element, index) => {
  stoppingIndex = index;
  return callbackCheckBool(element);
  }));
// true

console.log(stoppingIndex); // 2

console.log(arrOfDataTypes.some( element => typeof element === 'undefined'));
// false
```

In the above example, we wanted to check if there are *some* value/element in the array that are of the data type `'boolean'`, this return `true` because the array contains the element `"false"` which is a Boolean type at index `2` where the `.some()` method stopped. In the second `.some()` test, we check for data type of `'undefined'`, as the array does not have this type of value it returned `false`.

## Array.prototype.every()

If you guess that `.every()` method returns `true` only when every value/element in the array passes the callback function test, then you would be correct! I think of `.every()` as the opposite to `.some()` as it will return the `false` as soon as one element fails the test.

Example: 

```javascript
const arrOfStrings = ["How", "long", "is", "a", "piece", "of", "string?", 1];

const arrOfTwos = [2,2,2,2,2];

console.log(arrOfStrings.every( element => typeof element === 'string')); // false

console.log(arrOfTwos.every( element => element === 2)); // true
```

I hope the example above is straight forward, we checked if every value/element in the array is of the type `'string'` but this return `false` because of the sneaky number `1` at the end! And in the second `.every()` test, it returns `true` as all the element passed the test.

### Summary

The `.some()` method checks for first value/element in the array that passes the callback function test and returns `true` and if it does not find any that passes the test it returns `false`. While the `.every()` method checks for the first value/element in the array that fails the callback function test and returns `false` or it returns `true` if all the value passes the test.

If you made it this far, thank you for reading, and as always please leave comment and feedback if I have misunderstood anything. 

![Smiling Naruto](https://th.bing.com/th/id/OIP.eFOts8cw3lh2VOZiqs9-WQHaFj?pid=ImgDet&rs=1)