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

¿Hay alguna forma de map/ reduce/ filter/ etc a Seten JavaScript o tendré que escribir la mía?

Aquí hay algunas Set.prototypeextensiones sensatas

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 forma mejor de lograr mapy reduceusar un SetJavaScript?

Una forma abreviada 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()

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

En cuanto a map, llamarlo solo podría violar elSet restricción, 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 mapparte en cada elemento justo antes de pasarlos reduce, aceptando así que la colección intermedia ( que no es un Conjunto en este punto ) es podría reducirse podría tener elementos duplicados. Esto es esencialmente equivalente a convertir a Array para hacer el procesamiento.

La causa de la falta de map/ reduce/ filteren Map/ Setcolecciones parecen ser principalmente preocupaciones conceptuales. 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 vez 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 entries / values/ keysreturnIterator s. Sin embargo, es concebible que no todos los iterables sean "mapeables". Otra alternativa era especificar un "protocolo de recolección" separado para este mismo propósito.

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