Ako opraviť chybu „Typ 'null' nie je priraditeľný k typu“ v TypeScripte

TypeScript 7.0, vydaný 8. júla 2026, presunul kompilátor do novej natívnej implementácie, ale Microsoft tvrdí, že port zachováva sémantiku kontroly typov, na ktorú sa vývojári už spoliehali. To je tu dôležité, pretože známa Type 'null' is not assignable to type ...chyba sa stále v podstate týka vášho dátového modelu: hodnota môže byť null, zatiaľ čo cieľový typ hovorí, že nemusí byť .

Inými slovami, neexistuje žiadny nový trik špecifický pre TypeScript 7, ktorý by sa bolo potrebné naučiť. Správnym riešením je stále rozhodnúť, či nullide o platné dáta, chrániť sa pred nimi, keď ich používanie ešte nie je bezpečné, alebo poskytnúť zámernú záložnú možnosť. Oficiálne oznámenie TypeScript 7.0 vysvetľuje prechod kompilátora, zatiaľ čo súčasná dokumentácia strictNullChecks naďalej definuje nulla undefinedako samostatné typy, keď je povolená striktná kontrola null.

Prečo TypeScript hovorí „Typ 'null' nie je priraditeľný k typu“

Chyba sa zobrazí, keď sa výraz môže vyhodnotiť ako , nullale prijímajúci typ vylučuje null. Minimálny príklad je:

let name: string = null;

Ak strictNullChecksje povolené, stringznamená to skutočnú hodnotu reťazca. Nezahŕňa ticho null. Kompilátor preto odmietne priradenie namiesto toho, aby nechal možnú chýbajúcu hodnotu plynúť do kódu, ktorý predpokladá, že metódy reťazcov sú bezpečné.

Vypnutie strictNullChecksmôže spôsobiť zmiznutie diagnostiky, ale tiež odstráni dôležitú triedu kontrol. Vlastná konfiguračná referencia TypeScript varuje, že ignorovanie nullmôže undefinedviesť k neočakávaným chybám za behu. Pre väčšinu spravovaných aplikácií je oprava modelu alebo riadiaceho toku bezpečnejšia ako vypnutie kontroly.

Vyberte opravu na základe toho, čo vo vašom programe znamená null

Pred zmenou syntaxe sa rozhodnite, čo predstavuje chýbajúca hodnota. Najudržateľnejšie riešenie závisí od tejto odpovede.

Oprava 1: Zahrnutie hodnoty null do typu, keď je hodnota null legitímna

Ak má premenná skutočne stav „zatiaľ nie je k dispozícii“ alebo „žiadna hodnota“, modelujte tento stav explicitne:

let name: string | null = null;

name = "Avery";

Toto nie je riešenie. Je to presná zmluva. Stredné meno profilu, voliteľný výsledok databázy alebo vybraná položka, ktorá začína prázdna, môžu byť oprávnene nullovateľné. Keď typ hovorí string | null, následný kód musí pred použitím operácií iba s reťazcami overiť, či je hodnota reťazec.

Tento prístup použite, keď volajúci potrebujú rozlíšiť „neexistuje žiadna hodnota“ od skutočnej hodnoty. Nepridávajte | nullreflexívne len preto, aby ste umlčali kompilátor; tým sa požiadavka na spracovanie posúva smerom von.

Oprava 2: Zúžte hodnotu pred jej použitím

Ak sa hodnota s možnosťou null po kontrole stane bezpečnou, nechajte analýzu toku riadenia v TypeScripte zúžiť typ. Oficiálna príručka zúženia ukazuje, že kontroly ako napríklad value !== nullodstránenie nullz typu vo vnútri chránenej vetvy.

function printLength(text: string | null) {
  if (text === null) {
    console.log("No text");
    return;
  }

  console.log(text.length);
}

Po skorom návrate textje známe, že ide o string. Tento vzor sa dobre škáluje, pretože bezpečnostná kontrola zostáva blízko bodu, kde sa predpoklad stáva pravdivým.

Použite presnú kontrolu null, keď sú platné nepravdivé hodnoty

Podmienka ako napríklad if (text)vylučuje aj prázdne reťazce, pretože ""je nepravdivá. Ak má prázdny reťazec význam, uprednostnite text !== null. Ak hodnota môže byť buď , nullalebo undefined, value != nullje stručná kontrola JavaScriptu, ktorá vylučuje obe; TypeScript chápe toto zúženie, ako je zdokumentované v príručke.

