# Kas ir TypeScript funkcijas? Definīcija, tipa drošība un lietošana

Izmantojot TypeScript, lietotāji var deklarēt funkciju, parametru un atgriezenisko vērtību tipus. Tā kā TypeScript pārbauda, vai tiek izmantoti pareizie datu tipi, tipu deklarēšana palīdz **agrāk atklāt kļūdas** un uzlabo koda kvalitāti.

## Kas ir TypeScript funkcijas?

TypeScript funkcijas ir [TypeScript](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/kas-ir-typescript/) galvenā sastāvdaļa. TypeScript funkcijas ir līdzīgas JavaScript funkcijām, bet tām ir papildu priekšrocība – **statiskā tipizācija**. Šādā pieejā mainīgo, parametru un atgriezenisko vērtību datu tipi jau ir definēti kompilācijas 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 elastīgums. Funkcijām var būt **parametru** opcionālās un **noklusējuma vērtības**, kas atvieglo to pielāgošanu dažādiem lietošanas gadījumiem. Iespējamie lietojumi ietver datu apstrādi, lietotāja saskarnes mijiedarbību, asinhrono programmēšanu un daudz ko citu. Jūs varat arī definēt pārslodzes, lai nodrošinātu dažādas funkcijas, pamatojoties uz ievades vērtībām.

Papildus funkciju deklarēšanai TypeScript var izmantot arī **palīgfunkcijas**. Šīs funkcijas ir īsākas un bieži tiek izmantotas mūsdienu JavaScript izstrādes praksē.

TypeScript funkcijas ir būtiskas, lai palielinātu TypeScript projektos izmantotā koda drošību un lasāmību. Tajā pašā laikā to elastība un pielāgojamība padara tās piemērotas plašam prasību klāstam.

## Kāda ir TypeScript funkciju sintakse?

**TypeScript ir JavaScript paplašināta valoda**. Tādējādi TypeScript funkciju sintakse ir līdzīga JavaScript funkciju sintaksei. Funkcijas kods ir iekavās `{ }`. Šeit tiek īstenota funkcijas faktiskā loģika. Šeit ir TypeScript funkcijas pamata sintakse:

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

- **funkcija**: šis atslēgvārds iezīmē funkcijas deklarācijas sākumu.
- **funkcijas nosaukums**: tas ir funkcijas nosaukums. Jums jāizvēlas aprakstošs nosaukums, kas atspoguļo funkcijas uzdevumu.
- **parametrs1, parametrs2**: šie ir parametri, kurus funkcija sagaida. Katrs parametrs tiek identificēts pēc tā nosaukuma un sagaidāmā datu tipa (tipa anotācija).
- **returnType**: 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 fakultatīvs un tiek izmantots, ja funkcija atgriež vērtību.

TypeScript funkcijas tiek izsaucamas, izmantojot funkcijas nosaukumu, aiz kura seko iekavās. Iekavās norādiet funkcijas **argumentus (ievades vērtības)**, ja tai ir nepieciešami parametri.

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

## TypeScript funkciju piemēri

TypeScript funkcijas ir ļoti daudzpusīgas un tās var izmantot, lai veiktu aprēķinus, operācijas un sarežģītus procesus lietojumprogrammās.

### Anonīmas funkcijas

Anonīmas funkcijas TypeScript ir funkcijas, kurām **nav nosaukuma** un kuras tiek nodotas tieši izteiksmēs vai kā argumenti citām funkcijām. Anonīmas funkcijas ir noderīgas, ja funkcija ir nepieciešama tikai vienā kodā un nevēlaties piešķirt tai savu nosaukumu.

```typescript
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 personalizētu sveicienu `John`.

Anonīmās funkcijas ietver arī **lambda funkcijas**, kas pazīstamas kā bultu funkcijas.

```typescript
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 mainīgajam `add` un pēc tam izsaukta.

### Noklusējuma parametri

Noklusējuma parametri (pazīstami arī kā standarta parametri) TypeScript ļauj definēt TypeScript funkcijas tā, lai tām būtu **noklusējuma parametru vērtības**. Kad funkcija tiek izsaukta un kā parametrs netiek nodota nekāda vērtība, tiek izmantota noklusējuma vērtība.

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

Šeit funkcija `greet` parametram `name` ir piešķirta noklusējuma vērtība `world`. Ja funkcijas izsaukšanas brīdī parametram `name` netiek nodota nekāda vērtība, automātiski tiek izmantota noklusējuma vērtība.

### Atpūtas parametri

Izmantojot atpūtas parametrus (pazīstami arī kā atpūtas operatori vai atpūtas parametru sintakse) TypeScript, jūs varat savākt **nenoteiktu skaitu argumentu** kā [TypeScript masīvus](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/typescript-masivi/) funkcijā. Tas ir noderīgi, ja vēlaties rakstīt funkcijas, kas var apstrādāt dažādu skaitu argumentu.

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

Šajā piemērā funkcija `sum` savāc jebkuru skaitļu summu kā atlikušo parametru `numbers` un saskaita tos kopā, lai aprēķinā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 deklarācijas ar vienādiem nosaukumiem, bet atšķirīgiem parametriem vai atgriešanas tipiem. Tas palīdz TypeScript automātiski izvēlēties pareizo funkciju deklarāciju atkarībā no nodotajiem argumentiem un veikt **tipa pārbaudes**.

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

Iepriekš minētajā piemērā mums ir divas funkcijas pārslodzes `concatenate`. Pirmā pieņem divas virknes, bet otrā pieņem divus skaitļus. Funkcija pati pārvērš nodotos argumentus virknēs un savieno tos. TypeScript automātiski izvēlas atbilstošo pārslodzi, pamatojoties uz nodotajiem argumentiem, un veic nepieciešamās tipa pārbaudes.

Funkciju pārslodzes ir īpaši noderīgas, ja **izstrādājat API vai bibliotēku**, kurā vēlaties nodrošināt, ka funkcijas lietošana ir vienkārša un bez kļūdām, neatkarīgi no dažādiem parametru tipiem, ko nodrošina lietotāji.


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/typescript-funkcijas/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/typescript-funkcijas/) for AI/LLM consumption.