Vous avez découvert un point faible dans la terminologie que les amateurs utilisent pour parler des langages de programmation. n'utilisez pas les Termes" fort "et" faible "en tapant , car ils n'ont pas de signification technique universellement reconnue. En revanche, static typing signifie que les programmes sont vérifié avant d'être exécuté , et un programme pourrait être rejeté avant qu'il ne commence. typage dynamique signifie que les types de valeurs sont cochés pendant exécution , et une opération mal typée pourrait provoquer l'arrêt du programme ou autrement signal une erreur à l'exécution . Une raison principale pour la dactylographie statique est d'exclure les programmes qui pourraient avoir de telles "erreurs de type dynamique".

typage fort signifie généralement qu'il y a aucune échappatoire dans le système de type, alors que faible typage signifie que le système de type peut être subverti (invalider toutes les garanties). Les termes sont souvent utilisés incorrectement pour signifier la dactylographie statique et dynamique. Pour voir la différence, pensez à C: la langue est vérifiée au moment de la compilation (saisie statique), mais il y a beaucoup de failles; vous pouvez assez bien lancer une valeur de n'importe quel type à un autre type de la même taille---en particulier, vous pouvez lancer des types de pointeur librement. Pascal était un un langage qui devait être fortement dactylographié mais qui présentait une faille imprévue: une variante sans étiquette.

les implémentations de langues fortement typées acquièrent souvent des failles au fil du temps, généralement pour qu'une partie du système d'exécution puisse être implémentée dans la langue de haut niveau. Par exemple, objectif Caml a une fonction appelée Obj.magic qui a l'effet run-time de simplement retourner son argument, mais au moment de la compilation il convertit une valeur de n'importe quel type à un tout autre type. Mon exemple préféré est Modula-3, dont les concepteurs ont appelé leur construction de type-casting LOOPHOLE .

cela dit, vous ne pouvez pas compter sur deux personnes qui utilisent les mots "fort" et "faible" exactement de la même manière. Afin de les éviter.

simplement dit de cette façon: dans un langage statiquement typé le type est statique , ce qui signifie qu'une fois que vous définissez une variable à un type, vous ne pouvez pas la changer. C'est parce que taper est associé à la variable plutôt qu'à la valeur à laquelle elle se réfère.

par exemple en Java:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

alors que dans un langage dynamiquement typé le type est dynamique , ce qui signifie qu'après avoir défini une variable à un type, vous pouvez la changer. C'est parce que taper est associé à la valeur plutôt qu'à la variable.

par exemple en Python:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

d'un autre côté, le fort/faible typage dans une langue est lié à des conversions de type implicites (en partie tiré de la réponse de @Dario):

par exemple en Python:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

alors qu'en PHP:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

permet de vérifier l'exactitude du type au moment de la compilation. Les langues statiquement typées sont généralement compilées et les langues dynamiquement typées sont interprétées. Par conséquent, les langages dactylographiés dynamiquement peuvent vérifier la dactylographie au moment de l'exécution.

faible typage signifie que le type d'un objet peut changer en fonction du contexte. Par exemple, dans un langage faiblement dactylographié, la chaîne "123" peut être traitée comme le nombre 123 si vous y ajoutez un autre nombre. Bash, awk et PHP sont des exemples de langues à faible typage.

un autre type de langage faiblement typé est C, où les données à une adresse mémoire peuvent être traitées comme un type différent par casting.

Dans un langage fortement typé, le type de un objet ne change pas - int est toujours un int et d'essayer de l'utiliser comme une chaîne de caractères, une erreur sera générée. Java et Python sont tous deux fortement dactylographiés.

la différence entre la frappe dynamique et statique est lorsque les règles de type sont appliquées. Dans un langage statiquement typé, le type de chaque variable et paramètre doit être déclaré dans la source et appliqué au moment de la compilation. Dans un langage dactylographié dynamiquement, les types ne sont vérifiés que lorsqu'ils sont utilisés à l'exécution. Si Java est dactylographié statiquement et Python est dactylographié dynamiquement.

