Using 'reduce' vs 'for' loop for returning boolean [closed]

Question

I was wondering what people think about using a reduce function vs loop for returning true if a condition exists.

Example:

var a = [1, 5, 7, 4, 2, 5, 3];

var greaterThan5 = a.reduce(function(prev, val) {
    return (prev || val > 5);
}, false);

vs

var greaterThan5 = false;
for(var i = 0; i < a.length; i++) {
    if(a[i] > 5) {
        greaterThan5 = true;
        break;
    }
}

vs

var i = 0;
var greaterThan5 = false;
while(!greaterThan5 && i < a.length) {
    greaterThan5 = (a[i] > 5);
    i++;
}

The for loop and while loop will exit when the condition is true, but I think the reduce syntax is easier to read and gives less room for run-time errors.

Answer 1

First of all, why not use Array.prototype.some(), which seems to perfectly match what you're actually trying to do.

The some() method tests whether some element in the array passes the test implemented by the provided function.

Of course, that doesn't really answer your question: whether to use the for loop, or the call to Array.protoype.reduce()? Let me also try to answer that. The question is mostly regarding weighing performance against clarity of code.

For performance: measure, not just using random arrays, but using arrays that make sense in your project. No need in selecting a method that works fast on 1,000,000 element arrays, when all you need to process are arrays of up to 10 elements.

More importantly, only worry about performance when performance is an issue.

With respect to clarity. I actually think the explicit for-loop is more clear than the Array.prototype.reduce(). But, what matters most is, what the people on your team will find the most clear. If one of your team finds an explicit for-loop more clear, it's probably better to use that, if only because it uses a less advanced set of features.

Answer 2

For most functional languages, neither.

There is usually a reducing function which short circuts as you want it to.

In F# this is List.exists so you example would be

List.exists (fun x -> x > 5) a

In Haskell (with partial application of > to make a point free solution)

any (> 5) a