¿Cómo implementaría el producto cartesiano de múltiples matrices en JavaScript?

Como ejemplo,

cartesian([1, 2], [10, 20], [100, 200, 300]) 

debería volver

[
  [1, 10, 100],
  [1, 10, 200],
  [1, 10, 300],
  [2, 10, 100],
  [2, 10, 200]
  ...
]

Actualización de 2017: respuesta de 2 líneas con vanilla JS

Todas las respuestas aquí son demasiado complicadas , la mayoría de ellas toman 20 líneas de código o incluso más.

Este ejemplo usa solo dos líneas de JavaScript vanilla , sin lodash, subrayado u otras bibliotecas:

let f = (a, b) => [].concat(...a.map(a => b.map(b => [].concat(a, b))));
let cartesian = (a, b, ...c) => b ? cartesian(f(a, b), ...c) : a;

Actualizar:

Es el mismo que el anterior, pero mejorado para seguir estrictamente la Guía de estilo de JavaScript de Airbnb , validada con ESLint con eslint-config-airbnb-base :

const f = (a, b) => [].concat(...a.map(d => b.map(e => [].concat(d, e))));
const cartesian = (a, b, ...c) => (b ? cartesian(f(a, b), ...c) : a);

Un agradecimiento especial a ZuBB por informarme sobre problemas de linter con el código original.

Ejemplo

Este es el ejemplo exacto de su pregunta:

let output = cartesian([1,2],[10,20],[100,200,300]);

Salida

Esta es la salida de ese comando:

[ [ 1, 10, 100 ],
  [ 1, 10, 200 ],
  [ 1, 10, 300 ],
  [ 1, 20, 100 ],
  [ 1, 20, 200 ],
  [ 1, 20, 300 ],
  [ 2, 10, 100 ],
  [ 2, 10, 200 ],
  [ 2, 10, 300 ],
  [ 2, 20, 100 ],
  [ 2, 20, 200 ],
  [ 2, 20, 300 ] ]

Manifestación

Ver demostraciones en:

• JS Bin con Babel (para navegadores antiguos)
• JS Bin sin Babel (para navegadores modernos)

Sintaxis

La sintaxis que utilicé aquí no es nada nuevo. Mi ejemplo usa el operador de propagación y los demás parámetros, características de JavaScript definidas en la sexta edición del estándar ECMA-262 publicado en junio de 2015 y desarrollado mucho antes, mejor conocido como ES6 o ES2015. Ver:

• http://www.ecma-international.org/ecma-262/6.0/
• https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/rest_parameters
• https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Spread_operator

Hace que un código como este sea tan simple que es un pecado no usarlo. Para las plataformas antiguas que no lo admiten de forma nativa, siempre puede usar Babel u otras herramientas para transpilarlo a una sintaxis anterior, y de hecho, mi ejemplo transpilado por Babel es aún más corto y simple que la mayoría de los ejemplos aquí, pero no es así. realmente importa porque la salida de la transpilación no es algo que deba comprender o mantener, es solo un hecho que me pareció interesante.

Conclusión

No es necesario escribir cientos de líneas de código que sean difíciles de mantener y no es necesario utilizar bibliotecas completas para algo tan simple, cuando dos líneas de JavaScript vanilla pueden hacer el trabajo fácilmente. Como puede ver, realmente vale la pena usar funciones modernas del lenguaje y, en los casos en que necesite admitir plataformas arcaicas sin soporte nativo de las funciones modernas, siempre puede usar Babel u otras herramientas para transpilar la nueva sintaxis a la anterior. .

No codifique como si fuera 1995

JavaScript evoluciona y lo hace por una razón. TC39 hace un trabajo increíble en el diseño del lenguaje al agregar nuevas funciones y los proveedores de navegadores hacen un trabajo increíble al implementar esas funciones.

Para ver el estado actual del soporte nativo de cualquier característica dada en los navegadores, consulte:

• http://caniuse.com/
• https://kangax.github.io/compat-table/

Para ver el soporte en las versiones de Node, consulte:

• http://node.green/

Para usar la sintaxis moderna en plataformas que no la admiten de forma nativa, use Babel:

• https://babeljs.io/

Aquí hay una solución funcional al problema (¡sin ninguna variable mutable !) Usando reducey flatten, proporcionada por underscore.js:

