Perform a deeply recursive reduce on a JSON-encodable JavaScript Object hierarchy.

deep-reduce.js

/**
 * Perform a deeply recursive reduce on a set of JSON, or a JSON-encodable Object hierarchy.
 *
 * @param  {Array|Object} collection
 * @param  {Function}     fn
 * @param  {*}            memo
 * @return {*}
 */
function deepReduce(collection, fn, memo) {

  /**
   * @inner
   * @param  {*} value
   * @param  {String[]} path
   * @return {*}
   */
  function iterator(value, path) {
    var type = Object.prototype.toString.call(value);
    memo = fn(memo, value, path);
    if (type === '[object Array]') {
      for (var i = 0, len = value.length; i < len; i++) {
        iterator(value[i], path.concat(i));
      }
    } else if (type === '[object Object]') {
      for (var key in value) {
        iterator(value[key], path.concat(key));
      }
    }
    return memo;
  }

  return iterator(collection, []);

}

deep-reduce.ts

/*
 * Equivalent version in TypeScript
 */

import { each, isArray, isObject } from 'lodash';

export function deepReduce<In, Out>(
  reducer: (accumulator: Out, value: any, path: Array<string | number>) => Out,
  collection: In,
  accumulator: Out,
): Out {
  const iterator = <T>(value: T, paths: Array<string | number>) => {
    accumulator = reducer(accumulator, value, paths);
    if (isArray(value) || isObject(value)) {
      each(value, (innerValue, innerKey) =>
        iterator<typeof innerValue>(innerValue, paths.concat(innerKey)),
      );
    }
  };
  iterator<In>(collection, []);
  return accumulator;
}

Thanks mate. I was looking for something like this, saved my day!