# How to break on reduce method

How can I break the iteration on reduce method?

for

``````for (var i = Things.length - 1; i >= 0; i--) {
if(Things[i] <= 0){
break;
}
};
``````

reduce

``````Things.reduce(function(memo, current){
if(current <= 0){
//break ???
//return; <-- this will return undefined to memo, which is not what I want
}
}, 0)
`````` You can use functions like some and every as long as you don't care about the return value. every breaks when the callback returns false, some when it returns true:

``````things.every(function(v, i, o) {
// do stuff
if (timeToBreak) {
return false;
} else {
return true;
}
}, thisArg);
`````` Don't use reduce. Just iterate on the array with normal iterators (for, etc) and break out when your condition is met. There is no way, of course, to get the built-in version of `reduce` to exit prematurely.

But you can write your own version of reduce which uses a special token to identify when the loop should be broken.

``````var EXIT_REDUCE = {};

function reduce(a, f, result) {
for (let i = 0; i < a.length; i++) {
let val = f(result, a[i], i, a);
if (val === EXIT_REDUCE) break;
result = val;
}
return result;
}
``````

Use it like this, to sum an array but exit when you hit 99:

``````reduce([1, 2, 99, 3], (a, b) => b === 99 ? EXIT_REDUCE : a + b, 0);

> 3
`````` Array.every can provide a very natural mechanism for breaking out of high order iteration.

``````const product = function(array) {
let accumulator = 1;
array.every( factor => {
accumulator *= factor;
return !!factor;
});
return accumulator;
}
console.log(product([2,2,2,0,2,2]));
// 0`````` You can break every code - and thus every build in iterator - by throwing an exception:

``````function breakReduceException(value) {
this.value = value
}

try {
Things.reduce(function(memo, current) {
...
if (current <= 0) throw new breakReduceException(memo)
...
}, 0)
} catch (e) {
if (e instanceof breakReduceException) var memo = e.value
else throw e
}
`````` Another simple implementation that I came with solving the same issue:

``````function reduce(array, reducer, first) {
let result = first || array.shift()

while (array.length > 0) {
result = reducer(result, array.shift())
if (result && result.reduced) {
return result.reduced
}
}

return result
}
`````` You cannot break from inside of a reduce method. Depending on what you are trying to accomplish you could alter the final result (which is one reason you may want to do this)

``[1, 1, 1].reduce((a, b) => a + b, 0); // returns 3``

``````[1, 1, 1].reduce((a, b, c, d) => {
if (c === 1 && b < 3) {
return a + b + 1;
}
return a + b;
}, 0); // now returns 4``````

Keep in mind: you cannot reassign the array parameter directly

``````[1, 1, 1].reduce( (a, b, c, d) => {
if (c === 0) {
d = [1, 1, 2];
}
return a + b;
}, 0); // still returns 3``````

however (as pointed out below) you CAN affect the outcome by changing the array's contents:

``````[1, 1, 1].reduce( (a, b, c, d) => {
if (c === 0) {
d = 100;
}
return a + b;
}, 0); // now returns 102`````` As the `promise`s have `resolve` and `reject` callback arguments, I created the `reduce` workaround function with the `break` callback argument. It takes all the same arguments as native `reduce` method, except the first one is an array to work on (avoid monkey patching). The third  `initialValue` argument is optional. See the snippet below for the `function` reducer.

``````var list = ["w","o","r","l","d"," ","p","i","e","r","o","g","i"];

var result = reducer(list,(total,current,index,arr,stop)=>{
if(current === " ") stop(); //when called, the loop breaks
},'hello ');

console.log(result); //hello world

function reducer(arr, callback, initial) {
var hasInitial = arguments.length >= 3;
var total = hasInitial ? initial : arr;
var breakNow = false;
for (var i = hasInitial ? 0 : 1; i < arr.length; i++) {
var currentValue = arr[i];
var currentIndex = i;
var newTotal = callback(total, currentValue, currentIndex, arr, () => breakNow = true);
if (breakNow) break;
total = newTotal;
}
}``````

And here is the `reducer` as an Array `method` modified script:

``````Array.prototype.reducer = function(callback,initial){
var hasInitial = arguments.length >= 2;
var total = hasInitial ? initial : this;
var breakNow = false;
for (var i = hasInitial ? 0 : 1; i < this.length; i++) {
var currentValue = this[i];
var currentIndex = i;
var newTotal = callback(total, currentValue, currentIndex, this, () => breakNow = true);
if (breakNow) break;
total = newTotal;
}
};

var list = ["w","o","r","l","d"," ","p","i","e","r","o","g","i"];

var result = list.reducer((total,current,index,arr,stop)=>{
if(current === " ") stop(); //when called, the loop breaks
},'hello ');

console.log(result);
`````` Reduce functional version with break can be implemented as 'transform', ex. in underscore.

I tried to implement it with a config flag to stop it so that the implementation reduce doesn't have to change the data structure that you are currently using.

