Cómo aprobar una entrevista de TypeScript: las mejores preguntas de nivel avanzado

Entrevista avanzada de TypeScript: cómo impresionar al empleador

TypeScript hace tiempo que dejó de ser simplemente una "superposición" sobre JavaScript. En las entrevistas modernas para puestos Senior, no solo se evalúa el conocimiento de tipos, sino también la capacidad de trabajar con tipos condicionales, mapeo, decoradores y el sistema de inferencia de tipos. En este artículo analizaremos 4 temas clave que te ayudarán a superar con confianza una entrevista técnica de TypeScript a nivel avanzado.

1. Tipos condicionales (Conditional Types) y la palabra clave infer

Los tipos condicionales permiten elegir uno de dos tipos basándose en una condición. Se construyen siguiendo el principio del operador ternario: T extends U ? X : Y. En una entrevista, podrían pedirte que escribas un tipo que extraiga el tipo de retorno de una función.

// Ejemplo: extracción del tipo de retorno de una funcióntype ReturnTypeExtract<T> = T extends (...args: any[]) => infer R ? R : never;

function greet(name: string): string {  return "Hello, " + name;}

type GreetReturn = ReturnTypeExtract<typeof greet>; // string

La palabra clave infer se utiliza dentro de los tipos condicionales para declarar una nueva variable de tipo. Permite "extraer" una parte de un tipo a partir de una estructura compleja. A menudo preguntan: "¿Qué es infer y dónde se aplica?". Respuesta: para extraer tipos de promesas, funciones, tuplas.

// Extracción del tipo de elemento de una Promisetype UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type Result = UnwrapPromise<Promise<number>>; // numbertype Result2 = UnwrapPromise<string>; // string

2. Tipos mapeados (Mapped Types) y modificadores readonly/optional

Los tipos mapeados permiten crear nuevos tipos iterando sobre las propiedades de un tipo existente. Es una herramienta potente para crear tipos utilitarios como Partial<T> o Readonly<T>. En una entrevista, podrían pedirte que implementes tu propio análogo de Pick<T, K>.

// Implementación propia de Picktype MyPick<T, K extends keyof T> = {  [P in K]: T[P];};

interface User {  id: number;  name: string;  email: string;}

type UserBasic = MyPick<User, 'id' | 'name'>;// { id: number; name: string }

Observa keyof T — es un operador que devuelve la unión de las claves de un objeto. En combinación con el mapeo, permite transformar tipos de manera flexible. También suelen preguntar sobre los modificadores readonly y ? (optional). Se pueden agregar o eliminar usando los prefijos + y -:

// Eliminación de readonly de todas las propiedadestype Mutable<T> = {  -readonly [P in keyof T]: T[P];};

type ImmutableUser = Readonly<User>;type MutableUser = Mutable<ImmutableUser>; // todos los campos vuelven a ser mutables

3. Decoradores y su tipificación

Los decoradores son una característica experimental de TypeScript que se utiliza activamente en Angular y NestJS. En una entrevista, podrían preguntarte cómo tipificar un decorador de clase o método. Es importante entender que un decorador es simplemente una función que recibe el objeto objetivo y lo devuelve (o uno nuevo).

// Decorador de clase con tipificaciónfunction Logger<T extends { new (...args: any[]): {} }>(constructor: T) {  console.log(`Class ${constructor.name} created`);  return class extends constructor {    constructor(...args: any[]) {      super(...args);      console.log('Instance created');    }  };}

@Loggerclass MyService {  constructor(public name: string) {}}

const service = new MyService('Test'); // En consola: "Class MyService created", luego "Instance created"

En preguntas avanzadas, podrían pedirte que implementes un decorador que agregue metadatos o validación. Observa el uso de genéricos — <T extends { n