Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Set below:

Set - JavaScript | MDN

Baseline Widely available *

Das Set-Objekt ermöglicht das Speichern einzigartiger Werte jeglichen Typs, seien es primitive Werte oder Objektreferenzen.

Set-Objekte sind Sammlungen von Werten. Ein Wert im Set darf nur einmal vorkommen; er ist einzigartig in der Sammlung des Sets. Sie können durch die Elemente eines Sets in der Einfügereihenfolge iterieren. Die Einfügereihenfolge entspricht der Reihenfolge, in der jedes Element erfolgreich mittels der add()-Methode ins Set eingefügt wurde (das heißt, es gab kein identisches Element bereits im Set bei dem Aufruf von add()).

Die Spezifikation erfordert, dass Sets so implementiert werden, "dass sie im Durchschnitt Zugriffszeiten bieten, die sublinear zur Anzahl der Elemente in der Sammlung sind". Daher könnte es intern als Hashtabelle (mit O(1) Zugriff), Suchbaum (mit O(log(N)) Zugriff) oder einer anderen Datenstruktur dargestellt werden, solange die Komplexität besser als O(N) ist.

Die Wertgleichheit basiert auf dem SameValueZero-Algorithmus. (Früher wurde SameValue verwendet, das 0 und -0 als unterschiedlich behandelte. Überprüfen Sie die Browser-Kompatibilität.) Dies bedeutet, dass NaN als gleich zu NaN betrachtet wird (obwohl NaN !== NaN) und alle anderen Werte gemäß der ===-Operatorsemantik als gleich betrachtet werden.

Die Methode has überprüft, ob ein Wert im Set vorhanden ist, wobei ein Ansatz verwendet wird, der im Durchschnitt schneller ist als das Testen der meisten Elemente, die zuvor zum Set hinzugefügt wurden. Insbesondere ist sie im Durchschnitt schneller als die Methode Array.prototype.includes, wenn ein Array eine length hat, die der size eines Sets entspricht.

Das Set-Objekt bietet einige Methoden, die Ihnen ermöglichen, Sets wie bei mathematischen Operationen zu komponieren. Diese Methoden umfassen:

Um sie allgemeiner anwendbar zu machen, akzeptieren diese Methoden nicht nur Set-Objekte, sondern alles, was Set-ähnlich ist.

Alle Set-Kompositionsmethoden erfordern, dass this eine tatsächliche Set-Instanz ist, aber ihre Argumente müssen nur set-ähnlich sein. Ein set-ähnliches Objekt ist ein Objekt, das Folgendes bereitstellt:

• Eine size-Eigenschaft, die eine Zahl enthält.
• Eine has()-Methode, die ein Element übernimmt und einen Boolean zurückgibt.
• Eine keys()-Methode, die einen Iterator der Elemente im Set zurückgibt.

Beispielsweise sind Map-Objekte set-ähnlich, weil sie ebenfalls size, has(), und keys() haben, sodass sie sich wie Mengen von Schlüsseln verhalten, wenn sie in Set-Methoden verwendet werden:

const a = new Set([1, 2, 3]);
const b = new Map([
  [1, "one"],
  [2, "two"],
  [4, "four"],
]);
console.log(a.union(b)); // Set(4) {1, 2, 3, 4}

Hinweis: Das set-ähnliche Protokoll ruft die keys()-Methode anstelle von [Symbol.iterator]() auf, um Elemente zu erzeugen. Dies dient dazu, Karten zu gültigen set-ähnlichen Objekten zu machen, da beim Karten-Iterator Einträge produziert werden, jedoch die has()-Methode Schlüssel benötigt.

Arrays sind nicht set-ähnlich, da sie keine has()-Methode oder die size-Eigenschaft haben und ihre keys()-Methode Indizes anstelle von Elementen produziert. WeakSet-Objekte sind ebenfalls nicht set-ähnlich, da sie keine keys()-Methode haben.

Set-ähnliche Objekte (oder "set-ähnliche Objekte" im Browser) sind Web API-Schnittstellen, die sich in vielen Aspekten wie ein Set verhalten.

Genau wie Set können die Elemente in der gleichen Reihenfolge iteriert werden, in der sie dem Objekt hinzugefügt wurden. Set-ähnliche Objekte und Set haben auch Eigenschaften und Methoden, die den gleichen Namen und das gleiche Verhalten teilen. Im Gegensatz zu Set erlauben sie jedoch nur einen spezifischen vordefinierten Typ für jeden Eintrag.

