¿Cómo se anotan variables, parámetros y tipos de retorno?

Question

IT Interview Practice · Accepted Answer

Agregas un tipo después de dos puntos. TypeScript puede **inferir** muchos tipos, así que anotas donde aporta claridad o donde la inferencia no es posible.

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

## Tipos de retorno: ¿inferir o anotar?

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

Los tipos de retorno se infieren, pero anotarlos en funciones exportadas/públicas es una buena práctica: documenta la intención y atrapa errores *dentro* de la función (si accidentalmente retornas algo incorrecto, el error apunta a la función, no a quienes la llaman).

## Casos especiales

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

## Por qué es importante

La regla general: **anota las firmas de las funciones (parámetros y tipos de retorno públicos) de forma explícita, y deja que las variables locales se infieran.** Esto mantiene el código conciso a la vez que deja claros y verificados los contratos en los límites de las funciones.

Tipos de retorno: ¿inferir o anotar?

Casos especiales

Por qué es importante

Preguntas relacionadas