TypeScript Academy · Lektion

Non-null-Assertion-Operator

Verwenden Sie den Operator !, um zu bestätigen, dass ein Wert weder null noch undefined ist.

Non-null-Assertion-Operator ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Der Non-Null-Assertion-Operator

Der Postfix-Operator ! teilt TypeScript mit: „Dieser Wert ist hier nicht null oder undefined.“ Er entfernt diese beiden Typen aus dem Typ, ohne eine Laufzeitprüfung durchzuführen.

function firstChar(s: string | null): string {
  return s!.charAt(0); // assert s is not null
}
console.log(firstChar('hello'));

Wo Sie das ! platzieren

Das ! steht unmittelbar nach dem Ausdruck, für den Sie die Assertion vornehmen, und vor jedem weiteren Zugriff. Es entfernt null | undefined aus dem Typ dieses Ausdrucks.

type Box = { value?: number };
const box: Box = { value: 7 };
const n: number = box.value!; // value is number | undefined -> number
console.log(n);

Non-Null nach einem Guard behaupten

Manchmal haben Sie logisch sichergestellt, dass ein Wert vorhanden ist, aber der Compiler kann Ihre Überlegung nicht nachvollziehen. Mit ! können Sie fortfahren. Trotzdem ist eine tatsächliche Laufzeitprüfung normalerweise klarer.

const list: Array<string | null> = ['a', null, 'c'];
const present = list.filter((x) => x !== null);
// TS may still see string | null; assert if certain:
console.log(present[0]!.toUpperCase());

Wiederum nur zur Kompilierzeit

Wie as wird auch der Operator ! zur Laufzeit entfernt. Er führt keine Prüfung durch. Wenn der Wert tatsächlich null ist, erhalten Sie trotz zufriedengestelltem Compiler einen Laufzeitfehler.

function risky(s: string | null): number {
  return s!.length; // no runtime guard
}
console.log(risky('hi'));
// risky(null) would throw at runtime

Die Gefahr von !

Wenn Sie für einen Wert, der tatsächlich null sein kann, eine Non-Null-Assertion verwenden, haben Sie einen versteckten Fehler erzeugt. Der Compiler warnt Sie nicht mehr, sodass der Fehler erst auftritt, wenn dieser Nullwert tatsächlich in der Produktion vorkommt.

type User = { name?: string };
const u: User = {};
// const len = u.name!.length; // compiles, crashes at runtime
console.log('name is undefined here -> ! would crash');

Eine echte Prüfung bevorzugen

Ersetzen Sie !, wann immer es praktikabel ist, durch eine tatsächliche Nullprüfung oder optionales Chaining. Die sichere Variante kostet eine Zeile und beseitigt eine ganze Klasse von Laufzeitabstürzen.

type User = { name?: string };
function nameLen(u: User): number {
  if (u.name) return u.name.length; // checked
  return 0;
}
console.log(nameLen({ name: 'Ada' }), nameLen({}));

Assertion für definite Zuweisung

Eine verwandte Funktion ist die Assertion für definite Zuweisung: let x!: T. Sie verspricht dem Compiler, dass x vor der Verwendung zugewiesen wird, obwohl die Initialisierung bei der Deklaration fehlt.

let token!: string; // promise: assigned before use
function init() { token = 'abc123'; }
init();
console.log(token.length);

Definite Zuweisung in Klassen

Dies kommt häufig in Klassen vor, wenn eine Eigenschaft von einem Framework oder einer Initialisierungsmethode statt vom Konstruktor gesetzt wird. Das ! hinter dem Eigenschaftsnamen unterdrückt den Fehler, dass die Eigenschaft nicht definitiv zugewiesen ist.

class Service {
  config!: { url: string }; // set later by setup()
  setup() { this.config = { url: '/api' }; }
}
const s = new Service();
s.setup();
console.log(s.config.url);

Definite-Assignment-Assertions mit Bedacht verwenden

Die Assertion für definite Zuweisung ist ein weiteres Versprechen, das der Compiler nicht überprüfen kann. Wenn Sie auf die Eigenschaft zugreifen, bevor Sie sie zuweisen, lesen Sie zur Laufzeit ohne Warnung undefined.

class Late {
  data!: number[];
  read() { return this.data.length; } // crashes if called before init
}
const l = new Late();
l.data = [1, 2];
console.log(l.read());

! vs optionales Chaining

Verwenden Sie nicht !, wenn ?. ausreicht. Optionales Chaining behandelt null sicher zur Laufzeit, während ! lediglich den Compiler zum Schweigen bringt. Die beiden Operatoren lösen unterschiedliche Probleme.

type Cfg = { db?: { host?: string } };
const c: Cfg = {};
console.log(c.db?.host ?? 'localhost'); // safe
// c.db!.host! would crash here

Wann ! gerechtfertigt ist

Der Operator ! ist vertretbar, wenn Sie eine echte Garantie haben, die der Compiler nicht ausdrücken kann – etwa bei einem Wert, den Sie gerade eingefügt und sofort wieder gelesen haben. Dokumentieren Sie auch dann, warum die Verwendung sicher ist.

const cache = new Map<string, number>();
cache.set('hits', 0);
// We just set it, so get is non-null:
const hits = cache.get('hits')!;
console.log(hits);

Schnelltest

Testen Sie Ihr Verständnis des Non-Null-Assertion-Operators.

Zusammenfassung: Non-Null-Assertion

Sie haben gelernt:

Das Postfix-! entfernt null | undefined nur zur Compilezeit aus einem Typ.
Es führt keine Laufzeitprüfung durch. Eine falsche Assertion führt daher trotzdem zu einem Absturz.
let x!: T ist die Definite-Assignment-Assertion für Werte, die später initialisiert werden.
Bevorzugen Sie echte Prüfungen oder Optional Chaining. Reservieren Sie ! für tatsächliche Garantien.

Als Nächstes geht es um doppelte Assertions und ihre Risiken.

const map = new Map<string, number>();
map.set('a', 1);
const v = map.get('a')!;
console.log(v);

Häufig gestellte Fragen

Ist die Lektion „Non-null-Assertion-Operator“ kostenlos?

Ja — der vollständige Text von „Non-null-Assertion-Operator“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Non-null-Assertion-Operator“?

Verwenden Sie den Operator !, um zu bestätigen, dass ein Wert weder null noch undefined ist. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Non-null-Assertion-Operator“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu TypeScript Academy