Die erlaubten Typen sind in der Spezifikation der IDL-Definition festgelegt. Zum Beispiel ist GPUSupportedFeatures ein Set-ähnliches Objekt, das Zeichenfolgen als Schlüssel/Wert verwenden muss. Dies ist in der Spezifikation der unteren IDL definiert:

interface GPUSupportedFeatures {
  readonly setlike<DOMString>;
};

Set-ähnliche Objekte sind entweder schreibgeschützt oder schreib-/lesbar (siehe das readonly Schlüsselwort in der oberen IDL).

• Schreibgeschützte Set-ähnliche Objekte haben die Eigenschaft size, und die Methoden: entries(), forEach(), has(), keys(), values(), und Symbol.iterator().
• Beschreibbare Set-ähnliche Objekte haben zusätzlich die Methoden: clear(), delete(), und add().

Die Methoden und Eigenschaften haben das gleiche Verhalten wie die entsprechenden Entitäten in Set, außer der Einschränkung auf die Typen des Eintrags.

Folgende sind Beispiele für schreibgeschützte Set-ähnliche Browser-Objekte:

• GPUSupportedFeatures
• XRAnchorSet

Folgende sind Beispiele für beschreibbare Set-ähnliche Browser-Objekte:

• CustomStateSet
• FontFaceSet
• Highlight

Set()

Erstellt ein neues Set-Objekt.

Set[Symbol.species]

Die Konstrukturfunktion, die verwendet wird, um abgeleitete Objekte zu erstellen.

Diese Eigenschaften sind auf Set.prototype definiert und werden von allen Set-Instanzen geteilt.

Set.prototype.constructor

Die Konstrukturfunktion, die das Instanzobjekt erstellt hat. Für Set-Instanzen ist der initiale Wert der Set-Konstruktor.

Set.prototype.size

Gibt die Anzahl der Werte im Set-Objekt zurück.

Set.prototype[Symbol.toStringTag]

Der initiale Wert der [Symbol.toStringTag]-Eigenschaft ist der String "Set". Diese Eigenschaft wird in Object.prototype.toString() verwendet.

Set.prototype.add()

Fügt ein neues Element mit einem angegebenen Wert in ein Set-Objekt ein, falls nicht bereits ein Element mit gleichem Wert im Set vorhanden ist.

Set.prototype.clear()

Entfernt alle Elemente aus dem Set-Objekt.

Set.prototype.delete()

Entfernt das mit dem Wert assoziierte Element und gibt einen Boolean zurück, der bestätigt, ob ein Element erfolgreich entfernt wurde oder nicht. Set.prototype.has(value) wird danach false zurückgeben.

Set.prototype.difference()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente enthält, die sich in diesem Set befinden, aber nicht im angegebenen Set.

Set.prototype.entries()

Gibt ein neues Iterator-Objekt zurück, das ein Array von [value, value] für jedes Element im Set-Objekt in Einfügereihenfolge enthält. Dies ist dem Map-Objekt ähnlich, sodass der Schlüssel jedes Eintrags für ein Set der gleiche wie dessen Wert ist.

Set.prototype.forEach()

Ruft callbackFn einmal für jeden im Set-Objekt vorhandenen Wert in Einfügereihenfolge auf. Falls ein thisArg-Parameter angegeben wird, wird er als this-Wert für jeden Aufruf von callbackFn verwendet.

Set.prototype.has()

Gibt einen Boolean zurück, der bestätigt, ob ein Element mit dem gegebenen Wert im Set-Objekt vorhanden ist oder nicht.

Set.prototype.intersection()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente enthält, die sowohl in diesem Set als auch im gegebenen Set sind.

Set.prototype.isDisjointFrom()

Nimmt ein Set und gibt einen Boolean zurück, der anzeigt, ob dieses Set keine gemeinsamen Elemente mit dem angegebenen Set hat.

Set.prototype.isSubsetOf()

Nimmt ein Set und gibt einen Boolean zurück, der anzeigt, ob alle Elemente dieses Sets im angegebenen Set sind.

Set.prototype.isSupersetOf()

Nimmt ein Set und gibt einen Boolean zurück, der anzeigt, ob alle Elemente des angegebenen Sets in diesem Set sind.

Set.prototype.keys()

Ein Alias für Set.prototype.values().

Set.prototype.symmetricDifference()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente enthält, die entweder in diesem Set oder im angegebenen Set sind, aber nicht in beiden.

