TypeScript Academy · Lektion

Assertions jämfört med type guards

Föredra kontroller vid körning framför assertions när det är möjligt.

Lektion 4 av 413 steg

Assertions jämfört med type guards är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Två sätt att övertyga kompilatorn

När kompilatorn inte känner till ett värdes exakta typ har ni två alternativ: assertera den (påstå typen) eller använda en guard (bevisa typen vid körning). De ser likadana ut, men erbjuder mycket olika säkerhet.

function viaAssert(v: unknown): number {
  return (v as number) + 1; // claim
}
function viaGuard(v: unknown): number {
  return typeof v === 'number' ? v + 1 : 0; // prove
}
console.log(viaAssert(5), viaGuard(5), viaGuard('x'));

Assertions verifierar inte

En assertion är ett löfte utan någon kontroll. Om ni har fel tar sig buggen vidare till körningen. Assertions byter säkerhet mot bekvämlighet.

const v: unknown = 'hello';
const n = v as number;
console.log(n.toFixed(2)); // runtime error: toFixed is not a function

Type guards verifierar vid körning

En type guard kontrollerar faktiskt värdet. Om kontrollen lyckas vet både ni och kompilatorn att typen är korrekt – det finns ett verkligt test vid körning som stöder typförfiningen.

function toFixed2(v: unknown): string {
  if (typeof v === 'number') return v.toFixed(2);
  return 'N/A';
}
console.log(toFixed2(3.14159), toFixed2('hi'));

Egna type guard-funktioner

Kapsla in komplexa kontroller i en återanvändbar guard som returnerar value is T. Hela kodbasen drar nytta av en enda vältestad validering.

type Email = { address: string };
function isEmail(v: unknown): v is Email {
  return typeof v === 'object' && v !== null &&
    'address' in v && typeof (v as any).address === 'string';
}
console.log(isEmail({ address: 'a@b.com' }), isEmail(null));

Guards kan kombineras och återanvändas

Eftersom guards är vanliga funktioner kan ni kombinera, testa och återanvända dem. Assertions är däremot utspridda påståenden som inte kan valideras centralt.

function isString(v: unknown): v is string { return typeof v === 'string'; }
function isNonEmpty(v: unknown): v is string {
  return isString(v) && v.length > 0;
}
console.log(isNonEmpty('hi'), isNonEmpty(''));

Assertion-funktioner med asserts

TypeScript erbjuder även assertion-funktioner. Deras returannotering använder nyckelordet asserts. Om funktionen returnerar normalt förfinar kompilatorn argumentets typ från den punkten och framåt; om villkoret misslyckas kastar funktionen ett fel.

function assertNumber(v: unknown): asserts v is number {
  if (typeof v !== 'number') throw new Error('not a number');
}
function use(v: unknown): number {
  assertNumber(v); // after this line, v is number
  return v * 2;
}
console.log(use(21));

asserts jämfört med value is

En value is T-guard returnerar ett booleskt värde som ni förgrenar på. En asserts value is T-funktion kastar ett fel vid misslyckande och förfinar typen under återstoden av scopet. Båda stöds av kontroller vid körning, till skillnad från en vanlig as.

function assertDefined<T>(v: T): asserts v is NonNullable<T> {
  if (v === null || v === undefined) throw new Error('missing');
}
const maybe: string | null = 'ok';
assertDefined(maybe);
console.log(maybe.length); // narrowed to string

Generiska assertion-hjälpfunktioner

Assertion-funktioner passar utmärkt som återanvändbara förvillkor. En enda hjälpfunktion, assert(condition), kan skydda invariants i hela koden genom att kasta ett fel direkt när de bryts.

function assert(cond: unknown, msg: string): asserts cond {
  if (!cond) throw new Error(msg);
}
function half(n: number): number {
  assert(n % 2 === 0, 'must be even');
  return n / 2;
}
console.log(half(8));

Jämförelse av säkerhet

Rangordnade från säkrast till mest riskfyllda: type guards och assertion-funktioner (kontrollerade vid körning) står över vanliga as-assertions (okontrollerade), som i sin tur står över dubbla assertions (aktivt vilseledande). Välj det säkraste verktyg som passar.

// Safe: guard
function safe(v: unknown) {
  return typeof v === 'string' ? v.trim() : '';
}
console.log(safe('  hi  '));

Välj rätt verktyg

Använd en type guard när ni förgrenar utifrån typen. Använd en assertion-funktion när ett förvillkor måste vara uppfyllt eller körningen ska avbrytas. Använd as endast när typförfining inte är möjlig, till exempel vid specialisering av DOM-objekt.

function getInput(v: unknown): asserts v is string {
  if (typeof v !== 'string') throw new Error('expected string');
}
const raw: unknown = 'name';
getInput(raw);
console.log(raw.toUpperCase());

Kontroller vid körning vinner

Det återkommande temat i den här kursen är att föredra kontroller vid körning framför assertions. Guards och assertion-funktioner ger er både typer vid kompilering och säkerhet vid körning. Assertions ger er bara ett påstående.

function parsePort(v: unknown): number {
  if (typeof v === 'number' && Number.isInteger(v)) return v;
  throw new Error('invalid port');
}
console.log(parsePort(8080));

Snabbtest

Testa er förståelse av assertions och type guards.

Besvara frågan i den interaktiva lektionen

Repetition: assertions och guards

Ni har lärt er:

Type guards (value is T) bevisar en typ vid körning och låter er förgrena koden.
Assertion-funktioner (asserts value is T) kastar ett fel vid misslyckande och förfinar typen därefter.
Vanliga as-assertions påstår bara en typ – de ger ingen säkerhet vid körning.
Föredra verktyg med kontroll vid körning och reservera assertions för fall där typförfining inte kan hantera situationen.

Nästa kurs: optional chaining och nullish coalescing.

function isPositive(v: unknown): v is number {
  return typeof v === 'number' && v > 0;
}
console.log(isPositive(5), isPositive(-1));

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Assertions jämfört med type guards” gratis?

Ja – hela texten till ”Assertions jämfört med type guards” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Assertions jämfört med type guards”?

Föredra kontroller vid körning framför assertions när det är möjligt. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Assertions jämfört med type guards”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy