Diese Übersetzung ist unvollständig. Bitte helfen Sie, diesen Artikel aus dem Englischen zu übersetzen.

Ein Set-Objekt speichert eindeutige Werte jedes beliebigen Typs, egal ob es sich dabei um primitive Werte oder Objektreferenzen handelt.

Syntax

new Set([iterable]);

Parameter

iterable
Ein iterierbares Objekt, dessen Elemente zum neuen Set hinzugefügt werden sollen.
Ist dieser Parameter nicht angegeben oder null, wird ein leeres Set erzeugt.

Beschreibung

Set-Objekte sind Sammlungen von Werten. Jeder ist Wert nur einmal vorhanden; er ist im Set eindeutig.
Die Werte werden in der Reihenfolge ihres Hinzufügens gespeichert.

Gleichheit

Da jeder Wert innerhalb eines Sets eindeutig sein muss, wird seine Gleichheit geprüft, jedoch nicht mit dem Algorithmus des Operators ===

Insbesondere waren bis zur Veröffentlichung von ECMAScript 6 +0 und -0 unterschiedlich, obwohl sie mathematisch betrachtet identisch sind. Der Stand der Umsetzung ist der Tabelle Browserkompatibilität zu entnehmen.

NaN und undefined können ebenfalls in einem Set gespeichert werden. NaN wird dabei als identisch zu NaN behandelt, obwohl NaN !== NaN.

Eigenschaften

Set.length
Der Wert der Eigenschaft length ist immer 0.
Die Anzahl der Elemente eines Sets befindet sich in Set.prototype.size.
get Set[@@species]
The constructor function that is used to create derived objects.
Set.prototype
Represents the prototype for the Set constructor. Allows the addition of properties to all Set objects.

Set instances

All Set instances inherit from Set.prototype.

Properties

Set.prototype.constructor
Returns the function that created an instance's prototype. This is the Set function by default.
Set.prototype.size
Returns the number of values in the Set object.

Methods

Set.prototype.add(value)
Appends a new element with the given value to the Set object. Returns the Set object.
Set.prototype.clear()
Removes all elements from the Set object.
Set.prototype.delete(value)
Removes the element associated to the value and returns the value that Set.prototype.has(value) would have previously returned. Set.prototype.has(value) will return false afterwards.
Set.prototype.entries()
Returns a new Iterator object that contains an array of [value, value] for each element in the Set object, in insertion order. This is kept similar to the Map object, so that each entry has the same value for its key and value here.
Set.prototype.forEach(callbackFn[, thisArg])
Calls callbackFn once for each value present in the Set object, in insertion order. If a thisArg parameter is provided to forEach, it will be used as the this value for each callback.
Set.prototype.has(value)
Returns a boolean asserting whether an element is present with the given value in the Set object or not.
Set.prototype.keys()
Is the same function as the values() function and returns a new Iterator object that contains the values for each element in the Set object in insertion order.
Set.prototype.values()
Returns a new Iterator object that contains the values for each element in the Set object in insertion order.
Set.prototype[@@iterator]()
Returns a new Iterator object that contains the values for each element in the Set object in insertion order.

Examples

Using the Set object

var mySet = new Set();

mySet.add(1);
mySet.add(5);
mySet.add("some text");
var o = {a: 1, b: 2};
mySet.add(o);

mySet.has(1); // true
mySet.has(3); // false, 3 has not been added to the set
mySet.has(5);              // true
mySet.has(Math.sqrt(25));  // true
mySet.has("Some Text".toLowerCase()); // true
mySet.has(o); // true

mySet.size; // 4

mySet.delete(5); // removes 5 from the set
mySet.has(5);    // false, 5 has been removed

mySet.size; // 3, we just removed one value

Iterating Sets

// iterate over items in set
// logs the items in the order: 1, "some text" 
for (let item of mySet) console.log(item);

// logs the items in the order: 1, "some text" 
for (let item of mySet.keys()) console.log(item);
 
// logs the items in the order: 1, "some text" 
for (let item of mySet.values()) console.log(item);