function cartesianProductOf() {
    return _.reduce(arguments, function(a, b) {
        return _.flatten(_.map(a, function(x) {
            return _.map(b, function(y) {
                return x.concat([y]);
            });
        }), true);
    }, [ [] ]);
}

// [[1,3,"a"],[1,3,"b"],[1,4,"a"],[1,4,"b"],[2,3,"a"],[2,3,"b"],[2,4,"a"],[2,4,"b"]]
console.log(cartesianProductOf([1, 2], [3, 4], ['a']));  

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.9.1/underscore.js"></script>

Observación: esta solución se inspiró en http://cwestblog.com/2011/05/02/cartesian-product-of-multiple-arrays/

Aquí hay una versión modificada del código de @ viebel en JavaScript simple, sin usar ninguna biblioteca:

function cartesianProduct(arr) {
    return arr.reduce(function(a,b){
        return a.map(function(x){
            return b.map(function(y){
                return x.concat([y]);
            })
        }).reduce(function(a,b){ return a.concat(b) },[])
    }, [[]])
}

var a = cartesianProduct([[1, 2,3], [4, 5,6], [7, 8], [9,10]]);
console.log(JSON.stringify(a));

parece que la comunidad piensa que esto es trivial o fácil de encontrar una implementación de referencia, después de una breve inspección no pude o tal vez es solo que me gusta reinventar la rueda o resolver problemas de programación similares a los de un salón de clases de cualquier manera es tu día de suerte :

function cartProd(paramArray) {

  function addTo(curr, args) {

    var i, copy, 
        rest = args.slice(1),
        last = !rest.length,
        result = [];

    for (i = 0; i < args[0].length; i++) {

      copy = curr.slice();
      copy.push(args[0][i]);

      if (last) {
        result.push(copy);

      } else {
        result = result.concat(addTo(copy, rest));
      }
    }

    return result;
  }


  return addTo([], Array.prototype.slice.call(arguments));
}


>> console.log(cartProd([1,2], [10,20], [100,200,300]));
>> [
     [1, 10, 100], [1, 10, 200], [1, 10, 300], [1, 20, 100], 
     [1, 20, 200], [1, 20, 300], [2, 10, 100], [2, 10, 200], 
     [2, 10, 300], [2, 20, 100], [2, 20, 200], [2, 20, 300]
   ]

implementación de referencia completa que es relativamente eficiente ... :-D

en eficiencia: podría ganar algo sacando el if del bucle y teniendo 2 bucles separados, ya que es técnicamente constante y estaría ayudando con la predicción de ramas y todo ese lío, pero ese punto es un poco discutible en javascript

quien sea, disfruta -ck

La siguiente función generadora eficiente devuelve el producto cartesiano de todos los iterables dados :

// Generate cartesian product of given iterables:
function* cartesian(head, ...tail) {
  const remainder = tail.length > 0 ? cartesian(...tail) : [[]];
  for (let r of remainder) for (let h of head) yield [h, ...r];
}

// Example:
console.log(...cartesian([1, 2], [10, 20], [100, 200, 300]));

Acepta matrices, cadenas, conjuntos y todos los demás objetos que implementan el protocolo iterable. .

Siguiendo la especificación del producto cartesiano n-ario se obtiene

• []si uno o más iterables dados están vacíos, por ejemplo, []o''
• [[a]]si se da un único iterable que contiene un solo valor a.

Todos los demás casos se manejan como se esperaba, como lo demuestran los siguientes casos de prueba:

// Generate cartesian product of given iterables:
function* cartesian(head, ...tail) {
  const remainder = tail.length > 0 ? cartesian(...tail) : [[]];
  for (let r of remainder) for (let h of head) yield [h, ...r];
}

// Test cases:
console.log([...cartesian([])]);              // []
console.log([...cartesian([1])]);             // [[1]]
console.log([...cartesian([1, 2])]);          // [[1], [2]]

console.log([...cartesian([1], [])]);         // []
console.log([...cartesian([1, 2], [])]);      // []

console.log([...cartesian([1], [2])]);        // [[1, 2]]
console.log([...cartesian([1], [2], [3])]);   // [[1, 2, 3]]
console.log([...cartesian([1, 2], [3, 4])]);  // [[1, 3], [2, 3], [1, 4], [2, 4]]