Set.prototype.union()

Nimmt ein Set und gibt ein neues Set zurück, das Elemente enthält, die entweder in diesem oder im angegebenen Set oder in beiden sind.

Set.prototype.values()

Gibt ein neues Iterator-Objekt zurück, das die Werte für jedes Element im Set-Objekt in Einfügereihenfolge liefert.

Set.prototype[Symbol.iterator]()

Gibt ein neues Iterator-Objekt zurück, das die Werte für jedes Element im Set-Objekt in Einfügereihenfolge liefert.

const mySet1 = new Set();

mySet1.add(1); // Set(1) { 1 }
mySet1.add(5); // Set(2) { 1, 5 }
mySet1.add(5); // Set(2) { 1, 5 }
mySet1.add("some text"); // Set(3) { 1, 5, 'some text' }
const o = { a: 1, b: 2 };
mySet1.add(o);

mySet1.add({ a: 1, b: 2 }); // o is referencing a different object, so this is okay

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

mySet1.size; // 5

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

mySet1.size; // 4, since we just removed one value

mySet1.add(5); // Set(5) { 1, 'some text', {...}, {...}, 5 } - a previously deleted item will be added as a new item, it will not retain its original position before deletion

console.log(mySet1); // Set(5) { 1, "some text", {…}, {…}, 5 }

Die Iteration über ein Set besucht Elemente in Einfügereihenfolge.

for (const item of mySet1) {
  console.log(item);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

for (const item of mySet1.keys()) {
  console.log(item);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

for (const item of mySet1.values()) {
  console.log(item);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

// key and value are the same here
for (const [key, value] of mySet1.entries()) {
  console.log(key);
}
// 1, "some text", { "a": 1, "b": 2 }, { "a": 1, "b": 2 }, 5

// Convert Set object to an Array object, with Array.from
const myArr = Array.from(mySet1); // [1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}, 5]

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

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

// intersect can be simulated via
const intersection = new Set([...mySet1].filter((x) => mySet2.has(x)));

// difference can be simulated via
const difference = new Set([...mySet1].filter((x) => !mySet2.has(x)));

// Iterate set entries with forEach()
mySet2.forEach((value) => {
  console.log(value);
});
// 1
// 2
// 3
// 4

function isSuperset(set, subset) {
  for (const elem of subset) {
    if (!set.has(elem)) {
      return false;
    }
  }
  return true;
}

function union(setA, setB) {
  const _union = new Set(setA);
  for (const elem of setB) {
    _union.add(elem);
  }
  return _union;
}

function intersection(setA, setB) {
  const _intersection = new Set();
  for (const elem of setB) {
    if (setA.has(elem)) {
      _intersection.add(elem);
    }
  }
  return _intersection;
}

function symmetricDifference(setA, setB) {
  const _difference = new Set(setA);
  for (const elem of setB) {
    if (_difference.has(elem)) {
      _difference.delete(elem);
    } else {
      _difference.add(elem);
    }
  }
  return _difference;
}

function difference(setA, setB) {
  const _difference = new Set(setA);
  for (const elem of setB) {
    _difference.delete(elem);
  }
  return _difference;
}

// Examples
const setA = new Set([1, 2, 3, 4]);
const setB = new Set([2, 3]);
const setC = new Set([3, 4, 5, 6]);

isSuperset(setA, setB); // returns true
union(setA, setC); // returns Set {1, 2, 3, 4, 5, 6}
intersection(setA, setC); // returns Set {3, 4}
symmetricDifference(setA, setC); // returns Set {1, 2, 5, 6}
difference(setA, setC); // returns Set {1, 2}

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

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

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

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

// Use to remove duplicate elements from an array
const numbers = [2, 13, 4, 4, 2, 13, 13, 4, 4, 5, 5, 6, 6, 7, 5, 32, 13, 4, 5];

console.log([...new Set(numbers)]); // [2, 13, 4, 5, 6, 7, 32]

// Case sensitive (set will contain "F" and "f")
new Set("Firefox"); // Set(7) [ "F", "i", "r", "e", "f", "o", "x" ]

// Duplicate omission ("f" occurs twice in the string but set will contain only one)
new Set("firefox"); // Set(6) [ "f", "i", "r", "e", "o", "x" ]

const array = Array.from(document.querySelectorAll("[id]")).map((e) => e.id);

const set = new Set(array);
console.assert(set.size === array.length);

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4