JavaScript : un langage fortement typé
êtes-vous prêt à l'accepter ?

Les rubriques (actu, forums, tutos) de Développez
Réseaux sociaux


 Discussion forum

Sur le même sujet
Le , par Bovino, Responsable Développement Web


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 :
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 :
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 :
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 :
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 ?


 Poster une réponse

Avatar de SylvainPV SylvainPV
Membre Expert
le 09/08/2013 17:33
Belle initiative ce recadrage

Bon après tout est histoire de définition. Et je pense que tu auras du mal à convaincre que JS est fortement typé en montrant des bouts de code comme ça:
Code :
1
2
3
4
var hi = "Hello !"; 
hi = 83110; 
hi = ["H","e","l","l",0] ; 
hi = function(){ alert("Hello !"); };
On peut se demander à juste titre pourquoi on appellerait ça un typage fort quand on déclare une variable sans son type, quand tous les objets sont mutables, quand on peut mélanger les types dans les Array... Moi j'appelle ça du typage open-bar

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

Là encore question de définition. On notera quand même que:
Code :
"primitif" instanceof Object === false
Alors forcément c'est dur de s'entendre là-dessus.

Au contraire, me prenez-vous pour un illuminé ?

Il n'y a pas beaucoup de différence entre un illuminé et une lumière
Avatar de danielhagnoul danielhagnoul
Rédacteur
le 09/08/2013 23:29
Je crois que le "typage fort" ne passera pas.

Le "typage dynamique", la redéfinition du type, gênera toujours les puristes.

Mais il est clair que si l'on attribue un type lors de la définition (var n = 0; au lieu d'un simple var n;), on peut s'y fier. Seule la redéfinition modifiera le type de n.

JS est comme toujours hors-norme, on dira donc qu'il a un "typage solide".
Avatar de Lcf.vs Lcf.vs
Membre éprouvé
le 10/08/2013 4:11
Pour moi, la seule différence entre un langage fortement typé et un faiblement typé, c'est la possibilité, pour le développeur, de faire n'importe quoi ou pas et de devoir assumer (ou pas) ses erreurs.

Je dirais donc qu'il y a des développeurs fortement/faiblement typés.
Avatar de skywaukers skywaukers
Membre Expert
le 10/08/2013 8:22
Alors si on part du principe effectivement que Javascript est fortement typé parce qu'en fait il affecte dynamiquement le type de la variable, quel langage n'est pas fortement typé ?

Personnellement l'exemple que vous donnez vous même me heurte :

Code :
1
2
3
4
var nb = 42; 
console.log(typeof nb); // number 
nb = 'foo'; 
console.log(typeof nb); // string
Ok le typage est dynamique. Mais le principe du typage fort étant justement de limiter les erreurs de programmation, on ne peut pas dire que le contrat soit rempli. Là ok il y a 2 lignes d'écart entre les deux afefctation, mais ce genre de chose, noyée dans le code peut faire chercher un bug pas mal de temps.
Et justement pour moi un langage fortement typé impose que dans une même portée, une variable qui a un type n'en change pas en cours de route (et surtout pas dynamiquement !!)

@++
Dany
Avatar de Uther Uther
Expert Confirmé Sénior
le 10/08/2013 9:51
Citation Envoyé par Bovino
Considérez-vous comme moi qu'au final, JavaScript est fortement typé ?

Tout dépend la définition exacte de langage fortement typé, j'en ai vu plusieurs différente dont la plupart excluent sans ambiguïté le Javascript. D'autres qui excluraient plutôt le C et le C++.
J'aimerai bien avoir votre définition à vous.

Personnellement, quand je suis dans l'impossibilité de connaitre simplement avec exactitude le type des variables que je manipule, alors que je le suis parfaitement avec des langages pourtant à priori faiblement typés, j'ai du mal a me dire que j'ai a faire a un langage avec un typage fort.

Citation Envoyé par Bovino
Au contraire, me prenez-vous pour un illuminé ?

Non pour un tatillon qui joue sur les mots pour tourner autour du problème.
Peu importe que le problème soit le typage dynamique ou faible, il n'en reste pas moins qu'il est quand même là.
Avatar de sevyc64 sevyc64
Modérateur
le 10/08/2013 10:15
Citation Envoyé par Bovino  Voir le message
Considérez-vous comme moi qu'au final, JavaScript est fortement typé ?

Non !

