JavaScript is an easy to learn programming language. It’s easy to write programs that run and does something. However, it’s hard to account for all the uses cases and write robust JavaScript code.
In this article, we’ll look at more reliable ways to filter and check for items in arrays.
Check to See If Something Exists in All Entries of an Array With the every Method
The JavaScript array instance’s every method lets us easily check if something exists in all entries of an array.
All we have to do is to pass in a callback with the condition we want to check for in each entry.
For instance, if we want to check if every number in the array is even, we can write the following code:
const arr = [2, 4, 6];
const allEven = arr.every(a => a % 2 === 0);
In the code above, we have the arr array with all even numbers. Then we used every that has a callback with the array entry a as the parameter and we return a % 2 === 0 to check if all numbers in the array are even.
Since they’re all even, allEven is true as every returns true if every entry in the array instance meets the condition given in the callback and false otherwise.
This is more reliable than writing our own loops since it’s shorter and well-tested. Therefore, there’s less chance for bugs.
The callback can also take other parameters. The index that’s being looped through is the 2nd parameter and the array itself if the third. They’re both optional. However, if we need it, then we can include them.
For instance, we can rewrite our example as follows:
const arr = [2, 4, 6];
const allEven = arr.every((a, index, array) => array[index] % 2 === 0);
The every method also takes an object that we can set as the value of this in the callback, if we need to reference this in the callback function.
For instance, we can write the following code to set the value of this and use it inside the callback:
const arr = [1, 2, 3];
const allEven = arr.every(function(a){
return a >= this.min;
}, { min: 2 });
In the code above, we set the value of this in the callback by passing in { min: 2 } as the 2nd argument.
Then we switched our function into a traditional function so that we can reference the this value in the callback. In the callback, we checked that if each array entry is bigger than or equal than this.min , which is 2.
We don’t have to worry about how to set up our loops and when to end the loop and other things that come with the loop.
Creating an Array With Filtered Entries With the filter Method
The array instance’s filter method returns an array with the entries of an array that has the given condition in the callback included the returned array.
For instance, we can use it as follows:
const arr = [1, 2, 3];
const result = arr.filter(a => a > 1);
In the code above, we called filter on the array instance with the callback a => a > 1 to return a new array with all the entries in arr that’s bigger than 1.
Therefore, we should get [2, 3] as the value of result .
Like every , the callback can also take an optional index and array parameter. index is the 2nd parameter, and array is the 3rd parameter.
So we can also write the following code:
const arr = [1, 2, 3];
const result = arr.filter((a, index, array) => array[index] > 1);
In the code above, we used the array and index instead to reference the entries and instead of using the first parameter a to reference each entry.
Therefore, we should get the same result as before.
This is better than writing our loops since it comes with JavaScript’s standard library, so it’s been well tested to eliminate any bugs.
Also, the algorithm it uses for doing the filtering is guaranteed to be fast enough for production use since it’s in the standard library.
Finally, it’s also shorter than writing our own loops to do the same thing.
Conclusion
The array instance’s every method is great for checking is every entry has something we’re looking for.
To create a new array with the entries in the array instance that meets the given condition, we can use the array instance’s filter method to make that easy.
