Jak opravit chybu „Typ 'null' nelze přiřadit typu“ v TypeScriptu

TypeScript 7.0, vydaný 8. července 2026, přesunul kompilátor do nové nativní implementace, ale Microsoft tvrdí, že port zachovává sémantiku kontroly typů, na kterou se vývojáři již spoléhali. To je zde důležité, protože známá Type 'null' is not assignable to type ...chyba se stále zásadně týká vašeho datového modelu: hodnota může být null, zatímco cílový typ říká, že nemusí.

Jinými slovy, neexistuje žádný nový trik specifický pro TypeScript 7, který by se bylo třeba naučit. Správným řešením je stále rozhodnout, zda nullje jde o platná data, chránit se před nimi, když ještě nejsou bezpečná k použití, nebo poskytnout záměrnou záložní variantu. Oficiální oznámení TypeScript 7.0 vysvětluje přechod kompilátoru, zatímco aktuální dokumentace strictNullChecks nadále definuje nulla undefinedjako samostatné typy, když je povolena striktní kontrola null.

Proč TypeScript hlásí „Typ 'null' nelze přiřadit typu“

Chyba se objeví, když se výraz může vyhodnotit jako , nullale přijímající typ vylučuje null. Minimální příklad je:

let name: string = null;

Pokud strictNullChecksje povoleno, stringznamená to skutečnou řetězcovou hodnotu. Neobsahuje tiše null. Kompilátor proto odmítne přiřazení, místo aby nechal případnou chybějící hodnotu proudit do kódu, který předpokládá, že řetězcové metody jsou bezpečné.

Vypnutí strictNullChecksmůže způsobit zmizení diagnostiky, ale také odstraní důležitou třídu kontrol. Vlastní konfigurační reference TypeScriptu varuje, že ignorování nulla undefinedmůže vést k neočekávaným chybám za běhu. Pro většinu spravovaných aplikací je oprava modelu nebo řídicího toku bezpečnější než zakázání kontroly.

Vyberte opravu na základě toho, co ve vašem programu znamená null.

Před změnou syntaxe rozhodněte, co chybějící hodnota představuje. Na této odpovědi závisí nejudržovatelnější řešení.

Oprava 1: Zahrnutí hodnoty null do typu, pokud je hodnota null platná

Pokud má proměnná skutečně stav „zatím není k dispozici“ nebo „žádná hodnota“, modelujte tento stav explicitně:

let name: string | null = null;

name = "Avery";

Toto není alternativní řešení. Jedná se o přesnou smlouvu. Prostřední jméno profilu, volitelný výsledek databáze nebo vybraná položka, která začíná prázdná, mohou být rozumně nullovatelné. Jakmile typ říká string | null, musí následný kód před použitím operací pouze s řetězci ověřit, že hodnota je řetězec.

Tento přístup použijte, když volající potřebují rozlišit „neexistuje žádná hodnota“ od skutečné hodnoty. Nepřidávejte | nullreflexivně jen proto, abyste umlčeli kompilátor; tím se požadavek na zpracování posune ven.

Oprava 2: Zúžte hodnotu před jejím použitím

Pokud se hodnota s možnou hodnotou null po kontrole stane bezpečnou, nechte analýzu toku řízení v TypeScriptu zúžit typ. Oficiální příručka pro zúžení ukazuje, že kontroly typu value !== nullremove nullz typu uvnitř chráněné větve.

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

  console.log(text.length);
}

Po časném návratu textje známo, že se jedná o string. Tento vzor se dobře škáluje, protože bezpečnostní kontrola zůstává blízko bodu, kde se předpoklad stává pravdivým.

Použijte přesnou kontrolu null, když jsou platné falešné hodnoty

Podmínka typu if (text)také vylučuje prázdné řetězce, protože ""je nepravdivá. Pokud má prázdný řetězec smysl, upřednostněte text !== null. Pokud hodnota může být buď , nullnebo undefined, value != nullje stručná kontrola JavaScriptu, která vylučuje obě; TypeScript chápe toto zúžení, jak je popsáno v příručce.

Oprava 3: Zadejte výchozí hodnotu s nulovým slučovacím operátorem

Pokud má vaše obchodní logika skutečnou záložní možnost, záměrně převeďte hodnotu s povolenou hodnotou Null na hodnotu nenulovou:

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

Operátor ??používá pravou hodnotu pouze tehdy, když je levá strana nullnebo undefined. Díky tomu je lepším nástrojem pro nastavení výchozího nastavení, než ||když jsou platné hodnoty jako "", 0nebo , falsekteré by měly být zachovány.

Toto řešení je ideální pro popisky, výchozí hodnoty konfigurace a hodnoty pouze pro zobrazení. Je méně vhodné, když váš program musí vědět, zda hodnota skutečně chyběla, protože záložní řešení toto rozlišení záměrně ruší.

Oprava 4: Používejte operátor nenulového tvrzení pouze tehdy, když již máte záruku.

Postfix !říká TypeScriptu, aby s hodnotou zacházel jako s nenull a nedefinovanou:

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

Toto se kompiluje, protože !odstraňuje část s povolenou hodnotou null pro kontrolu typů. Nepřidává kontrolu za běhu. Pokud element neexistuje, kód může stále selhat při pokusu o přístup k textContent.

Používejte !pouze tehdy, když nějaký jiný invariant skutečně zaručuje existenci hodnoty a kompilátor nemůže tento invariant vyjádřit ani odvodit. Pro vyhledávání DOM, data požadavků, čtení z mezipaměti a vstup uživatele je skutečná kontrola obvykle robustnější:

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

