Curso de Programación Tipada con TypeScript

Pasá de JavaScript suelto a una API REST tipada con TypeScript

Al finalizar el curso vas a tener una API REST en Node.js y Express construida con TypeScript de punta a punta: modelos de datos, servicios, controladores, validación y manejo de errores, todo con tipado estricto. Lo hacés acompañado en grupos reducidos de máximo 6 personas, con feedback constante sobre tu código y una base sólida para cualquier stack moderno basado en TypeScript.

Métricas del curso

  • 150+

    10 clases en vivo (2 h cada una)

  • 10+

    Proyecto final: API REST full TypeScript

  • Grupos reducidos (máx. 6 personas por cohorte)

  • Certificado de finalización del curso de TypeScript y APIs

Inscripción a los cursos de programación

Elegí tu camino: frontend, backend o full stack. Inscribite en los cursos online en vivo y empezá a construir proyectos profesionales en grupos reducidos. Ver próximas fechas

No hay cohortes disponibles por el momento. Consultá por WhatsApp las próximas fechas para cursar programación.

Curso de TypeScript De JavaScript a APIs Tipadas

Este curso está pensado para quienes ya escriben algo de JavaScript y quieren llevar su código al siguiente nivel usando TypeScript. Vas a aprender a tipar correctamente funciones, modelos de datos y APIs, hasta llegar a una API REST con Node.js y Express completamente tipada. Las clases se dictan en grupos reducidos de hasta 6 personas, con revisión de tu código en vivo y devoluciones personalizadas en cada módulo.

  • Personas que conocen lo básico de JavaScript y quieren sumar TypeScript para escribir código más seguro y profesional.
  • Desarrolladores frontend o backend junior que necesitan fortalecer el sistema de tipos antes de entrar a stacks más complejos.
  • Perfiles que participan en el diseño de APIs (tech leads, arquitectos, seniors) y quieren definir contratos tipados claros entre equipos.
  • Equipos que desean estandarizar el uso de TypeScript en sus proyectos, mejorando calidad, mantenibilidad y experiencia de desarrollo.

MODALIDAD

¿Cómo vas a aprender TypeScript en este curso?

Aprendés TypeScript en clases online en vivo, escribiendo código desde el primer encuentro y avanzando hasta una API REST real. Cada cohorte tiene como máximo 6 personas, lo que permite revisar tus tipos, detectar malos olores en el código y acompañar tu proceso de migración de JavaScript a TypeScript paso a paso.

Clases en vivo enfocadas en código real

Sesiones prácticas donde tipeamos modelos, funciones y APIs juntos, analizamos errores del compilador y refactorizamos código en vivo.

Clases en vivo del curso

Repositorio y recursos de apoyo

Acceso a repositorios de ejemplo, snippets reutilizables y guías para seguir practicando TypeScript y Node.js entre clase y clase.

Contenido on demand del curso

Temario del Curso de TypeScript (de Cero a APIs con Node.js)

En este curso de TypeScript vas a pasar de conocer el tipado estático básico a construir una API REST completa con Node.js y Express totalmente tipada. Trabajamos el sistema de tipos en profundidad: tipos primitivos y literales, interfaces, type aliases, funciones genéricas, manejo de errores, módulos y programación orientada a objetos. Cerramos integrando Fetch/Axios, validación de datos y un proyecto final de API productiva. Todo en grupos reducidos de máximo 6 personas, con correcciones en vivo sobre tu código.

Introducción a TypeScript y Tipado Estático

  • Ventajas de TypeScript frente a JavaScript: feedback temprano, autocompletado y refactors seguros.

  • Instalación, configuración básica del compilador tsc y archivo tsconfig.json.

  • Primeros tipos: string, number, boolean, any y reglas de asignación.

Inicialización de un proyecto TypeScript desde cero con script de compilación listo para usar.

Tipos Primitivos, Literales y Type Narrowing

  • Repaso de tipos primitivos y literales para valores específicos ("success" | "error", etc.).

  • Uniones y type narrowing usando typeof, in, instanceof y chequeos personalizados.

  • Buenas prácticas para evitar any y mantener el tipado explícito pero práctico.

Modelado de un pequeño flujo de estados con tipos literales y funciones que hacen narrowing correctamente.

Interfaces, Tipos Personalizados y Type Aliases

  • Definir contratos de datos con interface y type para objetos y colecciones.

  • Propiedades opcionales, de solo lectura y composición con extends e intersecciones.

  • Patrones comunes para tipar DTOs, respuestas de APIs y configuraciones.

Modelo de dominio tipado para una mini aplicación (usuarios, productos o cursos) usando interfaces y type aliases.

Funciones Tipadas, Parámetros Opcionales y Genéricos

  • Funciones con parámetros obligatorios, opcionales y valores por defecto.

  • Firma de funciones, tipos de retorno, funciones que nunca retornan (never) y callbacks tipados.

  • Introducción a genéricos: funciones y utilidades que funcionan con múltiples tipos sin perder seguridad.

Pequeña librería de utilidades genéricas (filtros, búsquedas, helpers de lista) full TypeScript.

Módulos, Namespaces y Organización de Código

  • Importación y exportación con módulos ES y módulos comunes en proyectos TypeScript.

  • Separación por capas y responsabilidades: archivos, carpetas y convenciones de nombres.

  • Uso razonable de namespaces y declaración de tipos globales cuando realmente hace falta.

Refactor de la librería creada en módulos organizados, listos para ser reutilizados en otros proyectos.

Manejo de Errores, Never y Exhaustividad

  • Errores en TypeScript: tipos para Error, manejo con try/catch y propagación segura.

  • Uso del tipo never para asegurar que un switch es exhaustivo y no quedan casos sin manejar.

  • Patrones de resultado (Result<T, E>) y manejo explícito de éxito/error.

Módulo de servicios con manejo de errores exhaustivo y tipado que obliga a tratar los casos fallidos.

Programación Orientada a Objetos con TypeScript

  • Clases, constructores y propiedades con modificadores de acceso (public, private, protected).

  • Interfaces para contratos de clases, herencia y composición.

  • Clases abstractas, métodos estáticos y patrones simples aplicados a servicios de aplicación.

Diseño de un pequeño dominio orientado a objetos (por ejemplo, carrito de compras) implementado en TypeScript.

Working with APIs: Fetch, Axios y Tipado de Respuestas

  • Consumo de APIs REST usando fetch y Axios en proyectos TypeScript.

  • Tipado de requests y responses: DTOs, parámetros de ruta/query y body.

  • Manejo tipado de errores, estados de carga y respuestas parciales u opcionales.

Módulo de cliente HTTP fuertemente tipado que centraliza llamadas a una API externa.

Integración con Node.js, Express y Validación de Datos

  • Creación de un proyecto backend con Node.js, Express y TypeScript desde cero.

  • Rutas, controladores y middlewares completamente tipados (req, res, next).

  • Validación de datos de entrada con librerías como Zod o class-validator y tipos seguros en el controlador.

API REST básica con endpoints de ejemplo (usuarios, productos o cursos) tipada de punta a punta y validada.

Proyecto Final: API Tipada Full TypeScript

  • Diseño de la API final: recursos, endpoints, modelos de datos y relaciones.

  • Implementación de casos de uso reales: creación, listado, actualización y borrado con validaciones.

  • Buenas prácticas para desplegar una API TypeScript (scripts de build, variables de entorno y estructura productiva).

Construcción de una API CRUD completa en TypeScript con tipado estricto, módulos organizados y validación de datos lista para producción.
¿Necesito ser experto en JavaScript para tomar este curso?No necesitas ser experto, pero sí tener conocimientos sólidos de los fundamentos (variables, funciones, objetos, arrays). TypeScript se construye sobre JavaScript, así que cuanto mejor sea tu base de JS, más rápido aprenderás TS.
¿Por qué debería aprender TypeScript si ya sé JavaScript?Porque TypeScript te da seguridad. Evita el 90% de los errores comunes ('undefined is not a function') antes de ejecutar el código, mejora el autocompletado y hace que tu código sea mucho más fácil de mantener en equipos.
¿Qué es exactamente el 'tipado estático'?Significa que definimos los tipos de datos (string, number, etc.) mientras escribimos el código, y no en tiempo de ejecución. Esto permite que el compilador nos avise de errores antes de que el usuario use la aplicación.
¿El navegador entiende TypeScript?No. TypeScript debe ser 'transpilado' (traducido) a JavaScript estándar para que el navegador o Node.js puedan ejecutarlo. En el curso aprendemos a configurar este proceso con `tsc`.
¿Cuál es la diferencia entre `interface` y `type`?Es la pregunta clásica. Ambos sirven para definir estructuras, pero las `interfaces` son mejores para objetos y son extensibles (POO), mientras que los `types` son más flexibles para uniones, intersecciones y primitivos.
¿Qué es el tipo `any` y por qué debemos evitarlo?`any` desactiva el chequeo de tipos de TypeScript. Usarlo convierte tu código básicamente en JavaScript inseguro. Enseñamos a usarlo solo como último recurso o durante migraciones.
¿Qué son los Genéricos (`Generics`)?Son como 'variables para tipos'. Permiten crear componentes o funciones que funcionan con varios tipos de datos sin perder la seguridad del tipado. Son fundamentales para escribir código reutilizable.
¿Este curso sirve para Frontend o Backend?Para ambos. TypeScript es el lenguaje. Sin embargo, el proyecto final se enfoca en el **Backend** (crear una API con Node.js), lo cual te da una comprensión profunda de cómo manejar datos estrictos.
¿Qué es `tsconfig.json`?Es el archivo de configuración del proyecto. Define qué tan estricto será TypeScript, a qué versión de JavaScript vamos a compilar y dónde se guardarán los archivos generados.
¿Vemos Programación Orientada a Objetos (POO)?Sí. TypeScript mejora mucho la POO de JavaScript agregando modificadores de acceso (`public`, `private`, `protected`) y clases abstractas. Lo veremos aplicado a servicios.
¿Qué es el 'Type Narrowing'?Es el proceso de reducir un tipo amplio (como `string | number`) a uno más específico dentro de un bloque de código, usando condicionales como `typeof` o `instanceof`.
¿Cómo integro TypeScript con Express?Aprenderemos a instalar los tipos de Express (`@types/express`) para tener autocompletado en `req`, `res` y `next`, asegurando que no accedamos a propiedades que no existen.
¿Qué es Zod y para qué lo usamos?Es una librería de validación de esquemas. La usamos para validar que los datos que llegan a nuestra API (el `body` del request) coincidan con los tipos que espera TypeScript en tiempo de ejecución.
¿Qué es un DTO (Data Transfer Object)?Es un objeto que define cómo se envían los datos a través de la red. En TypeScript, usamos clases o interfaces para asegurar que lo que enviamos y recibimos tenga la forma correcta.
¿Es muy difícil configurar el entorno de TypeScript?Al principio puede intimidar, pero dedicamos el primer módulo a entender cómo instalar Node, Typescript y configurar el compilador para que tengas un entorno listo para trabajar.
¿Qué es el tipo `unknown`?Es la versión segura de `any`. Te obliga a verificar qué tipo de dato es antes de usarlo. Es una de las mejores prácticas que enseñamos para manejar datos externos.
¿Qué pasa con las librerías que no tienen tipos?Aprenderemos a buscar paquetes en `DefinitelyTyped` (los famosos `@types/nombre-libreria`) o, en el peor de los casos, a declarar nuestros propios archivos de definición `.d.ts`.
¿Usamos Fetch o Axios?Vemos ambos, pero nos enfocamos en cómo tipar las respuestas. El desafío no es la herramienta, sino decirle a TypeScript qué estructura de datos nos devuelve la API.
¿Qué es la inferencia de tipos?Es la capacidad de TypeScript de 'adivinar' el tipo de una variable por su valor inicial. Aprenderemos cuándo confiar en la inferencia y cuándo ser explícitos.
¿Qué son los Union Types?Permiten que una variable pueda ser de varios tipos (ej: `string | null`). Son vitales para manejar estados de carga o errores en aplicaciones reales.
¿Sirve este curso si uso React?Totalmente. Los fundamentos de TypeScript (props, interfaces, genéricos) son exactamente los mismos en React. Entender TS puro te hará un mejor desarrollador de React.
¿Qué es el 'Strict Mode'?Es una configuración en `tsconfig` que activa todas las comprobaciones de seguridad. En el curso trabajamos en modo estricto para acostumbrarnos a los estándares de la industria.
¿Cómo se manejan los errores en TypeScript?Vemos cómo tipar el bloque `catch` (que por defecto es `unknown`) y cómo crear clases de Error personalizadas para tener un control total del flujo de fallos.
¿Qué son los 'Utility Types' (Partial, Pick, Omit)?Son herramientas integradas de TS para transformar tipos existentes. Por ejemplo, `Partial<User>` hace que todas las propiedades de Usuario sean opcionales. Ahorran mucho código.
¿Qué es el tipo `never`?Representa valores que nunca ocurren (como una función que lanza un error infinito). Lo usamos para asegurar la 'exhaustividad' en los `switch` case.
¿Vemos bases de datos?El foco es TypeScript y la API. Usaremos datos en memoria o JSON para simular la base de datos, enfocándonos en cómo tipar los modelos y las respuestas.
¿Qué es un 'Tuple'?Es un array con un número fijo de elementos y tipos conocidos en cada posición. Muy útil para devolver múltiples valores desde una función.
¿Cómo afecta TypeScript al rendimiento?No afecta en nada en producción, porque el código final es JavaScript puro. Solo añade un paso de compilación durante el desarrollo.
¿Qué es 'Module Resolution'?Es cómo TypeScript encuentra los archivos cuando haces un `import`. Veremos cómo organizar carpetas y configurar alias (`@app/...`) para evitar rutas relativas largas.
¿Hacemos testing?No es un curso de testing, pero un código bien tipado es mucho más fácil de testear. Las interfaces que creamos sirven de base perfecta para tests unitarios futuros.
¿Qué son los Decoradores?Son una característica avanzada usada en frameworks como NestJS o Angular. Los explicamos conceptualmente al ver Clases, aunque en Express puro se usan menos.
¿Qué es el 'Optional Chaining' (`?.`)?Es una sintaxis que permite acceder a propiedades anidadas sin romper la app si un objeto intermedio es `null` o `undefined`. TypeScript lo maneja nativamente.
¿Qué es un archivo `.d.ts`?Son archivos de declaración. Solo contienen tipos, no código lógico. Sirven para describir librerías de JS existentes para que TS las entienda.
¿Por qué usar `const` en lugar de `let` ayuda al tipado?Porque `const` permite a TypeScript inferir tipos literales más estrictos (ej: el valor exacto "hola" en lugar de solo `string`), lo que mejora la seguridad.
¿Qué son los 'Type Guards'?Son funciones que retornan un booleano y le dicen al compilador: 'si esto es true, entonces la variable es de este tipo específico'.
¿Puedo migrar un proyecto JS a TS progresivamente?Sí. Enseñamos estrategias para configurar TS de forma permisiva al inicio e ir endureciendo las reglas a medida que migras archivo por archivo.
¿Qué es `Nodemon` con TypeScript?Usaremos `ts-node-dev` o herramientas similares para tener 'Hot Reload': que el servidor se reinicie automáticamente y recompile cuando guardamos cambios.
¿Es TypeScript más verboso (más código)?Escribes un poco más al definir tipos, pero escribes mucho menos al debuggear y arreglar errores. A la larga, ahorra tiempo y líneas de código defensivo.
¿Qué es la intersección de tipos (`&`)?Permite combinar múltiples tipos en uno solo. Por ejemplo, crear un tipo `AdminUser` uniendo las propiedades de `User` y `Admin`.
¿Qué proyecto final hacemos?Construimos una API REST completa (ej: gestión de cursos o productos) con rutas, controladores, validación de datos y manejo de errores, todo 100% tipado.
¿Vemos `async` y `await`?Sí. TypeScript maneja promesas de forma excelente. Aprenderemos a tipar el valor de retorno de una función asíncrona (`Promise<T>`).
¿Qué es el 'Duck Typing'?TypeScript usa 'tipado estructural'. Si un objeto tiene forma de pato, camina como pato y grazna como pato, TypeScript lo acepta como pato, aunque no se llame 'Pato'.
¿Qué son los Enums?Una forma de definir un conjunto de constantes con nombre. Veremos cuándo usarlos y cuándo es mejor usar uniones de strings literales.
¿Vemos variables de entorno en TS?Sí. Aprenderemos a crear un archivo de definición para `process.env` para que TS sepa qué variables de entorno existen y de qué tipo son.
¿Qué es la sobrecarga de funciones (Overloading)?Permite definir múltiples firmas para una misma función, de modo que pueda comportarse distinto según los argumentos que reciba.
¿Necesito saber Linux?No, pero usar la terminal es esencial. Usaremos comandos de npm y del compilador tsc constantemente.
¿Qué es `readonly`?Una propiedad de TS que hace que un campo de un objeto o clase no se pueda modificar después de su creación. Ideal para programación funcional.
¿Cómo se maneja `null` y `undefined`?En modo estricto, TS no te deja asignar `null` a menos que lo declares explícitamente. Esto elimina el famoso error 'Cannot read property of null'.
¿Sirve para entrevistas técnicas?Muchísimo. Hoy en día, la mayoría de las pruebas técnicas para puestos Mid/Senior exigen hacerlo en TypeScript, no en JavaScript plano.
¿Qué sigue después de este curso?Estarás listo para tomar el curso de **NestJS**, que es un framework de Node.js construido enteramente sobre TypeScript, o profundizar en React con TS.
Chateá por info