How to use async functions with Array.some and every in Javascript

An example is available on GistRun

Want to learn AWS serverless development? Click here

In the first article, we've covered how async/await helps with async commands but it offers little help when it comes to asynchronously processing collections. In this post, we'll look into the some and the every functions that are used for a more efficient reduce when the result is a boolean value.

Related

Asynchronous array functions in Javascript

Array#Extras meet async/await

The some and every functions

These functions get an iteratee function, just like the filter, but they return a single true/false, depending on whether the predicate returned a specific value. In the case of the some, if any of the predicates returned true, the result will be true. For the every function, if any returned false, the result will be false.

const arr = [1, 2, 3];

const someRes = arr.some((i) => {
	return i % 2 === 0;
});

console.log(someRes);
// true

const everyRes = arr.every((i) => {
	return i < 2;
});

console.log(everyRes);
// false

Async some/every

Using an async filter

Considering only the result, these functions can be emulated with an async filter, which is already covered in a previous article how to convert to async.

Related

How to use async functions with Array.filter in Javascript

How to keep only the elements that satisfy an async condition

// sync
const some = (arr, predicate) => arr.filter(predicate).length > 0;
const every = (arr, predicate) => arr.filter(predicate).length === arr.length;

// async
const asyncSome =
	async (arr, predicate) => (await asyncFilter(arr, predicate)).length > 0;
const asyncEvery =
	async (arr, predicate) => (await asyncFilter(arr, predicate)).length === arr.length;

Short-circuiting

But there is an important difference between the built-in some/every functions and the filter-based implementations. When there is an element that returns true for a some, it short-circuits and does not process the remaining elements:

const arr = [1, 2, 3];

const res = arr.some((i) => {
	console.log(`Checking ${i}`);
	return i % 2 === 0;
});

// Checking 1
// Checking 2

console.log(res);
// true

Similarly, every stops after the first false result:

const arr = [1, 2, 3];

const res = arr.every((i) => {
	console.log(`Checking ${i}`);
	return i < 2;
});

// Checking 1
// Checking 2

console.log(res);
// false

Let's see how to code an async version that works in a similar way and does the least amount of work!

Async some

The best solution is to use an async for iteration that returns as soon as it finds a truthy result:

const arr = [1, 2, 3];

const asyncSome = async (arr, predicate) => {
	for (let e of arr) {
		if (await predicate(e)) return true;
	}
	return false;
};
const res = await asyncSome(arr, async (i) => {
	console.log(`Checking ${i}`);
	await sleep(10);
	return i % 2 === 0;
});

// Checking 1
// Checking 2

console.log(res);
// true

For the first element predicate(e) returns true, it concludes the for-loop.

Async every

The similar structure works for every, it's just a matter of negating the conditions:

const arr = [1, 2, 3];

const asyncEvery = async (arr, predicate) => {
	for (let e of arr) {
		if (!await predicate(e)) return false;
	}
	return true;
};
const res = await asyncEvery(arr, async (i) => {
	console.log(`Checking ${i}`);
	await sleep(10);
	return i < 2;
});

// Checking 1
// Checking 2

console.log(res);
// false

Whenever there is a false value returned by predicate(e), the function is ended without checking the other elements.

Parallel processing

The short-circuiting implementation processes the elements sequentially, which is efficient in terms of resource usage, but it might result in longer execution.

For example, if the iteratee sends requests via a network, it might take some time to send them one at a time. On the other hand, while it might result in more requests sent, sending all of them at the same time would be faster.

Conclusion

The some and the every functions are easy to approximate with an async filter but to follow the synchronous version faithfully, an async for loop is a better choice.