Kas ir TypeScript funkcijas? De­fi­nī­ci­ja, tipa drošība un lietošana

Iz­man­to­jot TypeScript, lietotāji var deklarēt funkciju, parametru un at­grie­ze­nis­ko vērtību tipus. Tā kā TypeScript pārbauda, vai tiek izmantoti pareizie datu tipi, tipu dek­la­rē­ša­na palīdz agrāk atklāt kļūdas un uzlabo koda kvalitāti.

Kas ir TypeScript funkcijas?

TypeScript funkcijas ir TypeScript galvenā sa­stāv­da­ļa. TypeScript funkcijas ir līdzīgas Ja­vaScript funkcijām, bet tām ir papildu priekš­ro­cī­ba – statiskā ti­pi­zā­ci­ja. Šādā pieejā mainīgo, parametru un at­grie­ze­nis­ko vērtību datu tipi jau ir definēti kom­pi­lā­ci­jas laikā un tos nevar mainīt izpildes laikā. Tas samazina kļūdu skaitu ražošanas vidē.

Vēl viena TypeScript funkciju iezīme ir to elas­tī­gums. Funkcijām var būt parametru op­cio­nā­lās un no­klu­sē­ju­ma vērtības, kas atvieglo to pie­lā­go­ša­nu dažādiem lie­to­ša­nas ga­dī­ju­miem. Ie­spē­ja­mie lietojumi ietver datu apstrādi, lietotāja saskarnes mi­jie­dar­bī­bu, asinhrono prog­ram­mē­ša­nu un daudz ko citu. Jūs varat arī definēt pār­slo­dzes, lai no­dro­ši­nā­tu dažādas funkcijas, pa­ma­to­jo­ties uz ievades vērtībām.

Papildus funkciju dek­la­rē­ša­nai TypeScript var izmantot arī pa­līgfun­kci­jas. Šīs funkcijas ir īsākas un bieži tiek iz­man­to­tas mūsdienu Ja­vaScript izstrādes praksē.

TypeScript funkcijas ir būtiskas, lai pa­lie­li­nā­tu TypeScript projektos izmantotā koda drošību un lasāmību. Tajā pašā laikā to elastība un pie­lā­go­ja­mī­ba padara tās pie­mē­ro­tas plašam prasību klāstam.

Kāda ir TypeScript funkciju sintakse?

TypeScript ir Ja­vaScript pa­pla­ši­nā­ta valoda. Tādējādi TypeScript funkciju sintakse ir līdzīga Ja­vaScript funkciju sintaksei. Funkcijas kods ir iekavās { }. Šeit tiek īstenota funkcijas faktiskā loģika. Šeit ir TypeScript funkcijas pamata sintakse:

function functionName(parameter1: type, parameter2: type): returnType {
    // Function Code
    return result; // (optional)
}

• funkcija: šis at­slēg­vārds iezīmē funkcijas dek­la­rā­ci­jas sākumu.
• funkcijas nosaukums: tas ir funkcijas nosaukums. Jums jāizvēlas ap­rak­stošs nosaukums, kas atspoguļo funkcijas uzdevumu.
• parametrs1, parametrs2: šie ir parametri, kurus funkcija sagaida. Katrs parametrs tiek iden­ti­fi­cēts pēc tā nosaukuma un sagaidāmā datu tipa (tipa anotācija).
• re­turnType: tas ir datu tips, ko funkcija atgriež. Jūs varat arī norādīt void, ja funkcija neatgriež vērtību.
• return rezultāts ir fa­kul­ta­tīvs un tiek izmantots, ja funkcija atgriež vērtību.

TypeScript funkcijas tiek iz­sau­ca­mas, iz­man­to­jot funkcijas nosaukumu, aiz kura seko iekavās. Iekavās norādiet funkcijas ar­gu­men­tus (ievades vērtības), ja tai ir ne­pie­cie­ša­mi parametri.

functionName(argument1, argument2, ...);

TypeScript funkciju piemēri

TypeScript funkcijas ir ļoti daudz­pu­sī­gas un tās var izmantot, lai veiktu aprēķinus, ope­rā­ci­jas un sa­rež­ģī­tus procesus lie­to­jum­prog­ram­mās.

Anonīmas funkcijas

Anonīmas funkcijas TypeScript ir funkcijas, kurām nav nosaukuma un kuras tiek nodotas tieši iz­teik­smēs vai kā argumenti citām funkcijām. Anonīmas funkcijas ir noderīgas, ja funkcija ir ne­pie­cie­ša­ma tikai vienā kodā un ne­vē­la­ties piešķirt tai savu nosaukumu.

