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

    [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

    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

    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".

  4. #4
    Membre éclairé
    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
    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
    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

    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é
    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é
    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 <img src="images/smilies/icon_smile.gif" border="0" alt="" title=":)" class="inlineimg" />

  10. #10
    Rédacteur/Modérateur

    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
    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
    Rédacteur

    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

    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
    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
    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  
    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é
    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
    Membre expert
    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

    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

    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

###raw>template_hook.ano_emploi###