Mis on Ty­peSc­ripti funkt­sioo­nid? Mõiste, tüü­bi­kind­lus ja ka­su­ta­mine

Ty­peSc­rip­tiga saavad kasutajad dek­la­ree­rida funkt­sioo­nide, pa­ra­meet­rite ja ta­gas­ta­ta­vate väärtuste tüübid. Kuna Ty­peSc­ript kont­rol­lib, kas ka­su­ta­takse õigeid and­me­tüüpe, aitab tüüpide dek­la­ree­ri­mine varakult avastada vigu ja parandab koodi kva­li­teeti.

Mis on Ty­peSc­ripti funkt­sioo­nid?

Ty­peSc­ripti funkt­sioo­nid on Ty­peSc­ripti keskne komponent. Ty­peSc­ripti funkt­sioo­nid sar­na­ne­vad Ja­vaSc­ripti funkt­sioo­ni­dega, kuid neil on lisaks staa­ti­lise tüüpimise eelis. Selle lä­he­ne­mis­viisi puhul on muutujate, pa­ra­meet­rite ja ta­gas­ta­ta­vate väärtuste and­me­tüü­bid juba kom­pi­lee­ri­mise ajal mää­rat­le­tud ja neid ei saa täitmise ajal muuta. See vähendab vigu toot­mis­kesk­kon­nas.

Ty­peSc­ripti funkt­sioo­nide teine omadus on nende paind­lik­kus. Funkt­sioo­ni­del võivad olla va­li­ku­li­sed ja vaikimisi väärtused pa­ra­meet­ri­tele, mis liht­sus­tab nende ko­han­da­mist erinevate ka­su­tus­juh­tude jaoks. Või­ma­li­kud ka­su­tus­vii­sid hõlmavad and­me­tööt­lust, ka­su­ta­ja­lii­d­ese in­te­rakt­sioone, asünk­roon­set prog­ram­mee­ri­mist ja palju muud. Samuti on võimalik mää­rat­leda üle­koor­mu­sed, et pakkuda erinevaid funkt­sioone si­send­väär­tuste põhjal.

Lisaks funkt­sioo­nide dek­la­ree­ri­misele saate Ty­peSc­rip­tis kasutada ka abi­funkt­sioone. Need funkt­sioo­nid on lühemad ja neid ka­su­ta­takse sageli kaas­aeg­se­tes Ja­vaSc­ripti aren­dus­ta­va­des.

Ty­peSc­ripti funkt­sioo­nid on võt­me­täht­su­sega Ty­peSc­ripti pro­jek­ti­des ka­su­ta­tava koodi tur­va­li­suse ja loetavuse suu­ren­da­misel. Samal ajal muudab nende paind­lik­kus ja ko­han­da­ta­vus need sobivaks mit­me­su­guste nõuete täit­miseks.

Milline on Ty­peSc­ripti funkt­sioo­nide süntaks?

Ty­peSc­ript on Ja­vaSc­ripti ülemkeel. Seega on Ty­peSc­ripti funkt­sioo­nide süntaks sarnane Ja­vaSc­ripti funkt­sioo­nide sün­tak­siga. Funkt­siooni kood järgneb kaa­rek­lam­meri­tes { }. Siin ra­ken­da­takse funkt­siooni tegelikku loogikat. Siin on Ty­peSc­ripti funkt­siooni põhiline süntaks:

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

• funkt­sioon: see märksõna tähistab funkt­siooni dek­la­rat­siooni algust.
• func­tion­Name: see on funkt­siooni nimi. Valige kirjeldav nimi, mis peegeldab funkt­siooni ülesannet.
• parameter1, parameter2: need on pa­ra­meet­rid, mida funkt­sioon ootab. Iga pa­ra­mee­ter on iden­ti­fit­see­ri­tud oma nime ja oodatava and­me­tüübi (tüübi märge) järgi.
• re­turnType: see on andmetüüp, mida funkt­sioon tagastab. Võite määrata ka void, kui funkt­sioon ei tagasta väärtust.
• return result on va­li­ku­line ja seda ka­su­ta­takse, kui funkt­sioon peaks väärtuse tagastama.

Ty­peSc­ripti funkt­sioone kut­su­takse välja, kasutades funkt­siooni nime, millele järgneb sulgudes. Sulgudes mää­ra­takse funkt­siooni ar­gu­men­did (si­send­väär­tu­sed), kui funkt­sioon ootab pa­ra­meetreid.

functionName(argument1, argument2, ...);

Ty­peSc­ripti funkt­sioo­nide näited

Ty­peSc­ripti funkt­sioo­nid on äärmiselt mit­me­külg­sed ja neid saab kasutada arvutuste, ope­rat­sioo­nide ja kee­ru­liste prot­ses­side soo­ri­ta­miseks ra­ken­dus­tes.

Ano­nüüm­sed funkt­sioo­nid

Ano­nüüm­sed funkt­sioo­nid Ty­peSc­rip­tis on funkt­sioo­nid, millel pole nime ja mis edas­ta­takse otse väl­jen­di­tes või ar­gu­men­ti­dena teistele funkt­sioo­ni­dele. Ano­nüüm­sed funkt­sioo­nid on kasulikud, kui vajate funkt­siooni ainult ühes kohas koodis ja ei soovi sellele oma funkt­siooni nime anda.

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

Selles näites sal­ves­ta­takse anonüümne funkt­sioon muu­tu­jasse greet ja kut­su­takse see hiljem välja, et luua isi­kus­ta­tud ter­vi­tus­sõ­num numbrile John.

Ano­nüüm­sed funkt­sioo­nid hõlmavad ka lambda-funkt­sioone, mida tuntakse noo­le­funkt­sioo­ni­dena.

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

Siin mää­ra­takse muutujale add anonüümne funkt­sioon, mis liidab kaks arvu, ja seejärel kut­su­takse see välja.

Vaikimisi pa­ra­meet­rid

Ty­peSc­ripti vaikimisi pa­ra­meet­rid (tuntud ka kui stan­dard­pa­ra­meet­rid) või­mal­da­vad teil mää­rat­leda Ty­peSc­ripti funkt­sioone nii, et neil oleksid pa­ra­meet­rite vaikimisi väärtused. Kui funkt­siooni kut­su­takse ja pa­ra­meet­rina ei edastata ühtegi väärtust, ka­su­ta­takse selle asemel vaikimisi väärtust.

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

Siin on funkt­sioo­nil greet pa­ra­meetri name vaikimisi väärtus world. Kui funkt­siooni kut­su­misel ei edastata väärtust name, ka­su­ta­takse au­to­maat­selt vaikimisi väärtust.

Puh­ke­pa­ra­meet­rid

Ty­peSc­ripti puhul või­mal­da­vad puh­kus­pa­ra­meet­rid (tuntud ka kui puh­kusope­raa­to­rid või puh­kus­pa­ra­meetri süntaks) koguda funkt­sioo­nis määramata arvu argumente Ty­peSc­ripti mas­sii­vi­dena. See on kasulik, kui soovite kirjutada funkt­sioone, mis suudavad töödelda erinevat arvu argumente.

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

Näites kogub funkt­sioon sum mis tahes arvu numbreid jääk­pa­ra­meet­rina numbers ja liidab need kokku, et arvutada kogusumma. Saate edastada nii palju numbreid, kui soovite, ja funkt­sioon liidab need kõik kokku.

Üle­koor­mus

Funkt­siooni üle­kir­ju­ta­mist ka­su­ta­takse mitme sama nimega, kuid erinevate pa­ra­meet­rite või ta­gas­tus­tüü­pi­dega funkt­sioo­nide dek­la­rat­sioo­nide mää­rat­le­miseks. See aitab Ty­peSc­rip­til au­to­maat­selt valida õige funkt­siooni dek­la­rat­siooni vastavalt edastatud ar­gu­men­ti­dele ja teostada tüü­bi­kont­rolle.

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"

Eespool toodud näites on meil kaks funkt­siooni üle­kir­ju­tust numbrile concatenate. Esimene võtab vastu kaks stringi ja teine kaks numbrit. Funkt­sioon ise teisendab edastatud ar­gu­men­did strin­gi­deks ja ühendab need. Ty­peSc­ript valib au­to­maat­selt sobiva üle­kir­ju­tuse edastatud ar­gu­men­tide põhjal ja teostab vajalikud tüü­bi­kont­rol­lid.

Funkt­sioo­nide üle­kir­ju­ta­mine on eriti kasulik, kui arendate API-d või raa­ma­tu­kogu, kus soovite tagada, et funkt­siooni ka­su­ta­mine oleks lihtne ja veavaba, sõltumata ka­su­ta­jate poolt esitatud eri­ne­va­test pa­ra­meet­ri­test. 133e3bd4651a9100beeedd44acb6f1b4

4823016084ab8c27d0450cc1273217d7

ebbb996ca0c42db05ec8d690c6274b4e

f48f7dd8ebbaef40609973aaf3934a14