Învață TypeScript: comenzi explicate cu exemple

196 de comenzi 26 de categorii

TypeScript este JavaScript cu tipuri. Codul este verificat înainte de rulare, iar multe greșeli (o proprietate scrisă greșit, un undefined uitat) sunt prinse direct în editor.

Funcțiile din runtime (Array.map, fetch, JSON.parse…) sunt aceleași ca în JavaScript și sunt explicate în secțiunea JavaScript. Aici găsești ce adaugă TypeScript: tipuri, interfețe, generics, union și intersection, narrowing, tipurile utilitare (Partial, Pick, Record…) și opțiunile din tsconfig.json.

Toate exemplele au fost verificate cu tsc --strict și rulate cu Node.js; rezultatul afișat este cel real.

Tipuri de bază 12 comenzi

Interfețe, alias-uri, union și enum 8 comenzi

Funcții 6 comenzi

Clase 12 comenzi

Generics și tipuri avansate 9 comenzi

Narrowing și type guards 8 comenzi

Aserțiuni și operatori pentru null 6 comenzi

Module și declarații 6 comenzi

Cod asincron și iterare 5 comenzi

Verificare, medii și unelte 5 comenzi

Tipuri utilitare pentru obiecte 6 comenzi

Tipuri utilitare pentru union 4 comenzi

Tipuri utilitare pentru funcții și clase 6 comenzi

Tipuri utilitare pentru text 2 comenzi

Tipuri pentru decoratori (experimentalDecorators) 2 comenzi

tsconfig: verificarea tipurilor 19 comenzi

tsconfig: module și rezolvarea importurilor 18 comenzi

tsconfig: interoperabilitate între module 7 comenzi

tsconfig: limbaj și mediu 8 comenzi

tsconfig: fișierele generate (emit) 17 comenzi

tsconfig: fișiere JavaScript 2 comenzi

tsconfig: proiecte și compilare incrementală 3 comenzi

tsconfig: linia de comandă tsc 10 comenzi

tsconfig: diagnosticare 6 comenzi

tsconfig: editor și fișiere .d.ts 3 comenzi

tsconfig: opțiuni scoase (compatibilitate) 6 comenzi

Toate funcțiile

Lista completă a construcțiilor TypeScript, a tipurilor utilitare și a opțiunilor compilatorului incluse în această secțiune. Cele cu link au o pagină dedicată.

Tipuri și construcții TypeScript (78)

