Wie kann ich ein Set in JavaScript zuordnen/reduzieren/filtern?

Question 1

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

Hier ist etwas Vernünftiges Set.prototype Erweiterungen

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 Sie, 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 Verwendung des Iterators

// 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 einen besseren Weg, dies zu erreichen map und reduce Verwendung einer Set in Javascript?

Question 2

Ein kurzer Weg, dies zu tun, besteht darin, es über den Spread-Operator ES6 in ein Array zu konvertieren.

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

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

Question 3

Um die Diskussion aus Kommentaren zusammenzufassen: Es gibt zwar keine technischen Gründe für die Einstellung nicht haben reducees wird derzeit nicht bereitgestellt und wir können nur hoffen, dass es sich in ES7 ändert.

Wie für mapes allein zu nennen, könnte die verletzen Set Einschränkung, daher könnte seine Anwesenheit hier umstritten sein.

Betrachten Sie die Zuordnung mit einer Funktion (a) => 42 – Es wird die Größe des Satzes auf 1 ändern, und dies könnte oder vielleicht auch nicht sei, was du wolltest.

Wenn Sie damit einverstanden sind, dagegen zu verstoßen, weil Sie zB sowieso folden, können Sie das anwenden map Teil auf jedem Element, kurz bevor Sie sie weitergeben reducewodurch akzeptiert wird, dass die Zwischensammlung (was an dieser Stelle kein Set ist), die reduziert werden soll, kann doppelte Elemente enthalten. Dies entspricht im Wesentlichen der Konvertierung in Array, um die Verarbeitung durchzuführen.

Question 4

Die Ursache für das Fehlen von map/reduce/filter an Map/Set Sammlungen scheinen hauptsächlich konzeptionelle Anliegen zu sein. Sollte jeder Sammlungstyp in Javascript tatsächlich seine eigenen iterativen Methoden angeben, nur um dies zu ermöglichen

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 von

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

Eine Alternative wäre, map/reduce/filter als Teil des Iterable/Iterator-Protokolls anzugeben, da entries/values/keys Rückkehr Iterators. Denkbar ist aber, dass nicht jedes Iterable auch „mappable“ ist. Eine andere Alternative wäre, genau zu diesem Zweck ein separates „Sammelprotokoll“ vorzugeben.

Allerdings kenne ich die aktuelle Diskussion zu diesem Thema bei ES nicht.

Question 5

const set = new Set([1,2,3,4,5]);

function filterSet(index) {
    set.delete([...set][index]);
}

filterSet(3); // Set { 1, 2, 3, 5, [size]: 4 }

dachte, dies sei eine ziemlich anständige Lösung zum “Filtern” des Sets.