TypeScript null und undefined

In TypeScript werden null und undefined speziell behandelt.

AktivierungstrictNullChecksDanach müssen diese Werte explizit behandelt werden, was hilft, sichereren Code zu schreiben.


SVG-Diagramm: Umgang mit null und undefined Background Title null and undefined handling null Represents "empty value" Needs explicit declaration string | null vs undefined Represents "undefined" Optional properties automatically include name?: string Arrow Safe Handling approach Safe handling approach Optional chaining: obj?.prop Nullish coalescing: value ?? default Type guard: if (val !== null) Bottom section Handling scenarios Scenario 1 Union type declaration Scenario 2 Optional parameters and properties Scenario 3 Nullish coalescing operator Arrow marker

Warum null und undefined behandeln

In JavaScript sind null und undefined häufige Fehlerquellen, und viele Laufzeitfehler hängen mit ihnen zusammen.

Die TypeScript-Option strictNullChecks erfordert, dass Entwickler Werte, die null sein können, explizit behandeln.

Obwohl dies den Programmieraufwand erhöht, kann es Laufzeitfehler durch null-Werte stark reduzieren und die Codezuverlässigkeit verbessern.

Konzepterklärung:nullSteht für "leeren Wert", d. h., hier ist kein Wert vorhanden;undefinedSteht für "undefined", d. h., es wurde noch kein Wert zugewiesen.


Grundlagen zu null und undefined

null steht für "leeren Wert", undefined steht für "undefined". Beide sind eigenständige Typen in TypeScript.

Beispiel

// Eine Variable vom Typ null deklarieren
// Kann nur null zugewiesen werden
var empty: null = null;

// Eine Variable vom Typ undefined deklarieren
// Kann nur undefined zugewiesen werden
var notDefined: undefined = undefined;

console.log("null: " + empty);
console.log("undefined: " + notDefined);

Ausgabe:

null: null
undefined: undefined

Erklärung:Ohne Aktivierung von strictNullChecks können diese Typen einander zugewiesen werden. Nach der Aktivierung ist eine explizite Deklaration erforderlich.


Union-Typen und der Umgang mit null

Nach Aktivierung von strictNullChecks müssen Sie Union-Typen verwenden, um Werte, die null sein können, explizit zu deklarieren.

Beispiel

// Union-Typ: kann string oder null sein
// Explizit deklarieren, dass der Wert null sein kann
var name: string | null = "Alice";
name = null;  // Korrekt: kann null zugewiesen werden

// Der Zugriff auf einen Wert, der null sein kann, erfordert eine vorherige Prüfung
// Funktionsparameter kann string oder null sein
function getLength(str: string | null): number {
    // Verwenden Sie eine bedingte Prüfung, um zu sehen, ob er null ist
    if (str === null) {
        return 0;  // 0 zurückgeben, wenn null
    }
    // TypeScript wird ableiten, dass str nicht null ist
    return str.length;
}

console.log("Länge: " + getLength("hello"));
console.log("Länge: " + getLength(null));

Ausgabe:

长度: 5
长度: 0

Bewährte Vorgehensweisen:Verwenden Sie Typwächter (if-Prüfungen), um Typen einzugrenzen und TypeScript den spezifischen Typ mitzuteilen.


Optionale Parameter und Eigenschaften

Optionale Parameter und optionale Eigenschaften enthalten automatisch undefined; es ist nicht nötig, null explizit zu deklarieren.

Beispiel

// Optionaler Parameter: mit ? markiert
// Parameter kann string oder undefined sein
function greet(name?: string): string {
    // Prüfen, ob er undefined ist
    if (name === undefined) {
        return "Hallo, Fremder!";
    }
    return "Hallo, " + name;
}

console.log(greet("Alice"));
console.log(greet());

// Optionale Eigenschaft: mit ? markiert
// Die Eigenschaft age ist optional und existiert möglicherweise nicht
interface User {
    name: string;
    age?: number;  // Optionale Eigenschaft
}

var user: User = { name: "Bob" };
console.log("Benutzer: " + JSON.stringify(user));

Ausgabe:

Hello, Alice!
Hello, stranger!
User: {"name":"Bob"}

Erklärung:Optionale Parametername?: stringentsprichtstring | undefined。


Non-Null-Assertion-Operator

Verwendung!Teilt dem Compiler mit, dass ein Wert nicht null oder undefined ist. Dies sollte mit Vorsicht verwendet werden.

Beispiel