console.log([...cartesian('')]);              // []
console.log([...cartesian('ab', 'c')]);       // [['a','c'], ['b', 'c']]
console.log([...cartesian([1, 2], 'ab')]);    // [[1, 'a'], [2, 'a'], [1, 'b'], [2, 'b']]

console.log([...cartesian(new Set())]);       // []
console.log([...cartesian(new Set([1]))]);    // [[1]]
console.log([...cartesian(new Set([1, 1]))]); // [[1]]

Aquí hay una solución recursiva sencilla y sencilla:

function cartesianProduct(a) { // a = array of array
    var i, j, l, m, a1, o = [];
    if (!a || a.length == 0) return a;

    a1 = a.splice(0, 1)[0]; // the first array of a
    a = cartesianProduct(a);
    for (i = 0, l = a1.length; i < l; i++) {
        if (a && a.length) for (j = 0, m = a.length; j < m; j++)
            o.push([a1[i]].concat(a[j]));
        else
            o.push([a1[i]]);
    }
    return o;
}

console.log(cartesianProduct([[1,2], [10,20], [100,200,300]]));
// [[1,10,100],[1,10,200],[1,10,300],[1,20,100],[1,20,200],[1,20,300],[2,10,100],[2,10,200],[2,10,300],[2,20,100],[2,20,200],[2,20,300]]

Aquí hay una forma recursiva que usa una función generadora de ECMAScript 2015 para que no tenga que crear todas las tuplas a la vez:

function* cartesian() {
    let arrays = arguments;
    function* doCartesian(i, prod) {
        if (i == arrays.length) {
            yield prod;
        } else {
            for (let j = 0; j < arrays[i].length; j++) {
                yield* doCartesian(i + 1, prod.concat([arrays[i][j]]));
            }
        }
    }
    yield* doCartesian(0, []);
}

console.log(JSON.stringify(Array.from(cartesian([1,2],[10,20],[100,200,300]))));
console.log(JSON.stringify(Array.from(cartesian([[1],[2]],[10,20],[100,200,300]))));

Aquí hay un resumen usando el ES2019 nativo flatMap. No se necesitan bibliotecas, solo un navegador moderno (o transpilador):

data.reduce((a, b) => a.flatMap(x => b.map(y => [...x, y])), [[]]);

Es esencialmente una versión moderna de la respuesta de viebel, sin lodash.

Usando un retroceso típico con generadores ES6,

function cartesianProduct(...arrays) {
  let current = new Array(arrays.length);
  return (function* backtracking(index) {
    if(index == arrays.length) yield current.slice();
    else for(let num of arrays[index]) {
      current[index] = num;
      yield* backtracking(index+1);
    }
  })(0);
}
for (let item of cartesianProduct([1,2],[10,20],[100,200,300])) {
  console.log('[' + item.join(', ') + ']');
}

div.as-console-wrapper { max-height: 100%; }

A continuación hay una versión similar compatible con navegadores más antiguos.

function cartesianProduct(arrays) {
  var result = [],
      current = new Array(arrays.length);
  (function backtracking(index) {
    if(index == arrays.length) return result.push(current.slice());
    for(var i=0; i<arrays[index].length; ++i) {
      current[index] = arrays[index][i];
      backtracking(index+1);
    }
  })(0);
  return result;
}
cartesianProduct([[1,2],[10,20],[100,200,300]]).forEach(function(item) {
  console.log('[' + item.join(', ') + ']');
});

div.as-console-wrapper { max-height: 100%; }

Esta es una solución ES6 pura que utiliza funciones de flecha

function cartesianProduct(arr) {
  return arr.reduce((a, b) =>
    a.map(x => b.map(y => x.concat(y)))
    .reduce((a, b) => a.concat(b), []), [[]]);
}

var arr = [[1, 2], [10, 20], [100, 200, 300]];
console.log(JSON.stringify(cartesianProduct(arr)));

Una versión coffeescript con lodash:

_ = require("lodash")
cartesianProduct = ->
    return _.reduceRight(arguments, (a,b) ->
        _.flatten(_.map(a,(x) -> _.map b, (y) -> x.concat(y)), true)
    , [ [] ])

Un enfoque de una sola línea, para una mejor lectura con sangrías.

result = data.reduce(
    (a, b) => a.reduce(
        (r, v) => r.concat(b.map(w => [].concat(v, w))),
        []
    )
);

Se necesita una sola matriz con matrices de elementos cartesianos deseados.

