TypeScript Academy · Lekcja

Typ never i stany niemożliwe

Modeluj nieosiągalny kod i niemożliwe wartości za pomocą never

Typ never i stany niemożliwe 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.

Typ never

never to typ pusty — reprezentuje wartości, które nigdy nie mogą wystąpić. Żadnej wartości nie można przypisać do never (z wyjątkiem samego never). Oznacza sytuacje, które powinny być niemożliwe.

// You cannot create a value of type never
function crash(): never {
  throw new Error('boom');
}
try { crash(); } catch (e) { console.log('caught'); }

Funkcje, które nigdy nie zwracają wyniku

Funkcja, która zawsze wykonuje throw, nigdy nie zwraca wyniku w zwykły sposób, dlatego jej typem zwracanym jest never. Informuje to wywołujących oraz kompilator, że wykonywanie kończy się w tym miejscu.

function fail(message: string): never {
  throw new Error(message);
}
try { fail('invalid'); } catch (e) { console.log('handled'); }

Nieskończone pętle zwracają never

Funkcja zawierająca nieskończoną pętlę również nigdy nie zwraca wyniku, dlatego jej typem jest never. Kompilator rozpoznaje, że przepływ sterowania nie może być kontynuowany za tą funkcją.

function listen(): never {
  while (true) {
    // forever
    break; // (break added so the demo terminates)
  }
  throw new Error('stopped');
}
console.log('listen has return type never');

never a void

Nie należy mylić never z void. Funkcja typu void zwraca wynik (po prostu nie dostarcza użytecznej wartości). Funkcja typu never w ogóle nie zwraca wyniku — zgłasza wyjątek lub działa w nieskończonej pętli.

function logIt(): void {
  console.log('done'); // returns normally
}
function abort(): never {
  throw new Error('stop'); // never returns
}
logIt();
try { abort(); } catch (e) { console.log('ok'); }

never w sprawdzaniu kompletności

Najbardziej praktycznym zastosowaniem never jest sprawdzanie kompletności. W gałęzi domyślnej instrukcji switch przypisz zmienną do typu never. Jeśli uwzględniono wszystkie przypadki, zmienna ma już typ never i kod się kompiluje.

type Shape = 'circle' | 'square';

function area(s: Shape): string {
  switch (s) {
    case 'circle': return 'pi r^2';
    case 'square': return 'a^2';
    default:
      const _check: never = s; // ok: all handled
      return _check;
  }
}
console.log(area('square'));

Wykrywanie brakujących przypadków

Jeśli ktoś doda nowy element unii, ale zapomni o odpowiednim przypadku, pozostała wartość nie będzie już mieć typu never, więc przypisanie zakończy się błędem kompilacji. Sprawdzenie za pomocą never zmienia cichą lukę w wyraźny błąd.

type Shape = 'circle' | 'square' | 'triangle';
// If 'triangle' case is missing, assigning s to never
// would error: 'triangle' is not assignable to never.
console.log('Add a case for every member');

never w niemożliwych gałęziach unii

Gdy zawężanie usuwa wszystkie możliwości, pozostałym typem jest never. Kompilator wie, że ta gałąź jest nieosiągalna, co może ujawnić błędy w logice programu.

function check(x: string | number): void {
  if (typeof x === 'string') {
    console.log('string');
  } else if (typeof x === 'number') {
    console.log('number');
  } else {
    // x is never here
    console.log('unreachable');
  }
}
check('hi');

never jako typ najniższy

never jest typem najniższym: można go przypisać do każdego innego typu, ponieważ wartość, która nie może istnieć, jest w sposób pusty zgodna z dowolnym typem. Dlatego throw może wystąpić w miejscu dowolnego wyrażenia.

function getOrThrow(v: string | null): string {
  return v ?? fail();
}
function fail(): never {
  throw new Error('missing');
}
console.log(getOrThrow('value'));

Filtrowanie unii do never

W typach warunkowych i mapowanych never działa jak polecenie „usuń to”. Połączenie unią z never niczego nie zmienia: T | never to po prostu T. Dzięki temu never jest naturalnym wyborem do filtrowania.

type Keep<T> = T extends string ? T : never;
type R = Keep<'a' | 1 | 'b'>; // 'a' | 'b'
const x: R = 'a';
console.log(x);

Modelowanie niemożliwych stanów

Używaj never w kształtach obiektów, aby nieprawidłowe kombinacje były niemożliwe do przedstawienia. W tym przypadku stan „loading” nie może jednocześnie zawierać danych, ponieważ typ na to nie pozwala.

type State =
  | { status: 'loading'; data?: never }
  | { status: 'ready'; data: number };

const s: State = { status: 'ready', data: 7 };
console.log(s);

never zwiększa bezpieczeństwo refaktoryzacji

Ponieważ sprawdzanie kompletności za pomocą never kończy się błędem, gdy brakuje przypadku, zwiększa ono bezpieczeństwo refaktoryzacji: po rozszerzeniu unii kompilator wskaże każde miejsce wymagające aktualizacji.

type Cmd = 'start' | 'stop';
function run(c: Cmd): string {
  if (c === 'start') return 'starting';
  if (c === 'stop') return 'stopping';
  const _x: never = c;
  return _x;
}
console.log(run('start'));

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat typu never.

Podsumowanie: never

W tym rozdziale poznano, że never:

Jest typem pustym — żadna wartość nie może mieć typu never.
Jest typem zwracanym przez funkcje, które zgłaszają wyjątek lub wykonują nieskończoną pętlę.
Umożliwia sprawdzanie kompletności w domyślnych gałęziach instrukcji switch.
Pojawia się w niemożliwych gałęziach zawężania i filtruje unie w logice typów.

Następnie omówimy void i jego różnice względem innych typów.

function assertNever(x: never): never {
  throw new Error('Unexpected: ' + String(x));
}
console.log('assertNever guards exhaustiveness');

Często zadawane pytania

Czy lekcja „Typ never i stany niemożliwe” jest bezpłatna?

Tak — pełny tekst „Typ never i stany niemożliwe” 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 „Typ never i stany niemożliwe”?

Modeluj nieosiągalny kod i niemożliwe wartości za pomocą never Ć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 „Typ never i stany niemożliwe”?

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

← Powrót do TypeScript Academy