Wie ordne / reduziere / filtere ich ein Set in JavaScript?

Gibt es eine Möglichkeit zu map/ reduce/ filter/ etc a Setin JavaScript oder muss ich meine eigene schreiben?

Hier sind einige sinnvolle Set.prototypeErweiterungen

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;
};

Nehmen wir ein kleines Set

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

Und einige dumme kleine Funktionen

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

Und sehen, wie sie funktionieren

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

Ist das nicht schön Ja, das denke ich auch. Vergleichen Sie das mit der hässlichen Iterator-Verwendung

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

Und

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

Gibt es eine bessere Möglichkeit, eine in JavaScript zu erreichen mapund zu reduceverwenden Set?

Eine kurze Möglichkeit besteht darin, es über den ES6-Spread-Operator in ein Array zu konvertieren.

Dann stehen Ihnen alle Array-Funktionen zur Verfügung.

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

Um die Diskussion von Kommentaren Fazit: während es keine technischen Gründe für Satz sind nicht hat reduce, ist es derzeit nicht zur Verfügung gestellt und wir können nur hoffen , dass es in ES7 ändert.

Wenn Sie mapes alleine nennen, kann dies die SetEinschränkung verletzen , sodass seine Anwesenheit hier möglicherweise umstritten ist.

Ziehen Sie eine Zuordnung mit einer Funktion in Betracht (a) => 42- dadurch wird die Größe des Sets auf 1 geändert, und dies könnte das sein, was Sie wollten oder nicht .

Wenn Sie damit einverstanden sind, weil Sie z. B. sowieso falten, können Sie das mapTeil auf jedes Element anwenden, bevor Sie es übergeben, reduceund so akzeptieren, dass die Zwischensammlung ( die zu diesem Zeitpunkt kein Set ist ) das ist reduziert werden könnte doppelte Elemente haben. Dies entspricht im Wesentlichen der Konvertierung in ein Array für die Verarbeitung.

Die Ursache für den Mangel an map/ reduce/ filteron Map/ SetSammlungen scheinen hauptsächlich konzeptionelle Bedenken zu sein. Sollte jeder Sammlungstyp in Javascript tatsächlich seine eigenen iterativen Methoden angeben, nur um dies zuzulassen

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]);

anstatt

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

Eine Alternative bestand darin, map / redu / filter als Teil des iterable / iterator-Protokolls anzugeben, da entries/ values/ keysreturn Iterators. Es ist jedoch denkbar, dass nicht jedes iterable auch "abbildbar" ist. Eine andere Alternative bestand darin, zu diesem Zweck ein separates "Sammelprotokoll" anzugeben.

Die aktuelle Diskussion zu diesem Thema bei ES kenne ich jedoch nicht.