var data = [[1, 2], [10, 20], [100, 200, 300]],
    result = data.reduce((a, b) => a.reduce((r, v) => r.concat(b.map(w => [].concat(v, w))), []));

console.log(result.map(a => a.join(' ')));

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

Esto está etiquetado como programación funcional, así que echemos un vistazo a la mónada List :

Una aplicación para esta lista monádica es la representación de cálculos no deterministas. List puede contener resultados para todas las rutas de ejecución en un algoritmo ...

Bueno, eso suena perfecto para cartesian. JavaScript nos da Arrayy la función de enlace monádico es Array.prototype.flatMap, así que pongámoslos en uso:

const cartesian = (...all) =>
{ const loop = (t, a, ...more) =>
    a === undefined
      ? [ t ]
      : a .flatMap (x => loop ([ ...t, x ], ...more))
  return loop ([], ...all)
}

console .log (cartesian ([1,2], [10,20], [100,200,300]))

En lugar de lo loopanterior, tse puede agregar como un parámetro de curry:

const makeCartesian = (t = []) => (a, ...more) =>
  a === undefined
    ? [ t ]
    : a .flatMap (x => makeCartesian ([ ...t, x ]) (...more))

const cartesian =
  makeCartesian ()

console .log (cartesian ([1,2], [10,20], [100,200,300]))

Algunas de las respuestas de este tema fallan cuando alguna de las matrices de entrada contiene un elemento de matriz. Será mejor que compruebes eso.

De todos modos no hay necesidad de subrayado, lodash en absoluto. Creo que este debería hacerlo con JS ES6 puro, tan funcional como sea posible.

Este fragmento de código usa un mapa anidado y uno reducido, simplemente para obtener el producto cartesiano de dos arreglos, sin embargo, el segundo arreglo proviene de una llamada recursiva a la misma función con un arreglo menos; por lo tanto.. a[0].cartesian(...a.slice(1))

Array.prototype.cartesian = function(...a){
  return a.length ? this.reduce((p,c) => (p.push(...a[0].cartesian(...a.slice(1)).map(e => a.length > 1 ? [c,...e] : [c,e])),p),[])
                  : this;
};

var arr = ['a', 'b', 'c'],
    brr = [1,2,3],
    crr = [[9],[8],[7]];
console.log(JSON.stringify(arr.cartesian(brr,crr))); 

En mi entorno particular, el enfoque "pasado de moda" parecía ser más eficiente que los métodos basados ​​en características más modernas. A continuación se muestra el código (incluida una pequeña comparación con otras soluciones publicadas en este hilo por @rsp y @sebnukem) en caso de que también resulte útil para otra persona.

La idea sigue. Digamos que estamos construyendo el producto externo de Nmatrices, a_1,...,a_Ncada una de las cuales tiene m_icomponentes. El producto externo de estas matrices tiene M=m_1*m_2*...*m_Nelementos y podemos identificar cada uno de ellos con un N-vector dimensional cuyos componentes son enteros positivos y el icomponente -ésimo está estrictamente acotado desde arriba por m_i. Por ejemplo, el vector (0, 0, ..., 0)correspondería a la combinación particular dentro de la cual se toma el primer elemento de cada matriz, mientras que (m_1-1, m_2-1, ..., m_N-1)se identifica con la combinación donde se toma el último elemento de cada matriz. Así, para construir todosM combinaciones, la función a continuación construye consecutivamente todos esos vectores y para cada uno de ellos identifica la combinación correspondiente de los elementos de las matrices de entrada.

function cartesianProduct(){
    const N = arguments.length;

    var arr_lengths = Array(N);
    var digits = Array(N);
    var num_tot = 1;
    for(var i = 0; i < N; ++i){
        const len = arguments[i].length;
        if(!len){
            num_tot = 0;
            break;
        }
        digits[i] = 0;
        num_tot *= (arr_lengths[i] = len);
    }

    var ret = Array(num_tot);
    for(var num = 0; num < num_tot; ++num){

        var item = Array(N);
        for(var j = 0; j < N; ++j){ item[j] = arguments[j][digits[j]]; }
        ret[num] = item;

        for(var idx = 0; idx < N; ++idx){
            if(digits[idx] == arr_lengths[idx]-1){
                digits[idx] = 0;
            }else{
                digits[idx] += 1;
                break;
            }
        }
    }
    return ret;
}
//------------------------------------------------------------------------------
let _f = (a, b) => [].concat(...a.map(a => b.map(b => [].concat(a, b))));
let cartesianProduct_rsp = (a, b, ...c) => b ? cartesianProduct_rsp(_f(a, b), ...c) : a;
//------------------------------------------------------------------------------
function cartesianProduct_sebnukem(a) {
    var i, j, l, m, a1, o = [];
    if (!a || a.length == 0) return a;

    a1 = a.splice(0, 1)[0];
    a = cartesianProduct_sebnukem(a);
    for (i = 0, l = a1.length; i < l; i++) {
        if (a && a.length) for (j = 0, m = a.length; j < m; j++)
            o.push([a1[i]].concat(a[j]));
        else
            o.push([a1[i]]);
    }
    return o;
}
//------------------------------------------------------------------------------
const L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
const args = [L, L, L, L, L, L];

