TypeScript Academy · Les

Booleaanse literals en literal inference

Begrijp hoe TypeScript literal inference verbreedt of vernauwt

Les 2 van 413 stappen

Booleaanse literals en literal inference is een gratis TypeScript Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.

Booleaanse letterlijke typen

Het type boolean is eigenlijk de unie true | false. Elk van beide is een booleaans letterlijk type: een type dat slechts één specifieke booleaanse waarde toestaat.

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

Booleaanse letterlijke typen in unies

Booleaanse letterlijke typen komen goed tot hun recht in combinatie met andere letterlijke typen om onderscheidbare uitkomsten te modelleren, zoals een succesvlag in combinatie met de vorm van een lading.

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

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

Typeverbreding

Wanneer je een variabele initialiseert, bepaalt TypeScript welk type het afleidt. Soms behoudt het de exacte letterlijke waarde en soms verbreedt het type naar het algemene type. Als je dit begrijpt, kun je voorspelbare typen schrijven.

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

let wordt verbreed naar het algemene type

Omdat een let-variabele opnieuw kan worden toegewezen, leidt TypeScript het algemene type af, zodat toekomstige toewijzingen zijn toegestaan. Een tekenreeks met let begint als string, niet als het letterlijke type.

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

const behoudt het letterlijke type

Een const kan nooit opnieuw worden toegewezen, dus leidt TypeScript het meest specifieke type af — het letterlijke type. Daarom heeft const greeting = 'hi' het type 'hi' en niet string.

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

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

Verbreding met getallen en booleaanse waarden

Dezelfde regel geldt voor getallen en booleaanse waarden. const behoudt 42 of true als letterlijk type; let verbreedt het naar number of 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);

Waarom typeverbreding bestaat

Typeverbreding houdt alledaagse code gebruiksvriendelijk. Als elke let count = 0 het letterlijke type 0 zou krijgen, zou je de waarde niet kunnen verhogen. Typeverbreding zorgt ervoor dat variabelen waaraan opnieuw kan worden toegewezen zich natuurlijk gedragen.

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

Een letterlijk type afdwingen met een annotatie

Soms wil je dat een let een letterlijk type behoudt. Voeg een expliciete annotatie met een letterlijk type toe. TypeScript houdt het type dan beperkt, terwijl je nog steeds binnen die unie een andere waarde kunt toewijzen.

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

Typeverbreding in objecteigenschappen

Eigenschappen van objectliteralen worden standaard ook verbreed. Zelfs in een const-object krijgen veranderbare eigenschappen het algemene type, omdat je aan de eigenschap zelf opnieuw een waarde kunt toewijzen.

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

Letterlijke typeafleiding met functies

Ook retourwaarden van functies worden afgeleid. Een functie die een letterlijke waarde uit een const retourneert, verbreedt het retourtype nog steeds naar het algemene type, tenzij je het annoteert of letterlijke typen in de handtekening gebruikt.

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

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

Kiezen tussen letterlijk en algemeen

Vuistregel: gebruik const of expliciete annotaties met letterlijke typen wanneer je exacte waarden nodig hebt (configuratiesleutels, discriminanten). Laat verbreding plaatsvinden voor gewone veranderlijke variabelen. Als je weet welke variant je krijgt, voorkom je verrassende toewijsbaarheidsfouten.

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

Snelle controle

Toets hoe goed je verbreding en inferentie van letterlijke typen begrijpt.

Beantwoord dit in de interactieve les

Samenvatting: inferentie van letterlijke typen

Belangrijkste punten:

true en false zijn letterlijke typen; boolean is gelijk aan true | false.
let wordt verbreed naar het algemene type (string, number, boolean).
const behoudt het exacte letterlijke type.
Voorzie een let van een annotatie met een letterlijk type om het aan een smalle unie te binden.

Vervolgens maken we onveranderlijkheid expliciet met as const.

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

Gratis beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 101
Lessen: 352

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Booleaanse literals en literal inference” gratis?

Ja — de volledige tekst van “Booleaanse literals en literal inference” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.

Wat leer ik in “Booleaanse literals en literal inference”?

Begrijp hoe TypeScript literal inference verbreedt of vernauwt Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met TypeScript Academy te beginnen?

Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Booleaanse literals en literal inference”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?

Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Letterlijke typen voor strings en getallen
Booleaanse literals en literal inference
const-asserties met as const
Literals combineren in unions

← Terug naar TypeScript Academy