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
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
// 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
// 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
// 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 Parameter
name?: 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
// 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
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
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 Sie
string | 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
Weitere ErweiterungenEmpfehlung: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.