Oprava 3: Zadajte predvolenú hodnotu s operátorom koalescencie nullish

Ak má vaša obchodná logika skutočnú záložnú možnosť, zámerne preveďte hodnotu, ktorá môže byť null, na hodnotu, ktorá nie je null:

const rawName: string | null = getDisplayName();
const displayName: string = rawName ?? "Guest";

Operátor ??používa pravú hodnotu iba vtedy, keď je ľavá strana nullalebo undefined. Vďaka tomu je lepším nástrojom na nastavenie predvolených hodnôt, ako ||keď sú hodnoty ako "", 0alebo falseplatné a mali by sa zachovať.

Toto riešenie je ideálne pre označenia, predvolené hodnoty konfigurácie a hodnoty iba na zobrazenie. Je menej vhodné, keď váš program musí vedieť, či hodnota skutočne chýbala, pretože záložná možnosť toto rozlíšenie zámerne ruší.

Oprava 4: Operátor nenulového tvrdenia použite iba vtedy, keď už máte záruku

Postfix !hovorí TypeScriptu, aby s hodnotou zaobchádzal ako s nenulovou a nedefinovanou:

const element = document.getElementById("status");
element!.textContent = "Ready";

Toto sa kompiluje, pretože !odstraňuje časť s možnosťou nulovania pre kontrolu typu. Nepridáva kontrolu za behu. Ak prvok neexistuje, kód môže stále zlyhať pri pokuse o prístup k textContent.

Používajte !iba vtedy, keď nejaký iný invariant skutočne zaručuje existenciu hodnoty a kompilátor nedokáže tento invariant vyjadriť alebo odvodiť. Pre vyhľadávania DOM, požiadavky na dáta, čítania z vyrovnávacej pamäte a vstupy od používateľa je skutočná kontrola zvyčajne robustnejšia:

const element = document.getElementById("status");
if (element) {
  element.textContent = "Ready";
}

Dobrá otázka pri kontrole kódu znie: „Čo vynucuje túto hodnotu za behu?“ Ak je odpoveď iba „očakávame to“, tvrdenie pravdepodobne skôr skrýva chybu, než aby ju opravovalo.

Oprava 5: Oprava funkcie alebo typu objektu pri zdroji

Niekedy je stránka s priradením nevinná a skutočným problémom je zavádzajúca zmluva. Predpokladajme, že vyhľadávanie vráti výsledok, nullkeď neexistuje žiadny zákazník:

type Customer = { id: string; name: string };

function findCustomer(id: string): Customer | null {
  // Return a customer when found; otherwise return null.
  return null;
}

Ak by bola funkcia napísaná ako returning only Customer, volajúcim by bolo povedané, že zlyhanie je nemožné, aj keď implementácia hovorí niečo iné. Uprednostňujte opravu návratového typu a prinútenie volajúcich, aby ošetrili chýbajúci prípad.

Rovnaký princíp platí aj pre rozhrania. Ak pole API môže explicitne obsahovať JSON null, modelujte ho ako field: string | null. Ak môže vlastnosť chýbať, voliteľná vlastnosť, ako napríklad , field?: stringpredstavuje neprítomnosť prostredníctvom undefined, nie explicitná null. Ak sa vyskytnú obe formy, model môže potrebovať field?: string | null.

Oprava 6: Použitie NonNullable pre opakovane použiteľné transformácie typov

TypeScript obsahuje globálny NonNullable<Type>nástroj, ktorý odstraňuje null`and` undefinedz typu. Oficiálna dokumentácia k nástrojom pre typy ho uvádza ako štandardnú transformáciu typu.

type MaybeName = string | null | undefined;
type Name = NonNullable<MaybeName>; // string

Toto je užitočné pri odvodzovaní typu pre overenú vrstvu, ale samo o sebe to neoveruje hodnoty. Stále potrebujete riadiaci tok za behu, aby ste pred vrátením alebo odovzdaním ako typu, ktorý neumožňuje hodnotu null, overili, či skutočná hodnota nie je null.

A čo „ako reťazec“?

