Dividir tu código en archivos pequeños es una de las decisiones más sanas que puedes tomar como desarrollador. Aprender a crear módulos en TypeScript te permite separar funciones y constantes en archivos independientes, importarlas donde las necesites y mantener un proyecto escalable, legible y fácil de mantener.

Esto es clave si vienes trabajando con clases y quieres dar el siguiente paso hacia una arquitectura modular real, sin acumular cientos de líneas en un solo archivo.

¿Por qué evitar los monolitos en tu código?

Un monolito es ese archivo gigante que concentra toda la lógica de tu aplicación. Suena cómodo al inicio, pero se vuelve un problema cuando aparecen errores.

Entre más líneas de código tengas en un archivo, más probable es que aparezca un bug y más difícil será ubicarlo. En cambio, varios archivos con pocas líneas hacen tu vida más sencilla: navegas mejor, depuras más rápido y tu equipo entiende el proyecto sin pelearse con un muro de texto.

¿Qué es un monolito en programación? Es un archivo o aplicación que concentra toda la lógica en un solo bloque de código. Es difícil de mantener, escalar y depurar.

La idea con módulos es justamente lo contrario: fragmentar funcionalidad en piezas pequeñas que puedas reutilizar [01:30].

¿Cómo exportar funciones desde un archivo TypeScript?

Vamos a la práctica. Dentro de tu repositorio crea un folder llamado modulos (sin acento, para evitar problemas de tipado) y adentro un archivo calculator.ts [02:00].

En ese archivo vas a declarar funciones usando la palabra clave export, que es la que permite que otro archivo las pueda ver y usar.

typescript export function suma(num1: number, num2: number) { return num1 + num2; }

export function resta(num1: number, num2: number) { return num1 - num2; }

export function multiplicacion(num1: number, num2: number) { return num1 * num2; }

export function division(num1: number, num2: number) { return num1 / num2; }

Las cuatro funciones son prácticamente iguales. Lo único que cambia es el operador aritmético. Nada de ciencia oculta, solo separación clara de responsabilidades.

¿Qué hace la palabra export?

export marca una función, clase o constante como disponible hacia afuera. Sin ella, la función vive solo dentro de su archivo y nadie más puede invocarla. Es la llave que abre la puerta del módulo.

¿Cómo importar funciones en otro archivo .ts?

Ahora crea un segundo archivo llamado main.ts en la misma carpeta. Aquí es donde vas a consumir lo que exportaste [03:30].

La sintaxis usa llaves para traer funciones específicas, no la clase completa como hacíamos antes:

typescript import { suma, resta, multiplicacion, division, PI } from './calculator';

console.log(suma(10, 154)); console.log(resta(PI, 1));

Fíjate en el detalle: la ruta ./calculator no lleva la extensión .ts. TypeScript la resuelve solo. Y gracias a que cada función fue exportada, el editor te las sugiere automáticamente cuando empiezas a escribir.

¿Cómo importo solo una función de un archivo en TypeScript? Usa import { nombreFuncion } from './ruta'. Las llaves indican que traes elementos específicos, no todo el archivo.

¿Cómo exportar constantes además de funciones?

Los módulos no se limitan a funciones. También puedes exportar valores constantes que necesites reutilizar en distintas partes del proyecto [05:30].

En calculator.ts agrega:

typescript export const PI = 3.1416;

Esa constante ya está disponible para cualquier archivo que la importe. Es útil para configuraciones, valores matemáticos, mensajes fijos o cualquier dato que no debería cambiar en tiempo de ejecución.

¿Cómo compilar y ejecutar un proyecto con módulos?

Aquí pasa algo interesante. Desde la terminal, ubícate en la carpeta y compila solo el archivo principal:

1. Muévete al folder con cd modulos.
2. Compila con tsc main.ts.
3. Ejecuta con node main.js.

Aunque solo compilaste main.ts, TypeScript desencadena un efecto dominó y también genera el calculator.js correspondiente, porque detecta que estás importando desde ahí [05:00]. El resultado en consola con suma(10, 154) es 164, justo lo esperado.

¿Cuándo conviene refactorizar a módulos?

No necesitas escribir modular desde el minuto uno. Una estrategia muy práctica es construir primero un archivo grande que funcione, y luego dividirlo.

• Empieza con un archivo que cumpla el objetivo, aunque sea extenso.
• Identifica bloques de funcionalidad que se repiten o que tienen una responsabilidad clara.
• Mueve esos bloques a archivos pequeños y expórtalos.
• Importa solo lo necesario en tu archivo principal.

Este proceso de refactorización por módulos hace tu código más legible, escalable y cómodo de modificar. Cambias una función en un archivo pequeño y el cambio se hereda al archivo principal sin tocar nada más.

Y lo mejor: tu equipo lo agradece. Trabajar sobre archivos chicos y enfocados reduce conflictos de Git, acelera revisiones de código y baja la curva para quien se acaba de unir al proyecto.

¿Ya tienes algún proyecto donde puedas aplicar esta separación en módulos? Cuéntame en los comentarios qué archivo refactorizarías primero.