IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

JavaScript Discussion :

[Article] JavaScript est un langage fortement typé


Sujet :

JavaScript

  1. #1
    Rédacteur

    Avatar de Bovino
    Homme Profil pro
    Développeur Web
    Inscrit en
    Juin 2008
    Messages
    23 647
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 23 647
    Points : 91 418
    Points
    91 418
    Billets dans le blog
    20
    Par défaut [Article] JavaScript est un langage fortement typé


    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 ?
    Pas de question technique par MP !
    Tout le monde peut participer à developpez.com, vous avez une idée, contactez-moi !
    Mes formations video2brain : La formation complète sur JavaScriptJavaScript et le DOM par la pratiquePHP 5 et MySQL : les fondamentaux
    Mon livre sur jQuery
    Module Firefox / Chrome d'intégration de JSFiddle et CodePen sur le forum

  2. #2
    Rédacteur/Modérateur

    Avatar de SylvainPV
    Profil pro
    Inscrit en
    Novembre 2012
    Messages
    3 375
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2012
    Messages : 3 375
    Points : 9 944
    Points
    9 944
    Par défaut
    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 - Visualiser dans une fenêtre à part
    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 - Visualiser dans une fenêtre à part
    "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
    One Web to rule them all

  3. #3
    Rédacteur

    Avatar de danielhagnoul
    Homme Profil pro
    Étudiant perpétuel
    Inscrit en
    Février 2009
    Messages
    6 389
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 73
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant perpétuel
    Secteur : Enseignement

    Informations forums :
    Inscription : Février 2009
    Messages : 6 389
    Points : 22 933
    Points
    22 933
    Billets dans le blog
    125
    Par défaut
    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".

    Blog

    Sans l'analyse et la conception, la programmation est l'art d'ajouter des bogues à un fichier texte vide.
    (Louis Srygley : Without requirements or design, programming is the art of adding bugs to an empty text file.)

  4. #4
    Membre éclairé

    Femme Profil pro
    Experte JS / Conseillère en best practices / Chercheuse en programmation
    Inscrit en
    Octobre 2007
    Messages
    740
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 43
    Localisation : Belgique

    Informations professionnelles :
    Activité : Experte JS / Conseillère en best practices / Chercheuse en programmation
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Octobre 2007
    Messages : 740
    Points : 805
    Points
    805
    Par défaut
    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.
    Afin d'obtenir plus facilement de l'aide, n'hésitez pas à poster votre code de carte bancaire

    Mon GitHub

    Une alternative à jQuery, Angular, Vue.js, React, ... ? Testez anticore, en quelques secondes à peine !
    (Contributions bienvenues)

  5. #5
    Membre émérite
    Avatar de skywaukers
    Homme Profil pro
    Directeur de projet
    Inscrit en
    Juin 2005
    Messages
    1 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 215
    Points : 2 303
    Points
    2 303
    Par défaut
    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 - 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
    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

  6. #6
    Expert éminent sénior Avatar de Uther
    Homme Profil pro
    Tourneur Fraiseur
    Inscrit en
    Avril 2002
    Messages
    4 552
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Tourneur Fraiseur

    Informations forums :
    Inscription : Avril 2002
    Messages : 4 552
    Points : 15 463
    Points
    15 463
    Par défaut
    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à.

  7. #7
    Modérateur
    Avatar de sevyc64
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Janvier 2007
    Messages
    10 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 191
    Points : 28 070
    Points
    28 070
    Par défaut
    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).
    --- Sevyc64 ---

    Parce que le partage est notre force, la connaissance sera notre victoire

  8. #8
    Membre éclairé
    Inscrit en
    Juillet 2012
    Messages
    231
    Détails du profil
    Informations forums :
    Inscription : Juillet 2012
    Messages : 231
    Points : 870
    Points
    870
    Par défaut
    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 - 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.
    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 - 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é !
    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.

  9. #9
    Membre expérimenté
    Homme Profil pro
    Inscrit en
    Janvier 2008
    Messages
    623
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Hauts de Seine (Île de France)

    Informations forums :
    Inscription : Janvier 2008
    Messages : 623
    Points : 1 370
    Points
    1 370
    Par défaut
    En Java :

    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 :)

  10. #10
    Rédacteur/Modérateur


    Homme Profil pro
    Développeur .NET
    Inscrit en
    Février 2004
    Messages
    19 875
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Février 2004
    Messages : 19 875
    Points : 39 749
    Points
    39 749
    Par défaut
    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

  11. #11
    Expert éminent sénior

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 186
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 186
    Points : 17 126
    Points
    17 126
    Par défaut
    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.
    Mes principes de bases du codeur qui veut pouvoir dormir:
    • Une variable de moins est une source d'erreur en moins.
    • Un pointeur de moins est une montagne d'erreurs en moins.
    • Un copier-coller, ça doit se justifier... Deux, c'est un de trop.
    • jamais signifie "sauf si j'ai passé trois jours à prouver que je peux".
    • La plus sotte des questions est celle qu'on ne pose pas.
    Pour faire des graphes, essayez yEd.
    le ter nel est le titre porté par un de mes personnages de jeu de rôle

  12. #12
    gl
    gl est déconnecté
    Rédacteur

    Homme Profil pro
    Inscrit en
    Juin 2002
    Messages
    2 165
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Isère (Rhône Alpes)

    Informations forums :
    Inscription : Juin 2002
    Messages : 2 165
    Points : 4 637
    Points
    4 637
    Par défaut
    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.
    Pas vraiment.
    Le typage dynamique tient plus au fait que le type n'est pas portée par la variable elle-même mais par la valeur qu'elle contient et donc que le type peut évoluer au cours du programme lorsqu'on réaffecte une valeur à la variable.
    Ce que tu décris ici, les conversions implicites, tiennent plus de la force du typage que de son aspect statique/dynamique.


    Citation Envoyé par Bovino Voir le message
    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.
    Ca par contre (détermination du type de la variable à sa création) est de l'ordre du typage statique, pas de la force du typage.


    Citation Envoyé par sevyc64
    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.
    L'aspect détermination du type à la création de la variable ou changement en fonction de la valeur que l'on y stocke s'est de l'ordre du typage statique/dynamique.
    Quant à l'aspect explicite de la déclaration, c'est encore autre chose. On rentre ici dans le côté déclaratif vs. inféré du typage statique.



    Sinon, un gros +1 à grim7reaper sur sa remarque concernant l'aspect non binaire du typage fort/faible (ainsi que sur son excellente explication).

  13. #13
    Rédacteur
    Avatar de imikado
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Décembre 2006
    Messages
    5 239
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Finance

    Informations forums :
    Inscription : Décembre 2006
    Messages : 5 239
    Points : 19 100
    Points
    19 100
    Billets dans le blog
    17
    Par défaut
    Merci pour cet article, on en apprend tous les jours
    Framework php sécurisé et simple à prendre en main avec générateur web http://mkframework.com/ (hebergé sur developpez.com)
    Mes cours/tutoriaux

  14. #14
    Membre expert

    Avatar de germinolegrand
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    Octobre 2010
    Messages
    738
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : Octobre 2010
    Messages : 738
    Points : 3 892
    Points
    3 892
    Par défaut
    Pour ma part je dirais que les notions de typage visiblement sont des notions très faiblement définies à défaut d'être typées ...

    Je trouve pour ma part que le JS complète plutôt bien l'approche du C++ en restant dans du typage similaire. De mon œil de dev C++, je vois les variables JS comme étant des pointeurs (des shared_ptr pour être exact) et non des objets. Et je constate que si vous pouvez changer l'objet pointé, vous ne pouvez pas changer le type de l'objet en question. Vous pouvez changer la valeur du pointeur (ce que bovino appelle redéfinir), mais jamais vous ne travestirez une Voiture en une Carotte. Un exemple tout simple, c'est le code ci-dessous :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    var a;
    var b = "coucou";
     
    a = b;
     
    b = 3;
    Pas une seule fois le type de l'objet String contenant "coucou" n'a changé.
    Seule la valeur du pointeur b est différente, et pointe maintenant vers un objet de type Int dont la valeur est 3. La valeur de a passe de nullptr à l'adresse de l'objet String contenant "coucou". Cette analogie est encore plus visible quand on parle d'objets prototypés, on a un beau new qui est totalement bien nommé ^^.

    Pour ce qui est de l'operator+, Bovino est totalement dans le vrai, on peut faire exactement la même chose en C++ :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    string operator+(string s, int i)
    {
        return s + to_string(i);
    }

  15. #15
    Membre averti
    Homme Profil pro
    Inscrit en
    Juillet 2012
    Messages
    200
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Bénin

    Informations forums :
    Inscription : Juillet 2012
    Messages : 200
    Points : 342
    Points
    342
    Par défaut
    J'apprécie beaucoup cet article. Il m'a permis de comprendre un peu mieux les notions de typage faible et fort, dynamique et statique; et je remarque aussi que les avis divergent sur la notion de typage et que cette notion n'est pas clairement définie.

    En poussant un peu loin ma réflexion, je finis par me dire que le fait qu'un langage soit fortement ou faiblement typé n'est pas un reproche qu'on devrait faire à un langage. Le fait qu'un langage soit typé ou pas dépend de l'usage qui en sera fait.

    JavaScript a été conçu dans l'idée d'être un langage de script, et un script est un petit bout de code qui réalise une petite tâche et dans lequel le type d'une variable (je veux que le type soit fixé une fois pour toute) n'a pas beaucoup d'importance. A l'époque de sa création, je parie que les auteurs de JavaScript n'avaient pas pensé que le langage serait autant utilisé aujourd'hui.

    Les langages comme C++ et Java, vu leur vocation se doivent d'être fortement typés. Mais les langages de script, quant eux...

    Maintenant, je suis le premier à penser qu'il faudrait évoluer une version plus typés des langages JavaScript, PHP et Cie. On a déjà Dart pour JavaScript (Merci(?) à Google).

    Et pour finir, qui a jamais reproché à Batch (j'entends le langage de script shell GNU/Linux ou Windows) d'être faiblement typé?

  16. #16
    Inactif  

    Homme Profil pro
    Développeur .NET
    Inscrit en
    Janvier 2012
    Messages
    4 904
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 67
    Localisation : Canada

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : Finance

    Informations forums :
    Inscription : Janvier 2012
    Messages : 4 904
    Points : 10 168
    Points
    10 168
    Billets dans le blog
    36
    Par défaut
    Typé ou pas, Javascript est une vraie plaie. Quand vous passez l'équivalent de la moitié d'une recharge de batterie de portable à niaiser devant une page Web illisible parce que la maudite série de scripts n'est pas complètement exécutée; c'est le signe d'un maillon faible. Que Javascript soit typé ou non, c'est un débat inutile. Pour que le Web ait le moindrement d'allure, il faut une version compilée de JavaScript au plus sacrant. Parce que maintenant, le Web est rendu aussi "performant" qu'il pouvait l'être à l'époque du modem, même à 54000 bauds ou à peu près, et de la ligne téléphonique. Tout le progrès dans les vitesses de transmission est annihilé par la volonté des exploitants de sites Web d'avoir de beaux sites plus remplis de gugusses que celui du voisin. La beauté, le style et le clinquant ont pris le dessus sur la productivité. Et désolé d'avoir "cassé votre party".
    À ma connaissance, le seul personnage qui a été diagnostiqué comme étant allergique au mot effort. c'est Gaston Lagaffe.

    Ô Saint Excel, Grand Dieu de l'Inutile.

    Excel n'a jamais été, n'est pas et ne sera jamais un SGBD, c'est pour cela que Excel s'appelle Excel et ne s'appelle pas Access junior.

  17. #17
    Membre éprouvé
    Profil pro
    Inscrit en
    Mai 2011
    Messages
    498
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2011
    Messages : 498
    Points : 1 148
    Points
    1 148
    Par défaut
    Je fais actuellement une application de type intranet. Je peux vous dire que on peut très facilement faire des applications de type Client lourds sur son navigateur avec du Javascript.

    Il y a des outils comme Typescript, Coffescript et Dart qui te permettent de jouer avec le Javascript très facilement et d'avoir des typages lourds.

    Personnellement j'utilise Typescript pour avoir un typage fort et avoir un compilateur pour avoir une programmation simple et régulé (enfin au minimum, pas ouf non plus ...) . Car aujourd'hui on fait des types de programmations intelligente qui ont besoin d’être fortement typé.

    Car faire des vérifications de données à chaque fois sur une donnée que je reçois ou qui est susceptible d'avoir changer. Voilà, c'est pas trop ma grande passion.

    De toute façon, c'est pas possible de typé un truc pareil. On risquerait de détruire tout le web . On peut juste utilisé des alternatives si on aime le typage fort.

  18. #18
    Expert confirmé

    Profil pro
    Inscrit en
    Février 2006
    Messages
    2 376
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2006
    Messages : 2 376
    Points : 4 928
    Points
    4 928
    Par défaut
    Citation Envoyé par clementmarcotte Voir le message
    ...
    totalement d'accord, je rajouterai même qu'un langage de script n'est pas fait pour faire des applications, comme son nom l'indique c'est pour faire du script.

    résultat de cette aberration, des fichiers js qui font plusieurs 100 de Ko, yui compressé ou pas, contenant des "véritables" applications, lentes et foireuses au possible. et tout cela rendant (bien sur, sinon ça serait trop facile) nul les améliorations de performances des machines modernes ainsi que le débit des connexions internet.

    mais bon faut comprendre le monde du web, ça serait totalitaire de vouloir un second langage du adapté au dév lourd dans le standard web.

  19. #19
    Rédacteur
    Avatar de imikado
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Décembre 2006
    Messages
    5 239
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Finance

    Informations forums :
    Inscription : Décembre 2006
    Messages : 5 239
    Points : 19 100
    Points
    19 100
    Billets dans le blog
    17
    Par défaut
    Avec l'html5/css3/js on arrive à faire des applications de type SPA performante il me semble.
    Au hasard les applis de google: google docs
    Framework php sécurisé et simple à prendre en main avec générateur web http://mkframework.com/ (hebergé sur developpez.com)
    Mes cours/tutoriaux

  20. #20
    Rédacteur/Modérateur

    Avatar de SylvainPV
    Profil pro
    Inscrit en
    Novembre 2012
    Messages
    3 375
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2012
    Messages : 3 375
    Points : 9 944
    Points
    9 944
    Par défaut
    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
    One Web to rule them all

Discussions similaires

  1. Réponses: 31
    Dernier message: 21/02/2018, 19h15
  2. Réponses: 9
    Dernier message: 27/02/2010, 22h15
  3. Réponses: 2
    Dernier message: 15/01/2010, 18h52
  4. Réponses: 2
    Dernier message: 15/01/2010, 18h52
  5. Réponses: 1
    Dernier message: 05/10/2007, 18h56

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo