TypeScript 6.0: Pattern Matching, Pipe Operator şi Ce Contează Cu Adevărat

TypeScript 6.0: Noutăţile Care Contează Cu Adevărat

TypeScript 6.0 a fost lansat cu mai multe funcţionalităţi noi, dar nu toate merită atenţia ta. Î acest articol ne concentrăm pe cele trei schimbări care vor avea un impact real asupra modului în care scrii cod zi de zi: pattern matching, operatorul pipe şi îmbunăţirile inferenţei de tipuri.

Pattern Matching cu .exhaustive()

Pattern matching este una dintre cele mai aşteptate funcţionalităţi din TypeScript. Inspirat de Rust şi Swift, îţi permite să verifici structura datelor într-un mod declarativ şi sigur.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rectangle":
      return shape.width * shape.height;
    case "triangle":
      return (shape.base * shape.height) / 2;
  }
}

// Cu pattern matching:
function area(shape: Shape): number {
  return match(shape)
    .when({ kind: "circle" }, (s) => Math.PI * s.radius ** 2)
    .when({ kind: "rectangle" }, (s) => s.width * s.height)
    .when({ kind: "triangle" }, (s) => (s.base * s.height) / 2)
    .exhaustive();
}

Cheia este .exhaustive() — dacă adaugi un nou tip la union (de exemplu, un "pentagon"), TypeScript va returna o eroare de compilare până când adaugi şi cazul corespunzător. Acest lucru elimină bug-urile de tip „unhandled case” care erau dificil de depistat.

Operatorul Pipe pentru Lanţuri de Funcţii Componabile

Operatorul pipe («|») îţi permite să compui funcţii într-un mod liniar şi lizibil, în loc să îmbraci totul în paranteze.

// Fără pipe (nested):
const result = capitalize(trim(split(input, ",")[0]));

// Cu pipe (linear):
const result = input
  |> split(",")
  |> (arr) => arr[0]
  |> trim
  |> capitalize;

Pipe-ul este deosebit de util în pipeline-uri de date — transformări, validări, serializări. Face codul mult mai uşor de citit şi de depanat, mai ales când ai 5-6 transformări în lanţ.

Îmbunăţiri Ale Inferenţei de Tipuri

TypeScript 6.0 aduce mai multe rafinamente care fac experienţa de scriere a codului mai plăcută:

• Generic arrow functions — Poţi acum declara funcţii generice inline cu o sintaxă mai curată.
• Conditional types îmbunăţite — Inferenţa tipurilor în contexte conditionale este acum mai precisă, reducând nevoia de as casts.
• Template literal types avansaţi — TypeScript poate acum deduce tipuri complexe din template strings, ceea ce este util pentru API-uri cu paths dinamice.

Mesaje de Eroare Care Chiar Ajută

O schimbare subtilă dar importantă: TypeScript 6.0 a îmbunăţit semnificativ mesajele de eroare. Acum, când ai o eroare de tip, mesajul îţi spune exact ce lipseşte şi, în multe cazuri, îţi sugerează şi cum să repari. Asta reduce timpul de debug considerabil.

Ghid de Migrare: De la v5.x la 6.0

Migrarea la TypeScript 6.0 este în general uşoară, dar există câteva lucruri de verificat:

1. Actualizează dependenţele — Rulează npm update typescript sau pnpm update typescript.
2. Verifică Breaking Changes — Consultă changelog-ul oficial. Cele mai multe proiecte nu vor avea probleme, dar verifică tipurile custom complexe.
3. Rulează testele — Asigură-te că toate testele trec înainte şi după upgrade.
4. Profită de noile funcţionalităţi gradual — Nu trebuie să refaci tot codul. Adoptă pattern matching şi pipe-ul acolo unde au sens, pas cu pas.

De Ce Să Faci Upgrade Acum

TypeScript 6.0 nu este doar o actualizare de menţinere — este un salt calitativ. Pattern matching reduce bug-urile de runtime, pipe-ul îmbunăţeşte lizibilitatea, iar inferenţa îmbunăţită reduce boilerplate-ul. Cu cât migrezi mai devreme, cu cât beneficiezi mai devreme de aceste avantaje.

Concluzie: TypeScript 6.0 aduce funcţionalităţi care nu sunt doar „nice to have” — sunt instrumente care fac codul mai sigur, mai lizibil şi mai uşor de întreţinut. Dacă scrii TypeScript zilnic, upgrade-ul merită prioritate.