TypeScript vs Python: tipado, velocidad y usos comparados

TypeScript y Python son lenguajes de alto nivel con recolección de basura, funciones de primera clase y grandes ecosistemas de paquetes. La diferencia principal es el tipado: el compilador de TypeScript comprueba los tipos antes de que el programa se ejecute, y los type hints de Python son anotaciones opcionales que el intérprete ignora. Además se ejecutan en motores distintos y dominan tipos de software distintos: TypeScript la web, Python el trabajo con datos y el scripting.

Aquí tienes un programa pequeño en TypeScript. Pulsa Run:

interface Order {
    customer: string;
    amount: number;
    paid: boolean;
}

function totalPaid(orders: Order[]): number {
    return orders.filter((o) => o.paid).reduce((sum, o) => sum + o.amount, 0);
}

const orders: Order[] = [
    { customer: "Ada", amount: 120, paid: true },
    { customer: "Grace", amount: 80.5, paid: false },
    { customer: "Linus", amount: 42.25, paid: true },
];

const byAmount = [...orders].sort((a, b) => b.amount - a.amount).map((o) => o.customer);
console.log(totalPaid(orders));
console.log(byAmount);

Salida:

162.25
[ 'Ada', 'Grace', 'Linus' ]

El mismo programa en Python, con type hints:

from dataclasses import dataclass


@dataclass
class Order:
    customer: str
    amount: float
    paid: bool


def total_paid(orders: list[Order]) -> float:
    return sum(o.amount for o in orders if o.paid)


orders = [
    Order("Ada", 120.0, True),
    Order("Grace", 80.5, False),
    Order("Linus", 42.25, True),
]

by_amount = [o.customer for o in sorted(orders, key=lambda o: o.amount, reverse=True)]
print(total_paid(orders))
print(by_amount)

162.25
['Ada', 'Grace', 'Linus']

La estructura es parecida: un tipo para el registro, una función con parámetros tipados y una lista de valores. Las diferencias visibles son la sintaxis (llaves y punto y coma frente a indentación), interface frente a un @dataclass, y funciones flecha con filter/reduce frente a una expresión generadora.

TypeScript vs Python de un vistazo

Sintaxis lado a lado

Si conoces los type hints de Python, la mayoría de las anotaciones de TypeScript tienen un equivalente directo:

Tipos estáticos frente a type hints

Los dos lenguajes te dejan escribir la misma anotación, a: number o a: int. Lo que pasa después es distinto.

En TypeScript, el compilador comprueba cada llamada antes de que se ejecute nada. Un argumento incorrecto detiene la compilación:

// This does not compile: TypeScript checks the call before running it.
function add(a: number, b: number): number {
    return a + b;
}

console.log(add(2, 3));
console.log(add("2", "3"));

index.ts(7,17): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.

En Python, los hints son metadatos. El intérprete ejecuta la llamada y devuelve un string:

def add(a: int, b: int) -> int:
    return a + b


print(add(2, 3))      # 5
print(add("2", "3"))  # 23, the hints are not enforced

La comprobación es un paso aparte con una herramienta como mypy:

$ mypy hints.py
hints.py:6: error: Argument 1 to "add" has incompatible type "str"; expected "int"  [arg-type]
hints.py:6: error: Argument 2 to "add" has incompatible type "str"; expected "int"  [arg-type]
Found 2 errors in 1 file (checked 1 source file)

Así que el tipado de Python es gradual por diseño: el código sin anotaciones simplemente no se comprueba, y añades hints donde ayudan. TypeScript también puede ser permisivo (any desactiva la comprobación de un valor), pero con strict activado, que es lo habitual por defecto, un parámetro sin anotar es un error y no un pase libre.

Una cosa tienen en común: ninguno comprueba tipos mientras el programa se ejecuta. TypeScript borra sus tipos y Python ignora sus hints. Los datos que llegan en ejecución, como el JSON de una API, necesitan validación en los dos lenguajes (librerías como Zod en TypeScript y Pydantic en Python lo hacen a partir de un esquema).

Los números se comportan distinto