var greet = function(name) {
    return "Hello, " + name + "!";
};
var message = greet("John");
console.log(message); // Output: "Hello, John!"

Šajā piemērā anonīmā funkcija tiek saglabāta mainīgajā greet un vēlāk izsaukta, lai izveidotu per­so­na­li­zē­tu sveicienu John.

Anonīmās funkcijas ietver arī lambda funkcijas, kas pa­zīs­ta­mas kā bultu funkcijas.

const add = (a: number, b: number) => a + b;
const result = add(3, 5); // Output: 8

Šeit anonīma funkcija, kas saskaita divus skaitļus, tiek piešķirta mai­nī­ga­jam add un pēc tam izsaukta.

No­klu­sē­ju­ma parametri

No­klu­sē­ju­ma parametri (pazīstami arī kā standarta parametri) TypeScript ļauj definēt TypeScript funkcijas tā, lai tām būtu no­klu­sē­ju­ma parametru vērtības. Kad funkcija tiek izsaukta un kā parametrs netiek nodota nekāda vērtība, tiek izmantota no­klu­sē­ju­ma vērtība.

function greet(name: string = "World") {
    return "Hello, " + name + "!";
}
console.log(greet()); // Output: "Hello, World!"
console.log(greet("John")); // Output: "Hello, John!"

Šeit funkcija greet pa­ra­met­ram name ir piešķirta no­klu­sē­ju­ma vērtība world. Ja funkcijas iz­sauk­ša­nas brīdī pa­ra­met­ram name netiek nodota nekāda vērtība, au­to­mā­tis­ki tiek izmantota no­klu­sē­ju­ma vērtība.

Atpūtas parametri

Iz­man­to­jot atpūtas pa­ra­met­rus (pazīstami arī kā atpūtas operatori vai atpūtas parametru sintakse) TypeScript, jūs varat savākt ne­no­teik­tu skaitu argumentu kā TypeScript masīvus funkcijā. Tas ir noderīgi, ja vēlaties rakstīt funkcijas, kas var apstrādāt dažādu skaitu argumentu.

function sum(...numbers: number[]): number {
    let total = 0;
    for (const num of numbers) {
        total += num;
    }
    return total;
}
console.log(sum(1, 2, 3, 4, 5)); // Output: 15

Šajā piemērā funkcija sum savāc jebkuru skaitļu summu kā atlikušo parametru numbers un saskaita tos kopā, lai ap­rē­ķi­nā­tu kopējo summu. Jūs varat nodot tik daudz skaitļu, cik vēlaties, un funkcija tos visus saskaitīs.

Pārslodze

Funkciju pārslodze tiek izmantota, lai definētu vairākas funkciju dek­la­rā­ci­jas ar vienādiem no­sau­ku­miem, bet at­šķi­rī­giem pa­ra­met­riem vai at­grie­ša­nas tipiem. Tas palīdz TypeScript au­to­mā­tis­ki iz­vē­lē­ties pareizo funkciju dek­la­rā­ci­ju atkarībā no no­do­ta­jiem ar­gu­men­tiem un veikt tipa pārbaudes.

function concatenate(a: string, b: string): string;
function concatenate(a: number, b: number): string;
function concatenate(a: any, b: any): string {
    return a.toString() + b.toString();
}
console.log(concatenate("Hello, ", "World")); // Output: "Hello, World"
console.log(concatenate(3, 5)); // Output: "35"

Iepriekš minētajā piemērā mums ir divas funkcijas pār­slo­dzes concatenate. Pirmā pieņem divas virknes, bet otrā pieņem divus skaitļus. Funkcija pati pārvērš nodotos ar­gu­men­tus virknēs un savieno tos. TypeScript au­to­mā­tis­ki izvēlas at­bil­sto­šo pārslodzi, pa­ma­to­jo­ties uz no­do­ta­jiem ar­gu­men­tiem, un veic ne­pie­cie­ša­mās tipa pārbaudes.

Funkciju pār­slo­dzes ir īpaši noderīgas, ja iz­strā­dā­jat API vai bib­lio­tē­ku, kurā vēlaties no­dro­ši­nāt, ka funkcijas lietošana ir vienkārša un bez kļūdām, ne­at­ka­rī­gi no dažādiem parametru tipiem, ko nodrošina lietotāji. 133e3bd4651a9100beeedd44acb6f1b4

4823016084ab8c27d0450cc1273217d7

ebbb996ca0c42db05ec8d690c6274b4e

04954b418af6a01dc13e9a2176478907

028552f5e819ac4451c75eb7a49bcd5e