type Color = `#${string}`;
// 1. Cu adnotare clasică: pierzi cheile literale
const badPalette: Record<string, Color> = {
primary: '#ff0000',
secondary: '#00ff00'
};
// badPalette.primari nu dă eroare de compilare!
// 2. Cu satisfies: validare + autocompletare exactă
const goodPalette = {
primary: '#ff0000',
secondary: '#00ff00'
} satisfies Record<string, Color>;
// TypeScript știe sigur că goodPalette are cheia 'primary'
const myColor = goodPalette.primary;
// goodPalette.primari -> Property 'primari' does not exist! Eroare instantă.De când a apărut TypeScript 4.9, văd două extreme în code review: colegi care continuă să bage as SomeType oricând se supără compilatorul și colegi care pun satisfies peste tot, inclusiv unde o simplă adnotare era sfântă. La un monorepo mare la care am lucrat anul trecut, am scăzut vreo 12 bug-uri de runtime la lansare doar făcând curățenie în aserțiunile de tip.
Hai să trecem prin 4 situații practice ca să lămurim când merită fiecare abordare.
1. Dicționare de teme, culori sau rute (Câștigător: satisfies)
Clasica problemă: ai un obiect cu paleta de culori a aplicației. Vrei două lucruri: compilatorul să verifice că toate valorile respectă o schemă (de exemplu, hex valid sau un anumit format), dar vrei ca IDE-ul să știe exact ce chei există, nu un generic Record<string, string>.
Dacă pui const theme: Record<string, string> = { primary: '#00f' }, ai pierdut autocompletarea pe theme.primary. Dacă folosești satisfies Record<string, string>, TypeScript verifică dacă structura e conformă, dar păstrează tipurile literale exacte pentru proprietăți. Dacă scrii greșit theme.primari, primești eroare la compilare imediat.
2. Definirea unui contract strict pe obiecte mari (Câștigător: adnotarea clasică)
Când construiești un payload pentru un API sau un mock într-un test, de cele mai multe ori vrei adnotarea explicită const payload: CreateUserDto = { ... }.
De ce? Pentru că adnotarea forțează verificarea completă a interfeței direct la scriere. Dacă ai o proprietate obligatorie omisă, linia cu declararea variabilei se înroșește instantaneu. satisfies face același lucru dacă îl legi de interfață, dar adnotarea explicită este mult mai curată vizual și mai predictibilă pentru oricine citește codul după tine.
Trade-off sincer: adnotarea clasică face widen la tipuri (un 'active' devine string dacă interfața are string), ceea ce e fix ce vrei uneori ca să nu te blochezi în tipuri literale rigide.
3. Răspunsuri de API extern sau date din cache (Câștigător: type guard / Zod, dar cu as ca rău necesar)
Operatorul as nu validează nimic în runtime. Pur și simplu îi spui compilatorului: „taci din gură, știu eu mai bine”. Și de 9 din 10 ori, nu știi mai bine.
Singurul loc unde accept as într-un PR este la granița cu librării third-party scrise prost în JavaScript chior sau la migrări rapide când rescrii un codebase uriaș și nu ai timp să creezi validatori Zod pentru 80 de endpoint-uri. În rest, dacă scrii res.json() as User, te minți singur. Dacă backend-ul trimite null, aplicația crapă în producție fix când ți-e lumea mai dragă.
4. Normalizarea configurațiilor parțiale (satisfies + Record<Key, Type>)
Am avut cazul unui sistem de permisiuni bazat pe roluri (admin, editor, viewer). Aveam nevoie de un obiect de configurare unde fiecare rol declarat avea o listă de acțiuni, dar voiam certitudinea că nu inventez roluri noi din greșeală și că nu uit să pun metodele esențiale pe fiecare.
Folosind satisfies Record<Role, ActionConfig>, TypeScript mi-a validat că toate rolurile există, dar fără să-mi șteargă specificitatea tipurilor din interiorul fiecărui rol (cum ar fi funcții cu parametri particulari).
Pe scurt: folosește adnotarea clasică pentru contracte standard, satisfies când vrei validare fără să pierzi tipurile literale deduse și elimină as oriunde poți folosi un type guard.