TypeScript Academy · Lekcja

Literały boolean i wnioskowanie typów literałów

Dowiedz się, jak TypeScript rozszerza lub zawęża wnioskowanie typów literałów

Lekcja 2 z 413 kroki

Literały boolean i wnioskowanie typów literałów 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.

Typy literałów logicznych

Typ boolean jest w rzeczywistości unią true | false. Każda z tych wartości jest typem literału logicznego — typem zezwalającym tylko na jedną konkretną wartość logiczną.

let yes: true = true;
let no: false = false;
console.log(yes, no);
// yes = false; // Error: false not assignable to true

Literały logiczne w uniach

Literały logiczne są szczególnie przydatne w połączeniu z innymi literałami do modelowania wyników z rozróżnikiem, na przykład flagi powodzenia połączonej ze strukturą danych.

type Result =
  | { ok: true; value: number }
  | { ok: false; error: string };

const r: Result = { ok: true, value: 42 };
console.log(r);

Poszerzanie typów

Podczas inicjalizowania zmiennej TypeScript decyduje, jaki typ wywnioskować. Czasami zachowuje dokładny literał, a czasami poszerza go do typu ogólnego. Zrozumienie tego mechanizmu jest kluczowe dla przewidywalnych typów.

const exact = 'hello'; // type: 'hello' (literal)
let broad = 'hello';   // type: string (widened)
console.log(exact, broad);

let poszerza typ do ogólnego

Ponieważ zmiennej let można przypisać nową wartość, TypeScript wnioskuje ogólny typ, aby umożliwić przyszłe przypisania. Zmienna tekstowa zadeklarowana za pomocą let ma początkowo typ string, a nie typ literału.

let mood = 'happy'; // inferred as string
mood = 'sad';       // allowed
mood = 'tired';     // allowed
console.log(mood);

const zachowuje literał

Do stałej const nigdy nie można przypisać nowej wartości, dlatego TypeScript wnioskuje typ najbardziej szczegółowy — literał. Dlatego const greeting = 'hi' ma typ 'hi', a nie string.

const greeting = 'hi'; // type: 'hi'

type Greeting = typeof greeting; // 'hi'
const other: Greeting = 'hi';
console.log(other);

Poszerzanie liczb i wartości logicznych

Ta sama zasada dotyczy liczb i wartości logicznych. const zachowuje 42 lub true jako literał, natomiast let poszerza typ do number lub boolean.

const n = 42;   // type: 42
const b = true; // type: true
let m = 42;     // type: number
let c = true;   // type: boolean
console.log(n, b, m, c);

Dlaczego istnieje poszerzanie typów

Poszerzanie typów sprawia, że codzienny kod jest wygodniejszy w użyciu. Gdyby każde let count = 0 miało typ literału 0, nie można byłoby zwiększać tej wartości. Poszerzanie pozwala zmiennym, którym można przypisywać nowe wartości, działać w naturalny sposób.

let count = 0; // widened to number
count = count + 1;
count = 10;
console.log('Count:', count);

Wymuszanie literału za pomocą adnotacji

Czasami potrzebny jest typ literału dla zmiennej let. Należy dodać jawną adnotację typu literału, a TypeScript zachowa wąski typ, jednocześnie pozwalając na ponowne przypisanie wartości należącej do tej unii.

let status: 'on' | 'off' = 'on';
status = 'off'; // allowed
console.log(status);
// status = 'paused'; // Error

Poszerzanie typów właściwości obiektów

Właściwości literałów obiektowych również domyślnie ulegają poszerzeniu. Nawet w obiekcie const modyfikowalne właściwości otrzymują typ ogólny, ponieważ same właściwości można później zmieniać.

const config = { mode: 'dark' };
// config.mode has type string, not 'dark'
config.mode = 'light';
console.log(config.mode);

Wnioskowanie literałów za pomocą funkcji

Wnioskowane są również wartości zwracane przez funkcje. Funkcja zwracająca literał przechowywany w const nadal poszerza typ zwracany do typu ogólnego, chyba że zostanie on opatrzony adnotacją albo typy literałów zostaną użyte w sygnaturze.

function getMode(): 'dark' | 'light' {
  return 'dark';
}

const m = getMode(); // type: 'dark' | 'light'
console.log(m);

Wybór typu literałowego lub ogólnego

Praktyczna zasada: używaj const lub jawnych adnotacji typów literałowych, gdy potrzebujesz dokładnych wartości (kluczy konfiguracji, dyskryminatorów). W przypadku zwykłych zmiennych, które można modyfikować, pozwól na rozszerzenie typu. Wiedza o tym, jaki typ zostanie wywnioskowany, pozwala uniknąć nieoczekiwanych błędów przypisywania.

const KEY = 'apiUrl';     // literal 'apiUrl'
let retries = 3;          // number
let level: 'low' | 'high' = 'low'; // pinned literal
console.log(KEY, retries, level);

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat rozszerzania typów i inferencji literałów.

Odpowiedz w interaktywnej lekcji

Podsumowanie: inferencja literałów

Najważniejsze informacje:

true i false są typami literałowymi; boolean jest równoznaczny z true | false.
let jest rozszerzany do typu ogólnego (string, number, boolean).
const zachowuje dokładny typ literałowy.
Użyj adnotacji typu literałowego, aby przypisać zmiennej let wąską unię typów.

W następnym kroku jawnie wymusimy niezmienność za pomocą as const.

const literal = 'fixed'; // 'fixed'
let widened = 'fixed';   // string
let pinned: 'a' | 'b' = 'a';
console.log(literal, widened, pinned);

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 101
Lekcje: 352

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Literały boolean i wnioskowanie typów literałów” jest bezpłatna?

Tak — pełny tekst „Literały boolean i wnioskowanie typów literałów” 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 „Literały boolean i wnioskowanie typów literałów”?

Dowiedz się, jak TypeScript rozszerza lub zawęża wnioskowanie typów literałów Ć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 „Literały boolean i wnioskowanie typów literałów”?

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

Typy literałów stringów i liczb
Literały boolean i wnioskowanie typów literałów
Asercje const z użyciem as const
Łączenie literałów w unie

← Powrót do TypeScript Academy