Je vois ces termes circuler partout dans la programmation et j'ai une vague idée de ce qu'ils signifient. Une recherche me montre que de telles choses ont été posées partout en débordement de pile en fait. Pour autant que je sache, le typage statique / dynamique dans les langues est subtilement différent du typage fort / faible, mais quelle est cette différence m'échappe. Différentes sources semblent utiliser des significations différentes ou même utiliser les termes de manière interchangeable. Je ne trouve pas un endroit qui parle des deux et qui explique la différence. Ce qui serait bien, c'est que quelqu'un puisse expliquer cela clairement ici pour moi et le reste du monde.
319
Réponses:
La frappe statique / dynamique concerne le moment où les informations de type sont acquises (soit au moment de la compilation soit au moment de l'exécution)
Le typage fort / faible concerne la distinction stricte entre les types (par exemple, si le langage essaie de faire une conversion implicite des chaînes en nombres).
Voir la page wiki pour des informations plus détaillées.
la source
"12" + "34"
serait égal"46"
, mais"12" + "34Q"
égal"1234Q"
[heureusement, on pourrait écrire"12" & "34"
si l'on voulait la concaténation]. Curieusement, les variables contenant des nombres les stockaient sous forme de flottants à double précision, et les mathématiques sur ces variables utilisaient les valeurs à virgule flottante sans fusion de chaîne, mais il n'y avait aucun moyen de demander si une variable était une chaîne ou un nombre.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» , car ils n'ont pas une signification technique universellement acceptée. En revanche, le typage statique signifie que les programmes sont vérifiés avant d'être exécutés et qu'un programme peut être rejeté avant son démarrage. Le typage dynamique signifie que les types de valeurs sont vérifiés pendant l' exécution et qu'une opération mal typée peut entraîner l'arrêt du programme ou signaler une erreur au moment de l'exécution . Une raison principale du typage statique est d'exclure les programmes qui pourraient avoir de telles "erreurs de type dynamique".
Un typage fort signifie généralement qu'il n'y a pas de failles dans le système de typage , tandis qu'un typage faible signifie que le système de typage peut être inversé (annulant toute garantie). Les termes sont souvent utilisés de manière incorrecte pour désigner une frappe statique et dynamique. Pour voir la différence, pensez à C: le langage est vérifié au moment de la compilation (typage statique), mais il y a beaucoup de failles; vous pouvez à peu près convertir une valeur de n'importe quel type en un autre type de la même taille --- en particulier, vous pouvez convertir librement les types de pointeurs. Pascal était une langue qui devait être fortement typée mais qui avait une faille imprévue: une variante d'enregistrement sans étiquette.
Les implémentations de langages fortement typés acquièrent souvent des failles au fil du temps, généralement de sorte qu'une partie du système d'exécution peut être implémentée dans le langage de haut niveau. Par exemple, Objective Caml a une fonction appelée
Obj.magic
qui a pour effet au moment de l'exécution de simplement renvoyer son argument, mais au moment de la compilation, elle convertit une valeur de n'importe quel type en une autre. Mon exemple préféré est Modula-3, dont les concepteurs ont appelé leur construction de type-castingLOOPHOLE
.Cela dit, vous ne pouvez pas compter sur deux personnes utilisant exactement les mêmes mots "fort" et "faible". Alors évitez-les.
la source
Autrement dit, dans un langage de type statique , le type est statique , ce qui signifie qu'une fois que vous définissez une variable sur un type, vous NE POUVEZ PAS la changer. En effet, la saisie est associée à la variable plutôt qu'à la valeur à laquelle elle se réfère.
Par exemple en Java:
Alors que dans un langage typé dynamiquement, le type est dynamique , ce qui signifie qu'après avoir défini une variable sur un type, vous POUVEZ le changer. En effet, la saisie est associée à la valeur plutôt qu'à la variable.
Par exemple en Python:
D'un autre côté, le typage fort / faible dans une langue est lié à des conversions de type implicites (en partie tirées de la réponse de @ Dario):
Par exemple en Python:
alors qu'en PHP:
Le typage statique permet de vérifier l'exactitude du type au moment de la compilation. Les langues typées statiquement sont généralement compilées et les langues typées dynamiquement sont interprétées. Par conséquent, les langues typées dynamiquement peuvent vérifier la frappe au moment de l'exécution.
la source
Un typage faible signifie que le type d'un objet peut changer en fonction du contexte. Par exemple, dans une langue faiblement tapée, la chaîne "123" peut être traitée comme le numéro 123 si vous lui ajoutez un autre numéro. Bash, awk et PHP sont des exemples de langages à 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 transtypage.
Dans un langage fortement typé, le type d'un objet ne change pas - un int est toujours un int et essayer de l'utiliser comme chaîne entraînera une erreur. Java et Python sont fortement typés.
La différence entre la frappe dynamique et statique est lorsque les règles de type sont appliquées. Dans un langage typé statiquement, le type de chaque variable et paramètre doit être déclaré dans la source et est appliqué au moment de la compilation. Dans un langage typé dynamiquement, les types ne sont vérifiés que lorsqu'ils sont utilisés au moment de l'exécution. Java est donc typé statiquement et Python est typé dynamiquement.
Cependant, les limites peuvent parfois être un peu floues. Par exemple, bien que Java soit typé de façon statique, chaque fois que vous utilisez une réflexion ou un transtypage (par exemple lorsque vous utilisez des conteneurs d'objets), vous reportez la vérification de type à l'exécution.
De même, la plupart des langages fortement typés seront toujours automatiquement convertis entre des entiers et des flottants (et dans certains langages, une précision approximative BigInts).
la source
f
prend l'argumentx
(fun f(x)
) [** donc aucun type n'est déclaré **] et le corps de la fonction l'estx+1
. Sans types déclarés, le compilateur découvrira qu'ilx
doit s'agir d'un entier.- fun f x = x + 1;
val f = fn : int -> int
5 + 'c' // OK
Aujourd'hui, faisant des recherches sur ce sujet, je suis tombé sur cet excellent article http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Il a éclairci beaucoup de des choses pour moi et je pensais que cela pourrait ajouter à certaines des bonnes réponses ci-dessus.
Typage fort et faible:
Types statiques et dynamiques
Types explicites / implicites:
la source
D'après Scott's Programming Language Pragmatics , 3e édition, page 291, nous avons
Donc, en termes simples, le typage statique / dynamique se réfère au moment où la vérification de type se produit: temps de compilation pour le typage statique et temps d'exécution pour les langages dynamiques. De même, le typage fort / faible fait référence à l'agressivité d'une langue dans l'application de son système de typage.
J'ai essayé de traduire la description de Scott en un joli diagramme, que j'ai posté ci-dessous.
la source
Je pense que les autres collègues ont fait du bon travail esp. expliquant la différence entre le typage statique et dynamique. Mais en ce qui concerne le typage fort et le typage faible, il faut dire qu'il existe différentes compréhensions / vues.
Voici deux exemples:
Certains disent que Haskell est fortement typé, car vous n'êtes pas autorisé à effectuer des conversions de type.
D'autres (par exemple le point de vue de Dario) disent qu'un langage qui permet de convertir implicitement de la chaîne en nombre à dessein est faiblement typé, mais même d'autres appellent cela juste du typage canard.
Les deux déclarations ne mettent pas en évidence les extrêmes opposés d'un système de types, mais des aspects complètement différents. Je rejoins donc M. Ramsey pour ne pas utiliser les termes "fort" et "faible" pour distinguer les systèmes de types.
la source
Langages typiquement v / s dynamiquement typés
Langues fortement typées v / s faiblement typées
Bonnes lectures supplémentaires
la source
Les langages typés statiquement nécessitent généralement de déclarer les types de variables, qui sont ensuite vérifiés au moment de la compilation pour réduire les erreurs. Le mot "statique" dans "typé statiquement" fait référence à "l'analyse de code statique", qui est le processus d'examen du code avant de l'exécuter. Bien qu'il soit possible pour un langage à typage statique de déduire le type de la variable du côté droit d'une expression ou des paramètres réels, dans la pratique, la plupart des langages à typage statique nécessitent que les types de variable soient explicitement déclarés.
Les langages typés dynamiquement n'ont généralement pas besoin de déclarations de variables pour avoir des types, et ils déduisent des types de variables en fonction du type calculé à la suite de l'évaluation du côté droit de chaque instruction d'affectation ou des paramètres réels d'un appel de fonction. Étant donné que la variable peut recevoir plusieurs affectations au cours de sa durée de vie, son type peut changer avec le temps et c'est pourquoi elle est appelée "typée dynamiquement". En outre, l'environnement d'exécution doit garder une trace du type actuel pour chaque variable, de sorte que le type est lié à la valeur plutôt qu'à la déclaration de variable. Cela peut être considéré comme un système RTTI (runtime type information).
Les éléments des langages typés statiquement et dynamiquement peuvent être combinés. Par exemple, C # prend en charge les variables typées statiquement et dynamiquement, et les langages orientés objet prennent généralement en charge la conversion de la hiérarchie des types. Les langages typés statiquement offrent généralement diverses manières de contourner la vérification de type, par exemple en utilisant la conversion, la réflexion et l'invocation dynamique.
Typage fort vs faible fait référence à un continuum de combien le langage essaie d'empêcher les bogues dus à l'utilisation d'une variable comme s'il s'agissait d'un type alors qu'il s'agit en fait d'un autre type. Par exemple, C et Java sont des langages typés statiquement, mais Java utilise une vérification de type beaucoup plus forte que C. Le code C suivant est heureux de compiler et d'exécuter, et mettra une valeur aléatoire dans la variable b lors de l'exécution, provoquant très probablement un punaise:
Le code Java équivalent produira une erreur de compilation, ce qui est généralement préférable:
la source