Typage statique vs dynamique

On qualifie souvent un langage de « dynamiquement typé » (JavaScript) ou « statiquement typé » (C#, TypeScript). Derrière ces adjectifs se cache une seule question, cruciale : à quel moment les types sont-ils vérifiés ?

# Une seule question : quand vérifie-t-on ?

La réponse s'appuie directement sur l'axe compile-time / runtime :

• Typage statique → les types sont vérifiés à la compilation, avant d'exécuter le code.
• Typage dynamique → les types sont vérifiés à l'exécution, au moment où chaque opération se fait.

# Typage statique (C#, TypeScript)

Chaque variable a un type connu et fixé, et le compilateur refuse ce qui ne colle pas - avant même de lancer le programme :

int age = 25;
age = "vingt-cinq";  // ❌ Erreur de compilation : le code ne compile pas

int age = 25;

age = "vingt-cinq";  // ❌ Erreur de compilation : le code ne compile pas

L'erreur est attrapée à l'écriture, dans l'éditeur. Impossible de lancer un programme qui contient ce genre d'incohérence.

# Typage dynamique (JavaScript, Python)

Une variable peut contenir n'importe quel type, et en changer en cours de route. Rien n'est vérifié à l'avance : le problème n'apparaît qu'à l'exécution, quand l'opération tourne réellement.

let age = 25;
age = "vingt-cinq"; // ✅ parfaitement autorisé en JS
age.toFixed(2);     // 💥 plante seulement ici, à l'exécution

let age = 25;

age = "vingt-cinq"; // ✅ parfaitement autorisé en JS

age.toFixed(2);     // 💥 plante seulement ici, à l'exécution

C'est ce que change TypeScript : il rajoute une couche de typage statique par-dessus JavaScript, dynamiquement typé.

# Le compromis

Aucun n'est « meilleur » dans l'absolu : c'est un arbitrage entre sûreté et souplesse.

# L'inférence : le statique sans la lourdeur

« Statique » ne veut pas dire « écrire le type partout ». Les langages statiques modernes devinent le type quand il est évident : c'est l'inférence de type.

var age = 25;        // C# déduit : int
var nom = "Vidal";   // C# déduit : string

var age = 25;        // C# déduit : int

var nom = "Vidal";   // C# déduit : string

Le type reste fixé et vérifié à la compilation (tu ne pourras jamais mettre un texte dans age), mais tu n'as pas eu à l'écrire. TypeScript pousse l'inférence encore plus loin. Résultat : on garde la sûreté du statique sans (trop de) la verbosité d'autrefois.

# Le typage graduel : la frontière se brouille

La séparation statique/dynamique n'est plus étanche : on peut ajouter une couche de typage statique, optionnelle, par-dessus un langage dynamique. C'est le typage graduel.

• TypeScript ajoute des types vérifiés à la compilation par-dessus JavaScript. Au final ça reste du JS (les types disparaissent à l'exécution), mais tu as gagné la vérification avant de lancer.
• Python fait pareil avec les type hints (def prix(x: int) -> float:) : ignorés à l'exécution, mais un outil comme mypy les vérifie avant, comme le ferait un compilateur.

Tu peux donc typer progressivement : rester souple au début, ajouter de la rigueur là où ça compte.

# À ne pas confondre : fort vs faible typage

Statique/dynamique répond à « quand » vérifie-t-on. C'est un axe indépendant d'une autre notion : le typage fort ou faible, qui répond à « à quel point le langage autorise-t-il les conversions implicites ? ».

• Faiblement typé : le langage convertit tout seul, quitte à faire n'importe quoi. JS : "3" * 2 donne 6, [] + {} donne "[object Object]".
• Fortement typé : le langage refuse ces mélanges hasardeux.

Les deux axes se combinent :

Python montre bien que dynamique ≠ faible : il vérifie tard, mais refuse "3" * "2".

# À retenir

• Statique = types vérifiés à la compilation (avant de lancer) ; dynamique = à l'exécution.
• C#/TypeScript sont statiques ; JavaScript/Python sont dynamiques.
• C'est un compromis sûreté vs souplesse, pas une hiérarchie.
• Ne pas confondre avec fort/faible (les conversions implicites) : les deux axes sont indépendants.
• L'inférence de type rend le statique bien moins verbeux : le langage devine le type (var, TS) sans rien perdre en sûreté.
• Le typage graduel (TypeScript, Python + mypy) ajoute du statique optionnel sur un langage dynamique : la frontière n'est plus étanche.

À lire ensuite : Typage structurel vs nominal, l'autre grande distinction du typage.