TypeScript Academy · Lektion

Icke-null-assertionsoperatorn

Använd operatorn ! för att hävda att ett värde varken är null eller undefined.

Lektion 2 av 413 steg

Icke-null-assertionsoperatorn är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 2 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.

Operatorn för non-null assertion

Postfixoperatorn ! säger till TypeScript ’det här värdet är inte null eller undefined här’. Den tar bort dessa från typen utan någon kontroll vid körning.

function firstChar(s: string | null): string {
  return s!.charAt(0); // assert s is not null
}
console.log(firstChar('hello'));

Var du placerar !

! placeras direkt efter uttrycket som du gör en assertion av, före all vidare åtkomst. Den tar bort null | undefined från uttryckets typ.

type Box = { value?: number };
const box: Box = { value: 7 };
const n: number = box.value!; // value is number | undefined -> number
console.log(n);

Gör en non-null assertion efter en kontroll

Ibland har du logiskt säkerställt att ett värde finns, men kompilatorn kan inte följa resonemanget. ! låter dig fortsätta. Även då är en faktisk kontroll vid körning vanligtvis tydligare.

const list: Array<string | null> = ['a', null, 'c'];
const present = list.filter((x) => x !== null);
// TS may still see string | null; assert if certain:
console.log(present[0]!.toUpperCase());

Endast vid kompilering, igen

Precis som as tas operatorn ! bort vid körning. Den utför ingen kontroll. Om värdet faktiskt är null får du ett körningsfel trots att kompilatorn är nöjd.

function risky(s: string | null): number {
  return s!.length; // no runtime guard
}
console.log(risky('hi'));
// risky(null) would throw at runtime

Risken med !

Om du gör en non-null assertion av ett värde som faktiskt kan vara null har du skapat ett dolt fel. Kompilatorn slutar varna, så felet visar sig först när null verkligen förekommer i produktion.

type User = { name?: string };
const u: User = {};
// const len = u.name!.length; // compiles, crashes at runtime
console.log('name is undefined here -> ! would crash');

Föredra en verklig kontroll

När det är praktiskt möjligt bör du ersätta ! med en faktisk nullkontroll eller optional chaining. Den säkra versionen kostar en rad och eliminerar en hel klass av krascher vid körning.

type User = { name?: string };
function nameLen(u: User): number {
  if (u.name) return u.name.length; // checked
  return 0;
}
console.log(nameLen({ name: 'Ada' }), nameLen({}));

Definite assignment assertion

En närliggande funktion är definite assignment assertion: let x!: T. Den lovar kompilatorn att x kommer att tilldelas innan det används, även om det inte initieras vid deklarationen.

let token!: string; // promise: assigned before use
function init() { token = 'abc123'; }
init();
console.log(token.length);

Definite assignment i klasser

Detta är vanligt i klasser där en egenskap sätts av ett ramverk eller en init-metod i stället för konstruktorn. ! efter egenskapens namn undertrycker felet ’inte definitivt tilldelad’.

class Service {
  config!: { url: string }; // set later by setup()
  setup() { this.config = { url: '/api' }; }
}
const s = new Service();
s.setup();
console.log(s.config.url);

Använd definite assignment varsamt

Definite assignment assertion är ännu ett löfte som kompilatorn inte kan verifiera. Om du läser egenskapen innan du tilldelar den får du undefined vid körning utan någon varning.

class Late {
  data!: number[];
  read() { return this.data.length; } // crashes if called before init
}
const l = new Late();
l.data = [1, 2];
console.log(l.read());

! jämfört med optional chaining

Använd inte ! när ?. skulle räcka. Optional chaining hanterar null säkert vid körning, medan ! bara tystar kompilatorn. De löser olika problem.

type Cfg = { db?: { host?: string } };
const c: Cfg = {};
console.log(c.db?.host ?? 'localhost'); // safe
// c.db!.host! would crash here

När ! är motiverat

Operatorn ! är rimlig när du har en verklig garanti som kompilatorn inte kan uttrycka – till exempel ett värde som du precis har lagt till och omedelbart läser. Dokumentera även då varför det är säkert.

const cache = new Map<string, number>();
cache.set('hits', 0);
// We just set it, so get is non-null:
const hits = cache.get('hits')!;
console.log(hits);

Snabb kontroll

Testa dina kunskaper om non-null assertion-operatorn.

Besvara frågan i den interaktiva lektionen

Sammanfattning: non-null assertion

Ni har lärt er:

Postfixoperatorn ! tar endast bort null | undefined från en typ vid kompilering.
Den utför ingen kontroll vid körning, så en felaktig assertion leder fortfarande till en krasch.
let x!: T är en definite assignment-assertion för värden som initieras senare.
Föredra riktiga kontroller eller optional chaining och använd ! endast när det finns en faktisk garanti.

Härnäst: dubbla assertions och deras risker.

const map = new Map<string, number>();
map.set('a', 1);
const v = map.get('a')!;
console.log(v);

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 ”Icke-null-assertionsoperatorn” gratis?

Ja – hela texten till ”Icke-null-assertionsoperatorn” 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 ”Icke-null-assertionsoperatorn”?

Använd operatorn ! för att hävda att ett värde varken är null eller undefined. 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 2 av 4.

Hur lång tid tar lektionen ”Icke-null-assertionsoperatorn”?

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