# Mitä ovat TypeScript-funktiot? Määritelmä, tyyppiturvallisuus ja käyttö

TypeScriptin avulla käyttäjät voivat määrittää tyypit funktioille, parametreille ja palautusarvoille. Koska TypeScript tarkistaa, onko käytetty oikeita tietotyyppejä, tyyppien määrittäminen auttaa **havaitsemaan virheet aikaisemmin** ja parantaa koodin laatua.

## Mitä ovat TypeScript-funktiot?

TypeScript-funktiot ovat [TypeScriptin](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/mikae-on-typescript/) keskeinen osa. TypeScriptin funktiot ovat samanlaisia kuin JavaScriptin funktiot, mutta niillä on lisäksi **staattisen tyypityksen** etu. Tässä lähestymistavassa muuttujien, parametrien ja palautusarvojen tietotyypit määritellään jo kääntämisen aikana, eikä niitä voi muuttaa suorituksen aikana. Tämä vähentää virheitä tuotantoympäristössä.

Toinen TypeScript-funktioiden ominaisuus on niiden joustavuus. Funktioilla voi olla valinnaisia ja **oletusarvoisia parametrien arvoja**, mikä helpottaa niiden mukauttamista eri käyttötarkoituksiin. Mahdollisia käyttötarkoituksia ovat esimerkiksi tietojenkäsittely, käyttöliittymän vuorovaikutus, asynkroninen ohjelmointi ja paljon muuta. Voit myös määritellä ylikuormituksia, jotta saat erilaisia toimintoja syöttöarvojen perusteella.

Funktioiden määrittelyn lisäksi TypeScriptissa voi käyttää myös **apufunktioita**. Nämä funktiot ovat lyhyempiä merkintöjä, ja niitä käytetään usein nykyaikaisissa JavaScript-kehityskäytännöissä.

TypeScript-funktiot ovat avainasemassa TypeScript-projekteissa käytettävän koodin turvallisuuden ja luettavuuden parantamisessa. Samalla niiden joustavuus ja mukautuvuus tekevät niistä sopivia monenlaisiin vaatimuksiin.

## Mikä on TypeScript-funktioiden syntaksi?

**TypeScript on JavaScriptin yläjoukko**. Siksi TypeScript-funktioiden syntaksi on samanlainen kuin JavaScript-funktioiden. Funktiokoodi on aaltosulkeissa `{ }`. Siinä toteutetaan funktion varsinainen logiikka. Tässä on TypeScript-funktion perussyntaksi:

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

- **function**: tämä avainsana merkitsee funktion deklaroinnin alkua.
- **functionName**: tämä on funktion nimi. Valitse kuvaava nimi, joka kuvaa funktion tehtävää.
- **parametri1, parametri2**: nämä ovat parametrit, joita funktio odottaa. Jokainen parametri tunnistetaan sen nimen ja odotetun tietotyypin (tyyppimerkinnän) perusteella.
- **returnType**: tämä on tietotyyppi, jonka funktio palauttaa. Voit myös määrittää `void`, jos funktio ei palauta arvoa.
- **return result** on valinnainen ja sitä käytetään, jos funktion tulisi palauttaa arvo.

TypeScript-funktiot kutsutaan käyttämällä funktion nimeä, jota seuraa suluissa oleva argumentti ( **syöttöarvo** ). Suluissa määritellään funktion **argumentit (syöttöarvot)**, jos funktio odottaa parametreja.

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

## TypeScript-funktioiden esimerkkejä

TypeScript-funktiot ovat erittäin monipuolisia ja niitä voidaan käyttää laskelmien, operaatioiden ja monimutkaisten prosessien suorittamiseen sovelluksissa.

### Anonyymit funktiot

Anonyymit funktiot TypeScriptissä ovat funktioita, joilla **ei ole nimeä** ja jotka välitetään suoraan lausekkeissa tai argumentteina muille funktioille. Anonyymit funktiot ovat hyödyllisiä, jos tarvitset funktiota vain yhdessä kohdassa koodia etkä halua antaa sille omaa nimeä.

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

Tässä esimerkissä nimetön funktio tallennetaan muuttujaan `greet` ja kutsutaan myöhemmin luomaan henkilökohtainen tervehdysviesti `John`:lle.

Anonyymit funktiot sisältävät myös **lambda-funktiot**, jotka tunnetaan nuolipfunktioina.

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

Tässä kahden luvun yhteenlaskijana toimiva nimetön funktio määritetään muuttujalle `add` ja kutsutaan sitten.

### Oletusparametrit

TypeScriptin oletusparametrit (tunnetaan myös nimellä vakioparametrit) mahdollistavat TypeScript-funktioiden määrittelyn siten, että niillä on **parametrien oletusarvot**. Kun funktiota kutsutaan eikä parametriksi välitetä mitään arvoa, käytetään sen sijaan oletusarvoa.

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

Tässä `greet` funktiolla on oletusarvo `world` parametrille `name`. Jos funktiota kutsuttaessa ei anneta arvoa `name`, käytetään automaattisesti oletusarvoa.

### Lepoparametrit

TypeScriptin rest-parametreilla (tunnetaan myös nimellä rest-operaattorit tai rest-parametrisyntaksi) voit kerätä **määrittelemättömän määrän argumentteja** [TypeScript-taulukoina](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/typescript-taulukot/) funktiossa. Tämä on hyödyllistä, jos haluat kirjoittaa funktioita, jotka voivat käsitellä vaihtelevia määriä argumentteja.

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

Esimerkissä funktio `sum` kerää minkä tahansa määrän lukuja rest-parametrina `numbers` ja laskee niiden summan. Voit syöttää niin monta lukua kuin haluat, ja funktio laskee ne kaikki yhteen.

### Ylikuormitus

Funktioiden ylikuormitusta käytetään määrittelemään useita funktiomäärittelyjä, joilla on sama nimi mutta eri parametri- tai palautustyypit. Tämä auttaa TypeScriptiä valitsemaan automaattisesti oikean funktiomäärittelyn välitettyjen argumenttien perusteella ja suorittamaan **tyyppitarkistukset**.

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

Yllä olevassa esimerkissä on kaksi funktiota, jotka ylikuormittavat arvon `concatenate`. Ensimmäinen hyväksyy kaksi merkkijonoa ja toinen kaksi lukua. Funktio itse muuntaa välitetyt argumentit merkkijonoiksi ja yhdistää ne. TypeScript valitsee automaattisesti sopivan ylikuormituksen välitettyjen argumenttien perusteella ja suorittaa tarvittavat tyyppitarkistukset.

Funktioiden ylikuormitukset ovat erityisen hyödyllisiä, jos **kehität API:ta tai kirjastoa**, jossa haluat varmistaa, että funktion käyttö on yksinkertaista ja virheetöntä riippumatta käyttäjien antamien parametrien erilaisista tyypeistä.


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/typescript-functions/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/typescript-functions/) for AI/LLM consumption.