Ce este TypeScript

Ce este TypeScript

TypeScript (TS) e JavaScript cu tipuri. Scrii tipuri pentru variabile, parametri și rezultate, iar un program (compilatorul tsc, sau editorul) verifică înainte să rulezi codul că le folosești corect.

function total(price: number, qty: number): number {
  return price * qty
}

total(10, '2')   // ✗ eroare în editor: '2' nu e number — înainte de rulare

Important de înțeles: tipurile dispar la build. Browserul primește JavaScript simplu. TS te ajută doar cât scrii codul.

De ce merită

• Prinzi greșeli (typo, undefined, argument greșit) înainte de rulare.
• Autocomplete — editorul știe ce câmpuri are un obiect.
• Refactorizare sigură — redenumești un câmp, TS îți arată toate locurile afectate.
• Documentație vie — semnătura unei funcții spune ce primește și ce dă.

Costul: puțină sintaxă în plus. Next.js, React și toate librăriile moderne sunt scrise în TS.

Adnotări de tip

let name: string = 'Ana'
let age: number = 30
let active: boolean = true
let tags: string[] = ['js', 'ts']           // array de stringuri
let point: [number, number] = [10, 20]      // tuple — lungime și tipuri fixe

function greet(name: string, excited?: boolean): string {  // ? = parametru opțional
  return excited ? `Salut, ${name}!` : `Salut, ${name}`
}

Inferența — nu scrie tipuri peste tot

TS deduce tipul din valoare:

let count = 0              // TS știe: number
const user = { name: 'Ana' }  // { name: string }
const doubled = [1, 2].map(n => n * 2)   // number[]

Regula practică: scrie tipuri pentru parametrii funcțiilor și pentru datele care vin din afară (API, formulare). Restul lasă-l pe inferență.

Tipurile speciale — diferențe și când

any vs unknown:

const a: any = JSON.parse(text)
a.foo.bar()            // TS tace — crapă la runtime

const u: unknown = JSON.parse(text)
u.foo                  // ✗ TS: verifică întâi ce e
if (typeof u === 'object' && u !== null && 'foo' in u) { ... }   // ✓

Literal types

Un tip poate fi o valoare exactă:

let size: 'sm' | 'md' | 'lg' = 'md'
size = 'xl'            // ✗ nu e în listă

Exact așa sunt tipate variantele butonului din aplicația asta.

Configurarea

tsconfig.json controlează verificarea. Cea mai importantă opțiune: "strict": true — activează toate verificările utile (inclusiv null/undefined). Next o pune implicit.

Pe scurt

• TS = JS + tipuri verificate înainte de rulare; la runtime dispar.
• Tipuri pe parametri și pe datele din afară; restul — inferență.
• unknown în loc de any; strict: true mereu.

Surse oficiale

• TypeScript — The Basics
• TypeScript — Everyday Types
• TypeScript — TSConfig strict