metodo - que hace map en javascript

¿Cómo mapear/reducir/filtrar un conjunto en JavaScript?

Question

¿Hay alguna forma de map / reduce / filter / etc. un Set en JavaScript o tendré que escribir el mío?

Aquí hay algunas extensiones sensatas de Set.prototype

Set.prototype.map = function map(f) {
  var newSet = new Set();
  for (var v of this.values()) newSet.add(f(v));
  return newSet;
};

Set.prototype.reduce = function(f,initial) {
  var result = initial;
  for (var v of this) result = f(result, v);
  return result;
};

Set.prototype.filter = function filter(f) {
  var newSet = new Set();
  for (var v of this) if(f(v)) newSet.add(v);
  return newSet;
};

Set.prototype.every = function every(f) {
  for (var v of this) if (!f(v)) return false;
  return true;
};

Set.prototype.some = function some(f) {
  for (var v of this) if (f(v)) return true;
  return false;
};

Tomemos un pequeño set

let s = new Set([1,2,3,4]);

Y algunas estúpidas funciones

const times10 = x => x * 10;
const add = (x,y) => x + y;
const even = x => x % 2 === 0;

Y mira cómo funcionan

s.map(times10);    //=> Set {10,20,30,40}
s.reduce(add, 0);  //=> 10
s.filter(even);    //=> Set {2,4}
s.every(even);     //=> false
s.some(even);      //=> true

¿No es lindo? Sí, yo también lo creo. Compare eso con el uso del iterador feo

// puke
let newSet = new Set();
for (let v in s) {
  newSet.add(times10(v));
}

Y

// barf
let sum = 0;
for (let v in s) {
  sum = sum + v;
}

¿Hay alguna manera mejor de lograr un map y reduce usando un Set en JavaScript?

Answer 1

La causa de la falta de map / reduce / filter en colecciones de Map / Set parece ser principalmente una preocupación conceptual. Si cada tipo de colección en Javascript especifica realmente sus propios métodos iterativos solo para permitir esto

const mySet = new Set([1,2,3]);
const myMap = new Map([[1,1],[2,2],[3,3]]);

mySet.map(x => x + 1);
myMap.map(([k, x]) => [k, x + 1]);

en lugar de

new Set(Array.from(mySet.values(), x => x + 1));
new Map(Array.from(myMap.entries(), ([k, x]) => [k, x + 1]));

Una alternativa era especificar map / reduce / filter como parte del protocolo iterable / iterator, ya que las entries / values / keys devuelven Iterator s. Sin embargo, es concebible que no todos los iterables sean "mapeables". Otra alternativa era especificar un "protocolo de recopilación" separado para este mismo propósito.

Sin embargo, no conozco la discusión actual sobre este tema en ES.

Answer 2

Para resumir la discusión de los comentarios: si bien no hay razones técnicas para que el conjunto no tenga reduce , actualmente no se proporciona y solo podemos esperar que cambie en ES7.

En cuanto al map , llamarlo solo podría violar la restricción Set , por lo que su presencia aquí podría ser discutible.

Considere mapear con una función (a) => 42 : cambiará el tamaño del conjunto a 1, y esto podría o no ser lo que deseaba.

Si está de acuerdo con violar eso porque, por ejemplo, va a doblar de todos modos, puede aplicar la parte del map en cada elemento justo antes de pasarlos para reduce , aceptando así la colección intermedia ( que no es un Conjunto en este punto ) que se reducirá podría tener elementos duplicados. Esto es esencialmente equivalente a convertir a Array para hacer el procesamiento.

Answer 3

Una forma fácil de hacerlo es convertirlo en una matriz a través del operador de propagación ES6.

Entonces todas las funciones de la matriz están disponibles para usted.

const mySet = new Set([1,2,3,4]);
[...mySet].reduce()