# Kaj so funkcije TypeScript? Opredelitev, varnost tipov in uporaba

Z TypeScriptom lahko uporabniki deklarirate tipe za funkcije, parametre in vrnjene vrednosti. Ker TypeScript preverja, ali so uporabljeni pravilni podatkovni tipi, deklariranje tipov pomaga **zgodaj odkriti napake** in poveča kakovost kode.

## Kaj so funkcije TypeScript?

Funkcije TypeScript so osrednja sestavina [TypeScript](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/kaj-je-typescript/). Funkcije v TypeScript so podobne tistim v JavaScript, vendar imajo dodatno prednost **statičnega tipiziranja**. Pri tem pristopu so podatkovni tipi za spremenljivke, parametre in vrnjene vrednosti že definirani v času kompiliranja in jih med izvajanjem ni mogoče spremeniti. To zmanjša število napak v produkcijskem okolju.

Druga značilnost funkcij TypeScript je njihova prilagodljivost. Funkcije lahko imajo izbirne in **privzete vrednosti za parametre**, kar olajša njihovo prilagajanje različnim primerom uporabe. Možne uporabe vključujejo obdelavo podatkov, interakcije z uporabniškim vmesnikom, asinhrono programiranje in še veliko več. Opredelite lahko tudi preobremenitve, da zagotovite različne funkcionalnosti na podlagi vhodnih vrednosti.

Poleg deklariranja funkcij lahko v TypeScriptu uporabljate tudi **pomožne funkcije**. Te funkcije so krajše in se pogosto uporabljajo v sodobnih praksah razvoja JavaScript.

Funkcije TypeScript so ključnega pomena za povečanje varnosti in berljivosti kode, ki se uporablja v projektih TypeScript. Hkrati pa so zaradi svoje prilagodljivosti in prilagodljivosti primerne za širok spekter zahtev.

## Kakšna je sintaksa za funkcije TypeScript?

**TypeScript je nadgradnja jezika JavaScript**. Zato je sintaksa funkcij TypeScript podobna sintaksi funkcij JavaScript. Koda funkcije sledi v oklepajih `{ }`. Tu je implementirana dejanska logika funkcije. Tukaj je osnovna sintaksa funkcije TypeScript:

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

- **funkcija**: ta ključna beseda označuje začetek deklaracije funkcije.
- **functionName**: 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čakovanim tipom podatkov (tipom opombe).
- **vrstaVrsta**: to je podatkovni 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 TypeScript se kličejo z imenom funkcije, ki mu sledijo oklepaji. V oklepajih določite **argumente (vhodne vrednosti)** za funkcijo, če ta pričakuje parametre.

```typescript
functionName(argument1, argument2, ...);
```

## Primeri funkcij TypeScript

Funkcije TypeScript so izredno vsestranske in se lahko uporabljajo za izvajanje izračunov, operacij in kompleksnih procesov v aplikacijah.

### Anonimne funkcije

Anonimne funkcije v TypeScriptu so funkcije, ki **nimajo imena** in se posredujejo neposredno v izrazih ali kot argumenti drugim funkcijam. Anonimne funkcije so koristne, če potrebujete funkcijo le na enem mestu v kodi in ji ne želite dodeliti lastnega imena.

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

V tem primeru je anonimna funkcija shranjena v spremenljivki `greet` in se kasneje pokliče, da ustvari osebno pozdravno sporočilo za `John`.

Anonimne funkcije vključujejo tudi **lambda funkcije**, ki so znane kot puščice funkcije.

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

Tukaj je anonimna funkcija, ki sešteje dve števili, dodeljena spremenljivki `add` in nato poklicana.

### Privzeti parametri

Privzete parametre (znane tudi kot standardni parametri) v TypeScriptu omogočajo opredelitev funkcij TypeScript, 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.

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

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 parametrov (znanih tudi kot ostanki operaterjev ali sintaksa ostankov parametrov) v TypeScriptu lahko zberete **neomejeno število argumentov** kot [TypeScriptove nize](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/typescript-nizi/) v funkciji. To je koristno, če želite napisati funkcije, ki lahko obdelujejo različno število argumentov.

```typescript
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
```

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.

### Preobremenitev

Preobremenitev funkcij se uporablja za definiranje več deklaracij funkcij z istimi imeni, vendar z različnimi tipi parametrov ali vrstami vrnitve. To pomaga TypeScriptu, da samodejno izbere pravilno deklaracijo funkcije glede na prenesene argumente in izvede **preverjanje tipov**.

```typescript
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"
```

V zgornjem primeru imamo dve preobremenitvi funkcije za `concatenate`. Prva sprejema dva niza, druga pa dve številki. Funkcija sama pretvori prenesene argumente v nize in jih združi. TypeScript samodejno izbere ustrezno preobremenitev na podlagi prenesenih argumentov in opravi potrebne preverjanja tipov.

Preobremenitve funkcij so še posebej uporabne, če **razvijate API ali knjižnico**, kjer želite zagotoviti, da je uporaba funkcije preprosta in brez napak, ne glede na različne tipe parametrov, ki jih zagotovijo uporabniki.


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/funkcije-typescript/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/funkcije-typescript/) for AI/LLM consumption.