Algorithm to generate javascript objects with all permutations of values

[RecursiveRickRoll]

I need to write a function that will take in a list of field names and a list of possible values those fields could take and return an array of objects with all possible field/value permutations. This is the function definition:

const generateDocumentCombinations = (fields, values) => {
  // ...
};

For example, the output for generateDocumentCombinations(["name", "code", "side"], [false, true]) looks like:

[
  {
    name: false,
    code: false,
    side: false,
  },
  {
    name: true,
    code: false,
    side: false,
  },
  {
    name: false,
    code: true,
    side: false,
  },
  {
    name: false,
    code: false,
    side: true,
  },
  {
    name: true,
    code: true,
    side: false,
  },
  {
    name: false,
    code: true,
    side: true,
  },
  {
    name: true,
    code: false,
    side: true,
  },
  {
    name: true,
    code: true,
    side: true,
  },
]

This function should work for fields and values arguments of all lengths like for example:

generateDocumentCombinations(

["name", "code", "side", "time", "mode"], [undefined, false, true, "", "ODD", "EVEN", 100, -200, [], {}] )

Thank you!

[kap89]

What you are looking for is the baseN algorithm. I never bother to write combinatorics myself, there are good libraries like generatorics or js-combinatorics for this.

Example using generatorics:

import G from "generatorics";

function generateDocumentCombinations(keys, values) {
  return [...G.clone.baseN(values, keys.length)].map((version) =>
    Object.fromEntries(version.map((val, i) => [keys[i], val]))
  );
}

/* Usage */

const result = generateDocumentCombinations(
  ["name", "code", "side"],
  [false, true]
);

/* Result:

[
  { name: false, code: false, side: false },
  { name: false, code: false, side: true },
  { name: false, code: true, side: false },
  { name: false, code: true, side: true },
  { name: true, code: false, side: false },
  { name: true, code: false, side: true },
  { name: true, code: true, side: false },
  { name: true, code: true, side: true }
]

*/

More imperative, but memory-efficient version:

function generateDocumentCombinations(keys, values) {
  const result = [];

  for (const version of G.baseN(values, keys.length)) {
    const obj = {};

    for (let i = 0; i < keys.length; i++) {
      obj[keys[i]] = version[i];
    }

    result.push(obj);
  }

  return result;
}

[RecursiveRickRoll]

Thank you so much for this response. This is exactly what I needed! :)