Por ejemplo, tengo una serie de funciones: [func1, func2, func3, func4] y matriz de argumentos [arg1, arg2, arg3, arg4]. Necesito aplicar func1 a arg1, func2 a arg2, etc.

¿Cuál es la mejor manera de hacer esto? Por supuesto, puedo usar un bucle simple para pasar por los elementos, pero tal vez exista una forma más elegante.

0
splash27 16 feb. 2017 a las 07:46

3 respuestas

La mejor respuesta

Hay algunas formas de hacerlo. Sugeriría usar el método .map() para iterar sobre las funciones, porque entonces puede poner fácilmente sus valores de retorno en otra matriz:

const results = funcs.map((f, i) => f(args[i]))

En contexto:

const funcs = [
  (a) => a * 2,
  (a) => a * 3,
  (a) => a * 4,
  (a) => a * 5
]
const args = [1, 2, 3, 4]
const results = funcs.map((f, i) => f(args[i]))

console.log(results)
4
nnnnnn 16 feb. 2017 a las 04:57

No sé si es "elegante", pero puedes hacerlo

let results = functionArray.map((f, i) => f(arguments[i]))

Esto toma cada función en su matriz, encuentra el argumento asociado i y llama a la función con ese argumento.

3
bejado 16 feb. 2017 a las 04:49

Si usa una biblioteca como Lodash, puede usar _.zipWith, que itera varias matrices a la vez, todas en paralelo, llamando a la función proporcionada con los elementos de las matrices.

const results = _.zipWith(funcs, args, (f, a) => f(a));

Si desea una implementación simple de zipWith sin importar la biblioteca, use:

const zipWith = (...arrays) => {
  const func = arrays.pop();
  return arrays[0].map((_, i) => func(...arrays.map(arr => arr[i])));
};
const zipWith = (...arrays) => {
  const func = arrays.pop();
  return arrays[0].map((_, i) => func(...arrays.map(arr => arr[i])));
};

const funcs = [
  a => a * 2,
  a => a * 3,
  a => a * 4,
  a => a * 5
];
const args = [1, 2, 3, 4];

console.log(zipWith(funcs, args, (f, a) => f(a)));
1
4castle 16 feb. 2017 a las 05:43