let fns = {
    'cartesianProduct': function(args){ return cartesianProduct(...args); },
    'cartesianProduct_rsp': function(args){ return cartesianProduct_rsp(...args); },
    'cartesianProduct_sebnukem': function(args){ return cartesianProduct_sebnukem(args); }
};

Object.keys(fns).forEach(fname => {
    console.time(fname);
    const ret = fns[fname](args);
    console.timeEnd(fname);
});

con node v6.12.2, obtengo los siguientes tiempos:

cartesianProduct: 427.378ms
cartesianProduct_rsp: 1710.829ms
cartesianProduct_sebnukem: 593.351ms

Para aquellos que necesitan TypeScript (reimplementado @ la respuesta de Danny)

/**
 * Calculates "Cartesian Product" sets.
 * @example
 *   cartesianProduct([[1,2], [4,8], [16,32]])
 *   Returns:
 *   [
 *     [1, 4, 16],
 *     [1, 4, 32],
 *     [1, 8, 16],
 *     [1, 8, 32],
 *     [2, 4, 16],
 *     [2, 4, 32],
 *     [2, 8, 16],
 *     [2, 8, 32]
 *   ]
 * @see https://stackoverflow.com/a/36234242/1955709
 * @see https://en.wikipedia.org/wiki/Cartesian_product
 * @param arr {T[][]}
 * @returns {T[][]}
 */
function cartesianProduct<T> (arr: T[][]): T[][] {
  return arr.reduce((a, b) => {
    return a.map(x => {
      return b.map(y => {
        return x.concat(y)
      })
    }).reduce((c, d) => c.concat(d), [])
  }, [[]] as T[][])
}

Solo para una opción, una implementación realmente simple usando matrices reduce:

const array1 = ["day", "month", "year", "time"];
const array2 = ["from", "to"];
const process = (one, two) => [one, two].join(" ");

const product = array1.reduce((result, one) => result.concat(array2.map(two => process(one, two))), []);

JavaScript moderno en solo unas pocas líneas. Sin bibliotecas externas o dependencias como Lodash.

function cartesian(...arrays) {
  return arrays.reduce((a, b) => a.flatMap(x => b.map(y => x.concat([y]))), [ [] ]);
}

console.log(
  cartesian([1, 2], [10, 20], [100, 200, 300])
    .map(arr => JSON.stringify(arr))
    .join('\n')
);

Podría reducela matriz 2D. Úselo flatMapen la matriz de acumuladores para obtener el acc.length x curr.lengthnúmero de combinaciones en cada bucle. [].concat(c, n)se usa porque ces un número en la primera iteración y una matriz después.

const data = [ [1, 2], [10, 20], [100, 200, 300] ];

const output = data.reduce((acc, curr) =>
  acc.flatMap(c => curr.map(n => [].concat(c, n)))
)

console.log(JSON.stringify(output))

(Esto se basa en la respuesta de Nina Scholz )

Un enfoque no recursivo que agrega la capacidad de filtrar y modificar los productos antes de agregarlos al conjunto de resultados. Tenga en cuenta el uso de .map en lugar de .forEach. En algunos navegadores, .map se ejecuta más rápido.

