Chapitre 5.4.3Les types

Dans le chapitre précédent, on a vu qu'une variable est une boite dans laquelle on stocke une valeur. Mais quelle sorte de valeur ? Un nombre ? Du texte ? Vrai ou faux ? C'est ce qu'on appelle le type d'une variable.

Les types primitifs

Les langages de programmation fournissent un ensemble de types de base, appelés types primitifs. Ce sont les briques élémentaires avec lesquelles on construit tout le reste.

Les nombres

On distingue deux grandes familles de nombres :

• Les nombres entiers, appelés "integer" (ou "int") : 5, 42, -12... Pas de virgule, pas de décimale.
• Les nombres à virgule, appelés "float" (flottants) : 3.14, 0.001, -27.5... Les processeurs sont optimisés pour travailler avec des nombres entiers, mais beaucoup moins à l'aise avec les nombres à virgule. Les langages les différencient donc pour adapter leur traitement en mémoire.

Le piège classique des flottantsconsole.log(0.1 + 0.2)  // 0.30000000000000004

Oui, 0.1 + 0.2 ne donne pas exactement 0.3. C'est lié à la façon dont les processeurs représentent les nombres à virgule en binaire. Ça semble anecdotique, mais ça l'est beaucoup moins quand tu travailles sur des millions de transactions bancaires ou des calculs scientifiques. Les développeurs utilisent des outils spécialisés pour contourner ce problème quand la précision est critique.

Certains langages modernes ne font pas de distinction entre entiers et flottants. JavaScript, par exemple, possède un type numérique "number". Tous les nombres y sont représentés comme des nombres à virgule flottante : 1 est en interne traité comme 1.0. Ça consomme un peu plus de mémoire, mais simplifie l'utilisation des nombres pour les développeurs.

Le texte

On distingue deux sous-types de texte :

• Caractère : appelé un "char". C'est un symbole unique : 'a', '?', '5'... Oui, un chiffre est aussi un caractère. On parle ici de sa représentation en tant que symbole, pour l'afficher quelque part par exemple. C'est la même différence qu'entre le chiffre 5 et sa représentation romaine V. Un caractère est entouré de quotes simples, ce qui permet de différencier 5 (le nombre) et '5' (le symbole).
• Chaine de caractères : appelée une "string". C'est une suite de caractères : "Nico", "Bienvenue", "5".

