undefined

Probieren Sie es aus

function test(t) {
  if (t === undefined) {
    return "Undefined value!";
  }
  return t;
}

let x;

console.log(test(x));
// Expected output: "Undefined value!"

Wert

Der primitive Wert undefined.

Beschreibung

undefined ist eine Eigenschaft des globalen Objekts. Das heißt, es ist eine Variable im globalen Gültigkeitsbereich.

In allen nicht-veralteten Browsern ist undefined eine nicht konfigurierbare, nicht beschreibbare Eigenschaft. Selbst wenn dies nicht der Fall ist, vermeiden Sie es, undefined zu überschreiben.

Eine Variable, der kein Wert zugewiesen wurde, hat den Typ undefined. Eine Funktion gibt undefined zurück, wenn kein Wert zurückgegeben wurde. Der Zugriff auf eine nicht existierende Eigenschaft gibt ebenfalls undefined zurück. Der void Operator gibt immer undefined zurück.

// TUN SIE DAS NICHT

(() => {
  const undefined = "foo";
  console.log(undefined, typeof undefined); // foo string
})();

((undefined) => {
  console.log(undefined, typeof undefined); // foo string
})("foo");

Beispiele

Strikte Gleichheit und undefined

Sie können undefined und die strikten Gleichheits- und Ungleichheitsoperatoren verwenden, um zu bestimmen, ob eine Variable einen Wert hat. Im folgenden Code ist die Variable x nicht initialisiert, und die if-Anweisung wertet zu wahr aus.

let x;
if (x === undefined) {
  // these statements execute
} else {
  // these statements do not execute
}

typeof Operator und undefined

typeof kann auch bestimmen, ob eine Variable undefined ist:

let x;
if (typeof x === "undefined") {
  // these statements execute
}

Ein Grund, typeof zu verwenden, ist, dass es keinen Fehler auslöst, wenn die Variable im aktuellen Gültigkeitsbereich nicht existiert.

// x has not been declared before
// evaluates to true without errors
if (typeof x === "undefined") {
  // these statements execute
}

// Throws a ReferenceError
if (x === undefined) {
}

Es funktioniert auch mit Variablen, die mit var nach der Überprüfung deklariert werden, da die Deklaration an den Anfang des Gültigkeitsbereichs mit dem Wert undefined gehoben wird.

if (typeof x === "undefined") {
  // these statements execute
}
var x = 1;

Diese Technik ist normalerweise nur nützlich zum Testen globaler Variablen. Sie können wissen, ob eine Variable in jedem anderen Gültigkeitsbereich (Blöcke, Funktionen, Module usw.) existiert, indem Sie einfach den Quellcode betrachten. Der globale Gültigkeitsbereich ist an das globale Objekt gebunden, sodass das Vorhandensein einer Variablen im globalen Kontext durch Überprüfung auf das Vorhandensein einer Eigenschaft am globalen Objekt überprüft werden kann, zum Beispiel durch den in Operator:

if ("x" in window) {
  // These statements execute only if x is defined globally
}

Jedoch funktionieren keine der obigen Techniken, wenn die Variable mit let, const oder anderen lexikalischen Deklarationen deklariert ist. Die Verwendung von typeof vor der Deklarationszeile erzeugt trotzdem einen ReferenceError, aufgrund der temporalen toten Zone (TDZ).

if (typeof z === "undefined") {
  // Uncaught ReferenceError: Cannot access 'z' before initialization
}
let z = 1;

Darüber hinaus erstellen let und const Deklarationen keine Eigenschaften am globalen Objekt, sodass sie auch nicht mit dem in Operator überprüft werden können.

let z;
if ("z" in window) {
  // false, even if z is declared globally with let or const
}

Wenn Sie globale Variablen über verschiedene Skripte hinweg teilen möchten, ist es ratsamer, var zu verwenden oder sie explizit an das globale Objekt zu binden:

window.myGlobalVar = "foo";

void Operator und undefined

Der void Operator kann auch verwendet werden, um den Wert undefined zu erzeugen. Dies wird in komprimiertem Code sehr häufig gesehen, da void 0 3 Bytes kürzer ist und nicht überschrieben werden kann. Sie sollten dieses Muster in Ihrem eigenen Code normalerweise vermeiden.

let x;
if (x === void 0) {
  // these statements execute
}

// y has not been declared before
if (y === void 0) {
  // throws Uncaught ReferenceError: y is not defined
}

Spezifikationen

Browser-Kompatibilität

Siehe auch

• JavaScript Datenarten und Datenstrukturen
• null