Je fais parti de ceux qui définissent un langage fortement typé par le fait que l'on définie explicitement le type d'une variable lors de sa définition et que celui ci ne puisse pas changer même par une redéfinition implicite.
Pour moi, Javascript (tel que tu l'explique et que je ne connais pas) est faiblement typé, le type de la variable étant défini par le compilo à sa première affectation (et même redéfinie à chaque affectation si j'ai bien compris ta démo).

Citation Envoyé par Bovino  Voir le message
Au contraire, me prenez-vous pour un illuminé ?

Pas du tout, mais pour moi, tu ne démontre en rien que Javascript est fortement ou faiblement typé, tu démontre juste qu'il est typé, que l'on ne peut pas tout à fait faire ce que l'on veut

Et personnellement, peut-être par facilité d'esprit, je préfère largement les langages fortement typés (selon ma définition).
Avatar de grim7reaper grim7reaper
Membre expérimenté
le 10/08/2013 10:23
Salut,

Citation Envoyé par Bovino  Voir le message
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.

Comme tu le dis, il n’y a pas de définition communément accepté pour les notions de typages faibles et forts (au contraire des notions de typages dynamiques et statiques, qui elles sont plus clairement définies).
En fait, tel que je le vois, la force d’un typage est relative. Par exemple le C++ a un typage fort par rapport au C, mais son typage est faible par rapport à Haskell. Pour les langages dynamiques, le typage de Javascript est faible par rapport à Python ou Ruby.

On ne peut pas définir un langage comme étant typé faiblement ou fortement de manière absolue (tout du moins, ça ne fera sûrement pas consensus).

Après, je pense que, si l’on considère l’ensemble des langages, Javascript est quand même plutôt dans la partie typé faiblement que dans la partie typé fortement.
On pourrait mesurer la faiblesse de typage d’un langage par rapport au possibilités de conversions implicites qu’il offre. Plus il y a de conversions implicites, plus le typage est faible (car il est plus facile de faire des conversions entre les types et de mélanger des types différents dans une même opération), à contrario moins de conversion explicite => typage plus fort.
Je pourrais aussi citer un autre critère, mais comme là on parle de langage dynamique ça serait un peu HS.

Citation Envoyé par Bovino  Voir le message
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.

Et c’est bien ça qui, pour moi, fait de Javascript un langage à typage faible.
Car il doit absolument fournir un résultat, et pour cela il va passer par des conversions implicites (les règles dont tu parles) afin de produire une valeur.
Je ne connais pas trop Javascript, mais des bouts de codes que j’ai vu il semble y en avoir pas mal de ces règles de cœrcition qui agissent de manière implicite (le développeur n’a pas besoin d’ajouter un cast ou de faire appel à une fonction pour convertir le type).
Ce n’est pas un mal en soi, mais ça fait de lui un langage faiblement typé (de mon point de vue).

Et non, ce n’est pas juste « une notion de typage dynamique » car Python et Ruby (typé dynamiquement) ne permettent pas d’additionner les nombres et les chaînes de caractères.

Citation Envoyé par Bovino  Voir le message
Notez au passage que le code suivant :
Code :
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.

Le typage faible, ce n’est pas uniquement une histoire de changement de type, c’est aussi de permettre de mélanger des types facilement dans des opérations.
Et en fait si, le type des opérandes est affecté, mais c’est une promotion temporaire (comme ce que l’on voit en C quand on appelle une fonction qui prend un long avec un int).

Citation Envoyé par Bovino  Voir le message
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 !

Oui mais non.
Typage faible ne signifie pas absence de typage.
Encore une fois, ces histoires de typages faible/fort ce n’est pas binaire. Ce n’est pas tout ou rien.
À partir du moment où il y a typage (typage faible signifiant qu’il y a bien un typage), oui on risque d’avoir des erreurs de types. Heureusement d’ailleurs.
Mais ça n’est pas un argument pour dire que c’est un langage fortement typé.

Citation Envoyé par Bovino  Voir le message
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 :
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é !

Je ne suis pas d’accord avec ta conclusion.
Tu démontres juste que Javascript est typé, mais pas que son typage est fort.
D’ailleurs, vu que tu parles de transtypage dynamique on peut penser que ça penche plus vers le faible que le fort (mais encore une fois cela dépend des conditions de transtypage, si elles sont laxistes ou pas).

Citation Envoyé par Bovino  Voir le message
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.

