Zademy

TypeScript: El estándar del desarrollo web moderno

TypeScript
TypeScript; 2025
words palabras

Durante mucho tiempo usé TypeScript como quien usa el cinturón de seguridad en una calle vacía: sabía que era sensato, pero tampoco sentía que cambiara gran cosa. Escribía una interfaz, corregía dos advertencias y seguía trabajando. Si el proyecto era pequeño, JavaScript todavía me parecía suficiente.

Eso cambió sin una migración épica ni una charla que me convenciera. Cambió una tarde, al modificar una respuesta de una API y ver que el editor me señaló todos los lugares donde mi supuesto ya no era cierto. Eran errores ordinarios: un campo que podía faltar, un estado nuevo que nadie contempló, una propiedad privada que estaba a punto de salir en una respuesta pública. Justo los errores que uno suele descubrir tarde porque no parecen interesantes.

Ahí TypeScript dejó de sentirse opcional para mí. No porque JavaScript se volviera malo, sino porque los tipos empezaron a funcionar como contexto compartido entre el compilador, el editor, las herramientas y, sobre todo, las personas.

Los tipos sirven cuando describen una frontera

Lo que más valoro no es escribir tipos por todas partes. Es poder mirar la frontera de un módulo y entender qué entra, qué sale y qué cosas pueden fallar. Una firma honesta evita que cada persona tenga que reconstruir esas reglas leyendo la implementación o preguntando en Slack.

También evita errores bastante aburridos. Partial es un buen ejemplo cuando una operación admite cambios incompletos:

interface Producto {
  nombre: string;
  precio: number;
  stock: number;
}

function actualizar(id: string, cambios: Partial<Producto>) {
  // Solo llegan los campos que realmente cambiaron.
}

actualizar("prod-123", { precio: 29.99 });

No es una técnica sofisticada. Precisamente por eso me gusta. El tipo explica una operación cotidiana sin inventar otra jerarquía de interfaces.

En límites públicos intento ser todavía más deliberado. Prefiero Pick sobre Omit cuando decido qué datos exponer. Con Omit<Usuario, "password">, un campo sensible añadido mañana podría colarse sin que nadie revisara esa salida. Con Pick la lista permitida queda cerrada:

interface Usuario {
  id: string;
  nombre: string;
  email: string;
  passwordHash: string;
  notasInternas: string;
}

type PerfilPublico = Pick<Usuario, "id" | "nombre">;

Omit sigue siendo útil dentro de una aplicación. Solo desconfío de él cuando la ausencia de un campo es una decisión de seguridad o de contrato. En esos casos quiero declarar lo que sí sale, no mantener una lista de lo que espero recordar esconder.

Las uniones discriminadas me han dado una mejora parecida. En lugar de repartir booleanos y campos opcionales, puedo representar estados que de verdad existen:

type Resultado =
  | { estado: "cargando" }
  | { estado: "listo"; datos: string[] }
  | { estado: "error"; mensaje: string };

function resumen(resultado: Resultado) {
  switch (resultado.estado) {
    case "cargando": return "Cargando";
    case "listo": return `${resultado.datos.length} elementos`;
    case "error": return resultado.mensaje;
  }
}

El beneficio no es presumir que el código es “type-safe”. Es que un estado nuevo obliga a revisar los lugares que dependen de él. El compilador se convierte en una lista de pendientes bastante precisa.

El compilador no vigila la puerta

Hay una confusión que sigo encontrando: TypeScript no valida lo que llega por red, por un formulario, desde localStorage o desde un archivo. Sus tipos desaparecen al compilar. Si una API declara que devuelve Usuario, eso no hace que el JSON obedezca.

Por eso trato los datos externos como unknown. any apaga la pregunta; unknown me obliga a responderla antes de usar el valor.

function leerNombre(valor: unknown): string | undefined {
  if (
    typeof valor === "object" &&
    valor !== null &&
    "nombre" in valor &&
    typeof valor.nombre === "string"
  ) {
    return valor.nombre;
  }
}

En código real suelo usar una librería de esquemas cuando la estructura crece. El punto no es cuál librería. El punto es conservar la frontera: primero valido en tiempo de ejecución; después dejo que TypeScript cargue con el contexto dentro de la aplicación. Confundir ambas capas da una seguridad muy cómoda y muy falsa.

Esa claridad también ayuda a las herramientas. Un editor puede completar mejor, un refactor encuentra más lugares relevantes y un agente de código recibe pistas que no están escondidas en comentarios vagos. Pero no delego el diseño al sistema de tipos. Una interfaz enorme y mal nombrada sigue siendo una interfaz enorme y mal nombrada.

Migrar sin convertirlo en ceremonia

No creo en reescribir una aplicación estable solo para cambiarle la extensión a los archivos. Las reescrituras dramáticas acumulan riesgo y suelen mezclar dos trabajos: entender el sistema actual y reemplazarlo. Prefiero que TypeScript entre por las zonas que ya estoy tocando.

Las opciones allowJs y checkJs permiten incluir JavaScript y comprobarlo gradualmente. Se puede empezar por un módulo con una frontera clara, añadir anotaciones JSDoc donde aporten algo y convertir archivos cuando el costo tenga sentido. No hace falta detener el producto para declarar una nueva era.

Mi orden suele ser sencillo: activo comprobaciones donde hay cambios frecuentes, elimino los any que esconden decisiones importantes y dejo el resto para cuando tenga una razón concreta. La configuración más estricta puede llegar después. Encender todas las reglas el primer día y silenciar cientos de errores con aserciones no me parece progreso; solo cambia el lugar donde guardamos la deuda.

Hay buena documentación para recorrer esto sin adivinar: el manual de TypeScript, la guía de migración desde JavaScript y la referencia completa de opciones de TSConfig.

Una actualización pequeña desde el presente: al revisar esta nota el 28 de agosto de 2026, la versión estable más reciente que comprobé fue TypeScript 6.0.3; TypeScript 7 seguía en vista previa. Eso no era información disponible cuando publiqué el texto original y tampoco cambia mi argumento. Las versiones importan, pero la razón por la que sigo usando TypeScript es mucho menos espectacular.

Me evita equivocaciones normales. Hace visibles los contratos que antes vivían en la cabeza de alguien. Le da contexto útil a quien llega después, sea una persona o una herramienta. Y permite adoptar todo eso poco a poco, sin fingir que un compilador reemplaza la validación, las pruebas o el criterio.

Para mí, con eso basta.