TypeScript — Entrevista
Fuente: Generado con prompts/generar-mazo.md
typescripttiposfrontend
Tarjetas
¿Qué es el structural typing?
TS compara por FORMA, no por nombre: si un objeto tiene las propiedades que el tipo pide, asigna. Dos tipos con distinto nombre e igual estructura son intercambiables.
¿type vs interface?
`type` define cualquier forma (uniones, intersecciones, primitivas, condicionales). `interface` solo objetos, pero es extendible por declaración (`extends` y merging).
¿unknown vs any?
`any` apaga el checker por completo. `unknown` es "cualquier cosa, pero verificá antes de usar": no se puede usar sin narrow primero.
¿Qué son las discriminated unions y qué problema matan?
Uniones donde un campo literal (`type: "success" | "error"`) separa las variantes. El checker narrow automáticamente por ese campo.
¿Qué hace `satisfies`?
Verifica que un valor cumpla un tipo SIN ensancharlo ni ensuciarlo: `const config = {...} satisfies Config` — error si viola, pero el tipo inferido se conserva.
¿Para qué sirve `never`?
El tipo de lo imposible: el valor que no puede existir. Aparece en funciones que tiran/loopean siempre, y en el fondo agotado de una unión.
¿Cómo funciona el narrowing?
TS estrecha el tipo por control flow: checks de `typeof`, igualdad con literales, `in`, `instanceof`, early returns y type guards.
¿Qué ganan los genéricos vs usar `any`?
`T` preserva la relación entrada↔salida: `identity<T>(x: T): T` devuelve lo mismo que entró, y el checker lo sabe.
¿Qué resuelven los utility types (Partial, Pick, Omit)?
Derivar tipos de otros sin redeclarar: `UpdateUserDTO = Partial<Pick<User, "nombre" | "email">>`.
¿Qué hace `as const`?
Congela un literal: propiedades `readonly` y valores con el tipo literal exacto (`"GET"` en vez de `string`).
¿Qué es la erasure de tipos y cuál es su límite?
TS borra todo tipo al compilar a JS: los tipos existen solo en compile-time. No podés chequear un tipo en runtime.
¿Qué es una conditional type y cuándo se justifica?
Un tipo que bifurca por otra condición: `T extends string ? ... : ...`. El checker resuelve la rama por sustitución.
¿Qué garantiza `strict: true` y por qué no negarse?
Prende toda la familia de checks estrictos: `strictNullChecks`, `noImplicitAny`, `functionBoundChecks`, etc.
¿keyof e indexed access — para qué sirven?
`keyof T` es la unión de las keys de T; `T["k"]` el tipo de esa key. Juntos hacen tipos que siguen la forma de otro.
¿Qué garantía real da `readonly` y dónde termina?
Solo compile-time: bloquea reasignación/mutación en código tipado, pero no congela nada en runtime ni protege de alias mutables.
¿Qué problema resuelven `?.` y `??` que `&&` y `||` no?
`?.` recorre una ruta profunda cortando en nullish sin crash; `??` aplica el default SOLO con null/undefined, no con cualquier falsy.
¿Namespaces o modules — por qué ganaron los modules?
Modules (`import`/`export`) para todo código moderno; los namespaces son el agrupamiento de la era pre-ESModules.
¿Qué son los `.d.ts` y los paquetes `@types/...`?
Declaraciones sin implementación: describen la superficie pública de código JS para que el checker lo entienda. `@types/*` (DefinitelyTyped) las provee para libs que no traen tipos propios.
¿Cuándo una tuple y no un array?
Cuando la posición es contrato: longitud fija y un tipo por índice (`[string, number]`), vs el array de cantidad abierta y un solo tipo.
¿`import type` vs `import` — cuándo hace falta?
`import type { User }` trae solo el tipo: TS lo borra entero del output. El import común puede dejar código del módulo ejecutando en el bundle final.
¿target, lib y module en tsconfig — qué decide cada uno?
`target` = sintaxis del JS emitido; `lib` = qué APIs se asume que existen en runtime; `module` = formato de módulos del output.
¿Function overloads o parámetros con unión — cuándo cada uno?
Overloads cuando el retorno depende de la combinación de argumentos (`(x: string) → number`, `(x: number) → string`); unión cuando el cuerpo maneja todas las variantes igual.
¿Qué son los mapped types y qué hacen los modifiers `?` y `-?`?
Un tipo que transforma propiedad por propiedad: `{ [K in keyof T]: ... }`. Los modifiers agregan (`?`, `readonly`) o quitan (`-?`, `-readonly`) rasgos de a uno.
¿Para qué sirve el default de un genérico (`T = X`)?
Cubre el caso común sin parámetro: `Resp<T = Datos>` se escribe `Resp` a secas, y quien necesita otro tipo lo pasa explícito.
¿void vs undefined como return type?
`void` = "ignorá el retorno"; `undefined` = "devuelve undefined, y ese valor puede importarle a alguien".
¿Enum o unión de literales — cuándo cada uno?
Unión de literales para valores que viven solo en tipos; enum únicamente si necesitás el objeto en runtime (iterar constantes, agruparlas).
¿Qué papel cumple `infer` en una conditional type?
Nombra y captura un tipo dentro del match: `T extends Promise<infer U> ? U : never` destila la U de la promesa.
¿Qué resuelven los template literal types?
Arman tipos string por composición: `` `hola ${Nombre}` `` expande la unión de nombres en la unión de saludos exactos.
¿Qué es un branded type y cuándo se justifica?
Un primitivo con marca fantasma: `type UserId = string & { __brand: "UserId" }` — estructuralmente string, pero ya no intercambiable con cualquier otro string.
¿Qué es una assertion function (`asserts x is T`)?
Una función que, si no tira, estrecha el argumento hacia adelante: `assertEsUser(x)` y de ahí en más `x` es `User`.
¿Qué cambia un const type parameter (`<T extends const>`)?
La inferencia del argumento se vuelve literal y readonly sin que cada callsite escriba `as const`.
¿Por qué useUnknownInCatchVariables — qué rompía el any del catch?
Con el flag, `catch (e)` da `unknown`: hay que narrow antes de `e.message`. Antes, el `any` dejaba tocar cualquier propiedad de cualquier throw.
¿`object` o `Record<string, unknown>` para "un objeto cualquiera"?
`Record<string, unknown>`: deja leer cada propiedad previo narrow. `object` solo excluye primitivas — después no podés acceder a nada sin cast.
¿Qué significan las variance annotations `in` y `out`?
`in` marca contravarianza (T se consume), `out` covarianza (T se produce): `interface Fuente<out T> { leer(): T }`.