Naudodami „Ty­peSc­ript“, var­to­to­jai gali dekla­ruo­ti funkcijų, parametrų ir grą­ži­na­mų­jų verčių tipus. Kadangi „Ty­peSc­ript“ tikrina, ar naudojami teisingi duomenų tipai, tipų dekla­ra­vi­mas padeda anksčiau aptikti klaidas ir padidina kodo kokybę.

Kas yra Ty­peSc­ript funkcijos?

Ty­peSc­ript funkcijos yra pag­rin­di­nė Ty­peSc­ript su­de­da­mo­ji dalis. Ty­peSc­ript funkcijos yra panašios į Ja­vaSc­ript funkcijas, tačiau turi papildomą pranašumą – statinį ti­pi­za­vi­mą. Taikant šį metodą, kintamųjų, parametrų ir grą­ži­na­mų­jų verčių duomenų tipai yra apibrėžti jau kom­pi­lia­vi­mo metu ir negali būti keičiami vykdymo metu. Tai sumažina klaidų skaičių gamybos aplinkoje.

Kita Ty­peSc­ript funkcijų ypatybė yra jų lanks­tu­mas. Funkcijos gali turėti pa­si­rink­ti­nes ir nu­ma­ty­tą­sias parametrų vertes, todėl jas lengviau pri­tai­ky­ti įvairiems naudojimo atvejams. Galimi naudojimo atvejai apima duomenų ap­do­ro­ji­mą, sąveiką su vartotojo sąsaja, asin­ch­ro­ni­nį prog­ra­ma­vi­mą ir daugelį kitų. Taip pat galite apibrėžti per­kro­vi­mus, kad būtų teikiamos skir­tin­gos funkcijos, pagrįstos įvesties vertėmis.

Be funkcijų dekla­ra­vi­mo, Ty­peSc­ript taip pat galima naudoti pa­gal­bi­nes funkcijas. Šios funkcijos yra trum­pes­nės ir dažnai nau­do­ja­mos šiuo­lai­ki­nė­se Ja­vaSc­ript kūrimo prak­ti­ko­se.

Ty­peSc­ript funkcijos yra svarbios siekiant padidinti Ty­peSc­ript pro­jek­tuo­se naudojamo kodo saugumą ir skai­to­mu­mą. Tuo pačiu metu jų lanks­tu­mas ir pri­tai­ko­mu­mas leidžia jas pri­tai­ky­ti įvairiems rei­ka­la­vi­mams.

Kokia yra Ty­peSc­ript funkcijų sintaksė?

Ty­peSc­ript yra Ja­vaSc­ript kalbos superset kalba. Todėl Ty­peSc­ript funkcijų sintaksė yra panaši į Ja­vaSc­ript funkcijų sintaksę. Funkcijos kodas rašomas skliaus­tuo­se { }. Čia įgy­ven­di­na­ma tikroji funkcijos logika. Čia pa­tei­kia­ma pag­rin­di­nė Ty­peSc­ript funkcijos sintaksė:

function functionName(parameter1: type, parameter2: type): returnType {
    // Function Code
    return result; // (optional)
}
ty­pesc­ript
  • funkcija: šis raktinis žodis žymi funkcijos dekla­ra­ci­jos pradžią.
  • func­tion­Na­me: tai yra funkcijos pa­va­di­ni­mas. Tu­rė­tu­mė­te pa­si­rink­ti api­bū­di­nan­tį pa­va­di­ni­mą, kuris at­spin­dė­tų funkcijos užduotį.
  • parameter1, parameter2: tai yra pa­ra­met­rai, kurių tikisi funkcija. Kiek­vie­nas pa­ra­met­ras iden­ti­fi­kuo­ja­mas pagal jo pa­va­di­ni­mą ir tikėtiną duomenų tipą (tipo anotacija).
  • re­turn­Ty­pe: tai yra duomenų tipas, kurį funkcija grąžina. Taip pat galite nurodyti void, jei funkcija negrąžina vertės.
  • grą­ži­na­mas re­zul­ta­tas yra ne­pri­va­lo­mas ir nau­do­ja­mas, jei funkcija turi grąžinti reikšmę.

Ty­peSc­ript funkcijos yra iš­kvie­čia­mos naudojant funkcijos pa­va­di­ni­mą, po kurio eina skliaus­te­lės. Skliaus­te­lė­se nurodote funkcijos ar­gu­men­tus (įvesties vertes), jei ji rei­ka­lau­ja parametrų.

functionName(argument1, argument2, ...);
ty­pesc­ript

Ty­peSc­ript funkcijos pa­vyz­džiai

