TypeScript Academy · Lekcja

Operator asercji non-null

Używaj operatora !, aby potwierdzić, że wartość nie jest null ani undefined

Operator asercji non-null to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Operator asercji niebędącej null

Operator przyrostkowy ! informuje TypeScript: „ta wartość nie jest tutaj null ani undefined”. Usuwa te wartości z typu bez wykonywania sprawdzenia w czasie działania programu.

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

Gdzie umieścić !

! umieszcza się bezpośrednio po wyrażeniu, dla którego stosowana jest asercja, a przed każdym kolejnym dostępem. Usuwa ono null | undefined z typu tego wyrażenia.

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

Asercja niebędącej null wartości po sprawdzeniu

Czasami wiadomo na podstawie logiki programu, że wartość istnieje, ale kompilator nie potrafi prześledzić tego rozumowania. ! pozwala kontynuować pracę. Mimo to rzeczywiste sprawdzenie w czasie działania programu jest zwykle bardziej przejrzyste.

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());

Znów: tylko podczas kompilacji

Podobnie jak as, operator ! jest usuwany podczas działania programu. Nie wykonuje żadnego sprawdzenia. Jeśli wartość rzeczywiście jest równa null, wystąpi błąd w czasie działania programu, mimo że kompilator zaakceptował kod.

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

Niebezpieczeństwo związane z !

Jeśli zastosowano asercję niebędącej null wartości, która rzeczywiście może być równa null, powstał ukryty błąd. Kompilator przestaje ostrzegać, więc problem ujawni się dopiero wtedy, gdy wartość null rzeczywiście pojawi się na produkcji.

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

Preferuj rzeczywiste sprawdzenie

Gdy tylko jest to możliwe, należy zastąpić ! rzeczywistym sprawdzeniem wartości null lub opcjonalnym łańcuchowaniem. Bezpieczna wersja wymaga jednej linii kodu i eliminuje całą klasę awarii w czasie działania programu.

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({}));

Asercja definitywnego przypisania

Powiązaną funkcją jest asercja definitywnego przypisania: let x!: T. Obiecuje ona kompilatorowi, że x zostanie przypisane przed użyciem, mimo że nie jest zainicjalizowane w momencie deklaracji.

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

Definitywne przypisanie w klasach

Jest to częste w klasach, w których właściwość jest ustawiana przez framework lub metodę inicjalizującą, a nie przez konstruktor. Znak ! za nazwą właściwości wycisza błąd „nie zostało definitywnie przypisane”.

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);

Z asercji definitywnego przypisania należy korzystać ostrożnie

Asercja definitywnego przypisania to kolejna obietnica, której kompilator nie może zweryfikować. Jeśli właściwość zostanie odczytana przed przypisaniem, w czasie działania programu zostanie odczytana wartość undefined, bez żadnego ostrzeżenia.

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());

! a opcjonalne łańcuchowanie

Nie należy używać !, gdy wystarczyłoby ?.. Opcjonalne łańcuchowanie bezpiecznie obsługuje wartości null w czasie działania programu, natomiast ! jedynie wycisza kompilator. Te mechanizmy rozwiązują różne problemy.

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

Kiedy użycie ! jest uzasadnione

Operator ! jest uzasadniony, gdy istnieje rzeczywista gwarancja, której nie da się wyrazić w sposób zrozumiały dla kompilatora — na przykład w przypadku wartości właśnie dodanej do tablicy i natychmiast z niej odczytanej. Nawet wtedy należy udokumentować, dlaczego takie użycie jest bezpieczne.

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);

Szybkie sprawdzenie

Sprawdź zrozumienie operatora asercji niebędącej null.

Podsumowanie: asercja niebędącej null

Nauczyli się Państwo, że:

Przyrostek ! usuwa null | undefined z typu wyłącznie w czasie kompilacji.
Nie wykonuje żadnego sprawdzenia w czasie działania, więc błędna asercja nadal prowadzi do awarii.
let x!: T to asercja definitywnego przypisania dla wartości inicjalizowanych później.
Należy preferować rzeczywiste sprawdzenia lub opcjonalne łańcuchowanie, a ! stosować tylko wtedy, gdy istnieje rzeczywista gwarancja.

Następnie omówimy podwójne asercje i związane z nimi zagrożenia.

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

Często zadawane pytania

Czy lekcja „Operator asercji non-null” jest bezpłatna?

Tak — pełny tekst „Operator asercji non-null” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Operator asercji non-null”?

Używaj operatora !, aby potwierdzić, że wartość nie jest null ani undefined Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Operator asercji non-null”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Słowo kluczowe as do asercji typów
Operator asercji non-null
Podwójne asercje i związane z nimi ryzyko
Asercje a strażnicy typów

← Powrót do TypeScript Academy