Différence entre les langues fortement et faiblement typées?

J'ai lu plusieurs pages, dont la page wiki http://en.wikipedia.org/wiki/Strong_and_weak_typing traitant fortement et faiblement typé langues. Pour la plupart, je pense que je comprends la différence. Cependant, je voudrais un droit au point de répondre à différencier les deux.

À partir de ma compréhension, faiblement typé langues, types de données n'ont pas à être appelée explicitement. Ce serait une langue comme Matlab où vous pouvez ajouter les 4 et 2.3, sans avoir à transtypage. Langages fortement typés nécessitent que le programmeur de déclarer un type de données pour chaque variable et/ou de la valeur. Par exemple, en C, vous aurez besoin de faire quelque chose comme 4 + (int) 2.3 ou (float)4 + 2.3 (ne me souviens pas si c'est valide de type C-casting).

Toutes les informations de l'expansion ou de la correction de ma compréhension de ces concepts seraient grandement appréciés.

source d'informationauteur Josh

  1. 9

    Vérifier Eric Lippert du blog. Il y a une entrée sur exactement ce que vous cherchez pour ici.

    L'apparence de son blog, ces termes sont subjectives, afin de "parler plus précisément sur le type de fonctionnalités du système."

  2. 23

    La différence n'est pas sur la déclaration des types de variables. C'est un peu plus subtile que cela (et rythme Eric Lippert, je pense que le terme est assez bien défini). La différence est que dans un fortement typées langue, chaque expression a un type qui peut être déterminé au moment de la compilationet seules les opérations appropriées à ce type sont autorisés.

    Dans un non ("faiblement typé" les critiques, "dynamiquement typé" pour les fans) de la langue, qui n'est pas le cas. La langue permet à toute opération effectuée sur n'importe quel type, avec le plutôt importante réserve que l'opération peut échouer. C'est, alors que la langue peut autoriser l'opération, le runtime peut pas.

    Notez qu'il est possible d'avoir un typage fort de langue sans nécessiter de déclarations de type partout. En effet, aucun fortement typées la langue. Considérez ceci bits de Java:

    String s = "hellO";
int l = s.getBytes().length;

    Comment le compilateur décider que .length est légal? C'est légal, car il est utilisé sur un byte[]. Mais il n'y a aucune déclaration de quelque chose comme un byte[] ici. Plutôt, le compilateur sait que s est un Stringet que lorsque vous appelez getBytes() sur un Stringvous obtenez un byte[]. Il déduit de ces faits que le type de s.getBytes() est un byte[]et donc qu'il est légal de demander pour son length.

    Certaines langues, dont le type de systèmes sont plus sophistiqués que Java est de permettre au compilateur de déduire plus que cela. Par exemple, dans Scala, vous pouvez dire:

    val s = "hello"
val l = s.getBytes().length

    Et le compilateur déduit les types de s et lainsi que des expressions intermédiaires.

    Les langues qui ont un typage fort, mais des limites artificielles sur l'inférence de type qui nécessitent redondant déclarations de type (comme Java) sont décrits comme ayant manifeste tapantparce que les types doit être manifeste, ce qui est une façon élégante de dire explicitement amenés à l'existence, ce qui est une façon élégante de dire par écrit.

  3. 2

    Comme vous l'avez dit...
    ...dans faiblement typé langues, types de données n'ont pas à être appelée explicitement.

    Langages fortement typés nécessitent que le programmeur de déclarer un type de données pour chaque variable et/ou de la valeur.

    C'est correct...

    Il y a aussi une sorte de paradigme dans les soi-disant "vivement" tapé des langages tels que c# dans quels types peuvent être déclarés si nécessaire ou souhaité par le programmeur... par exemple C# a "var", mais a également un fort types (Int32, String, Boolean, etc.) qui beaucoup de programmeurs qui utilisent cette langue préférez.

    De cette façon, une langue peut être à la fois "fortement" et "faiblement" tapé.

    J'espère que cela vous aide à approfondir la compréhension de ce concept...