Ty­peSc­ript funkcijos yra labai uni­ver­sa­lios ir gali būti nau­do­ja­mos skai­čia­vi­mams, ope­ra­ci­joms ir su­dė­tin­giems procesams prog­ra­mo­se atlikti.

Ano­ni­mi­nės funkcijos

Ano­ni­mi­nės funkcijos Ty­peSc­ript kalboje yra funkcijos, kurios neturi pa­va­di­ni­mo ir yra per­duo­da­mos tie­sio­giai iš­raiš­ko­se arba kaip ar­gu­men­tai kitoms funk­ci­joms. Ano­ni­mi­nės funkcijos yra naudingos, jei funkcija rei­ka­lin­ga tik vienoje kodo vietoje ir nenorite priskirti savo funkcijos pa­va­di­ni­mo.

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

Šiame pavyzdyje anoniminė funkcija yra saugoma kin­ta­ma­ja­me greet ir vėliau iš­kvie­čia­ma, kad būtų sukurtas asmeninis svei­ki­ni­mo pra­ne­ši­mas John.

Ano­ni­mi­nės funkcijos taip pat apima lambda funkcijas, kurios yra žinomos kaip rodyklės funkcijos.

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

Čia anoniminė funkcija, kuri sudeda du skaičius, pri­ski­ria­ma kin­ta­ma­jam add ir tada iš­kvie­čia­ma.

Nu­ma­ty­tie­ji pa­ra­met­rai

Nu­ma­ty­tie­ji pa­ra­met­rai (taip pat žinomi kaip stan­dar­ti­niai pa­ra­met­rai) Ty­peSc­ript leidžia apibrėžti Ty­peSc­ript funkcijas taip, kad jos turėtų nu­ma­ty­tuo­sius parametrų vertes. Kai funkcija yra iš­kvie­čia­ma ir kaip pa­ra­met­ras nėra per­duo­da­ma jokia vertė, vietoj jos naudojama nu­ma­ty­to­ji vertė.

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

Čia funkcija greet turi nu­ma­ty­tą­ją vertę world pa­ra­met­rui name. Jei funkcijos iš­kvie­ti­mo metu nėra per­duo­da­ma jokia vertė name, au­to­ma­tiš­kai bus naudojama nu­ma­ty­to­ji vertė.

Poilsio pa­ra­met­rai

Naudodami Ty­peSc­ript kalbos poilsio pa­ra­met­rus (taip pat žinomus kaip poilsio ope­ra­to­riai arba poilsio parametrų sintaksė), galite surinkti ne­nu­ro­dy­tą skaičių argumentų kaip Ty­peSc­ript masyvus funk­ci­jo­je. Tai naudinga, jei norite rašyti funkcijas, kurios gali apdoroti įvairų argumentų skaičių.

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
ty­pesc­ript

Pavyzdyje funkcija sum surenka bet kokį skaičių kiekį kaip likutinį parametrą numbers ir sudeda juos, kad ap­skai­čiuo­tų bendrą sumą. Galite perduoti tiek skaičių, kiek norite, ir funkcija juos visus sudės.

Per­kro­vi­mas

Funkcijų per­kro­vi­mas nau­do­ja­mas apibrėžti kelias funkcijas su tais pačiais pa­va­di­ni­mais, bet skir­tin­gais pa­ra­met­rais ar grą­ži­na­mai­siais tipais. Tai padeda Ty­peSc­ript au­to­ma­tiš­kai pa­si­rink­ti teisingą funkcijos dekla­ra­ci­ją, pri­klau­so­mai nuo perduotų argumentų, ir atlikti tipų pa­tik­ri­ni­mus.

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"
ty­pesc­ript

Pa­teik­ta­me pavyzdyje turime dvi funkcijos perkrovas skaičiui concatenate. Pirmoji priima du styginius, o antroji – du skaičius. Funkcija pati kon­ver­tuo­ja perduotus ar­gu­men­tus į styginius ir sujungia juos. Ty­peSc­ript au­to­ma­tiš­kai pasirenka tinkamą perkrovą pagal perduotus ar­gu­men­tus ir atlieka reikiamus tipo pa­tik­ri­ni­mus.

Funkcijų per­kro­vi­mas yra ypač naudingas, jei kuriate API arba bi­b­lio­te­ką, kurioje norite už­tik­rin­ti, kad funkcijos nau­do­ji­mas būtų paprastas ir be klaidų, ne­pri­klau­so­mai nuo skirtingų parametrų tipų, kuriuos pateikia var­to­to­jai. 133e3bd4651a9100beeedd44acb6f1b4

4823016084ab8c27d0450cc1273217d7

ebbb996ca0c42db05ec8d690c6274b4e

04954b418af6a01dc13e9a2176478907

Go to Main Menu