Las entrevistas de TypeScript evalúan si entiendes el sistema de tipos, más allá de la sintaxis. A continuación tienes 20 preguntas con respuestas, desde lo básico hasta las que separan a quienes usan TypeScript de quienes saben por qué funciona. El código se compiló con el compilador de TypeScript en modo estricto antes de publicarse, y los mensajes de error citados son los reales.
Fundamentos
1. ¿Qué aporta TypeScript a JavaScript?
Un sistema de tipos estático que se verifica en tiempo de compilación y luego se borra. El resultado es JavaScript puro, así que los tipos no tienen costo ni presencia en tiempo de ejecución. Ese último punto importa: no puedes comprobar un tipo con typeof en tiempo de ejecución a menos que escribas la comprobación tú mismo.
2. ¿Cuál es la diferencia entre type e interface?
Ambos describen la forma de un objeto y a menudo son intercambiables. Las diferencias prácticas:
| interface | type | |
|---|---|---|
| Fusión de declaraciones | Sí, dos declaraciones se fusionan | No, un nombre duplicado es un error |
| Uniones y primitivos | No puede expresarlos | Puede expresarlos, como una unión de number y string |
| Extensión | extends | Intersección con & |
| Tipos mapeados y condicionales | No | Sí |
Declarar interface A dos veces fusiona los campos. Declarar type B dos veces produce error TS2300: Duplicate identifier 'B'. Una regla general habitual: usa interface para formas de objeto públicas que otros puedan extender, y type para todo lo demás.
3. ¿Cuál es la diferencia entre any, unknown y never?
- any desactiva la comprobación. Todo vale y los errores se ocultan.
- unknown es la versión segura. Puedes asignarle cualquier cosa, pero debes acotarlo antes de usarlo. Llamar a x.toFixed() sobre un unknown falla con error TS18046: 'x' is of type 'unknown'.
- never es el tipo de los valores que no pueden existir, como una función que siempre lanza una excepción. Es útil para comprobaciones exhaustivas.
Prefiere unknown antes que any para valores cuyo tipo no controlas, como un JSON parseado.
4. ¿Qué hace el modo strict?
Activa un grupo de comprobaciones, entre las más importantes strictNullChecks (de modo que null y undefined son tipos separados) y noImplicitAny. Con él activado, usar un valor opcional sin comprobarlo da error TS18048: 'x' is possibly 'undefined'. Los proyectos nuevos deberían empezar con strict activado.
5. ¿Cuál es la diferencia entre readonly y const?
const impide reasignar una variable. readonly impide asignar una propiedad. Escribir en una propiedad readonly da error TS2540: Cannot assign to 'n' because it is a read-only property. Ninguno de los dos hace que el objeto subyacente sea profundamente inmutable.
Tipos en la práctica
6. ¿Qué son los tipos unión y cómo se acotan?
Una unión significa "uno de estos tipos". La acotación (narrowing) usa comprobaciones que el compilador entiende:
type Id = number | string;
function describe(id: Id): string {
if (typeof id === "string") return id.toUpperCase();
return id.toFixed(1);
}
Dentro del if, id es un string. Después, el compilador sabe que es un number. Otras herramientas de acotación son instanceof, el operador in, las comparaciones de igualdad y los type guards personalizados.
7. ¿Qué es una unión discriminada?
Una unión en la que cada miembro tiene un campo literal compartido, el discriminante, que los distingue:
type Shape =
| { kind: "circle"; r: number }
| { kind: "sq"; s: number };
function assertNever(x: never): never {
throw new Error("unexpected " + x);
}
function area(s: Shape): number {
switch (s.kind) {
case "circle": return Math.PI * s.r ** 2;
case "sq": return s.s ** 2;
default: return assertNever(s);
}
}
Si más adelante añades una forma nueva y olvidas un case, la rama default deja de compilar, porque s ya no es never. Eso es una comprobación exhaustiva.
8. ¿Qué son los genéricos y por qué usarlos?
Permiten que una función o un tipo opere sobre muchos tipos manteniendo la relación entre ellos:
function first<T>(xs: T[]): T | undefined { return xs[0]; }
function pick<T, K extends keyof T>(o: T, k: K): T[K] { return o[k]; }
first([1, 2]) devuelve number | undefined, no any. pick(user, "name") devuelve el tipo de name. La restricción extends keyof T evita que pases una clave que no existe.
9. ¿Cuáles son los utility types más comunes?
| Utility | Qué hace |
|---|---|
| Partial<T> | Hace opcionales todas las propiedades |
| Required<T> | Hace obligatorias todas las propiedades |
| Readonly<T> | Hace readonly todas las propiedades |
| Pick<T, K> | Conserva solo las claves indicadas |
| Omit<T, K> | Elimina las claves indicadas |
| Record<K, V> | Un tipo de objeto con claves K y valores V |
| ReturnType<F> | El tipo de retorno de un tipo de función |
10. ¿Qué son los tipos mapeados?
Construyen un tipo nuevo recorriendo las claves de otro. Partial en sí mismo se escribe como { [K in keyof T]?: T[K] }. Saber eso demuestra que entiendes los utility types en lugar de memorizarlos.
11. ¿Qué es as const?
Le indica al compilador que infiera el tipo más estrecho y marque todo como readonly. const arr = [1, 2, 3] as const tiene el tipo readonly [1, 2, 3], y arr.push(4) falla con error TS2339: Property 'push' does not exist on type 'readonly [1, 2, 3]'. Es útil para listas de valores permitidos y para objetos de configuración.
12. ¿Qué es una aserción de tipo y cuándo es peligrosa?
value as Type le dice al compilador que confíe en ti. No realiza ninguna comprobación en tiempo de ejecución. Si te equivocas, el error aparece más tarde en forma de fallo. Prefiere acotar con una comprobación, o una función type guard, antes que usar una aserción.
Comportamiento del lenguaje
13. ¿Cuál es la diferencia entre null y undefined?
undefined significa que nunca se asignó un valor, y null significa que se estableció "sin valor" a propósito. Con strictNullChecks, son tipos separados. Usa encadenamiento opcional (a?.b) y coalescencia nula (a ?? b) para manejarlos. A diferencia de ||, ?? solo recurre al valor por defecto para null y undefined, así que 0 y la cadena vacía se conservan.
14. ¿Qué es la aserción de no-nulo !?
value! le dice al compilador que un valor no es null ni undefined. Al igual que as, no está verificada. Está bien en algunos casos donde sabes más que el compilador, pero una verificación en tiempo de ejecución suele ser más segura.
15. ¿Qué hace keyof, y qué es typeof en una posición de tipo?
keyof T produce la unión de los nombres de las propiedades de T. En una posición de tipo, typeof x toma el tipo de un valor, lo que evita repetirlo. Juntos, keyof typeof obj da las claves de un objeto que definiste como valor.
16. ¿Cómo se comparan los enums con los tipos unión?
Los enums crean un objeto en tiempo de ejecución y valores. Una unión de literales de cadena, como "idle" | "loading", se elimina en tiempo de compilación y no necesita código extra. Muchos equipos prefieren las uniones de literales de cadena por su simplicidad y usan enums cuando necesitan el objeto en tiempo de ejecución.
Herramientas y proyectos reales
17. ¿Qué hace tsconfig.json, y qué opciones importan?
Le indica al compilador qué archivos incluir y cómo verificarlos. Opciones por las que preguntan los entrevistadores: strict, target (la versión de JavaScript a emitir), module y moduleResolution, noEmit (solo verificar, lo cual es común cuando otra herramienta compila), esModuleInterop y skipLibCheck.
18. ¿Cómo tipas algo que viene de afuera, como la respuesta de una API?
Los tipos desaparecen en tiempo de ejecución, así que el compilador no puede verificar lo que devuelve la red. Trata los datos como unknown y luego valídalos con una librería de esquemas o un type guard escrito a mano antes de usarlos. Asertar un tipo sobre un JSON parseado oculta errores.
19. ¿Cómo migras un proyecto de JavaScript a TypeScript?
Hazlo de forma gradual. Agrega un tsconfig.json con allowJs, renombra los archivos de a uno, activa opciones más estrictas con el tiempo y agrega tipos primero en los límites, como los clientes de API y las utilidades compartidas. Evita una reescritura total de una sola vez.
20. ¿Qué es el tipado estructural?
TypeScript compara los tipos por su forma, no por su nombre. Si un objeto tiene los campos que un tipo requiere, se acepta, aunque nunca se haya declarado como ese tipo. Es diferente de los lenguajes que usan tipado nominal, donde el nombre declarado importa.
Cómo prepararte
- Abre un playground o un proyecto pequeño en modo estricto y prueba cada ejemplo de arriba, incluidos los que deberían fallar.
- Prepárate para escribir una función genérica y una unión discriminada de memoria.
- Conoce por qué elegirías unknown en lugar de any.
- Prepara una historia sobre cómo tipaste algo complicado en un proyecto real.
Para práctica relacionada, consulta nuestras guías de preguntas de entrevista de Node.js, preguntas de entrevista de Angular y preguntas de entrevista de Python.
Practica en voz alta y con tus propias palabras. Una transcripción posterior muestra dónde divagaste o te saltaste el punto. Sigue las reglas del empleador sobre herramientas de IA en cualquier entrevista o evaluación en vivo.
Practica tus respuestas con YesToTheOffer
Ensaya en voz alta, obtén respuestas creadas a partir de tu propio currículum y revisa tu transcripción después. 30 minutos gratis, sin suscripción.
