Parmi les nombreuses critiques formulées à l'encontre de JavaScript par ses détracteurs, celle qui revient surement le plus souvent est que JavaScript est un langage faiblement typé.

Or, selon le principe qu'une vérité est un mensonge mille fois répété, cette assertion selon laquelle JavaScript est un langage faiblement typé est devenue une vérité pour quasiment tout le monde (moi y compris pendant longtemps), sans que personne ne prenne le temps de réfléchir au problème.

J'ai donc voulu effectuer des recherches ici ou là pour vérifier cette affirmation. Quel ne fut pas mon désarroi en constatant qu'au final, il est très compliqué de savoir si un langage est à typage faible ou fort ! Les avis des plus éminents et avisés des développeurs sont souvent divergents, parfois contradictoires.

Alors basons-nous sur quelques faits.

Pourquoi dit-on que JavaScript est faiblement typé ?
En fait, les arguments se résument bien souvent à expliquer qu'on peut additionner des nombres et des chaines !
La réalité, c'est qu'effectivement, tout opérateur renvoie un résultat en JavaScript, quitte à modifier le type de l'un des opérandes.
Mais cela n'a rien à voir avec un typage fort ou faible : il ne s'agit là que d'une notion de typage dynamique.
Donc effectivement, pour chaque opérateur, des règles existent pour déterminer comment modifier dynamiquement le type d'un ou plusieurs opérandes afin de pouvoir toujours renvoyer un résultat.

Notez au passage que le code suivant :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
var nb = 42;
var txt = 'foo';
console.log('nb : ', typeof nb, 'txt : ', typeof txt);
var resultat = nb+txt;
console.log('resultat : ', typeof resultat, 'nb : ', typeof nb, 'txt : ', typeof txt);
Affichera
nb : number txt : string
resultat : string nb : number txt : string
Le typage dynamique n'affecte donc pas le type des opérandes.

Pourquoi JavaScript serait un langage fortement typé ?
La réponse courte serait tout simplement du fait de la présence d'erreurs de type en JavaScript !

En détaillant un peu, il faut considérer tout d'abord que JavaScript est un langage orienté objet dans lequel tout (absolument tout) est objet. Même si les types primitifs déclarés à l'aide de littéraux n'héritent pas de la même chaine de prototypes qu'avec un constructeur, ce sont malgré tout des objets.
De ce fait, à part avec les opérateurs, les seules manipulations que l'on peut faire sur des variables correspondent à des méthodes d'objets. Or si vous appliquez une méthode à un objet dont le type n'est pas conforme, vous obtiendrez une erreur de type.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
console.log(12..push(3)); // TypeError: 12.push is not a function
console.log(12..charAt(1)); // TypeError: 12.charAt is not a function
console.log([1,2,3,4].toFixed(2)); // TypeError: [1, 2, 3, 4].toFixed is not a function
On pourrait multiplier les exemples !
Notez toutefois que le paramètre passé à la méthode peut lui être transtypé dynamiquement afin d'obtenir un résultat.

Tout est donc clair maintenant : JavaScript est bel et bien un langage fortement typé !

Le mot de la fin
Pour terminer, certains "puristes" du typage fort vous diront qu'en fait, un typage fort existe si le type est défini à la création de la variable.
Alors effectivement, ce n'est pas forcément le cas en JavaScript, en revanche, le type est déterminé une fois pour toutes à la définition de la variable.
En effet, nous avons vu que le typage dynamique n'affecte pas en réalité le type de la variable, mais pour aller plus loin, il n'existe aucun mécanisme en JavaScript pour modifier réellement en JavaScript ! Aucun opérateur, aucune fonction n'existe pour cela !
Oh... j'en entends déjà se gausser : "sur ce coup là, on va vite le coincer !"
Et oui, si vous faites
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
var nb = 42;
console.log(typeof nb); // number
nb = 'foo';
console.log(typeof nb); // string
Le seul hic, c'est que là vous n'avez pas transtypé la variable nb, vous l'avez juste redéfinie !
Mais faites par exemple
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
var tab = [1,2,3];
tab.join(',');
console.log(Array.isArray(tab)); // true
La méthode join() a renvoyé une valeur de type chaine, mais n'a pas touché au type de tab.

Qu'en pensez-vous ?
Considérez-vous comme moi qu'au final, JavaScript est fortement typé ?
Si oui, avez-vous d'autres arguments pour étayer cette affirmation ?
Au contraire, me prenez-vous pour un illuminé ?
Dans ce cas, quels arguments vous font penser cela ?