TypeScript vs Python : typage, performances et usages comparés

TypeScript et Python sont deux langages de haut niveau avec ramasse-miettes, fonctions de première classe et vastes écosystèmes de paquets. La principale différence tient au typage : les types de TypeScript sont vérifiés par le compilateur avant l'exécution du programme, et les type hints de Python sont des annotations facultatives que l'interpréteur ignore. Ils tournent aussi sur des moteurs différents et dominent des types de logiciels différents : TypeScript le web, Python le travail sur les données et les scripts.

Voici un petit programme en TypeScript. Cliquez sur 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);

Sortie :

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

Le même programme en Python, avec des 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 structure est proche : un type pour l'enregistrement, une fonction aux paramètres typés, une liste de valeurs. Les différences visibles sont la syntaxe (accolades et points-virgules contre indentation), interface contre un @dataclass, et les fonctions fléchées avec filter/reduce contre une expression génératrice.

TypeScript vs Python en un coup d'œil

La syntaxe côte à côte

Si vous connaissez les type hints de Python, la plupart des annotations TypeScript ont un équivalent direct :

Types statiques contre type hints

Les deux langages permettent d'écrire la même annotation, a: number ou a: int. C'est la suite qui diffère.

En TypeScript, le compilateur vérifie chaque appel avant que quoi que ce soit ne s'exécute. Un mauvais argument arrête le build :

// 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, les hints sont des métadonnées. L'interpréteur exécute l'appel et renvoie une chaîne :

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 vérification est une étape séparée, avec un outil comme 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)

Le typage de Python est donc graduel par conception : le code non annoté n'est tout simplement pas vérifié, et vous ajoutez des hints là où ils aident. TypeScript peut aussi être permissif (any désactive la vérification pour une valeur), mais avec strict activé, ce qui est le cas par défaut, un paramètre non annoté est une erreur et non un laissez-passer.

Un point commun aux deux : aucun ne vérifie les types pendant l'exécution du programme. TypeScript efface ses types, et Python ignore ses hints. Les données qui arrivent à l'exécution, comme du JSON venu d'une API, doivent être validées dans les deux langages (des bibliothèques comme Zod en TypeScript et Pydantic en Python le font à partir d'un schéma).

Les nombres se comportent différemment

TypeScript a les nombres de JavaScript : number est une valeur à virgule flottante sur 64 bits, pour les entiers comme pour les décimaux, et bigint est un type distinct pour les grands entiers. Le int de Python grandit tout seul jusqu'à n'importe quelle taille.

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

Sortie :

0.30000000000000004
9007199254740992
3.5 3
1267650600228229401496703205376n

Python affiche 9007199254740993 pour 2**53 + 1, puisque ses entiers sont exacts quelle que soit leur taille, et il a un opérateur de division entière dédié, 7 // 2, qui donne 3. Il n'y a pas de type int en TypeScript ; un entier est un number qui se trouve ne pas avoir de partie décimale.

Exécution et performances

TypeScript s'exécute sous forme de JavaScript. V8 (dans Chrome et Node.js), JavaScriptCore (dans Safari et Bun) et SpiderMonkey (dans Firefox) compilent le code le plus sollicité en code machine pendant l'exécution, si bien que les boucles serrées en TypeScript sont en général bien plus rapides que les mêmes boucles dans CPython, qui exécute du bytecode.

Cet écart compte moins qu'il n'y paraît pour beaucoup de programmes :

• Les bibliothèques numériques et de machine learning de Python (NumPy, pandas, PyTorch) font leur gros travail en code compilé C, C++ ou CUDA : un programme Python qui les appelle n'exécute donc pas ses boucles internes en Python.
• Les serveurs web, dans un langage comme dans l'autre, passent une grande partie de leur temps à attendre les bases de données et le réseau.

Les deux langages utilisent un seul thread principal pour la majeure partie du code. TypeScript sur Node.js gère la concurrence avec une boucle d'événements et async/await, et utilise des worker threads pour le travail CPU en parallèle. Python propose asyncio pour le même style de concurrence, plus les threads et les processus.

Écosystèmes et usages

TypeScript est le choix par défaut pour :

• Le frontend web : React, Angular, Vue et Svelte le prennent tous en charge, et il se compile en JavaScript, que les navigateurs exécutent.
• Le code serveur sur Node.js, Deno et Bun : des API avec Express, Fastify, NestJS ou Hono.
• Les applications full stack où le serveur et le navigateur partagent des définitions de types, comme les projets Next.js.
• L'outillage, les outils en ligne de commande et les applications de bureau avec Electron.

Python est le choix par défaut pour :

• L'analyse et la visualisation de données (pandas, NumPy, Matplotlib, notebooks Jupyter).
• Le machine learning et l'IA (PyTorch, scikit-learn, et la plupart du code d'entraînement de modèles).
• Les scripts et l'automatisation : traitement de fichiers, administration système, code de liaison.
• Le backend web avec Django, Flask ou FastAPI.
• Le calcul scientifique et l'enseignement.

C'est le développement web backend qui les fait le plus se recouper. Les équipes choisissent souvent selon le reste de leur stack : TypeScript pour partager du code avec un frontend en TypeScript, Python pour rester proche du code data et ML.

Lequel apprendre ?

• Vous développez pour le web ? Apprenez JavaScript, puis TypeScript. Tout ce qui tourne dans un navigateur finit en JavaScript, et TypeScript est la façon dont s'écrit la plupart du code frontend professionnel.
• Vous travaillez sur les données, l'IA ou l'automatisation ? Apprenez Python. Ses bibliothèques dans ces domaines n'ont pas de véritable équivalent dans le monde JavaScript.
• Premier langage, sans objectif précis ? Python demande moins de syntaxe avant de pouvoir écrire des programmes utiles. TypeScript ajoute un système de types par-dessus JavaScript, ce qui fait davantage à apprendre au début et devient rentable à mesure que les programmes grandissent.

Beaucoup de développeurs utilisent les deux : Python pour les données et les scripts, TypeScript pour le code web du produit. Si vous connaissez déjà les type hints de Python, les annotations de TypeScript vous sembleront familières ; la nouveauté, c'est que le compilateur les impose par défaut et que l'environnement d'exécution sous-jacent est JavaScript.