Tipuri de unire și intersecție TypeScript

TypeScript oferă funcții puternice ale sistemului de tipare care vă ajută să scrieți cod mai sigur și mai previzibil. Printre aceste caracteristici se numără tipurile de unire și intersecție, care oferă flexibilitate în definirea și gestionarea tipurilor complexe. Acest articol prezintă aceste concepte și oferă exemple pentru a ilustra utilizarea lor.

Ce sunt tipurile de uniuni?

Tipurile de uniuni permit unei variabile să dețină valori de diferite tipuri. Acest lucru este util atunci când trebuie să reprezentați o valoare care ar putea fi una din mai multe tipuri. Tipurile de unire sunt notate folosind simbolul | (teava).

Definirea tipurilor de uniuni

Pentru a defini un tip de unire, specificați mai multe tipuri separate prin simbolul |:

let value: string | number;

value = "Hello, TypeScript"; // Valid
value = 42; // Valid
value = true; // Error: Type 'boolean' is not assignable to type 'string | number'

În acest exemplu, variabila valoare poate fi fie un șir, fie un număr, dar nu un boolean.

Utilizarea tipurilor de uniuni în funcții

Tipurile de unire sunt deosebit de utile în funcțiile în care parametrii sau tipurile de returnare pot fi mai multe tipuri:

function formatValue(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else {
    return value.toFixed(2);
  }
}

console.log(formatValue("hello")); // Output: HELLO
console.log(formatValue(123.456)); // Output: 123.46

Funcția formatValue preia un parametru care poate fi fie string, fie number și îl formatează în consecință.

Ce sunt tipurile de intersecție?

Tipurile de intersecție vă permit să combinați mai multe tipuri într-unul singur. Aceasta înseamnă că o valoare a tipului de intersecție va satisface toate tipurile din intersecție. Tipurile de intersecție sunt notate folosind simbolul & (ampersand).

Definirea tipurilor de intersectii

Pentru a defini un tip de intersecție, specificați mai multe tipuri separate prin simbolul &:

interface Person {
  name: string;
}

interface Employee {
  employeeId: number;
}

type EmployeePerson = Person & Employee;

const john: EmployeePerson = {
  name: "John Doe",
  employeeId: 1234
};

console.log(john.name); // Output: John Doe
console.log(john.employeeId); // Output: 1234

În acest exemplu, tipul EmployeePerson combină interfețele Person și Employee, rezultând un tip care are atât nume, cât și proprietățile employeeId.

Utilizarea tipurilor de intersecție în funcții

Tipurile de intersecție pot fi, de asemenea, utilizate în funcții pentru a solicita proprietăți de tip multiple:

function printEmployeeDetails(employee: Person & Employee): void {
  console.log(`Name: ${employee.name}`);
  console.log(`Employee ID: ${employee.employeeId}`);
}

const jane: EmployeePerson = {
  name: "Jane Smith",
  employeeId: 5678
};

printEmployeeDetails(jane);
// Output:
// Name: Jane Smith
// Employee ID: 5678

Funcția printEmployeeDetails necesită un argument care să satisfacă atât tipurile Person, cât și Employee.

Combinarea tipurilor de unire și intersecție

Puteți combina tipurile de unire și intersecție pentru a crea definiții complexe de tip:

type Shape = Circle | Rectangle;

interface Circle {
  kind: "circle";
  radius: number;
}

interface Rectangle {
  kind: "rectangle";
  width: number;
  height: number;
}

function getArea(shape: Shape): number {
  if (shape.kind === "circle") {
    return Math.PI * shape.radius * shape.radius;
  } else {
    return shape.width * shape.height;
  }
}

const myCircle: Circle = { kind: "circle", radius: 10 };
const myRectangle: Rectangle = { kind: "rectangle", width: 20, height: 30 };

console.log(getArea(myCircle)); // Output: 314.159...
console.log(getArea(myRectangle)); // Output: 600

În acest exemplu, tipul Shape este o unire a Circle și Rectangle, iar funcția getArea gestionează ambele tipuri în mod corespunzător.

Concluzie

Tipurile de unire și intersecție în TypeScript oferă modalități puternice de gestionare și combinare a tipurilor, oferind flexibilitate și precizie în definițiile tipurilor. Tipurile de unire permit unei variabile să fie una dintre mai multe tipuri, în timp ce tipurile de intersecție combină mai multe tipuri într-unul singur. Folosind aceste caracteristici, puteți crea aplicații mai robuste și mai sigure de tip.

Exersați utilizarea tipurilor de unire și intersecție pentru a vă familiariza cu capacitățile lor și pentru a vă îmbunătăți abilitățile de codare TypeScript.