Funcție	Ce face
`let și const cu tipuri`	Declari variabile cu let sau const și le pui tipul după două puncte: let x: number = 5.
`inferența tipurilor`	TypeScript deduce singur tipul variabilelor și al rezultatelor din valorile scrise.
`any`	Tipul care oprește verificarea: acceptă orice și permite orice operație, fără erori de compilare.
`unknown`	Tipul sigur pentru valori necunoscute: acceptă orice, dar cere o verificare înainte de folosire.
`never`	Tipul fără nicio valoare: funcții care nu se termină normal și cazuri imposibile (verificare exhaustivă).
`void`	Tipul returnat de funcțiile care nu întorc nicio valoare utilă.
`null și undefined`	Cu strictNullChecks sunt tipuri separate; o valoare care poate lipsi se scrie T \| null sau T \| undefined.
`string, number, boolean`	Tipurile primitive de bază: texte, numere (întregi și zecimale) și valori adevărat/fals.
`bigint și symbol`	bigint ține întregi oricât de mari (123n); symbol este o valoare unică, folosită drept cheie.
`tipuri literale`	Tipuri cu o singură valoare exactă („mic”, 3, true); în union dau liste de valori permise.
`array (T[] și Array<T>)`	Tipul tablourilor: T[] sau Array<T>; readonly T[] interzice modificarea.
`tuple`	Tablou cu număr fix de elemente și tip pe fiecare poziție: [string, number].
`interface`	Descrie forma unui obiect: proprietăți, tipurile lor, proprietăți opționale și metode.
`type (alias de tip)`	Dă un nume oricărui tip: obiect, union, tuple, funcție sau tip calculat.
`interface vs type`	Ce poate fiecare: interface se extinde și se unește, type numește union-uri și tipuri calculate.
`union (\|)`	A \| B acceptă valori de oricare dintre tipuri; restul se verifică prin narrowing.
`intersection (&)`	A & B combină tipuri: valoarea are toate proprietățile lui A și ale lui B.
`enum`	Set de constante cu nume, numerice sau text, care există și la rulare ca obiect.
`const enum`	Enum ale cărui valori sunt înlocuite direct în cod la compilare, fără obiect la rulare.
`funcții cu tipuri`	Tipuri pe parametri și pe rezultat; fiecare apel este verificat la compilare.
`parametri opționali și impliciți`	Parametrul cu ? poate lipsi (undefined); cel cu = valoare primește valoarea implicită.
`rest parameters`	…valori: T[] strânge oricâte argumente într-un tablou.
`overload`	Mai multe semnături pentru aceeași funcție, cu rezultat de tip diferit după argumente.
`arrow functions cu tipuri`	Funcții săgeată cu tipuri; în callback-uri parametrii primesc tipul din context.
`this în funcții`	Parametrul fals this: Tip declară pe ce obiect trebuie apelată funcția.
`class`	Clase cu câmpuri, constructor și metode tipizate; numele clasei este și un tip.
`public, private, protected`	Modificatori de acces: oricine, doar clasa, sau clasa și derivatele (verificați la compilare).
`readonly`	Proprietate care primește valoare o singură dată și nu mai poate fi modificată.
`#câmpuri private`	Câmpuri private din JavaScript (#nume), inaccesibile din afara clasei și la rulare.
`abstract`	Clasă care nu se instanțiază; metodele abstract trebuie implementate în clasele derivate.
`implements`	Clasa promite că respectă o interfață; tsc verifică dacă are toți membrii.
`extends`	Moștenire: clasa preia câmpurile și metodele altei clase; interfața preia proprietăți.
`static`	Membri care aparțin clasei, nu obiectelor: NumeClasa.membru; blocuri static { }.
`constructor parameter properties`	constructor(public x: number) declară și inițializează câmpul direct din parametru.
`accesori get/set`	Proprietăți calculate: get rulează la citire, set la scriere.
`override`	Marchează o metodă rescrisă; eroare dacă metoda nu există în clasa de bază.
`generics (<T>)`	Parametri de tip: cod scris o dată, care merge cu orice tip și păstrează tipul exact.
`constrângeri generice (extends)`	<T extends Tip> limitează tipurile permise pentru T; K extends keyof T pentru chei.
`keyof`	keyof T dă union-ul numelor de proprietăți ale lui T.
`typeof (tip)`	În poziție de tip, typeof x dă tipul variabilei sau funcției x.
`indexed access (T[K])`	T[„cheie”] dă tipul unei proprietăți; T[number] dă tipul elementelor unui tablou.
`mapped types`	{ [K in keyof T]: … } construiește un tip nou trecând prin fiecare cheie a altui tip.
`conditional types`	T extends U ? X : Y alege un tip după o condiție; distributiv pe union-uri.
`infer`	În condiția unui tip condițional, infer X extrage o parte din tip (element, rezultat, parametri).
`template literal types`	Tipuri de text construite ca template string: `id-${number}`.
`type guards`	Verificări la rulare (typeof, instanceof, in, predicate) din care TypeScript află tipul exact.
`typeof guard`	typeof x === „string” restrânge tipul la primitivul verificat.
`instanceof guard`	x instanceof Clasa restrânge tipul la clasă; util pentru erori în catch.
`in guard`	„cheie” in x restrânge un union de obiecte la variantele care au proprietatea.
`predicat de tip (is)`	Funcție cu rezultatul x is Tip: dacă returnează true, x are tipul Tip.
`asserts`	Funcție care aruncă dacă verificarea eșuează; după apel, tipul este cel cerut.
`discriminated unions`	Union de obiecte cu o proprietate literală comună; switch pe ea dă varianta exactă.
`narrowing`	TypeScript urmărește if, switch și return și restrânge tipul variabilei în fiecare ramură.
`as (type assertion)`	valoare as Tip spune compilatorului ce tip are valoarea; nu verifică și nu convertește.
`as const`	Face un literal readonly și păstrează valorile exacte ca tipuri literale.
`satisfies`	Verifică că o valoare respectă un tip, dar păstrează tipul ei exact, dedus.
`non-null (!)`	x! elimină null și undefined din tip, fără verificare la rulare.
`optional chaining (?.)`	a?.b citește proprietatea doar dacă a există; altfel dă undefined.
`nullish coalescing (??)`	a ?? b dă b doar când a este null sau undefined; păstrează 0, „” și false.
`index signatures`	[cheie: string]: Tip descrie obiecte cu chei necunoscute dinainte.
`Record și obiecte dinamice`	Record<string, T> și index signatures pentru dicționare cu chei dinamice.
`declare`	Anunță că o variabilă, funcție sau modul există la rulare, fără să genereze cod.
`fișiere .d.ts`	Fișiere doar cu tipuri, care descriu cod JavaScript; @types/* și declaration.
`namespace`	Grupează cod sub un nume (Geometrie.arie); formă veche, înlocuită de module ES.
`module și import/export`	Fiecare fișier cu import/export este un modul; în nodenext importul are extensia .js/.mjs.
`import type`	Importă doar tipuri; linia dispare din JavaScript-ul generat.
`export type`	Exportă sau re-exportă doar tipuri, fără cod la rulare.
`decoratori`	Funcții puse cu @ pe clase, metode sau câmpuri, care le modifică comportamentul (standard, TS 5.0).
`using (resurse)`	Resursă eliberată automat la ieșirea din bloc prin [Symbol.dispose]; await using pentru async.
`async/await cu tipuri`	O funcție async returnează Promise<T>; await scoate valoarea de tip T.
`Promise<T>`	Tipul unei valori disponibile mai târziu; T este tipul rezultatului.
`generatori cu tipuri`	function* produce valori cu yield; tipul este Generator<T, TReturn, TNext>.
`iteratori cu tipuri`	Obiecte cu [Symbol.iterator] parcurse cu for…of; Iterable<T> și Iterator<T>.
`@ts-ignore și @ts-expect-error`	Comentarii care opresc eroarea de pe linia următoare; @ts-expect-error cere ca ea să existe.
`strict mode`	Opțiunea strict pornește toate verificările stricte (null separat, fără any implicit etc.).
`tipuri pentru DOM`	Tipuri pentru document, elemente și evenimente din biblioteca dom; querySelector poate da null.
`tipuri pentru Node.js`	Tipurile modulelor Node.js (fs, path, process) din pachetul @types/node.
`JSDoc cu tipuri`	Tipuri în comentarii /** */ ca tsc să verifice fișiere JavaScript (// @ts-check).

Tipuri utilitare (25)

Funcție	Ce face
`Awaited`	Tipul valorii obținute cu await; desface și Promise-urile imbricate. `tip utilitar`
`Capitalize`	Face prima literă a unui tip text mare: Capitalize<„nume”> este „Nume”. `tip utilitar`
`ClassDecorator`	Tipul unui decorator de clasă în stilul experimentalDecorators: primește constructorul. `tip utilitar`
`ConstructorParameters`	Tipurile parametrilor constructorului unei clase, ca tuple: ConstructorParameters<typeof C>. `tip utilitar`
`Exclude`	Elimină dintr-un union variantele care se potrivesc cu U. `tip utilitar`
`Extract`	Păstrează dintr-un union doar variantele care se potrivesc cu U. `tip utilitar`
`InstanceType`	Tipul obiectelor create cu new dintr-un tip de clasă: InstanceType<typeof C>. `tip utilitar`
`Lowercase`	Transformă un tip text în litere mici: Lowercase<„GET”> este „get”. `tip utilitar`
`MethodDecorator`	Tipul unui decorator de metodă experimental: (target, cheie, descriptor). `tip utilitar`
`NoInfer`	Oprește deducerea unui generic dintr-un parametru; acolo valoarea doar se verifică. `tip utilitar`
`NonNullable`	Elimină null și undefined dintr-un tip. `tip utilitar`
`Omit`	Tipul T fără proprietățile cu numele din K. `tip utilitar`
`OmitThisParameter`	Tipul unei funcții fără parametrul this, ca după bind. `tip utilitar`
`ParameterDecorator`	Tipul unui decorator de parametru (doar experimentalDecorators): (target, cheie, index). `tip utilitar`
`Parameters`	Tipurile parametrilor unei funcții, ca tuple: Parameters<typeof f>. `tip utilitar`
`Partial`	Face toate proprietățile lui T opționale. `tip utilitar`
`Pick`	Păstrează din T doar proprietățile cu numele din K. `tip utilitar`
`PropertyDecorator`	Tipul unui decorator de proprietate experimental: (target, cheie). `tip utilitar`
`Readonly`	Face toate proprietățile lui T readonly. `tip utilitar`
`Record`	Obiect cu cheile K și valori de tipul T: Record<„lei” \| „euro”, number>. `tip utilitar`
`Required`	Face toate proprietățile lui T obligatorii, inclusiv cele cu ?. `tip utilitar`
`ReturnType`	Tipul rezultatului unei funcții: ReturnType<typeof f>. `tip utilitar`
`ThisParameterType`	Tipul parametrului this al unei funcții (unknown dacă nu are). `tip utilitar`
`Uncapitalize`	Face prima literă a unui tip text mică: Uncapitalize<„Nume”> este „nume”. `tip utilitar`
`Uppercase`	Transformă un tip text în majuscule: Uppercase<„get”> este „GET”. `tip utilitar`

Opțiunile compilatorului (tsconfig.json) (125)

Funcție	Ce face
`help`	Afișează ajutorul lui tsc: comenzile obișnuite și opțiunile principale. `tsconfig: Command-line Options`
`help`	Afișează ajutorul lui tsc: comenzile obișnuite și opțiunile principale. `tsconfig: Command-line Options`
`watch`	Recompilează automat proiectul la fiecare salvare a unui fișier. `tsconfig: Command-line Options`
`preserveWatchOutput`	În modul watch, nu mai golește ecranul la fiecare recompilare. `tsconfig: Output Formatting`
`listFiles`	Compilează și afișează la final toate fișierele citite. `tsconfig: Compiler Diagnostics`
`explainFiles`	Afișează fiecare fișier din compilare și motivul pentru care a fost inclus. `tsconfig: Compiler Diagnostics`
`listEmittedFiles`	Afișează căile fișierelor scrise la compilare (TSFILE: …). `tsconfig: Compiler Diagnostics`
`pretty`	Erori colorate, cu rândul de cod subliniat; implicit pornită în terminal. `tsconfig: Output Formatting`
`traceResolution`	Afișează pas cu pas cum este găsit fișierul din spatele fiecărui import. `tsconfig: Compiler Diagnostics`
`diagnostics`	Statistici după compilare: fișiere, tipuri, memorie, timpul fiecărei etape. `tsconfig: Compiler Diagnostics`
`extendedDiagnostics`	Statistici detaliate despre compilare (rânduri pe categorii, cache-uri, timpi). `tsconfig: Compiler Diagnostics`
`generateCpuProfile`	Scrie un profil CPU V8 al compilării, pentru analiza performanței. `tsconfig: Compiler Diagnostics`
`generateTrace`	Scrie trace.json și types.json pentru analiza detaliată a performanței. `tsconfig: Compiler Diagnostics`
`incremental`	Salvează .tsbuildinfo ca următoarea compilare să refacă doar ce s-a schimbat. `tsconfig: Projects`
`declaration`	Generează fișiere .d.ts cu tipurile, lângă JavaScript. `tsconfig: Emit`
`declarationMap`	Generează hărți .d.ts.map: „Go to Definition” duce la sursa .ts. `tsconfig: Emit`
`emitDeclarationOnly`	Scrie doar fișierele .d.ts, fără JavaScript. `tsconfig: Emit`
`sourceMap`	Generează hărți .js.map care leagă JavaScript-ul de sursa .ts. `tsconfig: Emit`
`inlineSourceMap`	Pune harta sursă direct în fișierul .js, nu într-un .map separat. `tsconfig: Emit`
`noCheck`	Generează fișierele fără verificarea tipurilor (doar erorile de sintaxă). `tsconfig: Compiler Diagnostics`
`noEmit`	Doar verifică tipurile, fără să scrie niciun fișier. `tsconfig: Emit`
`assumeChangesOnlyAffectDirectDependencies`	În watch/incremental, re-verifică doar fișierele care importă direct fișierul modificat. `tsconfig: Watch and Build Modes`
`locale`	Limba mesajelor de eroare (fr, de, it…); româna nu este disponibilă. `tsconfig: Command-line Options`
`all`	Afișează toate opțiunile compilatorului, cu tipul și valoarea implicită. `tsconfig: Command-line Options`
`version`	Afișează versiunea lui tsc. `tsconfig: Command-line Options`
`init`	Creează un tsconfig.json nou, cu setările recomandate. `tsconfig: Command-line Options`
`project`	Compilează proiectul dintr-un anumit fișier tsconfig sau director (-p). `tsconfig: Command-line Options`
`showConfig`	Afișează configurația finală, cu extends și opțiunile deduse, fără compilare. `tsconfig: Command-line Options`
`listFilesOnly`	Afișează fișierele din compilare și se oprește, fără verificare. `tsconfig: Command-line Options`
`target`	Versiunea de JavaScript generată (es5, es2022, esnext…). `tsconfig: Language and Environment`
`module`	Formatul modulelor generate (nodenext, esnext, commonjs, preserve…). `tsconfig: Modules`
`lib`	Declarațiile de tip pentru mediul de rulare (es2022, dom, webworker…). `tsconfig: Language and Environment`
`allowJs`	Permite fișiere .js în proiect, importate din TypeScript și copiate în outDir. `tsconfig: JavaScript Support`
`checkJs`	Raportează erorile de tip și în fișierele .js (cu JSDoc). `tsconfig: JavaScript Support`
`jsx`	Ce face tsc cu JSX din .tsx: react-jsx, react, preserve… `tsconfig: Language and Environment`
`outFile`	Pune tot JavaScript-ul într-un singur fișier (doar scripturi, amd sau system). `tsconfig: Emit`
`outDir`	Directorul în care sunt scrise fișierele generate. `tsconfig: Emit`
`rootDir`	Rădăcina surselor; structura de sub ea se păstrează în outDir. `tsconfig: Modules`
`composite`	Pregătește proiectul pentru references și tsc -b (pornește declaration și incremental). `tsconfig: Projects`
`tsBuildInfoFile`	Calea fișierului .tsbuildinfo folosit de compilarea incrementală. `tsconfig: Projects`
`removeComments`	Scoate comentariile din fișierele generate. `tsconfig: Emit`
`importHelpers`	Importă funcțiile ajutătoare din tslib, în loc să le copieze în fiecare fișier. `tsconfig: Emit`
`importsNotUsedAsValues`	Scoasă în TypeScript 5.5; înlocuită de verbatimModuleSyntax. `tsconfig: Backwards Compatibility`
`downlevelIteration`	Pentru target es5: for…of și spread folosesc iteratorii reali. `tsconfig: Emit`
`isolatedModules`	Dă eroare pentru cod care nu poate fi transformat fișier cu fișier (esbuild, Babel). `tsconfig: Interop Constraints`
`verbatimModuleSyntax`	Importurile rămân exact cum sunt scrise; tipurile cer import type. `tsconfig: Interop Constraints`
`isolatedDeclarations`	Cere tipuri explicite pe exporturi, ca .d.ts să poată fi generat fișier cu fișier. `tsconfig: Interop Constraints`
`erasableSyntaxOnly`	Interzice enum, namespace și parametri-proprietate, ca Node.js să ruleze direct .ts. `tsconfig: Interop Constraints`
`libReplacement`	Permite înlocuirea bibliotecilor lib cu pachete @typescript/lib-*; implicit pornită. `tsconfig: Language and Environment`
`strict`	Pornește toate verificările stricte de tipuri. `tsconfig: Type Checking`
`noImplicitAny`	Eroare când un tip ar deveni implicit any (de exemplu parametri fără tip). `tsconfig: Type Checking`
`strictNullChecks`	null și undefined devin tipuri separate și trebuie verificate. `tsconfig: Type Checking`
`strictFunctionTypes`	Verifică corect parametrii la atribuirea funcțiilor (fără bivarianță). `tsconfig: Type Checking`
`strictBindCallApply`	Verifică argumentele trimise prin bind, call și apply. `tsconfig: Type Checking`
`strictPropertyInitialization`	Eroare pentru proprietăți de clasă fără valoare inițială. `tsconfig: Type Checking`
`strictBuiltinIteratorReturn`	Valoarea finală a iteratorilor încorporați este undefined, nu any. `tsconfig: Type Checking`
`noImplicitThis`	Eroare când this are implicit tipul any. `tsconfig: Type Checking`
`useUnknownInCatchVariables`	Variabila din catch are tipul unknown în loc de any. `tsconfig: Type Checking`
`alwaysStrict`	Verifică în modul strict JavaScript și scrie „use strict”. `tsconfig: Type Checking`
`noUnusedLocals`	Eroare pentru variabile, importuri și funcții locale nefolosite. `tsconfig: Type Checking`
`noUnusedParameters`	Eroare pentru parametri nefolosiți (cei cu _ la început sunt permiși). `tsconfig: Type Checking`
`exactOptionalPropertyTypes`	O proprietate opțională poate lipsi, dar nu poate primi explicit undefined. `tsconfig: Type Checking`
`noImplicitReturns`	Eroare când o funcție nu întoarce valoare pe toate ramurile. `tsconfig: Type Checking`
`noFallthroughCasesInSwitch`	Eroare când un case cu cod trece în următorul fără break. `tsconfig: Type Checking`
`noUncheckedIndexedAccess`	Adaugă undefined la valorile citite prin index (a[0], obj[cheie]). `tsconfig: Type Checking`
`noImplicitOverride`	Cere cuvântul override pe metodele care înlocuiesc o metodă din clasa de bază. `tsconfig: Type Checking`
`noPropertyAccessFromIndexSignature`	Cheile din semnătura de index se citesc doar cu obj[„cheie”]. `tsconfig: Type Checking`
`moduleResolution`	Regulile după care sunt găsite modulele: nodenext, bundler, node10… `tsconfig: Modules`
`baseUrl`	Director de bază pentru importuri fără ./; nu schimbă JavaScript-ul generat. `tsconfig: Modules`
`paths`	Prescurtări pentru importuri („@/*”), folosite la verificarea tipurilor. `tsconfig: Modules`
`rootDirs`	Tratează mai multe directoare ca unul singur la importurile relative. `tsconfig: Modules`
`typeRoots`	Directoarele din care se încarcă automat pachetele de tipuri globale. `tsconfig: Modules`
`types`	Ce pachete de tipuri globale se încarcă (de exemplu [„node”]); [] = niciunul. `tsconfig: Modules`
`allowSyntheticDefaultImports`	Permite import x from „y” pentru module fără export default (doar la verificare). `tsconfig: Interop Constraints`
`esModuleInterop`	Importul implicit al modulelor CommonJS funcționează corect (cod ajutător). `tsconfig: Interop Constraints`
`preserveSymlinks`	Nu înlocuiește legăturile simbolice cu calea reală la rezolvare. `tsconfig: Interop Constraints`
`allowUmdGlobalAccess`	Permite folosirea globală a unei biblioteci UMD din module. `tsconfig: Modules`
`moduleSuffixes`	Sufixe încercate la import: „./buton” poate duce la buton.ios.ts. `tsconfig: Modules`
`allowImportingTsExtensions`	Permite importuri cu extensia .ts (cu noEmit sau emitDeclarationOnly). `tsconfig: Modules`
`rewriteRelativeImportExtensions`	Rescrie .ts în .js în importurile relative din fișierele generate. `tsconfig: Modules`
`resolvePackageJsonExports`	Respectă câmpul exports din package.json-ul pachetelor. `tsconfig: Modules`
`resolvePackageJsonImports`	Permite prescurtările #nume din câmpul imports al package.json. `tsconfig: Modules`
`customConditions`	Condiții proprii pentru câmpul exports (de exemplu „dezvoltare”). `tsconfig: Modules`
`noUncheckedSideEffectImports`	Verifică și importurile fără nume (import „./polyfill.js”). `tsconfig: Modules`
`sourceRoot`	Locul unde depanatorul caută sursele .ts. `tsconfig: Emit`
`mapRoot`	Locul unde depanatorul caută fișierele .map. `tsconfig: Emit`
`inlineSources`	Include codul sursă .ts în hărțile sursă. `tsconfig: Emit`
`experimentalDecorators`	Decoratorii vechi (Angular, NestJS) în locul celor standard. `tsconfig: Language and Environment`
`emitDecoratorMetadata`	Scrie metadate de tip pentru decoratori (cu reflect-metadata). `tsconfig: Language and Environment`
`jsxFactory`	Funcția pentru elementele JSX cu jsx: react (implicit React.createElement). `tsconfig: Language and Environment`
`jsxFragmentFactory`	Valoarea pentru fragmentele JSX <></> (implicit React.Fragment). `tsconfig: Language and Environment`
`jsxImportSource`	Pachetul din care se importă jsx-runtime (implicit react). `tsconfig: Language and Environment`
`resolveJsonModule`	Permite importul fișierelor .json, cu tipuri deduse. `tsconfig: Modules`
`allowArbitraryExtensions`	Import de .css, .svg etc. cu un fișier de declarații nume.d.css.ts. `tsconfig: Modules`
`reactNamespace`	Obiectul pe care se apelează createElement (implicit React). `tsconfig: Language and Environment`
`skipDefaultLibCheck`	Nu verifică bibliotecile standard lib.*.d.ts. `tsconfig: Completeness`
`charset`	Scoasă în TypeScript 5.5; fișierele sunt citite ca UTF-8. `tsconfig: Backwards Compatibility`
`emitBOM`	Scrie marcajul BOM UTF-8 la începutul fișierelor generate. `tsconfig: Emit`
`newLine`	Sfârșitul de rând în fișierele generate: lf (implicit) sau crlf. `tsconfig: Emit`
`noErrorTruncation`	Afișează tipurile complete în erori, fără „… more …”. `tsconfig: Output Formatting`
`noLib`	Nu include nicio bibliotecă standard de tipuri. `tsconfig: Language and Environment`
`noResolve`	Importurile nu adaugă fișiere noi în compilare. `tsconfig: Modules`
`stripInternal`	Scoate din .d.ts declarațiile marcate cu /** @internal */. `tsconfig: Emit`
`disableSizeLimit`	Scoate limita de 20 MB de JavaScript din editor. `tsconfig: Editor Support`
`disableSourceOfProjectReferenceRedirect`	Editorul folosește .d.ts în loc de sursele proiectelor referite. `tsconfig: Projects`
`disableSolutionSearching`	Editorul nu caută proiectul-rădăcină la „Find All References”. `tsconfig: Projects`
`disableReferencedProjectLoad`	Editorul nu încarcă automat toate proiectele referite. `tsconfig: Projects`
`noImplicitUseStrict`	Scoasă în TypeScript 5.5; oprea scrierea lui „use strict”. `tsconfig: Backwards Compatibility`
`noEmitHelpers`	Nu scrie și nu importă funcțiile ajutătoare (__awaiter…). `tsconfig: Emit`
`noEmitOnError`	Nu scrie niciun fișier dacă există erori de tip. `tsconfig: Emit`
`preserveConstEnums`	Păstrează în JavaScript obiectul unui const enum. `tsconfig: Emit`
`declarationDir`	Director separat pentru fișierele .d.ts. `tsconfig: Emit`
`skipLibCheck`	Nu verifică erorile din fișierele .d.ts; compilare mai rapidă. `tsconfig: Completeness`
`allowUnusedLabels`	false: etichetele nefolosite dau eroare; true: sunt ignorate. `tsconfig: Type Checking`
`allowUnreachableCode`	false: codul imposibil de atins dă eroare; true: este ignorat. `tsconfig: Type Checking`
`suppressExcessPropertyErrors`	Scoasă în TypeScript 5.5; ascundea erorile pentru proprietăți în plus. `tsconfig: Backwards Compatibility`
`suppressImplicitAnyIndexErrors`	Scoasă în TypeScript 5.5; ascundea erorile any la indexare. `tsconfig: Backwards Compatibility`
`forceConsistentCasingInFileNames`	Eroare când un fișier este importat cu litere mari/mici diferite. `tsconfig: Interop Constraints`
`maxNodeModuleJsDepth`	Cât de adânc citește tsc pachetele JavaScript fără tipuri (cu allowJs). `tsconfig: JavaScript Support`
`noStrictGenericChecks`	Scoasă în TypeScript 5.5; slăbea verificarea funcțiilor generice. `tsconfig: Backwards Compatibility`
`useDefineForClassFields`	Câmpurile de clasă după standardul JavaScript (define, nu atribuire). `tsconfig: Language and Environment`
`preserveValueImports`	Scoasă în TypeScript 5.5; înlocuită de verbatimModuleSyntax. `tsconfig: Backwards Compatibility`
`keyofStringsOnly`	Scoasă în TypeScript 5.5; azi se scrie keyof T & string. `tsconfig: Backwards Compatibility`
`plugins`	Pluginuri pentru serverul de limbaj din editor; tsc le ignoră. `tsconfig: Editor Support`
`moduleDetection`	Când este un fișier modul: auto (implicit), force sau legacy. `tsconfig: Language and Environment`