Tvrdenie typu, ako napríklad , value as stringmôže potlačiť chybu, ale má rovnaké základné obmedzenie ako !: mení to, čomu kompilátor verí, bez kontroly hodnoty za behu. Je vhodné iba vtedy, keď máte externé znalosti, ktoré TypeScript nedokáže odvodiť. Nemalo by to byť predvolená odpoveď na null dáta.

const value: string | null = getValue();
const forced = value as string; // Compiles, but may still be null at runtime

Ak potrebujete dokázať, že hodnota je reťazec, uprednostnite validáciu:

const value: string | null = getValue();
if (typeof value !== "string") {
  throw new Error("Expected a string");
}

const safeValue: string = value;

Neopravujte problém vypnutím funkcie strictNullChecks.

Ak strictNullChecksje nastavené na false, TypeScript do značnej miery ignoruje nulla undefinedv priraditeľnosti. To môže uľahčiť kompiláciu staršieho kódu, ale zároveň to odstraňuje schopnosť kompilátora označiť mnoho ciest chýbajúcich hodnôt pred spustením. Aktuálna dokumentácia o kompatibilite typov , aktualizovaná v septembri 2026, stále rozlišuje správanie nulových hodnôt v závislosti od tejto možnosti.

Ak migrujete rozsiahly starší projekt, povolenie prísnejších kontrol môže vyžadovať postupné čistenie. Aj v takom prípade berte vypnutie kontroly null ako obmedzenie migrácie, nie ako preferovanú lokálnu opravu jednej chyby.

Praktická ladiaca postupnosť

1. Prečítajte si typ destinácie. Ak je tam uvedený string, User, alebo iný konkrétny typ, opýtajte sa, či nullby tam malo byť naozaj povolené.
2. Sledujte, kde vstupuje null. Skontrolujte typ návratovej hodnoty funkcie, vlastnosť objektu, výsledok vyhľadávania, model databázy/API, dotaz DOM alebo počiatočný stav.
3. Vyberte sémantickú opravu. Modelujte hodnotu null pomocou únie, zúžte ju, poskytnite záložnú možnosť alebo opravte zdrojový kontrakt.
4. Používajte tvrdenia iba pre reálne invarianty. Nenulové tvrdenie alebo tvrdenie typu by malo dokumentovať vedomosti, ktoré skutočne vlastníte, nie vymazať neistotu.
5. Znova spustite kompilátor a otestujte nulovú cestu. Čisté zostavenie dokazuje, že vzťah medzi typmi je prijateľný; test za behu dokazuje, že vaše správanie pri chýbajúcej hodnote skutočne zodpovedá požiadavkám produktu.

Bežné príklady a najlepšia odpoveď

Vyhľadávanie môže zlyhať

const user = users.find(u => u.id === id);

Array.prototype.findmôže vrátiť undefined, takže výsledok ochráňte alebo poskytnite záložnú možnosť. Toto je rovnaké zdôvodnenie ako pre hodnotu s možnosťou null, aj keď chýbajúci typ je , undefineda nie null.

Pole databázy alebo API explicitne vracia hodnotu null

Ponechajte | nulltyp hranice, ak ho externý kontrakt skutočne odosiela. Potom konvertujte alebo overte na hranici, kde vaša aplikácia vyžaduje reálnu hodnotu.

Premenná je na začiatku prázdna, ale neskôr sa musí naplniť

Počas fázy, kde je „nie je pripravené“ legitímne, použite nullabilnú úniu alebo reštrukturalizujte kód tak, aby konštrukcia vyžadovala hodnotu. Uprednostnite druhý prístup, keď plne inicializovaný objekt nikdy nemá existovať v čiastočnom stave.

Zrátané a podčiarknuté

Najbezpečnejším riešením pre chybu „Typ 'null' nie je priraditeľný k typu“ nie je jediný operátor. Ide o výber typu, ktorý odráža realitu, a následné nastavenie postupu riadenia tak, aby zodpovedal tomuto typu. Použite, T | nullkeď je null platný, explicitné zúženie, keď sa musí hodnota skontrolovať, ??keď existuje skutočná záložná možnosť a !iba vtedy, keď existuje záruka behu mimo zobrazenia TypeScript.

TypeScript 7.0 mení architektúru kompilátora, nie tento princíp návrhu. Ak váš kód hovorí, že hodnota nemôže byť null, nastavte tento príkaz na pravdivý za behu programu, ako aj v typovom systéme.