function crossproduct(arrays,rowtest,rowaction) {
      // Calculate the number of elements needed in the result
      var result_elems = 1, row_size = arrays.length;
      arrays.map(function(array) {
            result_elems *= array.length;
      });
      var temp = new Array(result_elems), result = [];

      // Go through each array and add the appropriate element to each element of the temp
      var scale_factor = result_elems;
      arrays.map(function(array)
      {
        var set_elems = array.length;
        scale_factor /= set_elems;
        for(var i=result_elems-1;i>=0;i--) {
            temp[i] = (temp[i] ? temp[i] : []);
            var pos = i / scale_factor % set_elems;
            // deal with floating point results for indexes, this took a little experimenting
            if(pos < 1 || pos % 1 <= .5) {
                pos = Math.floor(pos);
            } else {
                pos = Math.min(array.length-1,Math.ceil(pos));
            }
            temp[i].push(array[pos]);
            if(temp[i].length===row_size) {
                var pass = (rowtest ? rowtest(temp[i]) : true);
                if(pass) {
                    if(rowaction) {
                        result.push(rowaction(temp[i]));
                    } else {
                        result.push(temp[i]);
                    }
                }
            }
        }
      });
      return result;
    }

Una solución simple "mental y visualmente amigable".

// t = [i, length]

const moveThreadForwardAt = (t, tCursor) => {
  if (tCursor < 0)
    return true; // reached end of first array

  const newIndex = (t[tCursor][0] + 1) % t[tCursor][1];
  t[tCursor][0] = newIndex;

  if (newIndex == 0)
    return moveThreadForwardAt(t, tCursor - 1);

  return false;
}

const cartesianMult = (...args) => {
  let result = [];
  const t = Array.from(Array(args.length)).map((x, i) => [0, args[i].length]);
  let reachedEndOfFirstArray = false;

  while (false == reachedEndOfFirstArray) {
    result.push(t.map((v, i) => args[i][v[0]]));

    reachedEndOfFirstArray = moveThreadForwardAt(t, args.length - 1);
  }

  return result;
}

// cartesianMult(
//   ['a1', 'b1', 'c1'],
//   ['a2', 'b2'],
//   ['a3', 'b3', 'c3'],
//   ['a4', 'b4']
// );

console.log(cartesianMult(
  ['a1'],
  ['a2', 'b2'],
  ['a3', 'b3']
));

Una versión simple y modificada del código de @ viebel en JavaScript simple:

function cartesianProduct(...arrays) {
  return arrays.reduce((a, b) => {
    return [].concat(...a.map(x => {
      const next = Array.isArray(x) ? x : [x];
      return [].concat(b.map(y => next.concat(...[y])));
    }));
  });
}

const product = cartesianProduct([1, 2], [10, 20], [100, 200, 300]);

console.log(product);
/*
[ [ 1, 10, 100 ],
  [ 1, 10, 200 ],
  [ 1, 10, 300 ],
  [ 1, 20, 100 ],
  [ 1, 20, 200 ],
  [ 1, 20, 300 ],
  [ 2, 10, 100 ],
  [ 2, 10, 200 ],
  [ 2, 10, 300 ],
  [ 2, 20, 100 ],
  [ 2, 20, 200 ],
  [ 2, 20, 300 ] ];
*/

Una implementación más legible

function productOfTwo(one, two) {
  return one.flatMap(x => two.map(y => [].concat(x, y)));
}

function product(head = [], ...tail) {
  if (tail.length === 0) return head;
  return productOfTwo(head, product(...tail));
}

const test = product(
  [1, 2, 3],
  ['a', 'b']
);

console.log(JSON.stringify(test));

f=(a,b,c)=>a.flatMap(ai=>b.flatMap(bi=>c.map(ci=>[ai,bi,ci])))

Esto es para 3 matrices.
Algunas respuestas dieron paso a cualquier número de matrices.
Esto puede contraerse o expandirse fácilmente a menos o más matrices.
Necesitaba combinaciones de un conjunto con repeticiones, por lo que podría haber usado:

f(a,a,a)

pero usado:

f=(a,b,c)=>a.flatMap(a1=>a.flatMap(a2=>a.map(a3=>[a1,a2,a3])))

Noté que nadie publicó una solución que permite pasar una función para procesar cada combinación, así que aquí está mi solución:

const _ = require('lodash')

function combinations(arr, f, xArr = []) {
    return arr.length>1 
    ? _.flatMap(arr[0], x => combinations(arr.slice(1), f, xArr.concat(x)))
    : arr[0].map(x => f(...xArr.concat(x)))
}

