Map.prototype.has() — Methode · JavaScript-Referenz

Signatur

Map.prototype.has(key)

Beschreibung

Die Methode has() von Map-Instanzen gibt einen booleschen Wert zurück. Er zeigt an, ob in der Map ein Eintrag mit dem angegebenen Schlüssel existiert. Der Wert des Eintrags spielt dabei keine Rolle: Auch ein Eintrag mit dem Wert undefined gilt als vorhanden.

Genau das ist der wichtigste Unterschied zu einer Prüfung mit map.get(key) !== undefined. Nur has() kann zuverlässig unterscheiden, ob ein Schlüssel fehlt oder ob unter ihm undefined gespeichert ist. Typische Einsatzfälle sind Caches, das Entfernen von Duplikaten, Zähler und das Prüfen, ob etwas schon registriert ist.

Schlüssel werden nach dem Algorithmus SameValueZero verglichen. Deshalb gilt NaN als gleich zu NaN, und +0 und -0 werden gleich behandelt. Objekte, Arrays und Funktionen werden über ihre Referenz verglichen, nicht über ihren Inhalt. Die Suche läuft bei gängigen Implementierungen im Mittel in konstanter Zeit (sublinear, wie von der Spezifikation verlangt).

Parameter

Name	Typ	Default	Beschreibung
$key Pflicht	any		Der Schlüssel, nach dem in der `Map` gesucht wird. Das kann jeder Wert sein, auch Objekte, Funktionen oder `NaN`.

Rückgabewert

Typ

boolean

Beschreibung

true, wenn ein Eintrag mit dem Schlüssel existiert, sonst false.

Beispiele

Einfache Prüfung auf vorhandene Schlüssel

const rollen = new Map([
  ['anna', 'admin'],
  ['ben', 'editor']
]);

console.log(rollen.has('anna'));
console.log(rollen.has('clara'));

true false

has() statt get() bei undefined-Werten

const einstellungen = new Map();
einstellungen.set('theme', undefined);

// get() kann fehlende und undefined-Einträge nicht unterscheiden
console.log(einstellungen.get('theme') !== undefined);
console.log(einstellungen.has('theme'));
console.log(einstellungen.has('sprache'));

false true false

Einfacher Cache für asynchrone Anfragen

const cache = new Map();

const ladeBenutzer = async (id) => {
  if (cache.has(id)) {
    return cache.get(id);
  }
  const res = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  const daten = await res.json();
  cache.set(id, daten);
  return daten;
};

const main = async () => {
  await ladeBenutzer(1);          // Netzwerkanfrage
  console.log(cache.has(1));      // jetzt im Cache
};
main();

true

Objektschlüssel werden per Referenz verglichen

const knoten = { id: 1 };
const besucht = new Map([[knoten, true]]);

console.log(besucht.has(knoten));     // gleiche Referenz
console.log(besucht.has({ id: 1 }));  // neues Objekt, andere Referenz

const zahlen = new Map([[NaN, 'keine Zahl']]);
console.log(zahlen.has(NaN));         // SameValueZero

true false true

// Wichtig · Fallstricke

Referenzvergleich: map.has({ a: 1 }) ist fast immer false, weil jedes Objektliteral eine neue Referenz erzeugt. Wer nach Inhalt suchen will, braucht einen einfachen Schlüssel, etwa eine ID oder einen serialisierten String.
Keine Typumwandlung: Anders als bei normalen Objekten sind 1 und '1' in einer Map zwei verschiedene Schlüssel.
has() + get(): Das Muster durchsucht die Map zweimal. Wenn niemals undefined als Wert gespeichert wird, reicht oft ein einzelnes get() mit Prüfung auf undefined.
Falscher this-Wert: Wird die Methode auf etwas aufgerufen, das keine Map ist (z. B. Map.prototype.has.call({}, 'x')), wirft sie einen TypeError.
Die Methode wird in allen modernen Browsern und seit Node.js 0.12 unterstützt (Baseline).

Siehe auch

Map Map.prototype.get() Map.prototype.set() Map.prototype.delete() Set.prototype.has() WeakMap.prototype.has()