Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

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

Le , par Bovino

16PARTAGES

12  11 


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

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de skywaukers
Membre chevronné https://www.developpez.com
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 : Sélectionner tout
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
16  1 
Avatar de grim7reaper
Membre éclairé https://www.developpez.com
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 : Sélectionner tout
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 : Sélectionner tout
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.
12  0 
Avatar de SylvainPV
Rédacteur/Modérateur https://www.developpez.com
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 : Sélectionner tout
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 : Sélectionner tout
"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
10  1 
Avatar de sekaijin
Expert éminent https://www.developpez.com
Le 15/08/2013 à 16:59
Personnellement je ne me prononcerais pas.
Pour moi, ce n'est pas une question.

Certains voient dans le mécanisme de typage de JS un problème.
Moi j'y vois une force.

D'ailleurs ce que fait naturellement JS est très péniblement reproduit avec des langages dits fortement typés. par exemple l'API réflexion de java ou le runtime Objective-C
Tous deux n'ont pour but que de passer outre les contraintes du modèle de programmation à base de classes.

Je ne me pose donc pas la question de savoir si, oui ou non, le langage est fortement typé. JS est un langage ou les définitions sont dynamiques et une fois qu'on a compris ça il suffit d'en tirer parti.

Tout comme lorsque j'utilise les langages à base de classe j'essaie de tirer, le meilleur partit du modèle de langage à base classes.
Lorsque j'utilise EcmaScript j'utilise au mieux la définition dynamique et la notion de prototype.

Pour moi, JS est un tas de références.
Une variable est une référence sur un objet comme en C++.
Lorsqu'on référence un autre objet (avec le même nom), il est logique que le type de l'objet ne soit pas nécessairement le même.

Est-il important qu'un nom de variable soit contraint à ne référencer qu'un seul type d'objet ?

Si cela peut être utile, il est tout aussi pertinent de ne pas avoir cette contrainte.
Car au final lorsque le langage impose ce genre de contrainte on en vient à la contourner.
Par exemple en java en utilisant la classe Object pour référencer tout et n'importe quoi.

Alors, tirez le meilleur de chaque langage et faites des caractéristiques de chacun une force.

A+JYT
9  2 
Avatar de tomlev
Rédacteur/Modérateur https://www.developpez.com
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
6  0 
Avatar de Lcf.vs
Membre éclairé https://www.developpez.com
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.
6  1 
Avatar de sevyc64
Modérateur https://www.developpez.com
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).
7  2 
Avatar de SylvainPV
Rédacteur/Modérateur https://www.developpez.com
Le 11/08/2013 à 13:45
Ah les bons vieux réfractaires du Javascript.
Qui voudraient qu'on balance du code compilé sans se soucier du fait que le Web est par nature universel et doit tourner sur une multitude d'environnements.
Qui se plaignent des pauvres performances alors que celles des moteurs d'exécution JS ont été décuplées ces dernières années.
Qui estiment que les pages Web d'aujourd'hui sont trop lourdes alors que les technos de templating client et de stockage local ont été boostées par le Web Mobile pour rendre les sites utilisables même en 2G.
Qui proclament que le Javascript n'est pas adapté aux applications lourdes, alors qu'aujourd'hui on peut en JS faire des moteurs 3D (Unreal Engine 3) des applications serveur (Node.js) qui font déjà leur preuve et servent des millions de clients, et même des systèmes d'exploitation (Firefox OS) !

Je suis habitué à ce genre de personnes, plusieurs de mes collègues sont comme ça. Et quand on leur montre une bonne application web, ils répondent tous "Mouais, c'est pas mal mais ça aurait été mieux fait en [insérer un langage natif discriminant 80% des utilisateurs ici]". Et ensuite ils prennent un air narquois et me montrent une webapp bien lourde et buggée, fait par des amateurs en un mois et surchargée depuis des années par diverses rustines et bricolages douteux. Comme si l'incompétence était réservée au Javascript
12  7 
Avatar de ptah35
Membre éclairé https://www.developpez.com
Le 11/08/2013 à 22:17
Le fait de ne pas déclarer le type des variables en JavaScript n'est pas ce qui fait que JavaScript a un typage faible. Un langage peut avoir à la fois un typage dynamique et fort, c'est le cas du LISP ou de Python par exemple.

Ce qui rend le typage de JavaScript "faible", ce sont essentiellement les conversions de type implicites. Par exemple, les conversions qui sont effectuées lors de l'utilisation de l'opérateur + qui, selon le type des opérandes, représente une addition ou une concaténation. Ce sont ce genre de conversions de types qui rendent difficile la compréhension du code.

Je suis toujours prêt à me faire l'avocat de JavaScript, mais il n'a définitivement pas un typage fort et ce n'est définitivement pas une qualité.
5  0 
Avatar de Kaamo
Membre émérite https://www.developpez.com
Le 19/08/2013 à 16:30
Le typage typique à Javascript vient en partie du fait qu'il n'y avait pas de gestionnaire d'erreur dans la v1 du langage. (comprendre les blocs try {} catch() {} finally {} ). Du coup, plutôt que de jeter une exception (impossible à l'époque!) les variables sont implicitement converties et c'est aussi pourquoi JS échoue silencieusement. (Source : un tweet de Brendan Eich, le papa de JS).

Bien que ce typage ait ses inconvénients (conversion implicite en chaîne de caractère : '5' + 6 === '56') il a ses points forts, par exemple, quand il s'agit de traduire implicitement en booléen. A chaque fois que JS s'attend à un booléen (par exemple dans un if) toutes les valeurs peuvent être utilisées, elles sont automatiquement converties en true ou false (false si la valeur de la variable est égale à undefined, null, false, -0, +0, NaN, ''. true sinon). Il faut avouer que dans ce sens cela en arrange plus d'un.
Considérez-vous comme moi qu'au final, JavaScript est fortement typé ?
Je dirais que Javascript a un typage dynamique et plus particulièrement un "typage canard" (voir Duck Typing).
Cela veut dire que Javascript ne va pas vérifier le type de la variable avant de réaliser ce qu'on lui demande, mais va tout simplement vérifier si la variable peut réaliser ce qu'on lui demande.
Code : Sélectionner tout
1
2
3
4
5
6
7
var donald = {};
donald.bafouille(); // Object #<Object> has no method 'bafouille'

donald.bafouille = function bafouille() {
  console.log('Kshhshsh blblbl');
}
donald.bafouille(); // Kshhshsh blblbl
5  1