Tipuri avansate TypeScript explicate cu exemple

TypeScript oferă mai multe tipuri avansate care depășesc tipurile de bază, permițând sisteme de tip mai flexibile și mai puternice. Aceste tipuri avansate ajută la crearea de aplicații robuste, oferind modalități suplimentare de definire și aplicare a constrângerilor de tip. Acest articol explorează unele dintre aceste tipuri avansate cu exemple.

Tipuri de uniuni

Tipurile de unire permit unei variabile să fie una dintre mai multe tipuri. Acest lucru poate fi util atunci când o valoare poate fi de mai multe tipuri, dar ar trebui să fie tratată în mod corespunzător pe baza tipului ei real.

// Union type example

function formatValue(value: string | number): string {
  if (typeof value === 'string') {
    return `String: ${value}`;
  } else {
    return `Number: ${value.toFixed(2)}`;
  }
}

console.log(formatValue("Hello"));
console.log(formatValue(123.456));

În acest exemplu, funcția `formatValue` acceptă fie un șir, fie un număr și formatează valoarea în consecință.

Tipuri de intersectii

Tipurile de intersecție combină mai multe tipuri într-unul singur. Un obiect de tip intersecție va avea toate proprietățile tipurilor combinate. Acest lucru este util pentru compunerea mai multor tipuri împreună.

// Intersection type example

interface Person {
  name: string;
  age: number;
}

interface Contact {
  email: string;
  phone: string;
}

type Employee = Person & Contact;

const employee: Employee = {
  name: "John Doe",
  age: 30,
  email: "[email protected]",
  phone: "123-456-7890"
};

console.log(employee);

Aici, tipul `Angajat` este o intersecție a `Persoană` și `Contact`, ceea ce înseamnă că conține proprietăți din ambele interfețe.

Tipuri literale

Tipurile literale specifică valorile exacte pe care le poate deține o variabilă. Acest lucru poate fi deosebit de util pentru a vă asigura că sunt permise numai anumite valori specifice.

// Literal type example

type Direction = "up" | "down" | "left" | "right";

function move(direction: Direction): void {
  console.log(`Moving ${direction}`);
}

move("up");    // Valid
move("down");  // Valid
// move("side"); // Error: Argument of type '"side"' is not assignable to parameter of type 'Direction'.

Tipul „Direction” aici este limitat la patru valori specifice șirului, asigurându-se că numai aceste direcții pot fi utilizate în funcția „mutare”.

Tipuri de tuplu

Tipurile de tuplu reprezintă o matrice cu un număr fix de elemente în care fiecare element poate avea un tip diferit. Tuplurile sunt utile pentru reprezentarea colecțiilor de dimensiuni fixe de articole eterogene.

// Tuple type example

let user: [string, number] = ["Alice", 30];

console.log(user[0]); // "Alice"
console.log(user[1]); // 30

// user = [30, "Alice"]; // Error: Type 'number' is not assignable to type 'string'.

Tuplu `user` este definit cu un șir urmat de un număr, iar această structură trebuie menținută.

Tipuri condiționale

Tipurile condiționate permit determinarea tipurilor în funcție de condiții. Ele oferă o modalitate de a selecta un tip sau altul în funcție de o condiție.

// Conditional type example

type IsString = T extends string ? "Yes" : "No";

type Test1 = IsString;  // "Yes"
type Test2 = IsString;  // "No"

În acest exemplu, tipul `IsString` verifică dacă un tip `T` este un șir. Returnează `"Da"` dacă este și `"Nu"` în caz contrar.

Tipuri mapate

Tipurile mapate permit crearea de noi tipuri prin transformarea proprietăților unui tip existent. Acest lucru este util pentru modificarea sau extinderea tipurilor existente.

// Mapped type example

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = {
  name: "Alice",
  age: 30
};

// readonlyPerson.age = 31; // Error: Cannot assign to 'age' because it is a read-only property.

Tipul `ReadonlyPerson` transformă tipul `Person` făcând toate proprietățile sale doar în citire.

Concluzie

Tipurile avansate ale TypeScript oferă instrumente puternice pentru definirea și gestionarea cerințelor complexe de tip. Utilizând tipuri de unire, intersecție, literal, tuplu, condiționat și mapat, dezvoltatorii pot crea aplicații mai robuste și mai ușor de întreținut. Înțelegerea și aplicarea eficientă a acestor tipuri poate îmbunătăți în mod semnificativ siguranța și flexibilitatea codului TypeScript.