``````const transform = (arr, reduce, init, config = {}) => {
const result = arr.reduce((acc, item, i, arr) => {
if (acc.found) return acc

acc.value = reduce(config, acc.value, item, i, arr)

if (config.stop) {
acc.found = true
}

return acc
}, { value: init, found: false })

return result.value
}

module.exports = transform
``````

Usage1, simple one

``````const a = [0, 1, 1, 3, 1]

console.log(transform(a, (config, acc, v) => {
if (v === 3) { config.stop = true }
if (v === 1) return ++acc
return acc
}, 0))
``````

Usage2, use config as internal variable

``````const pixes = Array(size).fill(0)
const pixProcessed = pixes.map((_, pixId) => {
return transform(pics, (config, _, pic) => {
if (pic[pixId] !== '2') config.stop = true
return pic[pixId]
}, '0')
})
``````

Usage3, capture config as external variable

``````const thrusts2 = permute([9, 8, 7, 6, 5]).map(signals => {
const datas = new Array(5).fill(_data())
const ps = new Array(5).fill(0)

let thrust = 0, config
do {

config = {}
thrust = transform(signals, (_config, acc, signal, i) => {
const res = intcode(
datas[i], signal,
{ once: true, i: ps[i], prev: acc }
)

if (res) {
[ps[i], acc] = res
} else {
_config.stop = true
}

return acc
}, thrust, config)

} while (!config.stop)

return thrust
}, 0)
`````` I solved it like follows, for example in the `some` method where short circuiting can save a lot:

``````const someShort = (list, fn) => {
let t;
try{
return list.reduce((acc, el) => {
t = fn(el);
console.log('found ?', el, t)
if (t) {
throw ''
}
return t
}, false)
} catch (e){
return t
}
}

const someEven = someShort([1,2,3,1,5], el => el % 2 === 0)

console.log(someEven)
`````` UPDATE

Some of the commentators make a good point that the original array is being mutated in order to break early inside the `.reduce()` logic.

Therefore, I've modified the answer slightly by adding a `.slice(0)` before calling a follow-on `.reduce()` step, yielding a copy of the original array. NOTE: Similar ops that accomplish the same task are `slice()` (less explicit), and spread operator `[...array]` (slightly less performant). Bear in mind, all of these add an additional constant factor of linear time to the overall runtime + 1*(O(1)).

The copy, serves to preserve the original array from the eventual mutation that causes ejection from iteration.

``````const array = ['9', '91', '95', '96', '99'];
const x = array
.slice(0)                         // create copy of "array" for iterating
.reduce((acc, curr, i, arr) => {
if (i === 2) arr.splice(1);    // eject early by mutating iterated copy
return (acc += curr);
}, '');

console.log("x: ", x, "\noriginal Arr: ", array);
// x:  99195
// original Arr:  [ '9', '91', '95', '96', '99' ]
``````

OLD

You CAN break on any iteration of a .reduce() invocation by mutating the 4th argument of the reduce function: "array". No need for a custom reduce function. See Docs for full list of `.reduce()` parameters.

Array.prototype.reduce((acc, curr, i, array))

The 4th argument is the array being iterated over.

``````const array = ['9', '91', '95', '96', '99'];
const x = array
.reduce((acc, curr, i, arr) => {
if(i === 2) arr.splice(1);  // eject early
return acc += curr;
}, '');
console.log('x: ', x);  // x:  99195
``````

WHY?:

The 1 and only reason I can think of to use this instead of the many other solutions presented is if you want to maintain a functional programming methodology to your algo, and you want the most declarative approach possible to accomplish that. If your entire goal is to literally REDUCE an array to an alternate non-falsey primitive (String, Number, Boolean, Symbol) then I would argue this IS in fact, the best approach.

WHY NOT?

There's a whole list of arguments to make for NOT mutating function parameters as it's a bad practice. If you want to chain promises sequentially with reduce using the pattern below:

``````return [1,2,3,4].reduce(function(promise,n,i,arr){
return promise.then(function(){
// this code is executed when the reduce loop is terminated,
// so truncating arr here or in the call below does not works
return somethingReturningAPromise(n);
});
}, Promise.resolve());
``````

But need to break according to something happening inside or outside a promise things become a little bit more complicated because the reduce loop is terminated before the first promise is executed, making truncating the array in the promise callbacks useless, I ended up with this implementation:

``````function reduce(array, promise, fn, i) {
i=i||0;
return promise
.then(function(){
return fn(promise,array[i]);
})
.then(function(result){
if (!promise.break && ++i<array.length) {
return reduce(array,promise,fn,i);
} else {
return result;
}
})
}
``````

Then you can do something like this:

``````var promise=Promise.resolve();
reduce([1,2,3,4],promise,function(promise,val){
return iter(promise, val);
}).catch(console.error);

function iter(promise, val) {
return new Promise(function(resolve, reject){
setTimeout(function(){
if (promise.break) return reject('break');
console.log(val);
if (val==3) {promise.break=true;}
resolve(val);
}, 4000-1000*val);
});
}
``````