// logs the items in the order: 1, "some text" 
//(key and value are the same here)
for (let [key, value] of mySet.entries()) console.log(key);

// convert set to plain Array
var myArr = Array.from(mySet); // [1, "some text"]

// the following will also work if run in an HTML document
mySet.add(document.body);
mySet.has(document.querySelector("body")); // true

// converting between Set and Array
mySet2 = new Set([1,2,3,4]);
mySet2.size; // 4
[...mySet2]; // [1,2,3,4]

// intersect can be simulated via 
var intersection = new Set([...set1].filter(x => set2.has(x)));

// difference can be simulated via
var difference = new Set([...set1].filter(x => !set2.has(x)));

// Iterate set entries with forEach
mySet.forEach(function(value) {
  console.log(value);
});

// 1
// 2
// 3
// 4

Relation with Array objects

var myArray = ["value1", "value2", "value3"];

// Use the regular Set constructor to transform an Array into a Set
var mySet = new Set(myArray);

mySet.has("value1"); // returns true

// Use the spread operator to transform a set into an Array.
console.log([...mySet]); // Will show you exactly the same Array as myArray

Specifications

Specification Status Comment
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Set' in dieser Spezifikation.
Standard Initial definition.
ECMAScript Latest Draft (ECMA-262)
Die Definition von 'Set' in dieser Spezifikation.
Entwurf  

Browser compatibility

Wir konvertieren die Kompatibilitätsdaten in ein maschinenlesbares JSON Format. Diese Kompatibilitätstabelle liegt noch im alten Format vor, denn die darin enthaltenen Daten wurden noch nicht konvertiert. Finde heraus wie du helfen kannst!

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support

38 [1]

13 (13) 11 25 7.1
Constructor argument: new Set(iterable) 38 13 (13) Nicht unterstützt 25 9.0
iterable 38 17 (17) Nicht unterstützt 25 7.1
Set.clear() 38 19 (19) 11 25 7.1
Set.keys(), Set.values(), Set.entries() 38 24 (24) Nicht unterstützt 25 7.1
Set.forEach() 38 25 (25) 11 25 7.1
Value equality for -0 and 0 38 29 (29) Nicht unterstützt 25 Nicht unterstützt
Constructor argument: new Set(null) (Ja) 37 (37) ? ? ?
Monkey-patched add() in Constructor (Ja) 37 (37) ? ? ?
Set[@@species] ? 41 (41) ? ? ?
Set() without new throws ? 42 (42) ? ? ?
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support Nicht unterstützt 38 [1] 13.0 (13) Nicht unterstützt Nicht unterstützt 8
Constructor argument: new Set(iterable) Nicht unterstützt 38 13.0 (13) Nicht unterstützt Nicht unterstützt Nicht unterstützt
iterable Nicht unterstützt Nicht unterstützt 17.0 (17) Nicht unterstützt Nicht unterstützt 8
Set.clear() Nicht unterstützt 38 19.0 (19) Nicht unterstützt Nicht unterstützt 8
Set.keys(), Set.values(), Set.entries() Nicht unterstützt 38 24.0 (24) Nicht unterstützt Nicht unterstützt 8
Set.forEach() Nicht unterstützt 38 25.0 (25) Nicht unterstützt Nicht unterstützt 8
Value equality for -0 and 0 Nicht unterstützt 38 29.0 (29) Nicht unterstützt Nicht unterstützt Nicht unterstützt
Constructor argument: new Set(null) ? (Ja) 37.0 (37) ? ? ?
Monkey-patched add() in Constructor ? (Ja) 37.0 (37) ? ? ?
Set[@@species] ? ? 41.0 (41) ? ? ?
Set() without new throws ? ? 42.0 (42) ? ? ?

[1] The feature was available behind a preference from Chrome 31. In chrome://flags, activate the entry “Enable Experimental JavaScript”.

See also

Schlagwörter des Dokuments und Mitwirkende

Mitwirkende an dieser Seite: mdnde2, Flonk, schlagi123, sspringer82
Zuletzt aktualisiert von: mdnde2,