CAP 05 · LEC 01·TypeScript
Tipado básico en TypeScript
TypeScript añade un sistema de tipos sobre JavaScript. El compilador valida tipos en tiempo de compilación — antes de que el código se ejecute — y te dice exactamente dónde está el error.
¿Encontraste un error o algo que mejorar?Editá esta lección en GitHub →
Anotaciones de tipo básicas
Para anotar el tipo de una variable, usa : Tipo después del nombre:
// Tipos primitivos
let nombre: string = "Ana";
let edad: number = 25;
let activo: boolean = true;
// TypeScript también puede inferir el tipo — no siempre necesitas anotarlo
let ciudad = "Madrid"; // TypeScript infiere: string
let puntos = 100; // TypeScript infiere: number
// ❌ Error: no puedes asignar un tipo incorrecto
// nombre = 42; // Type 'number' is not assignable to type 'string'
// activo = "sí"; // Type 'string' is not assignable to type 'boolean'
// undefined y null
let sin: undefined = undefined;
let nulo: null = null;Inferencia de tipos
TypeScript infiere el tipo a partir del valor inicial. Solo anota el tipo cuando la inferencia no es suficiente — por ejemplo, para aclarar la intención o cuando la variable se declara sin valor inicial.
Tipos en funciones
// Parámetros y tipo de retorno
function sumar(a: number, b: number): number {
return a + b;
}
// Arrow function tipada
const multiplicar = (a: number, b: number): number => a * b;
// void: la función no retorna valor significativo
function log(mensaje: string): void {
console.log(mensaje);
}
// never: la función nunca retorna (lanza o loop infinito)
function lanzar(msg: string): never {
throw new Error(msg);
}
// Parámetro opcional
function saludar(nombre: string, titulo?: string): string {
return titulo ? `${titulo} ${nombre}` : nombre;
}
console.log(saludar("Ana")); // "Ana"
console.log(saludar("Ana", "Dra.")); // "Dra. Ana"Salida
Ana
Dra. AnaArrays y objetos tipados
// Arrays
const numeros: number[] = [1, 2, 3];
const nombres: string[] = ["Ana", "Luis"];
const pares: Array<number> = [2, 4, 6]; // sintaxis alternativa
// Objeto inline
const usuario: { nombre: string; edad: number } = {
nombre: "Ana",
edad: 25,
};
// Tuplas: array de longitud y tipos fijos
const par: [string, number] = ["Ana", 25];
const coords: [number, number] = [40.4168, -3.7038];
// par[0] es string, par[1] es number — TypeScript lo sabe
// any: desactiva el chequeo de tipos (evitar)
let cualquiera: any = "texto";
cualquiera = 42; // no da error — pero pierdes la seguridad
cualquiera = true;
// unknown: como any pero seguro (debes verificar antes de usar)
let desconocido: unknown = obtenerDato();
if (typeof desconocido === "string") {
console.log(desconocido.toUpperCase()); // ✅ TypeScript sabe que es string aquí
}type alias básico
// type alias: nombre para cualquier tipo
type Nombre = string;
type Edad = number;
type Activo = boolean;
// Más útil para tipos complejos
type Coordenadas = [number, number];
type Callback = () => void;
type Predicado<T> = (valor: T) => boolean;
const origen: Coordenadas = [0, 0];
const esPositivo: Predicado<number> = n => n > 0;
console.log(esPositivo(5)); // true
console.log(esPositivo(-1)); // false
// Union types — un valor de uno de varios tipos
type EstadoPedido = "pendiente" | "enviado" | "entregado" | "cancelado";
let estado: EstadoPedido = "pendiente";
estado = "enviado";
// estado = "perdido"; // ❌ Error: no es un valor válido