function getLength(str: string | null): number {
    // Non-Null-Assertion: teilt dem Compiler mit, dass str nicht null ist
    // Dies ist ein gefährlicher Ansatz; wenn str tatsächlich null ist, verursacht es einen Fehler
    return str!.length;
}

console.log("Länge: " + getLength("hello"));

Warnung:Die Non-Null-Assertion umgeht TypeScripts Typüberprüfung. Wenn der Wert tatsächlich null ist, verursacht er dennoch einen Laufzeitfehler. Vermeide sie nach Möglichkeit.


Nullish-Coalescing-Operator

Verwendung??Stellt einen Standardwert bereit; der Standardwert wird nur verwendet, wenn der Wert null oder undefined ist.

Beispiel

// Anfangswert ist null
var name: string | null = null;

// ??-Operator: verwendet den Wert auf der rechten Seite, wenn die linke Seite null/undefined ist
// Wenn name null ist, verwende "Guest"
var displayName = name ?? "Gast";

console.log("Anzeigename: " + displayName);

// Vergleich mit dem ||-Operator (der 0 und leere Zeichenfolge als falsy behandelt)
var num: number | null = 0;
var result1 = num ?? 100;  // 0 (korrekt: 0 ist nicht null/undefined)
var result2 = num || 100;  // 100 (inkorrekt: 0 wird als falsy behandelt)

console.log("?? Ergebnis: " + result1);
console.log("|| Ergebnis: " + result2);

Ausgabe:

显示名称: Guest
?? 结果: 0
|| 结果: 100

Empfehlung:Bevorzugen Sie die Verwendung von??statt||, weil??Es behandelt nur null und undefined und stuft 0 oder eine leere Zeichenfolge nicht fälschlicherweise als falsy ein.


Optionale Verkettung

Verwendung?.Sicherer Zugriff auf verschachtelte Eigenschaften, die möglicherweise nicht existieren, und Vermeidung von null-Prüfungen über mehrere Verschachtelungsebenen hinweg.

Beispiel

// Definiere einen Personentyp; Adresse ist optional
interface Person {
    name: string;
    address?: {
        city: string;
    };
}

// Erstelle ein Personenobjekt ohne Adresse
var person: Person = { name: "Alice" };

// Optionale Verkettung: sicherer Zugriff auf Eigenschaften, die möglicherweise nicht existieren
// Wenn die Adresse nicht existiert, undefined zurückgeben, statt einen Fehler zu werfen
var city = person.address?.city;

// Kombiniert mit dem Nullish-Coalescing-Operator
console.log("City: " + city);
console.log("City: " + (person.address?.city ?? "Unknown"));

Ausgabe:

City: undefined
City: 未知

Bewährte Methode:Optionale Verkettung?.ist die beste Methode, um verschachtelte optionale Eigenschaften zu behandeln, kombiniert mit??kann es einen Fallback-Standardwert bereitstellen.


Hinweise

  • Strict-Modus:Es wird empfohlen, strictNullChecks für bessere Typsicherheit zu aktivieren
  • Assertions vermeiden:Versuchen Sie, Non-Null-Assertions zu vermeiden!
  • ?? vs ||:Verwenden Sie bevorzugt??um Fehlinterpretationen von 0 und leeren Zeichenfolgen zu vermeiden
  • Optional Chaining:Beim Umgang mit verschachtelten optionalen Eigenschaften verwenden?.

Best Practice:Verwenden Sie Type Guards, Optional Chaining und den Nullish-Coalescing-Operator, um null und undefined zu behandeln, wodurch der Code sicherer und lesbarer wird.


Zusammenfassung

Der korrekte Umgang mit null und undefined ist entscheidend für das Schreiben von sicherem TypeScript-Code.

  • Strict-Modus:Nach Aktivierung von strictNullChecks ist eine explizite Behandlung erforderlich
  • Union-Typen:Verwenden Siestring | nullzum Deklarieren
  • Optionale Parameter/Eigenschaften:schließen undefined automatisch ein
  • Non-Null-Zusicherung:Verwenden!(Mit Vorsicht verwenden)
  • Nullish Coalescing:Verwenden??Standardwert bereitstellen
  • Optionale Verkettung:Verwenden?.Sicherer Zugriff

Empfehlung:Machen Sie es sich zur Gewohnheit, Nullwerte zu behandeln, indem Sie optionale Verkettung und den Nullish-Coalescing-Operator verwenden, um den Code robuster zu machen.

Weitere Erweiterungen