// use case
const greetings = ["Hello", "Goodbye"]
const places = ["World", "Planet"]
const punctuationMarks = ["!", "?"]
combinations([greetings,places,punctuationMarks], (greeting, place, punctuationMark) => `${greeting} ${place}${punctuationMark}`)
  .forEach(row => console.log(row))

Salida:

Hello World!
Hello World?
Hello Planet!
Hello Planet?
Goodbye World!
Goodbye World?
Goodbye Planet!
Goodbye Planet?

Enfoque de fuerza bruta de JS simple que toma una matriz de matrices como entrada.

var cartesian = function(arrays) {
    var product = [];
    var precals = [];
    var length = arrays.reduce(function(acc, curr) {
        return acc * curr.length
    }, 1);
    for (var i = 0; i < arrays.length; i++) {
        var array = arrays[i];
        var mod = array.length;
        var div = i > 0 ? precals[i - 1].div * precals[i - 1].mod : 1;
        precals.push({
            div: div,
            mod: mod
        });
    }
    for (var j = 0; j < length; j++) {
        var item = [];
        for (var i = 0; i < arrays.length; i++) {
            var array = arrays[i];
            var precal = precals[i];
            var k = (~~(j / precal.div)) % precal.mod;
            item.push(array[k]);
        }
        product.push(item);
    }
    return product;
};

cartesian([
    [1],
    [2, 3]
]);

cartesian([
    [1],
    [2, 3],
    [4, 5, 6]
]);

var chars = ['A', 'B', 'C']
var nums = [1, 2, 3]

var cartesianProduct = function() {
  return _.reduce(arguments, function(a, b) {
    return _.flatten(_.map(a, function(x) {
      return _.map(b, function(y) {
        return x.concat(y);
      });
    }), true);
  }, [
    []
  ]);
};

console.log(cartesianProduct(chars, nums))

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>

Acabo de convertir la respuesta de @ dummersl de CoffeScript a JavaScript. Simplemente funciona.

var chars = ['A', 'B', 'C']
var nums = [1, 2, 3]

var cartesianProduct = function() {
  return _.reduce(arguments, function(a, b) {
    return _.flatten(_.map(a, function(x) {
      return _.map(b, function(y) {
        return x.concat(y);
      });
    }), true);
  }, [[]]);
};

console.log( cartesianProduct(chars, nums) )

Otra implementación más. No es el más corto ni elegante, sino rápido:

function cartesianProduct() {
    var arr = [].slice.call(arguments),
        intLength = arr.length,
        arrHelper = [1],
        arrToReturn = [];

    for (var i = arr.length - 1; i >= 0; i--) {
        arrHelper.unshift(arrHelper[0] * arr[i].length);
    }

    for (var i = 0, l = arrHelper[0]; i < l; i++) {
        arrToReturn.push([]);
        for (var j = 0; j < intLength; j++) {
            arrToReturn[i].push(arr[j][(i / arrHelper[j + 1] | 0) % arr[j].length]);
        }
    }

    return arrToReturn;
}

¡No se necesitan bibliotecas! :)

Sin embargo, necesita funciones de flecha y probablemente no sea tan eficiente. : /

const flatten = (xs) => 
    xs.flat(Infinity)

const binaryCartesianProduct = (xs, ys) =>
    xs.map((xi) => ys.map((yi) => [xi, yi])).flat()

const cartesianProduct = (...xss) =>
    xss.reduce(binaryCartesianProduct, [[]]).map(flatten)
      
console.log(cartesianProduct([1,2,3], [1,2,3], [1,2,3]))

Para el registro

Aquí va mi versión. Lo hice usando el iterador javascript más simple "for ()", por lo que es compatible en todos los casos y tiene el mejor rendimiento.

function cartesian(arrays){
    var quant = 1, counters = [], retArr = [];

    // Counts total possibilities and build the counters Array;
    for(var i=0;i<arrays.length;i++){
        counters[i] = 0;
        quant *= arrays[i].length;
    }

    // iterate all possibilities
    for(var i=0,nRow;i<quant;i++){
        nRow = [];
        for(var j=0;j<counters.length;j++){
            if(counters[j] < arrays[j].length){
                nRow.push(arrays[j][counters[j]]);
            } else { // in case there is no such an element it restarts the current counter
                counters[j] = 0;
                nRow.push(arrays[j][counters[j]]);
            }
            counters[j]++;
        }
        retArr.push(nRow);
    }
    return retArr;
}

Atentamente.