Miten lisäät tyyppiannotaatioita muuttujiin, parametreihin ja palautustyypeille?

Question

IT Interview Practice · Accepted Answer

Lisäät tyypin kaksoispisteeseen jälkeen. TypeScript osaa **päätellä** monia tyyppejä, joten lisäät annotaatiot siellä, missä se selkeyttää tai missä päättely ei ole mahdollista.

```ts
// variables — usually let inference work
let count: number = 0;     // explicit
let name = "Ann";          // inferred as string (annotation redundant)

// function parameters — always annotate (can't be inferred)
function greet(name: string, times: number): string {
  return name.repeat(times);
}

// arrays and objects
const ids: number[] = [1, 2, 3];
const user: { name: string; age: number } = { name: "Ann", age: 30 };
```

## Paluutyypit: päättely vai annotaatio?

```ts
function add(a: number, b: number) { return a + b; } // inferred return: number
function load(): Promise<User> { ... }                // explicit — documents the contract
```

Paluutyypit päätetään, mutta niiden annotoiminen vietyihin/julkisiin funktioihin on hyvä käytäntö: se dokumentoi tarkoitusta ja löytää virheitä *funktion sisällä* (jos vahingossa palautat väärää asiaa, virhe osoittaa funktioon, ei sen kutsujiin).

## Erikoistapaukset

```ts
function log(msg: string): void {}     // returns nothing
function fail(): never { throw new Error(); } // never returns normally
const fn: (x: number) => string = ...; // function type annotation
```

## Miksi se on tärkeää

Nyrkkeisääntö: **Annotoi funktioiden allekirjoitukset (parametrit ja julkiset paluutyypit) eksplisiittisesti, anna paikallisten muuttujien päätellä.** Tämä pitää koodin tiiviinä samalla kun funktiograniikkojen sopimukset ovat selkeitä ja tarkistettuja.

Paluutyypit: päättely vai annotaatio?

Erikoistapaukset

Miksi se on tärkeää

Aiheeseen liittyvät kysymykset