TypeScript tiene los números de JavaScript: number es un valor en coma flotante de 64 bits tanto para enteros como para decimales, y bigint es un tipo aparte para enteros grandes. El int de Python crece hasta cualquier tamaño por sí solo.

console.log(0.1 + 0.2);        // float rounding, same as Python
console.log(2 ** 53 + 1);      // beyond 2^53, not every integer fits in a number
console.log(7 / 2, Math.trunc(7 / 2));
console.log(2n ** 100n);       // bigint: exact, like Python's int

Salida:

0.30000000000000004
9007199254740992
3.5 3
1267650600228229401496703205376n

Python imprime 9007199254740993 para 2**53 + 1, porque sus enteros son exactos a cualquier tamaño, y tiene un operador propio de división entera, 7 // 2, que da 3. En TypeScript no existe un tipo int; un entero es un number que no tiene parte decimal.

Entorno de ejecución y rendimiento

TypeScript se ejecuta como JavaScript. V8 (en Chrome y Node.js), JavaScriptCore (en Safari y Bun) y SpiderMonkey (en Firefox) compilan a código máquina el código que más se ejecuta mientras corre, así que los bucles intensivos en TypeScript suelen ser mucho más rápidos que los mismos bucles en CPython, que ejecuta bytecode.

Esa diferencia importa menos de lo que parece en muchos programas:

• Las librerías numéricas y de machine learning de Python (NumPy, pandas, PyTorch) hacen el trabajo pesado en código compilado en C, C++ o CUDA, así que un programa Python que las llama no ejecuta sus bucles internos en Python.
• Los servidores web en cualquiera de los dos lenguajes pasan gran parte del tiempo esperando a bases de datos y a la red.

Los dos lenguajes usan un hilo principal para la mayor parte del código. TypeScript en Node.js gestiona la concurrencia con un event loop y async/await, y usa worker threads para el trabajo de CPU en paralelo. Python tiene asyncio para el mismo estilo de concurrencia, además de hilos y procesos.

Ecosistemas y casos de uso

TypeScript es la opción por defecto para:

• El front end web: React, Angular, Vue y Svelte lo soportan, y se compila al JavaScript que ejecutan los navegadores.
• Código de servidor en Node.js, Deno y Bun: APIs con Express, Fastify, NestJS o Hono.
• Aplicaciones full stack en las que el servidor y el navegador comparten definiciones de tipos, como los proyectos Next.js.
• Herramientas, aplicaciones de línea de comandos y aplicaciones de escritorio con Electron.

Python es la opción por defecto para:

• Análisis y visualización de datos (pandas, NumPy, Matplotlib, notebooks de Jupyter).
• Machine learning e IA (PyTorch, scikit-learn y la mayor parte del código de entrenamiento de modelos).
• Scripting y automatización: procesar archivos, administración de sistemas, código de pegamento.
• Back end web con Django, Flask o FastAPI.
• Computación científica y enseñanza.

El back end web es donde más se solapan. Los equipos suelen elegir según el resto del stack: TypeScript para compartir código con un front end en TypeScript, Python para estar junto al código de datos y de ML.

¿Cuál deberías aprender?

• ¿Vas a construir para la web? Aprende JavaScript y luego TypeScript. Todo lo que se ejecuta en un navegador acaba siendo JavaScript, y TypeScript es como se escribe la mayor parte del código front end profesional.
• ¿Trabajas con datos, IA o automatización? Aprende Python. Sus librerías en esas áreas no tienen un equivalente real en el mundo JavaScript.
• ¿Primer lenguaje, sin un objetivo concreto? Python tiene menos sintaxis que aprender antes de poder escribir programas útiles. TypeScript añade un sistema de tipos encima de JavaScript, que al principio es algo más que aprender y compensa a medida que los programas crecen.

Muchos desarrolladores usan los dos: Python para datos y scripts, TypeScript para el código web del producto. Si ya conoces los type hints de Python, las anotaciones de TypeScript te resultarán familiares; lo nuevo es que el compilador las hace cumplir por defecto y que el entorno de ejecución que hay debajo es JavaScript.