Certains langages, comme Java par exemple, donnent de l'importance à cette distinction entre un caractère et une chaine de caractères. Ils n'offrent pas les mêmes fonctionnalités selon le type : par exemple, tu peux compter le nombre de caractères d'une string, mais pas d'un char (ça n'aurait pas de sens). Les guillemets doubles permettent de différencier un caractère et une chaine d'un seul caractère : 'a' vs "a".

Ce concept de caractère seul tend à disparaitre dans les langages récents. Le développeur manipule directement des strings. En JavaScript par exemple, tu peux mettre indifféremment des quotes simples ou des guillemets doubles, c'est strictement la même chose :

Quotes ou guillemetslet phrase1 = "C'est parti"        // simple à l'intérieur, doubles à l'extérieur
let phrase2 = 'Il a dit "bonjour"'  // doubles à l'intérieur, simples à l'extérieur

Ici, tu choisis l'un ou l'autre selon ce qui t'arrange : si ton texte contient un guillemet double, entoure-le avec des simples, et inversement.

D'autres langages, comme PHP, Perl, Ruby et Groovy, traitent différemment la chaîne de caractère selon qu'elle est entourée de quotes ou de guillemets. Les guillemets doubles servent à l'interpolation, c'est-à-dire la capacité à injecter et interpréter des variables dans un texte.

Pour gérer l'interpolation, JavaScript a introduit une troisième syntaxe : les backticks (`).

Exemple d'interpolationlet prenom = "Nico"
let message = `Bienvenue ${prenom} sur Le Guide Tech`
console.log(message)  // Bienvenue Nico sur Le Guide Tech

Avant l'interpolation, pour construire du texte dynamique, on utilisait la concaténation : coller des morceaux de texte bout à bout. Dans la grande majorité des langages ça se fait avec l'opérateur + ou ..

Concaténation vs interpolation// Concaténation (ancienne méthode)
let message1 = "Bienvenue " + prenom + " sur Le Guide Tech"

// Interpolation (méthode moderne)
let message2 = `Bienvenue ${prenom} sur Le Guide Tech`

Le résultat est identique, mais l'interpolation est bien plus lisible.

La concaténation reste une pratique très utilisée pour les cas non adaptés à l'interpolation. Le symbole + est donc utilisé à la fois pour des strings et des nombres. Une mauvaise maîtrise du contenu des variables peut amener à des comportements imprévus.

Nombre vs texteconsole.log(5 + 3)      // 8 (addition)
console.log("5" + "3")  // "53" (concaténation)

Les booléens

Un booléen, c'est le type le plus simple : vrai ou faux.

Booléenslet estMajeur = true
let aPayeSonAbonnement = false
console.log(estMajeur)  // true

Ça a l'air basique, mais les booléens sont partout. À chaque fois qu'un programme prend une décision ("est-ce que l'utilisateur est connecté ?", "est-ce que le panier est vide ?"), il manipule des booléens. On y reviendra en détail dans le chapitre sur les conditions.

Les tableaux

Un tableau, appelé "array", c'est une liste ordonnée de valeurs :

Arrayslet fruits = ["pomme", "banane", "cerise"]
console.log(fruits[0])  // pomme
console.log(fruits[2])  // cerise

On accède à un élément par son index, c'est-à-dire sa position dans le tableau. Et attention, on commence à compter à partir de 0, pas de 1. Le premier élément est à l'index 0, le deuxième à l'index 1, etc.

Les langages proposent de nombreuses structures pour manipuler des collections de données. Certaines garantissent l'unicité des valeurs, certaines imposent que toutes les valeurs aient le même type, certaines lient les valeurs entre elles pour qu'on puisse les parcourir dans l'ordre. Le tableau est la plus courante et la plus simple.

En JavaScript, un tableau peut contenir n'importe quoi : [1, "toto", true, -3.14]. C'est techniquement possible, mais c'est rarement une bonne idée. En pratique, on s'efforce de ne stocker que des valeurs du meme type dans un tableau.

Typage fort et typage faible

Maintenant qu'on connaît les types, une question se pose : est-ce que le développeur doit les déclarer explicitement, ou est-ce que le langage se débrouille tout seul ?

La réponse dépend du langage, et c'est un choix de conception fondamental.

Les langages fortement typés

Dans un langage fortement typé comme Java ou C++, le développeur doit déclarer le type de chaque variable :

Java (langage fortement typé)int age = 28;
String prenom = "Nico";
boolean estMajeur = true;

// Erreur de compilation : on ne peut pas mettre du texte dans un int
age = "vingt-huit";

Si tu essaies de mettre du texte dans une variable déclarée comme nombre entier, le programme refuse de se lancer. Le compilateur joue le rôle de gardien : il vérifie que tout est cohérent avant même que le programme ne tourne.

C'est contraignant, mais ça offre de la robustesse. Beaucoup de bugs sont détectés avant même l'exécution. Et dans des environnements critiques (avions, robots, systèmes bancaires), c'est indispensable.

Les langages faiblement typés

Dans un langage faiblement typé comme JavaScript, pas besoin de déclarer le type. L'environnement d'exécution se débrouille tout seul :

JavaScript (langage faiblement typé)let age = 28       // nombre
age = "vingt-huit"   // string... et ça passe

En JavaScript, rien ne t'empêche de changer le type d'une variable en cours de route. C'est souple, c'est rapide à écrire, mais ça ouvre la porte à des bugs sournois. Le programme ne plante pas immédiatement : il continue avec des données incohérentes, et le problème ne se manifeste parfois que bien plus tard, dans un endroit complètement différent du code.

Les dégâts du faible typage

C'est notamment ce faible typage qui a donné mauvaise presse à des langages comme JavaScript ou PHP. Ils sont faciles d'utilisation, avec une courbe d'apprentissage rapide, le développement des projets va plus vite... Mais justement, ça va trop vite ! La flexibilité de ces langages ouvre la porte aux mauvaises pratiques :

• Involontaires : les développeurs avec un faible niveau peuvent monter des architectures abracadabrantesques. Et puisque ça semble marcher, ils n'ont aucune raison de se former davantage et d'améliorer leurs pratiques.
• Volontaires : même les développeurs aguerris sont tentés de prendre de mauvais raccourcis si on leur met trop de pression avec des délais intenables.

Ça explique en grande partie la dette technique colossale que l'on croise dans les entreprises du web basées sur ces technologies. Attention, je ne dis pas qu'il n'y a pas de dette avec des langages typés, mais elle est souvent plus limitée et plus facilement remboursable car les architectures sont, par force, mieux conçues.

Le typage oblige le développeur à connaître sa donnée et à construire son code de sorte qu'il respecte des contrats. Si un bout de code s'attend à un nombre et que tu lui passes du texte, ça pète immédiatement au lieu de silencieusement propager l'erreur.

Le retour du typage

Les communautés qui, il y a 20 ans, promulguaient la flexibilité du non-typage ("c'est plus simple, pourquoi vous vous faites chier pour rien !") ont compris leurs erreurs et tentent maintenant d'introduire du typage.

PHP est nativement de plus en plus typé à chaque version. Il reste quelques trucs qui m'agacent, mais il se rapproche beaucoup de ce que font les langages à fort typage.

L'écosystème JavaScript compte maintenant TypeScript, une surcouche qui permet un typage très solide. Perso, j'adore TypeScript, c'est simple et efficace. Ça sera encore mieux quand il sera complètement indépendant du JavaScript et qu'il se répandra nativement dans les navigateurs web.

Python, lui, a introduit un module permettant la déclaration explicite des types dans le code. Pour le moment ça sert surtout pour faciliter la vie des développeurs, ça n'a pas d'impact réel sur l'exécution des scripts : il n'y aura pas d'erreur si le typage n'est pas respecté lors de l'exécution.

Tous ces exemples offrent un mode hybride : le développeur peut typer s'il le souhaite, mais rien ne l'y oblige. Ça permet de garder un peu de flexibilité contrôlée et, pour certains cas, de rester dans la philosophie du Duck typing :

Quand je vois un oiseau marcher comme un canard, nager comme un canard et cancaner comme un canard, j'appelle cet oiseau un canard. <James Whitcomb Riley>