Personnellement non, ce n’est pas ma définition du typage fort.
De mon point de vue, ça ça rentrerait plus dans la catégorie typage statique/dynamique.

Citation Envoyé par Bovino  Voir le message
Considérez-vous comme moi qu'au final, JavaScript est fortement typé ?

Pour conclure, non je ne suis pas d’accord avec toi (pour les raisons énoncés plus haut).
Pour moi Javascript est un langage à typage dynamique et faible.
Ça ne veux pas dire que je considère Javascript comme un mauvais langage (et ne faisant pas de Javascript je serai bien mal placé pour le juger).
Je ne juge pas si le typage faible c’est bien ou mal (mais j’ai une préférence personnelle pour le typage fort), mais je considère Javascript comme étant typé faiblement.

Citation Envoyé par Bovino  Voir le message
Au contraire, me prenez-vous pour un illuminé ?
Dans ce cas, quels arguments vous font penser cela ?

Je ne te prends pas pour un illuminé non, ça ne serait pas très sympa.
Mais je ne suis pas d’accord avec toi, pour les arguments cf. plus haut.
Avatar de Farid63 Farid63
Membre Expert
le 10/08/2013 11:20
En Java :

Code java :
1
2
3
4
5
6
7
8
9
String chaine = "Bonjour"; 
  
chaine = 2; // Pas de nombre dans un String 
  
chaine = "2"; // Ok  
  
int a = chaine; // Pas de conversion implicite 
  
a = Integer.parseInt(chaine); // Si possible OK sinon NumberFormatException

Ici, tu ne pourras jamais mettre autre chose que des int dans la variable "a". Tu peux caster la valeur de la variable pour la mettre dans une autre variable d'un autre type mais "a" pourra recevoir que des int. Ca c'est du typage fort.

En Javascript :

Code javascript :
1
2
3
4
5
6
7
8
9
10
11
12
  
var a; // C'est quoi sont type? 
  
a = 12; // La je viens de dire que a est un integer Ok 
  
a = "Hi !" // Je viens de mettre un string dans une variable de type int... 
  
a = function() { 
	alert("WHAT"); 
}; // Maintenant une fonction 
  
alert(a + 2 + "WTFJS !!"); // Pas d'erreur ici, tout est normal :)
Avatar de tomlev tomlev
Rédacteur/Modérateur
le 10/08/2013 14:04
L'argument de l'erreur de type sur l'appel d'une fonction qui n'existe pas ne veut pas dire grand chose... en tous cas ça ne montre pas que c'est un langage fortement typé. Selon toi, un langage faiblement typé serait un langage où 12..push(3) ne provoquerait pas d'erreur ? D'après cette définition, il ne doit pas y avoir beaucoup de langages faiblement typés
Avatar de leternel leternel
Expert Confirmé
le 10/08/2013 15:03
Dans tous les langages typés, les valeurs sont intrinsèquement typées.
Dans "var i = 2", 2 est un entier, et i une variable.
dans "int i = 2" aussi. C'est juste que là, on précise en plus que i soit une variable contrainte à contenir un type i.

Comme on ne peut pas écrire "2 = 4", c'est à dire modifier une valeur, bien sûr qu'on ne peut pas non plus changer son type.

Donc toutes les valeurs, dans tous les langages (typés), sont totalement et strictement typées.

Les considérations de qualités de typage portent sur les variables elles-mêmes.
Dans cette considération, JavaScript n'a pas de type de variable, il est le plus faiblement typé qu'on puisse.
C, Java et C++ possèdent des types de variables, ca les placent dans la catégorie des langage fortement typés (j'ai parfois lu "var-typed").
D'ailleurs, comme en Java, il n'y a pas de slicing à la C++, on pourrait dire qu'il est un peu moins fortement typé que celui-ci.

Dire que Java-script est fortement typé me semble un peu décalé avec la définition classique de la "force" de typage.
Offres d'emploi IT
Front-end engineer
CDI
Mobile Social Games provider - Autre - Tokyo
Parue le 07/04/2014
CHEF DE PROJET MOA (H/F)
CDI
Décision RH - Ile de France - Paris
Parue le 11/04/2014
Ingénieur Automatique des Systèmes embarqués H/F
CDI
DCNS - Pays de la Loire - Nantes/Indret
Parue le 07/04/2014

Voir plus d'offres Voir la carte des offres IT
 
 
 
 
Partenaires

PlanetHoster
Ikoula