# Kas yra TypeScript funkcijos? Apibrėžimas, tipų saugumas ir naudojimas

Naudodami „TypeScript“, vartotojai gali deklaruoti funkcijų, parametrų ir grąžinamųjų verčių tipus. Kadangi „TypeScript“ tikrina, ar naudojami teisingi duomenų tipai, tipų deklaravimas padeda **anksčiau aptikti klaidas** ir padidina kodo kokybę.

## Kas yra TypeScript funkcijos?

TypeScript funkcijos yra pagrindinė [TypeScript](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/kas-yra-typescript/) sudedamoji dalis. TypeScript funkcijos yra panašios į JavaScript funkcijas, tačiau turi papildomą pranašumą – **statinį tipizavimą**. Taikant šį metodą, kintamųjų, parametrų ir grąžinamųjų verčių duomenų tipai yra apibrėžti jau kompiliavimo metu ir negali būti keičiami vykdymo metu. Tai sumažina klaidų skaičių gamybos aplinkoje.

Kita TypeScript funkcijų ypatybė yra jų lankstumas. Funkcijos gali turėti pasirinktines ir **numatytąsias parametrų vertes**, todėl jas lengviau pritaikyti įvairiems naudojimo atvejams. Galimi naudojimo atvejai apima duomenų apdorojimą, sąveiką su vartotojo sąsaja, asinchroninį programavimą ir daugelį kitų. Taip pat galite apibrėžti perkrovimus, kad būtų teikiamos skirtingos funkcijos, pagrįstos įvesties vertėmis.

Be funkcijų deklaravimo, TypeScript taip pat galima naudoti **pagalbines funkcijas**. Šios funkcijos yra trumpesnės ir dažnai naudojamos šiuolaikinėse JavaScript kūrimo praktikose.

TypeScript funkcijos yra svarbios siekiant padidinti TypeScript projektuose naudojamo kodo saugumą ir skaitomumą. Tuo pačiu metu jų lankstumas ir pritaikomumas leidžia jas pritaikyti įvairiems reikalavimams.

## Kokia yra TypeScript funkcijų sintaksė?

**TypeScript yra JavaScript kalbos superset kalba**. Todėl TypeScript funkcijų sintaksė yra panaši į JavaScript funkcijų sintaksę. Funkcijos kodas rašomas skliaustuose `{ }`. Čia įgyvendinama tikroji funkcijos logika. Čia pateikiama pagrindinė TypeScript funkcijos sintaksė:

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

- **funkcija**: šis raktinis žodis žymi funkcijos deklaracijos pradžią.
- **functionName**: tai yra funkcijos pavadinimas. Turėtumėte pasirinkti apibūdinantį pavadinimą, kuris atspindėtų funkcijos užduotį.
- **parameter1, parameter2**: tai yra parametrai, kurių tikisi funkcija. Kiekvienas parametras identifikuojamas pagal jo pavadinimą ir tikėtiną duomenų tipą (tipo anotacija).
- **returnType**: tai yra duomenų tipas, kurį funkcija grąžina. Taip pat galite nurodyti `void`, jei funkcija negrąžina vertės.
- **grąžinamas rezultatas** yra neprivalomas ir naudojamas, jei funkcija turi grąžinti reikšmę.

TypeScript funkcijos yra iškviečiamos naudojant funkcijos pavadinimą, po kurio eina skliaustelės. Skliaustelėse nurodote funkcijos **argumentus (įvesties vertes)**, jei ji reikalauja parametrų.

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

## TypeScript funkcijos pavyzdžiai

TypeScript funkcijos yra labai universalios ir gali būti naudojamos skaičiavimams, operacijoms ir sudėtingiems procesams programose atlikti.

### Anoniminės funkcijos

Anoniminės funkcijos TypeScript kalboje yra funkcijos, kurios **neturi pavadinimo** ir yra perduodamos tiesiogiai išraiškose arba kaip argumentai kitoms funkcijoms. Anoniminės funkcijos yra naudingos, jei funkcija reikalinga tik vienoje kodo vietoje ir nenorite priskirti savo funkcijos pavadinimo.

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

Šiame pavyzdyje anoniminė funkcija yra saugoma kintamajame `greet` ir vėliau iškviečiama, kad būtų sukurtas asmeninis sveikinimo pranešimas `John`.

Anoniminės funkcijos taip pat apima **lambda funkcijas**, kurios yra žinomos kaip rodyklės funkcijos.

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

Čia anoniminė funkcija, kuri sudeda du skaičius, priskiriama kintamajam `add` ir tada iškviečiama.

### Numatytieji parametrai

Numatytieji parametrai (taip pat žinomi kaip standartiniai parametrai) TypeScript leidžia apibrėžti TypeScript funkcijas taip, kad jos turėtų **numatytuosius parametrų vertes**. Kai funkcija yra iškviečiama ir kaip parametras nėra perduodama jokia vertė, vietoj jos naudojama numatytoji vertė.

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

Čia funkcija `greet` turi numatytąją vertę `world` parametrui `name`. Jei funkcijos iškvietimo metu nėra perduodama jokia vertė `name`, automatiškai bus naudojama numatytoji vertė.

### Poilsio parametrai

Naudodami TypeScript kalbos poilsio parametrus (taip pat žinomus kaip poilsio operatoriai arba poilsio parametrų sintaksė), galite surinkti **nenurodytą skaičių argumentų** kaip [TypeScript masyvus](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/typescript-masyvai/) funkcijoje. Tai naudinga, jei norite rašyti funkcijas, kurios gali apdoroti įvairų argumentų skaičių.

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

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

### Perkrovimas

Funkcijų perkrovimas naudojamas apibrėžti kelias funkcijas su tais pačiais pavadinimais, bet skirtingais parametrais ar grąžinamaisiais tipais. Tai padeda TypeScript automatiškai pasirinkti teisingą funkcijos deklaraciją, priklausomai nuo perduotų argumentų, ir atlikti **tipų patikrinimus**.

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

Pateiktame pavyzdyje turime dvi funkcijos perkrovas skaičiui `concatenate`. Pirmoji priima du styginius, o antroji – du skaičius. Funkcija pati konvertuoja perduotus argumentus į styginius ir sujungia juos. TypeScript automatiškai pasirenka tinkamą perkrovą pagal perduotus argumentus ir atlieka reikiamus tipo patikrinimus.

Funkcijų perkrovimas yra ypač naudingas, jei **kuriate API arba biblioteką**, kurioje norite užtikrinti, kad funkcijos naudojimas būtų paprastas ir be klaidų, nepriklausomai nuo skirtingų parametrų tipų, kuriuos pateikia vartotojai.


This is a markdown version of: [https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/typescript-funkcijos/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/typescript-funkcijos/) for AI/LLM consumption.