I recently wrote a recursive function to create all combinations of arrays. You would have to translate your data into an array of arrays that my function uses, but that shouldn't be difficult.

Anyway, here's the code with a runnable example:

var v = [['Miniors','Kadettes','Juniors', 'Seniors'], ['Boys','Girls','Men','Women'],['54kg - 62kg','64kg - 70kg','71kg - 78kg','79kg - 84kg']];
var combos = createCombinations(v);
for(var i = 0; i < combos.length; i++) {
  document.getElementsByTagName("body")[0].innerHTML += combos[i] + "<br/>";
}

function createCombinations(fields, currentCombinations) {
  //prevent side-effects
  var tempFields = fields.slice();

  //recursively build a list combinations
  var delimiter = ' | ';
  if (!tempFields || tempFields.length == 0) {
    return currentCombinations;
  }
  else {
    var combinations = [];
    var field = tempFields.pop();

    for (var valueIndex = 0; valueIndex < field.length; valueIndex++) {
      var valueName = field[valueIndex];

      if (!currentCombinations || currentCombinations.length == 0) {
        var combinationName = valueName;
        combinations.push(combinationName);
      }
      else {
        for (var combinationIndex = 0; combinationIndex < currentCombinations.length; combinationIndex++) {
          var currentCombination = currentCombinations[combinationIndex];
          var combinationName = valueName + delimiter + currentCombination;
          combinations.push(combinationName);
        }
      }
    }
    return createCombinations(tempFields, combinations);
  }
}

var arr = [[1,2], [3,4], [5,6]];

This is an array of arrays. It is a little bit easier to read like this:

var arr = [
            [1,2],
            [3,4],
            [5,6]
          ];

That makes it a little bit easier to see that you have an array of 3 arrays. The outer 'for' will loop through each of 1st level arrays. So the very first outer for loop when i=0 you are going to grab the first inner array [1,2]:

for (var i=0; i < arr.length; i++) {
    //First time through i=0 so arr[i]=[1,2];
}

In the inner loop you are going to loop through each of the 3 inner arrays one at a time.

for (var j=0; j < arr[i].length; j++) {
    //Handle inner array.
}

This argument grabs the length of the inner array:

arr[i].length

So on your first time through the outer loop i=0 and arr[i] is going to equal [1,2] because you are grabbing the 0th element. Remember, arrays elements are always counted starting at 0, not 1.

Finally you are printing out the results with:

console.log(arr[i][j]);

The first time through you can break it down a little. i=0 and j=0. arr[0][0] which translates as grab the first element from the outer array and then the first element from the first inner array. In this case it is '1':

[
    [1,2], <-- 0
    [3,4], <-- 1
    [5,6]  <-- 2
];

The code will loop through the first first set [1,2], then the second [3,4], and so on.

Generators are really useful then to yield values up, also you can pass down the previous sum and values through the recursion:

function* sumUp(values, target, n, previous = [], sum = 0) {
  // Base case: if the combination of n values is target, yield it, or exit
  if(n <= 0) {
    if(sum === target) yield previous;
    return;
  }

  // otherwise add this combo
  for(const value of values) {
    // don't use the same number twice
    if(previous.includes(value)) continue;

    yield* sumUp(values, target, n - 1, [...previous, value], sum + value);       
  }
}

Usable as:

  // all combinations
 console.log([...sumUp([1, 2, 3, 4], 7, 2)]);
 // just the first
 console.log(sumUp([1, 2, 3, 4], 7, 2).next().value);

You could take a function for a cartesian product, an array of the wanted signs and the wanted length and return this result.

function getCombinations(signs, length) {
    const cartesian = array => array
        .reduce((a, b) => a.reduce((r, v) => r.concat(b.map(w => [].concat(v, w))), []));
    
    return cartesian(Array.from({ length }, _ => signs));
}

console.log(getCombinations([1, 2, 3], 5).map(a => a.join(' ')));

.as-console-wrapper { max-height: 100% !important; top: 0; }

As I mentioned in the comments you can get the same result directly from MongoDB using a MapReduce query; However a cleaner JavaScript equivalent for your nested loops can be something like this:

var data = [
 {"_id": "81724587125","name": "Object 1", "arrayOne":["1","2","3"]},
 {"_id": "87687687687","name": "Object 2", "arrayOne":["4","5","6"]}
];

var result = data.reduce(function (previousValue, currentValue, currentIndex, array) {
    return previousValue.arrayOne.concat( currentValue.arrayOne );
});

You can use reduceRight() for this. It just starts from the inside at the last item in the keys list and works its way out starting with "cool":

let keys = ["a", "b", "c", "d"]
let limit = 3

let result = keys.reduceRight((obj, key) => ({[key]: obj}), "cool")

console.log(result)

To limit where the object stops you can iterate over a slice of the keys. For example:

let keys = ["a", "b", "c", "d"]
let start = 0
let stop = 3 // slices are don't inlcude the last item, so this will stop at index 2

let result = keys.slice(start, stop).reduceRight((obj, key) => ({
  [key]: obj
}), "cool")

console.log(result)

The problem is that:

• your console.log should only be executed at the deepest level. So put that console.log in an else clause.

• The base case happens when loopNumber === maxNestedLoops - 1 as that is the last index of your array, so the if condition should correspond to that

     if (loopNumber < maxNestedLoops - 1){
         looper(loopNumber + 1);
     } else {
         console.log(indexes);
     }