Cómo aprobar una entrevista de TypeScript: preguntas principales

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Cómo pasar una entrevista de TypeScript: preguntas principales

TypeScript se ha consolidado firmemente como una de las herramientas más demandadas en el desarrollo web moderno. Si te estás preparando para una entrevista técnica, conocer los fundamentos y las capacidades avanzadas de TypeScript es un requisito obligatorio. En este artículo, analizaremos las principales preguntas que suelen hacer en las entrevistas y daremos ejemplos de código para afianzar el material.

1. Tipos básicos y sus diferencias con JavaScript

En la entrevista seguramente te preguntarán sobre los tipos básicos de TypeScript y su comportamiento. La principal diferencia con JavaScript es la tipificación estática. Veamos los puntos clave.

1.1. Tipos primitivos: `string`, `number`, `boolean`

TypeScript añade anotación explícita de tipos. Por ejemplo:

let name: string = 'Ana';let age: number = 30;let isActive: boolean = true;

Sin anotación, TypeScript infiere el tipo automáticamente (type inference).

1.2. Tipo `any` y `unknown`

any desactiva la comprobación de tipos — es mejor evitarlo. unknown es una alternativa segura, requiere comprobación antes de usarlo:

let data: unknown = 'cadena';// console.log(data.toUpperCase()); // ¡Error!if (typeof data === 'string') {  console.log(data.toUpperCase()); // Ok}

1.3. `never` y `void`

void — la función no devuelve nada.
never — la función nunca termina (lanza un error o bucle infinito).

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

2. Interfaces y tipos (`interface` vs `type`)

Esta es una de las preguntas más frecuentes. Ambos mecanismos permiten describir la estructura de objetos, pero tienen diferencias.

2.1. Cuándo usar `interface`

Para declarar contratos de objetos y clases.
Posibilidad de extensión (declaration merging):

interface User {  name: string;}interface User {  age: number;}// User ahora contiene name y age

2.2. Cuándo usar `type`

Para uniones (union), intersecciones (intersection) y alias primitivos.
No soporta declaration merging.

type Status = 'active' | 'inactive';type Person = { name: string } & { age: number };

Pregunta de entrevista: «¿Se puede reemplazar interface por type?» — Sí, pero para clases y extensión es mejor interface.

3. Genéricos (Generics)

Los genéricos permiten crear componentes reutilizables que funcionan con cualquier tipo. Son imprescindibles para posiciones senior.

3.1. Función genérica simple

function firstElement<T>(arr: T[]): T {  return arr[0];}const num = firstElement([1, 2, 3]); // numberconst str = firstElement(['a', 'b']); // string

3.2. Restricciones de genéricos (extends)

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {  return obj[key];}const user = { name: 'Iván', age: 25 };console.log(getProperty(user, 'name')); // Iván

3.3. Genéricos en interfaces

interface Repository<T> {  getById(id: number): T;  save(item: T): void;}

A menudo preguntan: «¿Para qué sirven los genéricos si existe any?» — Los genéricos mantienen la seguridad de tipos.

4. Utility Types y capacidades avanzadas

Los tipos utilitarios incorporados (Partial, Required, Pick, Omit) son indicadores de un profundo conocimiento de TypeScript.

4.1. `Partial` y `Required`

interface Task {  title: string;  done: boolean;}const partialTask: Partial<Task> = { title: 'Tarea' };const requiredTask: Required<Task> = { title: 'Tarea', done: false };