Dobrá otázka při kontrole kódu zní: „Co vynucuje tuto hodnotu za běhu?“ Pokud je odpověď pouze „očekáváme ji“, tvrzení pravděpodobně spíše skrývá chybu než ji opravuje.

Oprava 5: Oprava funkce nebo typu objektu u zdroje

Někdy je web s přiřazením nevinný a skutečným problémem je zavádějící smlouva. Předpokládejme, že vyhledávání vrátí výsledek, nulli když žádný zákazník neexistuje:

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

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

Pokud by byla funkce napsána jako returning only Customer, volajícím by bylo řečeno, že selhání je nemožné, i když implementace říká opak. Raději opravte návratový typ a vynuťte volajícím, aby se postarali o chybějící případ.

Stejný princip platí pro rozhraní. Pokud pole API může explicitně obsahovat JSON null, modelujte jej jako field: string | null. Pokud může vlastnost chybět, volitelná vlastnost, například , field?: stringpředstavuje absenci prostřednictvím undefined, nikoli explicitní null. Pokud se vyskytují oba tvary, model může potřebovat field?: string | null.

Oprava 6: Pro opakovaně použitelné transformace typů použijte NonNullable

TypeScript obsahuje globální NonNullable<Type>utilitu, která odstraňuje null`and` undefinedz typu. Oficiální dokumentace k utilitám pro typy ji uvádí jako standardní transformaci typů.

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

To je užitečné při odvozování typu pro ověřenou vrstvu, ale samo o sobě to neověřuje hodnoty. Stále potřebujete běhový řídicí tok, abyste před vrácením nebo předáním jako typu, který nelze použít k nastavení hodnoty Null, ověřili, že skutečná hodnota není null.

A co „jako řetězec“?

Aserce typu , například , value as stringmůže chybu potlačit, ale má stejné základní omezení jako !: mění to, čemu kompilátor věří, bez kontroly běhové hodnoty. Je vhodný pouze tehdy, když máte externí znalosti, které TypeScript nedokáže odvodit. Neměl by být výchozí odpovědí na data s povolenou hodnotou null.

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

Pokud potřebujete dokázat, že hodnota je řetězec, upřednostňujte validaci:

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

const safeValue: string = value;

Neopravujte problém zakázáním strictNullChecks.

Pokud je strictNullChecksnastaveno na false, TypeScript do značné míry ignoruje nulla undefinedv přiřaditelnosti. To může usnadnit kompilaci staršího kódu, ale také to odstraňuje schopnost kompilátoru označit mnoho cest k chybějícím hodnotám před během. Aktuální dokumentace o kompatibilitě typů , aktualizovaná v září 2026, stále rozlišuje chování nulových hodnot v závislosti na této možnosti.

Pokud migrujete rozsáhlý starší projekt, může povolení přísnějších kontrol vyžadovat čištění po etapách. I v tomto případě považujte zakázání kontroly hodnot null za omezení migrace, nikoli za preferovanou lokální opravu jedné chyby.

Praktická ladicí sekvence

1. Přečtěte si typ cíle. Pokud je tam uvedeno string, User, nebo jiný konkrétní typ, zeptejte se, zda nullby tam mělo být opravdu povoleno.
2. Sledujte, kde vstupuje null. Zkontrolujte návratový typ funkce, vlastnost objektu, výsledek vyhledávání, model databáze/API, dotaz DOM nebo počáteční stav.
3. Vyberte sémantickou opravu. Modelujte hodnotu null pomocí sjednocení, zúžte ji, poskytněte záložní variantu nebo opravte zdrojový kontrakt.
4. Používejte tvrzení pouze pro reálné invarianty. Nenulové tvrzení nebo tvrzení typu by mělo dokumentovat znalosti, které skutečně vlastníte, ne mazat nejistotu.
5. Znovu spusťte kompilátor a otestujte cestu s hodnotou null. Čisté sestavení prokáže, že vztah mezi typy je přijatelný; běhový test prokáže, že vaše chování při chybějící hodnotě skutečně odpovídá požadavku na produkt.

Běžné příklady a nejlepší reakce

Vyhledávání může selhat

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

Array.prototype.findmůže vrátit undefined, takže výsledek ochraňte nebo poskytněte záložní hodnotu. Toto je stejné uvažování jako u hodnoty s povolenou hodnotou null, i když chybějící typ je undefinedspíše než null.

Pole databáze nebo API explicitně vrací hodnotu null

Pokud je to typ hranice, který externí kontrakt skutečně odesílá, ponechte | nulljej. Poté převeďte nebo ověřte na hranici, kde vaše aplikace vyžaduje reálnou hodnotu.

Proměnná je zpočátku prázdná, ale později musí být naplněna

Použijte nullabilní unii během fáze, kdy je „není připraveno“ legitimní, nebo přestrukturujte kód tak, aby konstrukce vyžadovala hodnotu. Druhý přístup upřednostňujte, když by plně inicializovaný objekt nikdy neměl existovat v částečném stavu.

Sečteno a podtrženo

Nejbezpečnějším řešením pro chybu „Typ 'null' nelze přiřadit typu“ není použití jediného operátoru. Jde o výběr typu, který odráží realitu, a následné nastavení řídicího toku tak, aby odpovídal tomuto typu. Použijte, T | nullkdyž je platná hodnota null, explicitní zúžení, když je nutné hodnotu zkontrolovat, ??když existuje skutečná záložní možnost a !pouze když existuje záruka běhu mimo zobrazení TypeScriptu.

TypeScript 7.0 mění architekturu kompilátoru, nikoli tento princip návrhu. Pokud váš kód říká, že hodnota nemůže být null, nastavte tento příkaz na hodnotu true za běhu i v typovém systému.