TypeScript Academy · leksjon

Typesikker behandling av unknown

Snevr inn unknown-verdier før du bruker dem på en trygg måte.

Leksjon 4 av 413 trinn

Typesikker behandling av unknown er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Arbeide trygt med unknown

Å angi eksterne data som unknown er bare halve jobben. Den andre halvdelen er å innsnevre dem til en konkret type før bruk. Denne leksjonen dekker de viktigste teknikkene for innsnevring.

function describe(v: unknown): string {
  if (typeof v === 'string') return 'string: ' + v;
  if (typeof v === 'number') return 'number: ' + v;
  return 'other';
}
console.log(describe('hi'), describe(7), describe(true));

Innsnevring med typeof

typeof-sjekken er det enkleste verktøyet. Den snevrer unknown inn til primitive typer: string, number, boolean, function, object og flere.

function double(v: unknown): number {
  if (typeof v === 'number') {
    return v * 2; // v is number here
  }
  return 0;
}
console.log(double(21), double('no'));

Innsnevring med instanceof

For klasseinstanser bruker du instanceof. Den snevrer unknown inn til den spesifikke klassen, slik at du trygt får tilgang til metodene og egenskapene dens.

function handle(v: unknown): string {
  if (v instanceof Date) {
    return v.toISOString(); // v is Date
  }
  return 'not a date';
}
console.log(handle(new Date(0)));

Innsnevring med in-operatoren

in-operatoren sjekker om en egenskap finnes på et objekt, og snevrer inn verdier av objekttype. Bekreft først at verdien er et objekt som ikke er null, og undersøk deretter nøklene.

function getName(v: unknown): string {
  if (typeof v === 'object' && v !== null && 'name' in v) {
    return String((v as { name: unknown }).name);
  }
  return 'anonymous';
}
console.log(getName({ name: 'Ada' }), getName(5));

Egendefinerte type guards

En egendefinert type guard er en funksjon med returtypen value is T. Når den returnerer true, snevrer TypeScript argumentet inn til T på stedet der funksjonen kalles.

function isString(v: unknown): v is string {
  return typeof v === 'string';
}

function shout(v: unknown): string {
  return isString(v) ? v.toUpperCase() : '?';
}
console.log(shout('hey'), shout(9));

Type guards for objektstrukturer

Egendefinerte type guards er spesielt nyttige når du skal validere objektstrukturer. Skriv én funksjon som sjekker alle obligatoriske felter, så kan resten av koden stole på den innsnevrede typen.

type User = { id: number; name: string };

function isUser(v: unknown): v is User {
  return typeof v === 'object' && v !== null &&
    'id' in v && 'name' in v;
}
console.log(isUser({ id: 1, name: 'Sam' }), isUser({}));

JSON.parse returnerer data som ligner unknown

JSON.parse er angitt til å returnere any, noe som omgår typesikkerheten uten varsel. Beste praksis er å hente resultatet inn som unknown og validere formen før du stoler på den.

function parseConfig(text: string): unknown {
  return JSON.parse(text);
}
const raw = parseConfig('{"port":8080}');
console.log(typeof raw);

Validere tolket JSON

Kombiner JSON.parse med en type guard for å gjøre upålitelig tekst om til en verdi med riktig type på en trygg måte. Hvis valideringen mislykkes, må du håndtere feilen i stedet for å stole på ugyldige data.

type Config = { port: number };

function isConfig(v: unknown): v is Config {
  return typeof v === 'object' && v !== null &&
    'port' in v && typeof (v as any).port === 'number';
}

const data: unknown = JSON.parse('{"port":8080}');
if (isConfig(data)) console.log('Port:', data.port);

Kjede flere type guards

For komplekse inndata legger du type guards oppå hverandre: Sjekk den overordnede formen først, og finjuster deretter. Hver guard snevrer litt mer inn, slik at du trinnvis får presise og trygge typer.

function process(v: unknown): string {
  if (Array.isArray(v)) {
    if (v.every((x) => typeof x === 'string')) {
      return v.join('-');
    }
  }
  return 'invalid';
}
console.log(process(['a', 'b']), process([1, 2]));

Kaste feil ved ugyldige data

Når validering mislykkes for data som kreves, bør du kaste et unntak. Kombinert med en hjelpefunksjon som returnerer never, holder dette den normale flyten ren og gir korrekte typer.

function asNumber(v: unknown): number {
  if (typeof v === 'number') return v;
  throw new Error('Expected a number');
}
console.log(asNumber(42));
try { asNumber('x'); } catch (e) { console.log('rejected'); }

Sett det hele sammen

Det fullstendige mønsteret er: Motta data som unknown, snevr inn med type guards, og arbeid deretter med den presise typen. Dette er den trygge grensen mellom den utypede verdenen utenfor og den typede koden din.

type Point = { x: number; y: number };
function isPoint(v: unknown): v is Point {
  return typeof v === 'object' && v !== null &&
    'x' in v && 'y' in v;
}
const input: unknown = { x: 1, y: 2 };
if (isPoint(input)) console.log(input.x + input.y);

Hurtigsjekk

Test forståelsen din av trygg håndtering av unknown.

Besvar den i den interaktive leksjonen

Oppsummering: håndtering av unknown

Du lærte å snevre inn unknown med:

typeof for primitive typer og instanceof for klasseinstanser.
in-operatoren for objektegenskaper.
Egendefinerte type guards som returnerer value is T.
Validering av resultater fra JSON.parse før du stoler på dem.

Neste kurs: type assertions og casting.

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

Gratis å komme i gang

Lær deg TypeScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 101
Leksjoner: 352

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Typesikker behandling av unknown» gratis?

Ja – hele teksten i «Typesikker behandling av unknown» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Typesikker behandling av unknown»?

Snevr inn unknown-verdier før du bruker dem på en trygg måte. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med TypeScript Academy?

Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Typesikker behandling av unknown»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?

Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til TypeScript Academy