cependant les limites peuvent être un peu floues parfois. Par exemple, bien que Java soit tapé statiquement, chaque fois que vous utilisez reflection ou cast (par exemple quand vous utilisez des conteneurs D'objets), vous reportez le contrôle de type à runtime.

de la même façon, les langues les plus fortement dactylographiées se convertiront encore automatiquement entre les entiers et les flottants (et dans certaines langues une précision aberrante BigInts).

aujourd'hui, en faisant des recherches sur ce sujet, je suis tombé sur ce grand article http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html cela a éclairci beaucoup de choses pour moi et j'ai pensé Qu'il pourrait ajouter à certaines des grandes réponses ci-dessus.

typage fort et faible:

probablement la manière la plus courante de classer les systèmes de type est " forte" ou "faible."C'est malheureux, car ces mots ont presque aucun de sens du tout. Il est possible, dans une certaine mesure, de comparer deux langages avec des systèmes de type très similaires, et en désigner un comme ayant le plus fort de ces deux systèmes. Au-delà, les mots ne veulent rien dire à tous.

types statiques et dynamiques

C'est presque la seule classification commune des systèmes de type qui a un réel sens. Comme une question de fait, il est d'une importance souvent sous-estimés [...] Les systèmes de type dynamique et statique sont deux choses complètement différentes, dont les objectifs se produisent en partie chevauchement.

Un système de type statique est un mécanisme par lequel un compilateur examine code source et attribue des étiquettes (appelées "types") à des morceaux de syntaxe, puis les utilise pour inférer quelque chose sur le programme comportement. Un système de type dynamique est un mécanisme par lequel un compilateur génère du code pour garder la trace du type de données (coïncidence, aussi appelé son "type") utilisé par le programme. L'utilisation d'un même mot "type" dans chacun de ces deux systèmes est, bien sûr, pas vraiment entièrement coïncidence; mais il est mieux compris comme une sorte de faiblesse l'importance historique. Grande confusion résulte d'essayer de trouver un vue du monde dans laquelle "type" signifie vraiment la même chose dans les deux système. Ça ne l'est pas.

Types Explicites / Implicites:

Lorsque ces termes sont utilisés, ils se réfèrent à la mesure dans laquelle compilateur va raisonner sur les types statiques des parties d'un programme. Tout les langages de programmation ont une certaine forme de raisonnement sur les types. Quelque ont plus que d'autres. ML et Haskell ont des types implicites, en ce que no (ou très peu, selon la langue et les extensions utilisées) tapez les déclarations sont nécessaires. Java et Ada ont des types très explicites, et on est constamment en train de déclarer ce genre de choses. Tout ce qui précède a (relativement, par rapport à C et c++, par exemple) système.

je pense que les autres collègues ont fait un bon travail de l'esp. expliquer la différence entre la dactylographie statique et dynamique. Mais en ce qui concerne la dactylographie forte et faible, il faut dire qu'il y a différentes compréhensions / vues.

voici deux exemples:

• certains disent que Haskell est fortement dactylographié, parce que vous n'êtes pas autorisé à faire tout conversions de type.

• D'autres (par exemple, le point de vue de Dario) disent qu'un langage qui permet de passer implicitement d'une chaîne à un nombre exprès est faiblement tapé, mais même d'autres appellent cela Duck dactylography.

les deux énoncés mettent en évidence non pas les extrêmes opposés d'un système de type, mais des aspects complètement différents. Je me joins donc au point de vue de M. Ramsey de ne pas utiliser les Termes "fort" et "faible" pour distinguer les systèmes de type.

Statiquement v/s typées dynamiquement langues

• les langages statiquement typés sont ceux dans lesquels la vérification de type est effectuée au moment de la compilation, ce qui signifie également que dans les langages statiquement typés chaque variable a un type et ne change pas au cours du cours. maintenant, en contraste, les lanaguges dactylographiées dynamiquement sont celles dans lesquelles la vérification de type est faite à l'exécution, et il n'y a pas de vérification de type au moment de la compilation, donc ceci cela signifie également que dans les langages dactylographiés dynamiquement , il peut y avoir ou non un type associé à une variable , et si un type est associé, alors il peut s'agir d'un type générique comme "var" dans JS qui est valable à la fois pour une chaîne et un nombre.
  • " les implémentations de langages contrôlés dynamiquement associent généralement chaque objet runtime à une étiquette de type (i.e., une référence à un type) contenant ses informations de type. Cette information de type d'exécution (RTTI) peut également être utilisée mise en œuvre de la régulation dynamique, de la fixation tardive, de la coulée vers le bas, de la réflexion et d'autres caractéristiques similaires."
• même si la langue est dactylographiée statiquement, elle peut néanmoins avoir une fonction dactylographiée dynamiquement, ce qui signifie essentiellement qu'une sorte de vérification de type à l'exécution aussi bien. C'est utile dans la fonte des types.
  • " un certain nombre de caractéristiques utiles et communes du langage de programmation ne peuvent pas être vérifiées de façon statique, comme la mise en bas. Ainsi, de nombreux langages feront l'objet d'une vérification de type statique et dynamique; le vérificateur de type statique vérifie ce qu'il peut faire, et les vérifications dynamiques vérifient le reste."
• " certaines langues permettent d'écrire un code qui n'est pas du type sûr. Par exemple, en C, les programmeurs peuvent librement jeté une valeur entre deux types qui ont la même taille."
• les avantages des langages dactylographiés" statiquement "sont les suivants:
  • Comme la plupart des vérifications de type sont effectuées au moment de la compilation, l'interpréteur ou l'exécution peuvent donc fonctionner à pleine vitesse, sans se soucier des types.
  • cela conduit à un nombre moindre d'exceptions d'exécution ou d'erreurs liées au type, parce que la plupart de la vérification de type est faite au moment de la compilation.
• les avantages des langages dactylographiés "dynamiquement "sont les suivants:
  • ils pourraient aider dans extrêmement rapide prototypage, puisque le développeur n'a pas besoin de comprendre le système de type donc dev peut librement créer des variables et l'exécuter, et cela conduit à un prototypage très rapide.
• Liste de statiquement et dynamiquement typé lanaguges :
  • statique:
    • Java
    • C (C est un langage statiquement typé mais moins" fortement " typé par rapport à Java parce qu'il permet plus de conversions implicites)
    • C++
    • C#
  • dynamiquement:
    • PERL
    • PHP
    • Python
    • JavaScript
    • Ruby
• la vérification de Type est une caractéristique de sécurité importante. supposons, il n'y a pas vérification de type, et une méthode accepte un objet de type "BankAccount "qui a une méthode appelée" creditAccount(BankAccountDetails)", maintenant à l'exécution s'il n'y a pas de vérification de type alors je peux passer un objet de ma propre classe qui a la même méthode" creditAccount(BankAccountDetails) "et il sera exécuté, considérant que nous parlons de langage orienté objet parce que OOP soutient" polymorphism "et ici ce que nous discutons n'est rien d'autre que"polymorphism". Donc, fondamentalement orientée objet le langage (qui signifie essentiellement qu'il supporte le "polymorphisme") qui n'a pas de vérification de type forte peut conduire à des problèmes de sécurité.

lanaguges fortement v / s faiblement dactylographiées

• les langaguges fortement dactylographiées sont celles dans lesquelles les conversions implicites ne sont pas permises en cas de perte de précision. Par exemple, en Java, vous pouvez lancer un "int à long" parce qu'il n'y a pas de perte de précision mais vous ne pouvez pas "implicitement" lancer un "long int" parce qu'il y aurait une perte de précision. En revanche, dans les langages faiblement dactylographiés, les conversions implicites sont autorisées même en cas de perte de précision.
• je pense que le langage dynamiquement typé peut aussi être un langage fortement typé si" à l'exécution " il ne permet pas les conversions implicites dans lesquelles il y a perte de précision.

les Bonnes nouvelles lectures

• Type_system
• Strong_and_weak_typing
• Category:Statically_typed_programming_langues
• Category:Dynamically_typed_programming_langues

De Scott Langage de Programmation Pragmatique , 3ème edidition page 291, nous avons

la vérification de Type est le processus visant à s'assurer qu'un programme respecte les règles de compatibilité de type du langage. Une violation des règles est connu comme un choc de type. Une langue est dite fortement typée si elle interdit, d'une manière que la mise en œuvre de la langue peut faire respecter, application de toute opération à tout objet qui n'est pas prévu pour soutenez cette opération. Une langue est dit d'être statiquement typé si il est fortement tapé et la vérification de type peut être effectuée à la compilation temps. Au sens strict du terme, peu de langues sont statiquement taper. Dans la pratique, le termis s'applique souvent aux langues dans lesquelles la plupart des vérifications de type peuvent être effectuées au moment de la compilation, et le reste peut être effectué au moment de l'exécution.

quelques exemples: fortement typé, et pour la plupart statically typed (certaines contraintes de type doivent être vérifiées à l'exécution) temps.) Une implémentation Pascal peut également effectuer la plupart de ses vérifications de type au moment de la compilation, bien que la langue ne soit pas très fortement tapée: les enregistrements de variantes non étiquetés (dont il sera question à la Section 7.3.4) sont les suivants: seule échappatoire. C89 est significativement plus fortement typé que son les dialectes antérieurs, mais encore nettement moins dactylographiés que Pascal. Ses lacunes comprennent les syndicats, subroutineswith nombre variable de paramètres, et de l'interopérabilité des pointeurs et tableaux (à discuté dans la Section 7.7.1). Les implémentations de C sont rarement vérifiées rien au moment de l'exécution.

contrôle de type dynamique (run-time) est une forme de fixation tardive, et tend à trouver dans les langues qui retardent d'autres questions jusqu'à l'exécution bien. Lisp et Smalltalk sont dactylographiés dynamiquement (bien que fortement). La plupart des les langages de script sont aussi dactylographiés dynamiquement; certains (par ex., Python et Ruby) sont fortement dactylographiés. Les langues à cadrage dynamique sont généralement tapé dynamiquement (ou pas tapé du tout): si le compilateur ne peut pas identifier l'objet auquel un nom se réfère, il ne peut généralement pas déterminer le type de l'objet.

ainsi, en termes simples, la dactylographie statique/dynamique se réfère au moment où la vérification de type se produit: compiler le temps pour la dactylographie statique, et exécuter le temps pour les langages dynamiques. De même, le typage fort / faible renvoie à la façon dont agressivité d'une langue est dans l'application de son type de système.

j'ai essayé de traduire la description de Scott en un joli diagramme, que j'ai posté ci-dessous.

les langages statiquement typés vous obligent généralement à déclarer les types de variables, qui sont ensuite vérifiées au moment de la compilation pour réduire les erreurs. Le mot "statique" dans "statiquement typé" se réfère à "l'analyse de code statique", qui est le processus d'examen le code avant de l'exécuter. Bien qu'il soit possible pour un langage statiquement typé d'inférer le type de la variable du côté droit d'une expression ou de paramètres réels, dans la pratique les langages statiquement typés exiger que les types de variables soient explicitement déclarés.

les langages dactylographiés dynamiquement n'ont généralement pas besoin de déclarations variables pour avoir des types, et ils déduisent des types variables basés sur le type calculé à la suite de l'évaluation du côté droit de chaque instruction d'affectation ou des paramètres réels à un appel de fonction. Puisque la variable peut être assignée à plusieurs tâches au cours de sa durée de vie, son type peut changer au fil du temps et c'est pourquoi on l'appelle "dynamiquement typée". Aussi, l'environnement d'exécution doit suivre le type de courant pour chaque variable, le type est lié à la valeur plutôt qu'avec la déclaration de la variable. Cela peut être considéré comme un système D'information de type d'exécution (RTTI).

les éléments des langages statiquement et dynamiquement typés peuvent être combinés. Par exemple, C# supporte les variables statiquement et dynamiquement typées, et les langages orientés objet supportent généralement la hiérarchie de type. Statiquement les langages dactylographiés offrent généralement diverses façons de contourner la vérification de type, par exemple en utilisant le casting, la réflexion et l'invocation dynamique.

forte vs. faible typage se réfère à un continuum de combien le langage essaie de prévenir les bogues dus à l'utilisation d'une variable comme si elle était un type alors qu'il est en fait un autre type. Par exemple, C et Java sont des langages statiquement typés, mais Java utilise des contrôles de type beaucoup plus rigoureux que C. le code C suivant est heureux de compiler et lancer, et mettra une valeur aléatoire dans la variable b à l'exécution, causant très probablement un bug:

char *a = "123";
int b = (int)a;

le code Java équivalent produira une erreur de compilation, ce qui est généralement préférable:

String a = "123"
int b = (int)a;