Cómo aprobar una entrevista de TypeScript: las mejores preguntas de la A a la Z

Introducción: por qué TypeScript es un must have para el desarrollador moderno

TypeScript se ha consolidado como el estándar de facto en el desarrollo empresarial. Según las encuestas de Stack Overflow, más del 70% de los desarrolladores frontend usan o planean usar TypeScript. En las entrevistas, las preguntas sobre esta tecnología son inevitables, incluso si el puesto está formalmente etiquetado como "JavaScript Developer".

En este artículo, analizaremos los temas clave que seguramente te preguntarán en una entrevista técnica: desde tipos básicos hasta genéricos complejos y tipos condicionales. El material está estructurado de lo simple a lo complejo para que puedas prepararte de manera sistemática.

1. Base: tipos, interfaces y sus diferencias

1.1. Tipos primitivos y especiales

Empecemos con lo básico. El entrevistador casi con toda seguridad preguntará sobre any, unknown, never y void.

• any — desactiva la verificación de tipos. Se usa solo como último recurso durante la migración.
• unknown — una alternativa segura a any. Requiere verificación de tipo antes de su uso.
• never — un tipo que nunca ocurre (funciones que lanzan excepciones o bucles infinitos).
• void — ausencia de valor de retorno en una función.

function throwError(msg: string): never {    throw new Error(msg);}

function log(msg: string): void {    console.log(msg);}

let data: unknown = JSON.parse('{"name":"John"}');// data.name // ¡Error! Se necesita verificaciónif (typeof data === 'object' && data !== null) {    console.log((data as Record<string, unknown>).name);}

1.2. Interface vs Type: ¿cuál elegir?

Esta es una pregunta clásica. Ambos enfoques permiten describir la estructura de un objeto, pero hay matices:

• Interface — es extensible (extends), puede fusionarse (declaration merging).
• Type — puede describir tipos unión, intersección y primitivos. No admite declaration merging.

// Interface - extensióninterface User {    name: string;}interface User {    age: number; // declaration merging}const user: User = { name: 'Alice', age: 30 };

// Type - unióntype Status = 'active' | 'inactive';type UserOrStatus = User | Status;

Consejo: Para objetos y clases, usa interface; para composiciones complejas, usa type.

2. Genéricos y tipos utilitarios

2.1. Genéricos: programación genérica

Ninguna entrevista seria está completa sin genéricos. Saber escribir un tipo que se adapte al argumento pasado es una señal de madurez del desarrollador.

// Genérico simplefunction identity<T>(arg: T): T {    return arg;}

// Restricción de genéricofunction getLength<T extends { length: number }>(arg: T): number {    return arg.length;}

// Genérico para arrayfunction last<T>(arr: T[]): T | undefined {    return arr[arr.length - 1];}

A menudo preguntan sobre infer, la palabra clave para inferir tipos dentro de construcciones condicionales:

// Extraemos el tipo de elemento de Promisetype Unwrap<T> = T extends Promise<infer U> ? U : T;type Result = Unwrap<Promise<number>>; // number

2.2. Tipos utilitarios (Utility Types)

Conocer los utilitarios integrados es un mínimo obligatorio. El entrevistador puede pedirte que implementes un análogo manualmente.

• Partial<T> — todos los campos se vuelven opcionales.
• Required<T> — todos los campos son obligatorios.
• Pick<T, K> — selecciona solo las claves indicadas.
• Omit<T, K> — om