Funcții TypeScript: Cum să utilizați parametrii și tipurile de returnare

Funcțiile sunt elementele de bază ale oricărui limbaj de programare, iar TypeScript le îmbunătățește prin adăugarea siguranței tipului. Prin definirea tipurilor pentru parametri și valori returnate, TypeScript permite dezvoltatorilor să scrie cod mai fiabil și mai ușor de întreținut. Acest ghid vă va prezenta funcțiile TypeScript, acoperind cum să utilizați parametrii și să returnați în mod eficient tipurile.

Definirea unei funcții în TypeScript

În TypeScript, funcțiile pot fi definite folosind cuvântul cheie function, similar cu JavaScript. Cu toate acestea, TypeScript vă permite să specificați tipurile de parametri și valorile returnate pentru siguranță și lizibilitate suplimentară.

Exemplu de funcție de bază

Iată un exemplu de funcție de bază TypeScript cu parametri tastați și un tip de returnare:

function add(a: number, b: number): number {
  return a + b;
}

const result = add(5, 3); // Output: 8

În acest exemplu, funcția add acceptă doi parametri de tip number și returnează o valoare de tip number. Acest lucru asigură că atât intrarea, cât și ieșirea sunt conforme cu tipurile așteptate.

Parametrii funcției în TypeScript

Funcțiile TypeScript pot accepta diferite tipuri de parametri, cum ar fi parametrii opționali, impliciti și restul. Să explorăm fiecare tip în detaliu.

Parametri opționali

Puteți defini parametrii opționali adăugând un ? după numele parametrului. Parametrii opționali nu trebuie furnizați atunci când funcția este apelată.

function greet(name: string, age?: number): string {
  if (age) {
    return `Hello, ${name}. You are ${age} years old.`;
  } else {
    return `Hello, ${name}.`;
  }
}

console.log(greet("Alice")); // Output: Hello, Alice.
console.log(greet("Bob", 25)); // Output: Hello, Bob. You are 25 years old.

În acest exemplu, parametrul age este opțional. Funcția funcționează corect indiferent dacă este furnizat sau nu age.

Parametrii impliciti

Parametrii impliciti vă permit să specificați valori implicite pentru parametrii în cazul în care nu sunt furnizați atunci când funcția este apelată.

function multiply(a: number, b: number = 2): number {
  return a * b;
}

console.log(multiply(5)); // Output: 10
console.log(multiply(5, 3)); // Output: 15

În acest exemplu, parametrul b are o valoare implicită de 2. Dacă nu este furnizat un al doilea argument, 2 va fi folosit în mod implicit.

Parametrii de odihnă

Parametrii rest vă permit să transmiteți un număr variabil de argumente unei funcții. Ele sunt definite folosind sintaxa ....

function sum(...numbers: number[]): number {
  return numbers.reduce((total, num) => total + num, 0);
}

console.log(sum(1, 2, 3, 4)); // Output: 10
console.log(sum(5, 10, 15)); // Output: 30

În acest exemplu, funcția sum acceptă orice număr de argumente, toate de tip number, și returnează suma lor.

Tipuri returnate în TypeScript

Specificarea tipului de returnare al unei funcții este la fel de importantă ca și definirea tipurilor de parametri. Ajută TypeScript să înțeleagă rezultatul așteptat al funcției, asigurându-se că returnează tipul corect de date.

Specificarea tipurilor de returnare

Pentru a specifica tipul de returnare al unei funcții, adăugați două puncte : urmate de tipul după lista de parametri.

function isEven(num: number): boolean {
  return num % 2 === 0;
}

console.log(isEven(4)); // Output: true
console.log(isEven(5)); // Output: false

În acest exemplu, funcția isEven returnează un boolean care indică dacă numărul de intrare este par sau nu.

Funcții fără tip de returnare

Când o funcție nu returnează o valoare, tipul ei de returnare este void. Acest lucru este util pentru funcțiile care efectuează o acțiune fără a furniza un rezultat.

function logMessage(message: string): void {
  console.log(message);
}

logMessage("Hello, TypeScript!"); // Output: Hello, TypeScript!

În acest exemplu, funcția logMessage înregistrează un mesaj în consolă și nu returnează nimic, prin urmare tipul de returnare este void.

Concluzie

Funcțiile TypeScript oferă o modalitate puternică de a scrie cod sigur prin definirea tipurilor de parametri și a celor returnate. Folosind parametrii opționali, impliciti și rest, precum și prin specificarea tipurilor de returnare, puteți crea funcții mai robuste și mai ușor de întreținut. Începeți să utilizați funcțiile TypeScript în proiectele dvs. pentru a asigura o mai bună calitate și siguranță a codului.