+ Répondre à la discussion Actualité déjà publiée
Page 6 sur 7 PremièrePremière ... 234567 DernièreDernière
  1. #101
    Membre chevronné
    Avatar de la.lune
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    décembre 2010
    Messages
    531
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Comores

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2010
    Messages : 531
    Points : 2 048
    Points
    2 048

    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.

    Le typage dynamique n'affecte donc pas le type des opérandes.
    Dans quel langage, quelque soit le typage, les opérateur ou les fonctions, modifient le type des opérandes ou les variables passé en paramètre? Tant qu'il n y a aucune affectation quelque part sur les opérandes, que soit après ou inter instruction, ou en interne de l'objet qui appel la fonction, alors ils restent tel qu'ils sont.

    Le casting, le parsing , les appel de fonctions et toutes les instructions s'en chargent de retourner quelque chose qu'on veut, ils ne modifient jamais le contenu ou le type des variables, a moins que les variables soient aussi utilisés pour affecter la valeur retourné.

    C'est un principe de base de la programmation, et montrez moi un seul langage qui enfreint ce principe.

    Alors le fait que JavaScript suit ce principe de base de tous les langages, ça n'a rien rien n'avoir avec un typage faible ou fort.

    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 !
    On travail avec JavaScript et les erreurs de type de JavaScript ne sont pas vraiment significatives, et ne servent pas à grand chose dans le cadre du typage.

    Rappelons que quand vous voulez appeler une fonction qui n'existe pas, et qu'avant les deux parenthèses d'appel ce n'est pas une fonction déjà défini ou une fonction en cours de définition, ou une variable qu'on a affecté une fonction, alors il va donner un message de Type error disant que tel n'est pas une fonction et si l'objet existe alors que vous appeler une méthode qui n'existe pas il va vous donner une erreur de type et vous dire tel objet ne contient pas tel fonction.

    Et si il reconnait le type de la variable autre que fonction, il va vous dire que le type de cette variable n'est pas une fonction.

    A ma modeste connaissance, JavaScript ne reconnait que cela pour donner un message "Type error", c'est l’inexistence de fonction ce qui ne peut en aucun cas faire l'objet d'un typage fort. Il peut vous dire dans certains cas que tel variable est indéfini, mais c'est une erreur de base.

    Loin du fait d'un typage dynamique, mais toute instruction est censé retourner quelque chose, s'il y a une erreur de type ça doit nous signaler. Alors dans le cas d'erreur de type autre que ce que j'ai mentionné, JavaScript quand il n'arrive pas à retourner quelque chose avec les opérandes ou fonction il va vous retourner null ou quelque chose de type undefined, et c'est tout.

    Il ne détecte pas les vrai erreurs de type.

    En faisant par exemple:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    a="djdj";
    b=2;
    c=b-a;
    //c=null
    c est égale à null, alors que JavaScript a su que "a" est de type string et "b" est de type nombre. Il ne peut jamais nous dire "on ne peut pas convertir un string en entier ! Jamais!!!
    Mais il se contente de nous retourner null.

    Mais viendrons par exemple en Java:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    String a="ddd";
    int b; 
    int c=b-a;
    Ce code ne va même pas se compiler le compilateur va vous dire qu'on ne peut pas convertir un string en entier.

    Et si on fait par exemple en JavaScript
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    String a="ddd";
    int b; 
    int c=b-parseInt(a);
    Il va juste vous retourner null, par contre en java par exemple
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    int a=2;
    String b="ddd";
    int c=a-Integer.parseInt(b);
    Il va compiler, mais lors de l’exécution il va vous retourner une vraie erreur de type en levant une Exception de type NumberFormatException.

    Le typage fort aussi peut entrer dans le cadre du nombre de type primitif, mais aussi de l'espace mémoire alloué pour chaque type de variable, et ça devient important maintenant que JavaScript fonctionne côté serveur. JavaScript gère seulement 3 type primitifs string, number et boolean, point barre. On ne peut pas le comparer par exemple à C/C++ ou java.

    Un type double en C n'est pas un type float, et un type int n'est pas un long , ils n'occupent la même espace mémoire.

    Pour conclure, JavaScript est typé comme tous les autres langages. Le fait qu'un langage comprenne le type des contenus des variables qu'il traite (à la limite ce qu'il sait gérer) est un pilier de chaque langage de programmation, sinon il ne pourra jamais faire des calcules.

    Mais si on veut classer le typage de JavaScript, je ne vois pas en quoi il peut se mettre au rend des langages à typage fort. Son typage est faible.

  2. #102
    Membre expert
    Avatar de Kaamo
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    avril 2007
    Messages
    1 169
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : avril 2007
    Messages : 1 169
    Points : 3 029
    Points
    3 029

    Par défaut

    Dans quel langage, quelque soit le typage, les opérateur ou les fonctions, modifient le type des opérandes ou les variables passé en paramètre? Tant qu'il n y a aucune affectation quelque part sur les opérandes, que soit après ou inter instruction, ou en interne de l'objet qui appel la fonction, alors ils restent tel qu'ils sont.
    Je n'ai pas compris

    a="djdj";
    b=2;
    c=b-a;
    //c=null
    Quelle machine JavaScript utilises tu ? Chez moi il retourne NaN
    c est égale à null, alors que JavaScript a su que "a" est de type string et "b" est de type nombre. Il ne peut jamais nous dire "on ne peut pas convertir un string en entier ! Jamais!!!
    JavaScript convertit implicitement des string en entier, quand c'est possible. Sinon il utilise NaN. C'est sa façon de dire qu'il ne peut pas convertir implicitement l'opérande en entier.
    Bien sûr, la valeur de la variable (opérande) n'est pas modifiée mais elle est implicitement convertie durant une opération sur celle-ci.
    Exemples :
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    // Conversion implicite des string en number
    var a = '5';
    var b = '3';
    console.log(a - b, typeof (a-b)); // 2, number. Les opérandes sont implicitement converties durant le calcul et donnent un résultat de type number
    // Par contre, les opérandes ne sont pas modifiées
    console.log(a, typeof a); // '5', string
    console.log(b, typeof b); // '3', string
     
    // Conversion implicite en boolean
    // Grâce à ce principe, l'instruction if, par exemple, peut prendre n'importe quelle valeur.
    var testedValues = [undefined, null, false, -0, +0, NaN, '', 1, -1, 'a', true, Infinity, {}, []], len = testedValues.length, i = 0;
    for (; i<len ; i++) {
      console.log(testedValues[i] + ' => implicitement convertie à ' + (testedValues[i] ? 'true' : 'false'));
    }
    /*
    Tu l'auras compris, undefined, null, false, -0, +0, NaN, '' sont implicitement convertis en false, le reste à true
     
    undefined => implicitement convertie à false
    null => implicitement convertie à false
    false => implicitement convertie à false
    0 => implicitement convertie à false
    0 => implicitement convertie à false
    NaN => implicitement convertie à false
    '' => implicitement convertie à false
    1 => implicitement convertie à true
    -1 => implicitement convertie à true
    a => implicitement convertie à true
    true => implicitement convertie à true
    Infinity => implicitement convertie à true
    [object Object] => implicitement convertie à true
    [] => implicitement convertie à true 
    */
     
    // Conversion implicite en string
    // l'opérateur + est particulier. Il a le rôle de concaténation de string et d'addition de number. Analyse de l'expression de gauche à droite. Rant qu'il rencontre des number : addition. Dès qu'une string apparaît : concaténation.
    var x = '5';
    console.log(x + 1); // 51
    console.log(1 + x); // 15
    console.log(1 + 3 + x); // 45
     
    // Conversion implicite des Object en string ou en number
    // Quand JavaScript attend un string ou un number (exemple lors d'une concaténation / addition), il va tenter de convertir l'objet dans le type souhaité.
     
    // Si JavaScript attend un number, mais qu'il rencontre un Object : Il va checker s'il contient une méthode valueOf, si oui, retourne la valeur. Sinon, il check s'il contient une méthode toString, si oui, retourne la valeur. Sinon, NaN.
    var a = { valueOf: function () { return 5 } };
    3 * a; // 15, se sert de valueOf()
    var a = { bipbip: function () { return 5 }, toString: function () { return 7 } };
    3 * a; // 21, se sert de toString()
    var a = { bipbip: function () { return 5 } };
    3 * a; // NaN, pas de méthode valueOf ou toString
     
    // Si JavaScript attend une string, même principe que ci-dessus
    var a = { toString: function () { return 'toto' } };
    'je suis ' + a; // "je suis toto", se sert de toString  de l'objet a
    var a = { bipbip: function () { return 'toto' } };
    'je suis ' + a; // 'je suis [object Object]',  toString  est absent dans a, donc se sert de toString de a.prototype (soit la méthode toString native de Object).

    Pour quoi cette conversion implicite ? Car JavaScript, dans sa première version, n'avait pas la gestion des erreurs (comprendre bloc try{}catch() voir (1) ). Pas de gestion des erreurs => conversion implicite + échoue silencieusement.

    JavaScript gère seulement 3 type primitifs string, number et boolean, point barre
    Il y a aussi undefined et null (2), qui sont des cas particuliers car pas d'objet "wrapers" associés.

    Pour conclure, JavaScript est typé comme tous les autres langages

    Mais si on veut classer le typage de JavaScript, je ne vois pas en quoi il peut se mettre au rend des langages à typage fort. Son typage est faible.
    Qu'est-ce qu'un typage faible ? A l'instar du typage fort, il n'y a pas de réelle définition. Mieux vaut parler de typage dynamique ou statique.

    JavaScript a un typage à "tendance dynamique". Les types des variables ne sont pas connus au moment de la compilation (parsing). Ils le sont par contre à l'exécution. Et encore, il ne contrôle pas tout :
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    // null, il jette une erreur
    var a = null;
    a.prop; // TypeError: Cannot read property 'prop' of null
     
    // object, il ne bronche pas
    var a = {};
    a.prop; // silencieux, undefined

    Comme je l'ai écrit un peu avant dans cette discussion :

    Je dirais que Javascript a un typage à "tendance 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 javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    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

    Source :
    (1) Tweet Brendan Eich
    (2) ECMA spéc.

  3. #103
    Membre chevronné
    Avatar de la.lune
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    décembre 2010
    Messages
    531
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Comores

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2010
    Messages : 531
    Points : 2 048
    Points
    2 048

    Par défaut

    Citation Envoyé par Kaamo Voir le message
    Je n'ai pas compris
    J'ai lu tout le message de bovino , et il nous a fait comprendre comme quoi la manipulation des opérandes n'affecte pas le type de ces opérandes, c'est pour celà que le typage dynamique ne modifient pas le type des variables. Moi j'ai demandé quel language fait le contraire?

    Comment une opérande, un paramètre de fonction ou objet qui appel une fonction, peut être modifié alors qu'acune affectation quelque part n'est fait?

    Il a donné par exemple un exemple ici:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    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.
    Mais la question que je me demande quel language allait modifié le type de tab alors la fonction join() ne s'en charge pas de modifier le status de tab dans son espace mémoire, mais de prendre ce qui est là et le manipuler, pour retourner quelque chose, tant qu'il n y a pas d'affectation ou destruction quelque part(déjà un objet ne peut jamais se détruire lui même), tous les languages objets fonctionnent ainsi, la référence et le type resterons tel qu'ils sont.

  4. #104
    Membre expert
    Avatar de Kaamo
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    avril 2007
    Messages
    1 169
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : avril 2007
    Messages : 1 169
    Points : 3 029
    Points
    3 029

    Par défaut

    Mais la question que je me demande quel language allait modifié le type de tab
    join ne modifie pas tab .. mais la plupart des méthodes d'Array modifie l'occurrence. Par exemple :
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    var tab = [1,2,3];
    tab.push(4);
    console.log(tab); // [1, 2, 3, 4] 
     
    var tab = [3,2,1];
    tab.sort();
    console.log(tab); // [1, 2, 3]
    Sans qu'il n'y ait eu d'affectation

  5. #105
    Membre chevronné
    Avatar de la.lune
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    décembre 2010
    Messages
    531
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Comores

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2010
    Messages : 531
    Points : 2 048
    Points
    2 048

    Par défaut

    Citation Envoyé par Kaamo Voir le message
    join ne modifie pas tab .. mais la plupart des méthodes d'Array modifie l'occurrence. Par exemple :
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    var tab = [1,2,3];
    tab.push(4);
    console.log(tab); // [1, 2, 3, 4] 
     
    var tab = [3,2,1];
    tab.sort();
    console.log(tab); // [1, 2, 3]
    Sans qu'il n'y ait eu d'affectation
    Je suis désolé, a mon avis tu n'a pas compris ma question, ton exemple est loin de ce que j'ai posé comme question. Ce que tu vient de faire, tu as juste apporter des modifications sur le contenu de l'objet de type Array. Mais tu n'a pas modifié le type , tab reste de type Array.

    Par contre si on fait:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    var a=[1,2,3,4];
    var f=a.join(',');
    //typeof(f)==string;
    Pour tous les langages le type d'un objet sera modifié, si tout simplement on affecte sur lui même quelque chose objet=machin, ou bien on le détruit, qu'il pointe vers null, ou autre objet, ou variable.

    Citation Envoyé par Kaamo Voir le message
    JavaScript convertit implicitement des string en entier, quand c'est possible. Sinon il utilise NaN. C'est sa façon de dire qu'il ne peut pas convertir implicitement l'opérande en entier.
    C'est ça façon de "dire", ou c'est sont choix de retour. Car comme je l'ai dis toute instruction doit retourner quelque chose. JavaScript doit absolument retourner quelque chose, ou rompre le programme en signalant qu'il n peut rien retourner car il y a des erreurs. Pour ce cas là il retourne NaN mais comme si tout va bien.

    Les concepteurs du langage considèrent que c'est un comportement normal qui ne doit pas rompre le programme ou renvoyer un message d'erreur.

    Le problème, c'est que dans ce genre de situation, on peux perdre beaucoup du temps à chercher où est l'erreur, si on avait pas demandé d'afficher le résultat qui renvoie NaN. Soyons sérieux on ne peut pas demander d'afficher tout variable qu'on va convertir, sinon ça serait un programme de log.

    Alors on appel pas ça "dire", car on sait bien que tout ne va pas, il faut au moins un message d'erreur, si on ne rompe pas le programme, pour aider le développeur à comprendre les erreurs qu'il fait. Un langage c'est pour coder, mais c'est aussi pour parler avec le développeur afin qu'il réussisse aisément sa mission, sinon aucun langage n'allait renvoyer des message d'erreur.

    Citation Envoyé par Kaamo Voir le message
    Bien sûr, la valeur de la variable (opérande) n'est pas modifiée mais elle est implicitement convertie durant une opération sur celle-ci.
    La conversion implicite, c'est une nouvelle donnée et un espace mémoire que la convertie sera placée, la source reste non touchée.

    Soyons claire, certes il n y a pas de définition pour dire quel tel est de typage fort ou faible. Mais les langages sont le fruit de l'homme, quand il veut fortifier un concept il le fait et quand il veut rendre les choses un peu souple, sans tenir trop de paramètre, il le fait aussi. Ce n'est pas un bon matin que beaucoup de concepteurs de langages ont choisit d'être sévère sur les types, (pas dans son contexte dynamique ou static), mais sur la manière de gérer leurs comportement au sein d'un programme si c'est fortifié ou le contraire.

    A l'appui de ce que je dis, Bovino a voulu donner à l'appuis de ce qu'il disait le fait du renvoie de message d'erreur de type. Mais malheureusement, JavaScript ne renvoie celà que s'il ne trouve pas de fonction. Seulement! Or une fonction n'est même pas un type primitif.

  6. #106
    Expert éminent
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    juillet 2004
    Messages
    3 933
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2004
    Messages : 3 933
    Points : 8 229
    Points
    8 229

    Par défaut

    heu j'ai la berlue ou quoi

    tu applique une méthode de tri à un tableau
    je ne vois pas en quoi il serait anormal que le tableau en sorte trié.

    le type de base array comme en C ou Java n'existe pas
    le type Array de javaScript c'est comme si tu avais la classe java
    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    public class Array
    {
     
       private ArrayList<Object> data = new ArrayList<Object>();
     
       public Array(Object... initData) {
          for(Object object : initData){
             data.add(object);
          }
       }
     
       public Array reverse() {
          ArrayList<Object> nData = new ArrayList<Object>();
          int size = data.size();
          for(int i = 0; i < size; i++){
             nData.add(size - i, data.get(i));
          }
          data = nData;
          return this;
       }
     
    }
    Je ne vois pas ce qu'il y a d'étrange dans
    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    Array tab = new Array(4, 3, 2, 1); // [4, 3, 2, 1] 
    tab.reverse();// [1, 2, 3, 4]
    C'est exactement ce que tu demande.

    il n'y a là aucune magie ou d'effet de bord ou quoi que ce soit.
    la méthode sort tri le tableau et le retourne c'est sa spec
    ce n'est pas une méthode qui retourne une copie trié.

    on peu ne pas être d'accords sur le fait d'avoir choisi cette spec mais ça n'a rien avoir avec le langage.

    On a la même chose en C++
    la méthode String.Append ajoute une string à l'objet courant
    la méthode String.Concat retourne la concaténation des deux chaines
    on choisit celle qu'on veut.

    Pour Array.sort javascript à choisit d'implémenter la méthode qui tri le tableau sachant qu'une méthode existe pour avoir une copie.

    si tu veux une copie trié et non trier le tableau lui même se choix permet de savoir à coup sur ce que tu tri.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    var tab = [3,2,1];  // [3,2,1]
    var copyTrie = tab.slice(0).sort(); // obtenir une copie trié On voit bien la copie puis le tri de la copie.
    console.log(copyTrie ); // [1, 2, 3]
    console.log(tab);  // [3,2,1]
    tab.sort();
    console.log(tab); // [1, 2, 3]
    Ce n'est pas parce que tu CROIS que les tableau JavaScript sont des Object[] Java ou C++ que c'est le cas.
    Array est une structure de donnée qui à sa spec et qui est cohérente. c'est un objet (ou une classe) comme on en trouve dans tous les langage à objet.

    JavaScript à fait le choix de ne pas avoir de type de base Object[] comme Java C C++ etc.
    et ce choix vaut aussi pour les String qui ne sont pas des char[]en fait JavaScript à défini des types de base qui sont des "Classes" bref le littéraux sont des Objets
    On peut donc écrire des chose comme
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    true.toString();
    //ou 
    "test".charAt(2);
    //ou 
    [4, 3, 2, 1].sort()[2]
    Il y a malheureusement JS n'est pas parfait une exception à cela il s'agit des nombres
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    15.3.toString(); // "15.3"
    15.toString(); //SyntaxError: Unexpected token ILLEGAL
    cela est du à la notation pointé.
    en javascript on utilise objet.method() ou objet.attribut pour accéder à un membre
    et un nombre littéral en Javascript est un object de type Number
    mais un Number peut contenir un . ce . est le séparateur des unités. lorsqu'on utilise un littéral 15 ou 15.3 on a bien un number
    mais à l'analyse syntaxique le compilateur js interprète toujours le premier . comme étant le séparateur des unité et non comme l'accès à un membre.
    JS offre la possibilité d'utiliser l'accès par nom objet["nomMembre"] que ce soit pour une méthode ou un attribut et on peu constater que le littéral 15 est bien un objet comme les autre en faisant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    15["toString"](); //"15"
    Je crois qu'encore une fois tout cela relève d'une méconnaissance et non d'un langage qui serait mal fait.
    Si on prends les définitions des types JS Array
    JS Boolean
    JS Date
    JS Math
    JS Number
    JS String
    JS RegExp
    JS Global
    qu'on implémente des classes Java qui ont le même comportement on pourra voir que ces Classes sont parfaitement utilisables
    Elle n'on rien d'extraordinaire.
    Tout ce que je viens de lire sur les problème de codification non voulu des objets ne sont en fait que une non connaissance de l'API.

    Je pourrais formuler la même critique à PHP lorsqu'on tri un tableau il est trié. C'est pas normal.
    ben si C'est normal : c'est la définition de la fonction de tri array_sort qui tri le tableau pas une copie

    A+JYT
    PS: Pour tout langage à base de classe on lit la doc d el'API pour l'utiliser au mieux pourquoi en javascript les développeurs s'imagine qu'il n'y a que 4 fonctions et pas de structure ? lisez la spec ouvrez l'api
    http://www.ecma-international.org/ecma-262/5.1/

  7. #107
    Membre expert
    Avatar de Kaamo
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    avril 2007
    Messages
    1 169
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : avril 2007
    Messages : 1 169
    Points : 3 029
    Points
    3 029

    Par défaut

    Je suis désolé, a mon avis tu n'a pas compris ma question, ton exemple est loin de ce que j'ai posé comme question. Ce que tu vient de faire, tu as juste apporter des modifications sur le contenu de l'objet de type Array. Mais tu n'a pas modifié le type , tab reste de type Array.
    En effet, la question n'était pas claire.
    Je m'étais arrêté à :
    Comment une opérande, un paramètre de fonction ou objet qui appel une fonction, peut être modifié alors qu'acune affectation quelque part n'est fait?
    Où là ma réponse prend tout son sens

  8. #108
    Rédacteur

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

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

    Informations forums :
    Inscription : juin 2008
    Messages : 23 761
    Points : 92 059
    Points
    92 059
    Billets dans le blog
    20

    Par défaut

    Citation Envoyé par sekaijin
    Il y a malheureusement JS n'est pas parfait une exception à cela il s'agit des nombres
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    15.3.toString(); // "15.3"
    15.toString(); //SyntaxError: Unexpected token ILLEGAL
    Comme tu l'expliques par la suite, c'est dû à la notation pointée en JavaScript qui crée une ambiguïté, mais tu peux tout à fait écrire
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    15..toString(); // "15"
    car l'ambiguïté est alors levée.
    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

  9. #109
    Membre expert
    Avatar de Kaamo
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    avril 2007
    Messages
    1 169
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 29
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : avril 2007
    Messages : 1 169
    Points : 3 029
    Points
    3 029

    Par défaut

    heu j'ai la berlue ou quoi

    tu applique une méthode de tri à un tableau
    je ne vois pas en quoi il serait anormal que le tableau en sorte trié.
    Ce message m'est destiné ? Je ne trouve pas du tout ce comportement anormal. Car j'ai appris le langage.
    Du moment que le développeur connait la spéc. du langage et l'implémentation qui en est faite sur son environnement de travail, tout va bien. Il faut simplement qu'il en ait bien conscience.

    sort, par exemple, modifie le tableau en question sans qu'il n'y ait une affectation.
    slice, par exemple, quant à lui, ne modifie pas le tableau en question mais en renvoie une copie.
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    var a = [1, 2, 3];
    a.slice(1); // [2, 3]
    a; // N'a pas changé ! [1, 2, 3]

    Au début, quand j'ai appris JavaScript, cela m'a semblé anormal que slice ne modifie pas l'instance courante du tableau alors que d'autres méthodes la modifient.

  10. #110
    Expert éminent
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    juillet 2004
    Messages
    3 933
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2004
    Messages : 3 933
    Points : 8 229
    Points
    8 229

    Par défaut

    @kaamo
    ce que tu dit est possible

    un Compilateur ou un interprète peux très bien implémenter une méthode toString() qui ne retourne pas une chaîne mais transforme l'objet en chaîne.

    Je dis bien le compilateur ou l'interprète. ce ne peut pas être une méthode d'un Objet car il faudrait pour ça que l'objet perde son allocation mémoire.

    il nous parait naturel aujourd'hui d'user et d'abuser des pointeurs et des références. mais il fut un temps ou la mémoire était étroite.
    on utilisait donc un système de handler en clair toutes les référence ou les "pointeurs" étaient en fait des double référence.

    dans une zone privilégiée on plaçait de vrai pointeur vers les zone ou les objet étaient placés en mémoire.
    le programme utilisant un pointeur vers ce pointeur. (de façon transparente)
    lorsque la mémoire était morcelée et qu'on n'avait plus de place assez grande pour allouer un nouvel objet on déplaçais les autres objets et on mettait à jour les pointeur dans la zone. le programme pouvais continuer à utiliser son handler qui n'avait pas changé.

    avec une telle gestion de la mémoire la transmutation devient possible est simple.
    lorsque le compilateur ou l'interprète tombe sur une transmutation il exécute une méthode qui crée en mémoire l'objet transmuté et change le pointeur en zone protégé
    à l'accès suivant à son handler le programme tombe sur un objet transmuté.

    du point de vu du développeur dans un tel langage un appel à une transmutation changerais bien l'objet courant sans aucune affectation.

    Même si je vois facilement comment faire un petit langage et un interprète qui implémente un tel concept je ne vois pas à quoi ça pourrait servir ni comment on pourrait ensuite gérer les problèmes que cela engendrerait.

    A+JYT

  11. #111
    Inactif
    Homme Profil pro
    Collégien
    Inscrit en
    octobre 2012
    Messages
    78
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Collégien

    Informations forums :
    Inscription : octobre 2012
    Messages : 78
    Points : 0
    Points
    0

    Par défaut

    pour moi, un langage fortement typé, c'est un langage qui dit :
    "On mélange les bananes avec les pommes!" (comprendre : on fait pas "1"+1, car sinon on sait pas si ça fait 2 ou 11)
    Du coup, Python est un langage fortement typé, JS un langage faiblement typé.
    Il y a différentes sortes de langages fortement typés :
    -Les bizzares, qui n'affichent rien comme résultat. Ex: C
    -Les logiques, qui affichent une erreur. Ex : Python

    Du côté des faiblements typés, il y a ceux qui disent :
    Pour éviter de planter quand on fait "string"+1, on va mettre les strings vont être propriétaire. "1"+1="11". Ex : JS
    C'est l'opération qui décide du type et non l'inverse. "1"+1=2, parceque "+" sert à l'addition et à rien d'autre. Ex : Perl

  12. #112
    Membre chevronné
    Avatar de la.lune
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    décembre 2010
    Messages
    531
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Comores

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2010
    Messages : 531
    Points : 2 048
    Points
    2 048

    Par défaut

    Citation Envoyé par sosolal Voir le message
    pour moi, un langage fortement typé, c'est un langage qui dit :
    "On mélange les bananes avec les pommes!" (comprendre : on fait pas "1"+1, car sinon on sait pas si ça fait 2 ou 11)
    Du coup, Python est un langage fortement typé, JS un langage faiblement typé.
    Il y a différentes sortes de langages fortement typés :
    -Les bizzares, qui n'affichent rien comme résultat. Ex: C
    -Les logiques, qui affichent une erreur. Ex : Python
    Le langage C est un langage faiblement typé, il est juste à typage static. Un langage fortement typé c'est le compilateur qui doit détecter les irrégularités de type avant exécution et une fois aussi joué le compilateur en respectant les normes mais avec de fausses données il faut que le langage soit aussi capable de dire que ça ne va pas et que c'est due au type. De la même chose pour les langages interprétés l’interpréteur doit être capable de signaleur en donnant un message d'erreur pour toutes irrégularités liés aux types. Alors il faut respecter les deux conditions qui suivent, voir wikipédia.
    Un langage est fortement typé si :
    1. la compilation ou l'exécution peuvent détecter des erreurs de typage. Si ces erreurs ne sont jamais reconnues, le langage est faiblement typé ;
    2. les conversions implicites de types sont formellement interdites. Si de telles conversions sont possibles, le langage est faiblement typé
    Au moins le typage faible a bien une définition, si on trouve que les deux conditions posés dans la définit ne sont pas vérifiés et détectés comme erreur en cas d'enfreint alors c'est fini le langage est typage faible.

    Mais, là vient la question sur le langage à typage fort, là le débat est sans limite, car certains vont dire que si un tel langage respecte au moins une des deux conditions peut on le classer fort ou faible. Ce qui est sûr si les deux conditions sont à la fois respectés alors le langage est fortement typé sans discussion.

  13. #113
    Inactif
    Homme Profil pro
    Collégien
    Inscrit en
    octobre 2012
    Messages
    78
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Collégien

    Informations forums :
    Inscription : octobre 2012
    Messages : 78
    Points : 0
    Points
    0

    Par défaut

    Je dirais que seul le deuxième point de la définition qui compte. Le premier n'a rien avoir avec la force du typage : tout langage avec un minimum de logique devrait avoir ça, indépendamment de la force de son typage. Parce qu'additionner des objets de type Banane avec des objets de type Voiture, ce n'est absolument pas logique, indépendamment de la force de typage. (À moins que ça fasse un objet de type BananeEcrasee, faut voir.)

  14. #114
    Expert éminent
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    juillet 2004
    Messages
    3 933
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2004
    Messages : 3 933
    Points : 8 229
    Points
    8 229

    Par défaut

    je trouve cela complètement absurde.

    ramener le faiblement typé au fait qu'on peut faire "1" + 1.

    cela n'est qu'une question de définition de l'opérateur +
    ce n'est pas parce que le compilateur interdit de changer le type d'un objet qu'on ne peut pas définir des opérateurs qui prennent des opérandes de type différents.

    il est tout aussi faux de dire que JS est faiblement typé parce qu'on peut écrire ce genre d'expression.
    Si j'écris add("1", 1) il devient fortement typé ?

    la nature des objets à changé ?

    je trouve tout aussi absurde de dire qu'un langage est faiblement typé parce qu'il permet d'affecter à une variable un Integer puis une String.
    C++ et Java sont faiblement typé alors.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    Object a = new Integer(5);
    a = new String();
    et enfin je pense que beaucoup confondent les noms de leurs objets dans leur code source est les variables dans la mémoire. un nom est un nom et rien de plus.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    var a = new Integer(5);
    var b = a;
    a = "test";
    un prog C++ qui ferait ce genre de chose produirait un code exécutable où ni a ni b n'existe en mémoire seuls l'entier 5 et la chaine "test" existerait.

    JS garde la liste des noms (besoin pour l'interprétation) cela en fait-il un objet en mémoire ?
    les nom des variables ne sont rien de plus que des références.
    viendrait-il à l'idée de quelqu'un de dire que les objets vont changer de nature parce qu'ils sont référencés par une référence de type void& ou Object

    pour reprendre le propos du premier post de cette discussion
    prenez un langage considéré comme fortement type genre C++ ou Java
    développez en utilisant uniquement des variables et des paramètres de fonction de type void& ou Object.

    et vous aurez les même capacités que celle de JS concernant vos variables.
    cela fait-il de ces langages des langages faiblement typés ?

    A+JYT

  15. #115
    Membre chevronné
    Avatar de la.lune
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    décembre 2010
    Messages
    531
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Comores

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2010
    Messages : 531
    Points : 2 048
    Points
    2 048

    Par défaut

    Citation Envoyé par sekaijin Voir le message
    ramener le faiblement typé au fait qu'on peut faire "1" + 1.
    cela n'est qu'une question de définition de l'opérateur +

    il est tout aussi faux de dire que JS est faiblement typé parce qu'on peut écrire ce genre d'expression.
    Si j'écris add("1", 1) il devient fortement typé ?
    Je partage avec vous que le faiblement typé n'est pas lié au fait de faire "1"+1, car c'est juste la définition. Seulement il n y a une différence entre
    "1" + 1 et add("1", 1) , car d'abord ce qui est sûr c'est que la signature est soit add(Object,Object) ou s'il y a bien un surcharge de la méthode comme ça: add(String,Integer) et add(Integer,String) et add(String,String) ..., un des méthodes est bien choisit.

    Ce qui est sûr add("1",1) te donnera sans doute 2, et non pas "11". Si je veux faire "11" on appel pas ça AJOUTER, c'est ce qui fait que dans ce cas on utilise la méthode concat()

    Tout reste que moi je ne vois pas le vrai problème lorsqu'on travail avec des variables de type Object, tant que les normes préalablement définis sont respectés et pour moi il n'est pas question de nom de variables. Avant d'avancer reculons un peu pour voir: l'opérateur + par exemple en Java et JavaScript s'utilisent pour ajouter des nombres et concaténer, il y a une règle en commun c'est que tant qu'il y a une chaîne au milieu alors le résultat final sera une chaîne et tout ce qui est avant la chaîne sera évalué et tout ce qui est après la chaîne s'il n a pas de parenthèse et ben il sera concaténé.
    C'est pour cela que j'arrive à écrire des trucs comme ça en Java:
    Code Java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     Object a=1+2;//a=3 
             a="1"+"2";//a=="12"
             a="1"+2; //a=="12"
             a=1+2+"3";//a==(1+2)+"3"=="33"
             a=1-2+"3";//a==(1-2)+"3"=="-13"
             a="1"+2+3;//a=="12"+3=="123"
             a="1"+(2-3);//a=="1-1"
             a=1+2+"3"+4;//a==(1+2)+"34"=="334" 
             a=new String("2")+new String("3");//b=="23"
             a=new Integer("2")+new String("3");//b=="23"
             a=new Integer("2")+new Integer(3);//b==new Integer(5)
    a=new Integer("3")-new Integer("2")+new String("3");//b=="23"
    Mais ça s’arrête là vu que l'opérateur + a été surchargé pour la concaténation, du coup il fallait un certains nombre de règles à appliquer, ainsi si je veux faire "1"-2 ou ça a="1"+2-3;, il va refusé, c'est une erreur de compilation car aucune règle d'utilisation de l’opérateur - pour des chaîne, on a surchargé + à la limite pour faciliter des milliers de taches répétitives de concaténation, et qu'enfin ça vous donnera toujours des chaines, mais il est hors de question de faire des calculs sur des chaines. On pourrait utiliser le <.> comme en php, mais le jeu serait le même.

    Un tableau de caractère ça reste un tableau de caractère, si vous êtes sûr ce que vous voulez convertissez le. Ce qui est important ici c'est que l'exception a été donné seulement à l'objet de type String, et dés que ce dernier se trouve dans l’instruction alors il sera obligatoirement le type du résultat final on sort carrément du cadre de calcul, ça reste de la concaténation et le type est déjà défini et connu comme type final. D'autres objets n'ont pas de places ici.

    Mais en JavaScript ils mélangent tout à part le fait de permettre des conversion implicites des chaines, mais tu peux tout mélanger à la fois faire des calculs sur n'importe quoi, un truc comme ça par exemple:
    var a=new Array()+new Number(4)-new String("2")+new Boolean(true); a==3
    var b=12/['2']+['2','3'];a=="62,3"
    Du coup, au delà des règles fixés en cas de présence de chaîne, JavaScript devient un peu bordélique en typage.

    En plus de ça si je me permet de mettre de fausses données il va seulement me retourner NaN sans me dire que ce qui lui a causé tout ça, il est incapable de dire "Eh je n'arrive pas à convertir un tel en tel, ou calculer tel avec tel" non, il se tais et retourne NaN et si c'est dans des milliers de lignes de code: un jeux par exemple où on manipule beaucoup les nombres c'est fini toute la journée va passer là, car il ne te dira rien. Ça bug c'est tout.

    Du coup si en Java je fais
    a=new Integer("b")+new Integer("2"); ça va compiler mais, quand ça ne va pas marcher avec le b quand il voudra convertir, tu saura là où est l'erreur et même la ligne exacte et toute la pile des méthodes infectés.
    prenez un langage considéré comme fortement type genre C++ ou Java
    développez en utilisant uniquement des variables et des paramètres de fonction de type void& ou Object.
    Non, car ce qui est après la variable de type Object est évalué et enfin un objet est retourné à la fin, et mis dans Object, certes si je teste son type je saurais de quel type il s'agit
    En JavaScript je peux faire:
    Code JavaScript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    var a=2;
    var b=3
    var c=a+b;//c==5
    Mais je ne peux pas faire en Java ceci:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Object a=2;        
    Object b=3;
    Object c=a+b;//ERREUR DE COMPILATION
    Le compilateur dira qu'il n y a pas de calcul sur des Objet, le typage fort oblige, je dois faire ceci pour que ça marche:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Object c=((Integer)a)+((Integer)b); c==new Integer(5)
    J'ai vu dans un de tes messages ici, faire une comparaison sur entre JavaScript et Java en montrant comme quoi Java oblige d'ajouter une variable de plus c'était ça:
    Citation Envoyé par sekaijin Voir le message
    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    Object obj = myMap.get("truc");
    if (obj instenceof Machin) {
    Machin truc = (Machin)obj;
    truc.myMethod();
    }
    et
    Code javascript : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    var truc = myMap.get("truc");
    if (truc instanceof Machin) {
    truc.myMethod();
    }
    Je tiens à rappeler que c'est juste toi qui a ajouter cette variable, mais je ne suis obligé de l'ajouter, juste un casting de plus, je peux faire tout court en Java:
    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    Object truc = myMap.get("truc");
    if (truc instenceof Machin) {
    ((Machin)truc).myMethod();
    }

  16. #116
    Membre éprouvé

    Profil pro
    Inscrit en
    juin 2007
    Messages
    745
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2007
    Messages : 745
    Points : 1 017
    Points
    1 017

    Par défaut

    sur le typage c'est un sujet sur lequel cela à déjà été fortement débattu;

    mais clairement, pour moi encore une fois, ce que l'on peu "typer" c'est une variable ou quelque chose que l'on peu imaginer être typable.

    le fait que C soit un langage fort, est principalement admis parce que c'est le langage même employé par les gens qui l'utilisent qui ont définis des normes.

    le fait est que certaines personnes utilisent des languages plus récent comme JavaScript, et a une époque action script ou d'autre, et que de façon très "matériel", logique et mathématique, il ne me semble pas crédible de dire que JS ne soit pas "tres fortement typé", juste parce que des Ayatollah ont décidés que js ne serait pas comme cela pour les 50 ans à venir, il suffis de se servir de JS pour s'en rendre compte...

    Donc voila, cherchez pas...

    Js pour moi est fortement typé comme le piment d’Espelette est typé pour toi!

    La personne qui ne reconnais pas le fort typage de ce langage , a peu être vu autre chose, mais pas son typage fort...

    et voilà, ce n'est pas tout à fait un langage typé fort comme pour l'obligation d'avoir des déclaration en C ou java, mais c'est sur que le typage des variables dans ce langage à des normes, et peu être autant aussi précise que pour les les autres.

    Mais le plus choquant, c'est les personnes essayant de détruire le typage propre à js, pour dire oui mais ce n'est pas fortement typé...

    sisi, dans le context JS c'est fortement typé, toi tu viens de C, tu trouve c'est pas fortement typé, c'est pas la faute au langage, mais réfléchi un peu!!!


    voila

    enjoy
    Conception / Dev

  17. #117
    Expert éminent
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    juillet 2004
    Messages
    3 933
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2004
    Messages : 3 933
    Points : 8 229
    Points
    8 229

    Par défaut

    Citation Envoyé par la.lune Voir le message
    ...
    Je ne me prononçais pas sur le fait que js est ou pas fortement typé.
    je consteste simplement qu'un dise qu'un langage quelqu'il soit soit dit faiblement typé parce qu'on peut écrire de telle expression.

    tout cela ne relève que de la définition de l'opérateur et non du fait que le langage est fortement typé.

    C++ qui est communément admi comme fortement typé permet d'écrire
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    a=new Array()+new Number(4)-new String("2")+new Boolean(true)
    . cela ne fait pas de C++ un langage faiblement typé.

    quant à la comparaison entre js et java tu as surement mal lu mes propos car ce que je dis c'est qu'en java on vérifie qu'un objet est membre d'une classe avant de faire un cast pour appeler une méthode et qu'en js on fait pareil avec en plus la possibilité de tester si l'objet possède la méthode. et que donc ça ne change rien. je ne parle pas d'ajouter ou pas une variable.
    je dis qu'inévitablement en Java on se retrouve avec des Cast et que pour moi devoir vérifier l'appartenance d'un objet à une classe (ou s'en assurer) ou vérifier l'existence d'une méthode ne change rien.

    JavaScript est assez intéligent pour que tu n'ai pas à ecrire le cast alors cela change la nature des variables ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Object c=((Integer)a)+((Integer)b); c==new Integer(5)
    aprest cette expression en java a et b ne sont plus des objet ?

    lorsque tu écris en javascript
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    var a=2;
    var b=3
    var c=a+b;
    c = "test;
    tu est en train de faire l'équivalent en java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    Object a=new Integer(2);        
    Object b=new Integer(3);
    Object c=((Integer)a)+((Integer)b);
    c = "test";
    Je ne vois là aucune différence quant au typage du langage. l'un fait une inférence de type pour déterminer l'expression l'autre demande un cast explicite. mais dans les deux cas les objets ne changent pas de nature en cours de route.
    A+JYT

  18. #118
    Expert éminent Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    3 468
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2002
    Messages : 3 468
    Points : 7 993
    Points
    7 993

    Par défaut

    Citation Envoyé par sekaijin
    Je ne vois là aucune différence quant au typage du langage. l'un fait une inférence de type pour déterminer l'expression l'autre demande un cast explicite. mais dans les deux cas les objets ne changent pas de nature en cours de route.
    Sauf que dans le cas de JavaScript c'est le fonctionnement naturel alors qu'en java ce que tu présente est clairement un anti-pattern que l'on essaie autant que possible d'éviter. Depuis que Java a les génériques il est plutôt rare d'avoir a faire du downcasting et encore plus d'utiliser le type Object directement.

    J'ai vraiment l'impression quand je lis tes messages que tu essaies d'utiliser Java de la même manière que le Javascript alors que l’intérêt du typage fort quand il est correctement utilisé est qu'il permet généralement d'éviter de se retrouver dans ces cas.

  19. #119
    Expert éminent
    Avatar de sekaijin
    Homme Profil pro
    Urbaniste
    Inscrit en
    juillet 2004
    Messages
    3 933
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Urbaniste
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2004
    Messages : 3 933
    Points : 8 229
    Points
    8 229

    Par défaut

    Mais ça ne change pas la nature de tes objets

    ce que j'écris en java ne vise qu'à montrer que l'expréssion que tu utilise en JS pour dire qu'il est faiblement typé existe aussi en Java.

    Cela ne faisant pas de Java un langage faiblement typé pourquoi cette même expression ferait-elle de JS un langage faiblement typé.

    tu ne peux pas dire qu'une expression démontre que JS est faiblement typé si dans le même temps la même expression démontre l'oposé pour Java.

    Je n'essais pas d'utiliser Java ou JavaScript pour quoi que ce soit.

    Je dis que l'argument est falacieux.

    Je dis que ce n'est pas parce que tu utilise le même nom à deux moments différent pour désigner deux objets de nature différente que ça change le type de tes objets. un nom reste un nom. si tu ne veux pas utiliser le même dans deux partie de ton code ne change rien à l'affaire. pour t'aider Java t'inderdit d'utiliser le même nom pour deux objet de nature différente dans la même section de code. car pour s'y retrouver il associe un type à chaque nom. Javascript considère que tout est objet est que donc un nom peut désignier n'importe quel objet. il associe le type uniquement qu'à l'objet.
    Je ne dis pas que c'est mieux ou moi bien. je dis juste que dans un cas comme dans l'autre le nom utilisé ne change pas la nature de ton objet.

    Je dis qu'utiliser une expression qui peut se traduire dans deux langage l'un dit fortement typé l'autre faiblement typé ne démontre rien.

    Je dit qu'untiliser un méthode (opérateur) comme argument pour le typage fort ou faible d'un langage n'a aucun sens vu que les paramètres de la méthodes ou de l'oppérateur peuvent être de toute nature dans les deux approche du typage. ce n'est qu'une question de signature.

    enfin je dit que le typage dynamique n'implique pas obligatoirement que le typage soit faible.

    En javaScript tout comme en Java lorsque tu crée un Objet il a un certain type et celui-ci ne changera jamais jusqu'à sa destruction.

    A+JYT

  20. #120
    Expert éminent Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    3 468
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2002
    Messages : 3 468
    Points : 7 993
    Points
    7 993

    Par défaut

    On peut faire de l'objet en C, ça n'est pas un langage objet pour autant.
    De même, utiliser "Object" partout revient tout à fait à faire du typage faible en Java pour moi. Java n'est pas un langage pour autant faiblement typé, car il ne s'agit pas de l'usage idiomatique.

    Il en va de même pour presque tous les langages dit a typage fort : on peut presque toujours ignorer le typage si on le souhaite. Ça n'en fait pas des langages à typage faible, quand c'est juste un choix volontaire qui est fait ponctuellement.

Discussions similaires

  1. Réponses: 30
    Dernier message: 20/09/2012, 14h25
  2. Réponses: 9
    Dernier message: 27/02/2010, 21h15
  3. Réponses: 2
    Dernier message: 15/01/2010, 17h52
  4. Réponses: 2
    Dernier message: 15/01/2010, 17h52
  5. Réponses: 1
    Dernier message: 05/10/2007, 17h56

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