Z Type­Scrip­tom lahko upo­rab­ni­ki de­kla­ri­ra­te tipe za funkcije, parametre in vrnjene vrednosti. Ker Type­Script preverja, ali so upo­ra­blje­ni pravilni po­dat­kov­ni tipi, de­kla­ri­ra­nje tipov pomaga zgodaj odkriti napake in poveča kakovost kode.

Kaj so funkcije Type­Script?

Funkcije Type­Script so osrednja sestavina Type­Script. Funkcije v Type­Script so podobne tistim v Ja­va­Script, vendar imajo dodatno prednost sta­tič­ne­ga ti­pi­zi­ra­nja. Pri tem pristopu so po­dat­kov­ni tipi za spre­men­ljiv­ke, parametre in vrnjene vrednosti že de­fi­ni­ra­ni v času kom­pi­li­ra­nja in jih med iz­va­ja­njem ni mogoče spre­me­ni­ti. To zmanjša število napak v pro­duk­cij­skem okolju.

Druga zna­čil­nost funkcij Type­Script je njihova pri­la­go­dlji­vost. Funkcije lahko imajo izbirne in privzete vrednosti za parametre, kar olajša njihovo pri­la­ga­ja­nje različnim primerom uporabe. Možne uporabe vklju­ču­je­jo obdelavo podatkov, in­te­rak­ci­je z upo­rab­ni­škim vmesnikom, asinhrono pro­gra­mi­ra­nje in še veliko več. Opre­de­li­te lahko tudi pre­o­bre­me­ni­tve, da za­go­to­vi­te različne funk­ci­o­nal­no­sti na podlagi vhodnih vrednosti.

Poleg de­kla­ri­ra­nja funkcij lahko v Type­Scrip­tu upo­ra­blja­te tudi pomožne funkcije. Te funkcije so krajše in se pogosto upo­ra­blja­jo v sodobnih praksah razvoja Ja­va­Script.

Funkcije Type­Script so ključnega pomena za povečanje varnosti in ber­lji­vo­sti kode, ki se uporablja v projektih Type­Script. Hkrati pa so zaradi svoje pri­la­go­dlji­vo­sti in pri­la­go­dlji­vo­sti primerne za širok spekter zahtev.

Kakšna je sintaksa za funkcije Type­Script?

Type­Script je nad­gra­dnja jezika Ja­va­Script. Zato je sintaksa funkcij Type­Script podobna sintaksi funkcij Ja­va­Script. Koda funkcije sledi v oklepajih { }. Tu je im­ple­men­ti­ra­na dejanska logika funkcije. Tukaj je osnovna sintaksa funkcije Type­Script:

function functionName(parameter1: type, parameter2: type): returnType {
    // Function Code
    return result; // (optional)
}
type­script
  • funkcija: ta ključna beseda označuje začetek de­kla­ra­ci­je funkcije.
  • func­ti­on­Na­me: to je ime funkcije. Izberite opisno ime, ki odraža nalogo funkcije.
  • parameter1, parameter2: to so parametri, ki jih funkcija pričakuje. Vsak parameter je označen z imenom in pri­ča­ko­va­nim tipom podatkov (tipom opombe).
  • vr­sta­Vr­sta: to je po­dat­kov­ni tip, ki ga funkcija vrne. Lahko tudi navedete void, če funkcija ne vrne vrednosti.
  • vrnjeni rezultat je neobvezen in se uporablja, če mora funkcija vrniti vrednost.

Funkcije Type­Script se kličejo z imenom funkcije, ki mu sledijo oklepaji. V oklepajih določite argumente (vhodne vrednosti) za funkcijo, če ta pričakuje parametre.

functionName(argument1, argument2, ...);
type­script

Primeri funkcij Type­Script

Funkcije Type­Script so izredno vse­stran­ske in se lahko upo­ra­blja­jo za izvajanje izračunov, operacij in kom­ple­ksnih procesov v apli­ka­ci­jah.

Anonimne funkcije

Anonimne funkcije v Type­Scrip­tu so funkcije, ki nimajo imena in se po­sre­du­je­jo ne­po­sre­dno v izrazih ali kot argumenti drugim funkcijam. Anonimne funkcije so koristne, če po­tre­bu­je­te funkcijo le na enem mestu v kodi in ji ne želite dodeliti lastnega imena.

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

V tem primeru je anonimna funkcija shranjena v spre­men­ljiv­ki greet in se kasneje pokliče, da ustvari osebno pozdravno sporočilo za John.

Anonimne funkcije vklju­ču­je­jo tudi lambda funkcije, ki so znane kot puščice funkcije.

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

Tukaj je anonimna funkcija, ki sešteje dve števili, dodeljena spre­men­ljiv­ki add in nato poklicana.

Privzeti parametri

Privzete parametre (znane tudi kot stan­dar­dni parametri) v Type­Scrip­tu omogočajo opre­de­li­tev funkcij Type­Script, tako da imajo privzete vrednosti za parametre. Ko se funkcija pokliče in se kot parameter ne prenese nobena vrednost, se namesto tega uporabi privzeta vrednost.

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

Tukaj ima funkcija greet privzeto vrednost world za parameter name. Če ob klicu funkcije ni podana nobena vrednost za name, se samodejno uporabi privzeta vrednost.

Parametri počitka

Z ostankom pa­ra­me­trov (znanih tudi kot ostanki ope­ra­ter­jev ali sintaksa ostankov pa­ra­me­trov) v Type­Scrip­tu lahko zberete neomejeno število ar­gu­men­tov kot Type­Scrip­to­ve nize v funkciji. To je koristno, če želite napisati funkcije, ki lahko ob­de­lu­je­jo različno število ar­gu­men­tov.

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
type­script

V primeru funkcija sum zbira poljubno število številk kot preostali parameter numbers in jih sešteje, da izračuna skupno vsoto. Lahko prenesete poljubno število številk, funkcija pa jih bo vse seštela.

Pre­o­bre­me­ni­tev

Pre­o­bre­me­ni­tev funkcij se uporablja za de­fi­ni­ra­nje več de­kla­ra­cij funkcij z istimi imeni, vendar z raz­lič­ni­mi tipi pa­ra­me­trov ali vrstami vrnitve. To pomaga Type­Scrip­tu, da samodejno izbere pravilno de­kla­ra­ci­jo funkcije glede na prenesene argumente in izvede pre­ver­ja­nje tipov.

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"
type­script

V zgornjem primeru imamo dve pre­o­bre­me­ni­tvi funkcije za concatenate. Prva sprejema dva niza, druga pa dve številki. Funkcija sama pretvori prenesene argumente v nize in jih združi. Type­Script samodejno izbere ustrezno pre­o­bre­me­ni­tev na podlagi pre­ne­se­nih ar­gu­men­tov in opravi potrebne pre­ver­ja­nja tipov.

Pre­o­bre­me­ni­tve funkcij so še posebej uporabne, če razvijate API ali knjižnico, kjer želite za­go­to­vi­ti, da je uporaba funkcije preprosta in brez napak, ne glede na različne tipe pa­ra­me­trov, ki jih za­go­to­vi­jo upo­rab­ni­ki. 133e3bd4651a9100beeedd44acb6f1b4

4823016084ab8c27d0450cc1273217d7

ebbb996ca0c42db05ec8d690c6274b4e

04954b418af6a01dc13e9a2176478907

705341800163cbdf9246e52b056e2666

Go to Main Menu