error TS2589: Type instantiation is excessively deep and possibly infinite.
Un tip recursiv (sau o combinație de generice dintr-o bibliotecă) are nevoie de prea mulți pași ca să fie calculat, iar TypeScript se oprește. Rescrie tipul recursiv în formă tail-recursive, limitează adâncimea sau folosește un tip mai simplu (number[] în loc de un tuplu de 100 de elemente).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
TypeScript calculează tipurile recursive pas cu pas și are o limită de adâncime, ca să nu se blocheze. Când un tip are nevoie de mai mulți pași (de exemplu un tuplu construit element cu element până la 100), compilatorul se oprește cu TS2589.
Cauze tipice: tipuri recursive scrise de mână (tupluri de lungime N, căi adânci de tip 'a.b.c', parsere de text la nivel de tip), tipuri care se recursează fără caz de oprire sau biblioteci cu generice complexe (validatoare de scheme, ORM-uri, formulare) combinate în moduri neprevăzute.
Ce poți face: rescrie recursivitatea ca tail-recursive (apelul recursiv e chiar rezultatul, cu un acumulator), caz în care limita crește la aproximativ 1000 de pași; pune o limită de adâncime; sau acceptă un tip mai puțin precis (boolean[]). La biblioteci, adaugă tipuri explicite pe variabilele intermediare.
De ce apare: cauzele frecvente
1Tuplu recursiv care nu e tail-recursive
type Rand<T, N extends number, A extends unknown[] = []> =
A['length'] extends N ? [] : [T, ...Rand<T, N, [...A, 0]>];
type Sala = Rand<boolean, 100>;type Rand<T, N extends number, A extends T[] = []> =
A['length'] extends N ? A : Rand<T, N, [...A, T]>;
type Sala = Rand<boolean, 100>;În varianta corectă, rezultatul se construiește în acumulatorul A, iar apelul recursiv e ultimul pas, așa că TypeScript îl poate optimiza.
2Precizie inutilă
type Rand<T, N extends number, A extends unknown[] = []> =
A['length'] extends N ? [] : [T, ...Rand<T, N, [...A, 0]>];
const locuri = [] as unknown as Rand<boolean, 500>;const locuri: boolean[] = Array(500).fill(false);Pentru 500 de locuri, un tablou cu lungimea verificată la rulare e mai simplu decât un tuplu de 500 de elemente.
Repară eroarea, direct în pagină
Codul de mai jos dă eroarea TS2589: Type instantiation is excessively deep and possibly infinite. Tipul Rand descrie un rând de N locuri. Rescrie-l ca tail-recursive, cu acumulatorul A, ca programul să afișeze Locuri: 100, ocupate: 0.
type Rand<T, N extends number, A extends unknown[] = []> =
A['length'] extends N ? [] : [T, ...Rand<T, N, [...A, 0]>];
type Sala = Rand<boolean, 100>;
const sala = Array(100).fill(false) as Sala;
const ocupate = sala.filter((x) => x).length;
console.log(`Locuri: ${sala.length}, ocupate: ${ocupate}`);Locuri: 100, ocupate: 0
Indiciu
Când lungimea lui A e N, întoarce A; altfel, apelează Rand cu [...A, T].
Reparația
type Rand<T, N extends number, A extends T[] = []> =
A['length'] extends N ? A : Rand<T, N, [...A, T]>;
type Sala = Rand<boolean, 100>;
const sala = Array(100).fill(false) as Sala;
const ocupate = sala.filter((x) => x).length;
console.log(`Locuri: ${sala.length}, ocupate: ${ocupate}`);De ce merge
Varianta inițială construiește tuplul ca [T, ...Rand<...>]: fiecare pas trebuie să aștepte rezultatul următorului, iar la 100 de pași TypeScript depășește limita. În varianta tail-recursive, acumulatorul A crește cu un T la fiecare pas, iar apelul recursiv e chiar rezultatul. TypeScript îl evaluează ca pe o buclă, care suportă până la aproximativ 1000 de pași.
Cum o eviți pe viitor
- Scrie tipurile recursive cu acumulator (tail-recursive) și cu un caz de oprire clar.
- Pune o limită de adâncime la tipurile care parcurg obiecte imbricate (de exemplu maximum 5 niveluri).
- Nu cere precizie la nivel de tip acolo unde o verificare la rulare e suficientă.
- La erori din biblioteci, adaugă tipuri explicite pe rezultatele intermediare ca să scurtezi lanțul de deducere.
Întrebări frecvente
Pot crește limita de adâncime din tsconfig?
Nu, limita e fixă în compilator. Trebuie să schimbi tipul, nu configurația.
Ce înseamnă tail-recursive la un tip?
Ramura recursivă a tipului condițional e direct apelul recursiv (... ? A : Rand<T, N, [...A, T]>), nu un tip care îl conține ([T, ...Rand<...>]). TypeScript evaluează astfel de tipuri ca pe o buclă, cu o limită mult mai mare.
Erori înrudite
error TS2456: Type alias 'Lista' circularly references itself. Tipul se definește direct prin el însuși (type A = A, sau printr-un lanț de aliasuri), fără o structură (obiect, tablou) care să „oprească” recursivitatea. Tipurile recursive trebuie să treacă printr-un obiect sau tablou: type Nod = { copii: Nod[] }. error TS2558: Expected 1 type arguments, but got 2. Ai pus între < > mai multe (sau mai puține) tipuri decât parametri de tip are funcția ori clasa. Numără parametrii din declarație (de exemplu function f<T>) și scrie exact atâtea, sau scoate-le complet și lasă TypeScript să le deducă. error TS2344: Type 'string' does not satisfy the constraint '{ id: number; }'. Ai dat unui tip generic un argument care nu respectă constrângerea din extends (aici T trebuie să aibă câmpul id: number, iar string nu are). Folosește un tip care respectă constrângerea sau, dacă trebuie să accepte și alte tipuri, relaxează constrângerea. Învață TypeScript de la zero, cu exerciții la fiecare lecție
Curs TypeScript: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
