Statique/Dynamique vs Forts/Faibles

Je vois ces termes véhiculés à travers la place dans la programmation et j'ai une vague idée de ce qu'ils signifient. Une recherche m'indique que de telles choses ont été posées à tous les coins de débordement de pile en fait. Pour autant que je suis au courant Statique/Dynamique tapant dans des langues est subtilement différent de force et de Faiblesse de frappe mais ce que la différence m'échappe. Différentes sources semblent utiliser des significations différentes ou même utiliser les termes de façon interchangeable. Je ne peux pas trouver quelque part qui parle à la fois et en fait des sorts de la différence. Ce serait sympa si quelqu'un pourrait s'il vous plaît préciser clairement là pour moi et le reste du monde.

Dupe: is-my-understanding-of-type-systems-correct
Double Possible de Quelle est la différence entre typé statiquement et dynamiquement typé langues?

InformationsquelleAutor Dan Revell | 2010-02-28

397
- Statique/Dynamique de frappe est d'environ quand type d'information est acquis (Soit au moment de la compilation ou à l'exécution)
- De force et de Faiblesse de frappe est d'environ comment strictement types sont distingués (par exemple, si la langue essaie de faire une conversion implicite de chaînes de nombres).
Voir le page wiki pour de plus amples informations.
- Wikipédia a toutes les réponses. Pourquoi je n'ai pas trébuché à travers ce déjà je ne sais pas.
- C'est une honte que beaucoup ne sont pas conscients que statique/dynamique, c'est autre chose que de force et de faiblesse... Il serait vraiment économiser de la partialité et de la discussion.
- Il existe différents degrés de type "faiblesse". Un fortement typées langue pourrait tenter de conversions de chaînes en nombres. D'autre part, HyperTalk (une langue que j'ai utilisé il y a plusieurs décennies), c'était faiblement typé que "12" + "34" serait égal à "46", mais "12" + "34Q" serait égal à "1234Q" [heureusement, on pourrait écrire "12" & "34" si l'on voulait concaténation]. Curieusement, les variables de la tenue des nombres stockés en tant que double-précision des flotteurs et des mathématiques sur ces variables utilisées les valeurs à virgule flottante sans chaîne munging, mais il n'y avait aucun moyen de demander si une variable est une chaîne ou un nombre.
- C'est juste flat-out faux. Forts n'est pas synonyme de statique, ni faible synonyme de dynamique. Voir Norman Ramsey réponse à la réalité.
- Je ne vois pas où cette réponse suggère que forte est synonyme de statique
- ++ pour (à peu près) les définitions de ligne.
- Est Java un faiblement et le type statique de la langue?
- Probablement parce qu'il est trop académique, trop long, trop fastidieux, et vous obtenez seulement ce qu'ils essayent de vous apprendre, après que vous avez déjà appris ailleurs. Simple Wikipédia en anglais est meilleur.
- Je pense que Java est fortement typé.
- Je ne comprends pas ce typage faible est exactement, mais je suis parfaitement au fait que vous avez mal compris le typage faible. Vous voyez, la conversion implicite de chaînes en nombres n'a rien à voir avec la dynamique de frappe ou de typage faible, mais avec la sémantique de la PL en question.
- Est-il un terme pour lors de l'utilisation des langues int etc mots-clés pour les déclarations de variables, ou quand ils ont un var ou mot clé similaire?
InformationsquelleAutor Dario
205

Vous avez découvert un point faible dans la terminologie que les amateurs utilisent pour parler des langages de programmation.
Ne pas utiliser les termes "forte" et "faible", en tapant, parce qu'ils n'ont pas universellement d'accord sur la signification technique. En revanche, le typage statique signifie que les programmes sont vérifiées avant d'être exécuté, et un programme peut être rejeté avant qu'il ne commence. Typage dynamique signifie que les types de valeurs sont vérifiées pendant exécution, et un mal tapé l'opération pourrait provoquer le programme pour arrêter ou sinon signal une erreur au moment de l'exécution. Une des principales raisons pour le typage statique est la règle de programmes qui pourraient avoir de tels "dynamique des erreurs de type".

Typage fort signifie généralement qu'il y a aucun échappatoire dans le système de type, tandis que typage faible signifie que le type de système peut être subverti (invalidant des garanties). Les termes sont souvent utilisés de manière incorrecte à la moyenne de la statique et de la dynamique de la frappe.
Pour voir la différence, pensez à C: le langage est de type vérifiée au moment de la compilation (typage statique), mais il y a beaucoup de lacunes; vous pouvez très bien la fonte d'une valeur d'un type vers un autre type de la même taille---en particulier, vous pouvez convertir les types pointeur librement. Pascal est un langage qui a été destiné à être fortement typé, mais célèbre eu un imprévu échappatoire: une variante du dossier avec pas de tag.

Implémentations de langages fortement typés souvent acquérir des lacunes au fil du temps, habituellement de sorte qu'une partie du système d'exécution peut être mis en œuvre dans le langage de haut niveau. Par exemple, Objective Caml possède une fonction appelée Obj.magic qui a l'effet de retour de son argument, mais au moment de la compilation il convertit tout type de valeur à un tout autre type. Mon exemple préféré est Modula-3, dont les concepteurs ont appelé leur type coulée de construire LOOPHOLE.

Cela dit, vous ne pouvez pas compter sur deux personnes en utilisant les mots "forts" et "faibles" exactement de la même manière. Afin de les éviter.
- (+1) pour votre suggestion afin d'éviter les termes "forte" et "faible".
- D'accord, viens de lire par le biais de Jon Skeet du livre, et c'est la même réponse noté.
- Pour autant que je suis conscient, Java a ces lacunes, mais il est toujours considéré comme un typage fort de la langue, donc je suppose que cela donne plus de poids à votre conseil d'éviter les termes "forte" et "faible".
InformationsquelleAutor Norman Ramsey
66

Simplement mis de cette façon: dans un statiquement typé langue le type est statique, sens une fois que vous définissez une variable d'un type, vous NE pouvez pas le changer. C'est parce que la saisie est associé à la variable plutôt que de la valeur qu'elle renvoie.

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 une typées dynamiquement langue le type est dynamique, du sens une fois que vous définissez une variable d'un type, vous POUVEZ le modifier. C'est parce que le typage est associée à la valeur plutôt que de la variable.

Par exemple en Python:
```
str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK
```
D'autre part, la de force et de faiblesse de frappe dans une langue est liée à des conversions de types implicites (en partie pris en de @de Dario réponse):

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.
```
Le typage statique permet de vérifier le type de l'exactitude au moment de la compilation. Les langages statiquement typés sont généralement compilés, et typées dynamiquement langues sont interprétées. Par conséquent, dynamicly langages à typage pouvez vérifier en tapant au moment de l'exécution.
- super réponse, et bravo pour l'aide d'exemples concrets.
- C'est pourquoi PHP doit être utilisé avec beaucoup de soin.
- La langue des exemples sont vraiment utiles. Très apprécié.
- Dans ce sens, Java-être un peu faiblement typé parce que vous pouvez concaténer non chaînes avec des cordes, et en raison de l'auto-unboxing / boxe?
- vous avez raison, ma réponse peut être compris de cette façon, et qu'il n'est pas le cas. J'ai utilisé la concaténation par souci de simplicité, mais en fait, fort-ness/faiblesse est sur l'implicite de conversion de type de la variable elle-même.
InformationsquelleAutor mehmet
19

Typage faible signifie que le type d'un objet peut changer selon le contexte. Par exemple, dans un langage faiblement typé de la chaîne "123" peut être considéré comme le numéro 123 si vous ajoutez un autre numéro. Exemples de langages à typage faible sont bash, awk et PHP.

Un autre type de langage faiblement typé est C, où les données à une adresse de mémoire peut être considérée comme un type différent par la coulée.

Dans un langage fortement typé le type d'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 fortement typés.

La différence entre la dynamique et le typage statique est lorsque les règles sont respectées. Dans un langage statiquement typé le type de toutes les variables et les paramètres doivent être déclarés dans la source et est appliquée au moment de la compilation. Dans un typées dynamiquement langue les types sont vérifiées uniquement lorsqu'ils sont utilisés lors de l'exécution. Si Java est statiquement typé et Python est typées dynamiquement.

Cependant les limites peuvent être un peu floue par moments. Par exemple, même si Java est statiquement typé, chaque fois que vous utilisez une réflexion ou d'un plâtre (par exemple lors de l'utilisation de conteneurs d'Objets), ils vous reporter à plus tard la vérification de type à l'exécution.

De même la plupart des langages fortement typés sera toujours automatiquement la conversion entre les nombres entiers et décimaux (et, dans certaines langues, abitrary précision BigInts).
- Je ne peux pas d'accord avec cette phrase . "Dans un langage statiquement typé le type de toutes les variables et les paramètres doivent être déclarés dans la source" - en SML les types de variables n'ont pas à être déclaré (comment ils sont contrôlés). Permet de dire que la fonction f prend en argument x (fun f(x)) [** donc pas de types sont déclarés**] et le corps de la fonction est x+1. Sans types déclaré compilateur va comprendre que x doit être un int. - fun f x = x + 1; val f = fn : int -> int
- Concernant C, le casting n'est pas à l'encontre de taper fort, mais C vous permet d'ajouter différents types sans casting aussi, par exemple: 5 + 'c' // OK
- en C, le caractère des valeurs de l'entier domaine, de sorte que l'exemple particulier ne viole pas le type de la sécurité". c' est juste sucre syntaxique pour 99. C n'a pas de type de caractère.
- Peter Lewerin: droit j'aurais dû donner un meilleur exemple. Malheureusement, il a été près de 20 ans que je n'ai pas touché C 🙂
- C pas un langage faiblement typé. C'est juste que Java, C#, etc sont plus des langages fortement typés par rapport à C. Lire plus ici - en.wikipedia.org/wiki/Strong_and_weak_typing Si vous cochez la définition de "faiblement" tapé langue puis "faiblement" tapé langues sont celles dans lesquelles vous pouvez faire n'importe quel type de conversion, par exemple un int peut être "implicitement" convertis ou intégré dans une chaîne de caractères, maintenant, pensez à vous-même que si c'est possible en C ou pas?
- Bartuzi similaire à l'inférence de type en C#. Le type est fourni implicitement par le codeur via l'utilisation des littéraux au lieu de mentionner explicitement le type.
InformationsquelleAutor Dave Kirby
14

Aujourd'hui faire 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 dissipé beaucoup de choses pour moi et j'ai pensé qu'Il peut en ajouter quelques-uns des grands des réponses ci-dessus.

Forts et Faibles de frappe:

Probablement le moyen le plus commun type de systèmes sont classés est "forte"
ou "faibles". C'est malheureux, car ces mots n'ont presque pas de
de sens du tout. Il est, dans une certaine mesure, possible de comparer les deux
langues très similaire à type de systèmes, et de désigner l'un comme ayant
le plus fort de ces deux systèmes. Au-delà, les mots ne veulent rien dire
à tous.

Statique et Dynamique des Types de

C'est à peu près 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 [...] Dynamique et statique type de systèmes sont
de deux choses complètement différentes, dont les objectifs arriver à partiellement
chevauchement.

Un système de type statique est un mécanisme par lequel un compilateur examine
le code source et donne des étiquettes (appelés "types") à des morceaux de la
la syntaxe, et les utilise pour en déduire quelque chose sur le programme de
comportement. Un système de type dynamique est un mécanisme par lequel un compilateur
génère du code de garder une trace de ce genre de données (par coïncidence, également
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. Une grande confusion résultats d'essayer de trouver un
vision du monde dans laquelle "type" veut vraiment dire la même chose dans les deux
les systèmes. Il n'a pas.

Explicite/Implicite Types:

Lorsque ces termes sont utilisés, ils font référence à la mesure dans laquelle un
le compilateur va raisonner sur la statique des types de parties d'un programme. Tous
les langages de programmation ont une certaine forme de raisonnement sur les types. Certains
ont plus que d'autres. ML et Haskell ont implicite types, dans la mesure où aucun
(ou très peu, en fonction de la langue et des extensions en cours d'utilisation) type de
les déclarations sont nécessaires. Java et Ada ont très explicite types, et
on est constamment en déclarant les types de choses. Tous les ci-dessus ont
(relativement, par rapport à C et C++, par exemple) forte de type statique
les systèmes.

InformationsquelleAutor gonz
7

De Scott Langage de Programmation Pragmatique, 3e édition, page 291, nous avons

Type de vérification est le processus permettant de s'assurer qu'un programme obéit à la
la langue de la compatibilité du type de règles. Une violation des règles est connu
comme un type de choc. Une langue est dit d'être fortement typé si c'
interdit, de façon que le langage de la mise en œuvre peut faire exécuter, l'
l'application de toute opération sur un objet qui n'est pas prévu pour
l'appui de l'opération. Une langue est dit d'être statiquement typé si
il est fortement typé et type de vérification peut être effectuée lors de la compilation
temps. Dans le sens le plus strict du terme, peu de langues sont statiquement
tapé. Dans la pratique, les termis souvent appliqué aux langues dans lesquelles
la plupart de type de vérification peut être effectuée au moment de la compilation, et le reste peut
être effectué au moment de l'exécution.

Quelques exemples: Ada est fortement typé, et pour la plupart
typé statiquement (certains type de contraintes doivent être vérifiés lors de l'exécution
de temps). Pascal mise en œuvre peut aussi faire plus de son type de vérification
au moment de la compilation, bien que la langue n'est pas assez fortement typé:
non balisés variante de dossiers (pour être discuté dans la Section 7.3.4) sont ses
seule échappatoire. C89 est beaucoup plus fort que sa
prédécesseur dialectes, mais toujours beaucoup moins fortement typé qu'
Pascal. De ses lacunes inclure 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 rarement vérifier
rien au moment de l'exécution.

Dynamique (run-time) type de vérification est une forme de la liaison tardive, et tend
pour être trouvé dans les langues que retarder les autres questions jusqu'au moment de l'exécution que
bien. Lisp et Smalltalk sont dynamiquement (bien que fortement) tapé. La plupart des
les langages de script sont aussi typées dynamiquement; certains (par exemple, Python et
Ruby) sont fortement typés. Langues, avec la dynamique de la portée sont généralement
dynamiquement typés (ou pas tapé à tous): si le compilateur ne peut pas
identifier l'objet pour lequel un nom fait référence, il est généralement impossible de déterminer les
le type de l'objet.

Donc, en termes simples, statique/dynamique de frappe se réfère à la fois lors de la vérification de type se produit: le temps de compilation pour le typage statique, et le temps d'exécution pour les langages dynamiques. De même, de force et de faiblesse de frappe désigne le degré d'agressivité d'une langue est dans l'application de son type de système.

J'ai essayé de traduire Scott description dans un joli schéma, que j'ai posté ci-dessous.

InformationsquelleAutor Evan Rosica
5

Je pense que les autres collègues ont fait un bon travail de l'esp. expliquer la différence entre statique et dynamique de la frappe. Mais aussi loin que les forts et les faibles de frappe, il faut dire qu'il y a
les différentes compréhensions/points de vue.

Ici deux exemples:
- Certains disent que Haskell est fortement typé, parce que vous n'êtes pas autorisé à faire tout les conversions de type.
- Autres (par exemple, de Dario vue) dire un langage qui permet de convertir implicitement de la chaîne de nombre sur le but est faiblement typé, mais même d'autres appellent cela juste duck-typing.
Les deux états en évidence les extrémités opposées d'un système de type, mais des aspects complètement différents. Donc, je rejoins M. Ramsey est d'avis de ne pas utiliser les termes "forte" et "faible" pour distinguer le type de systèmes.

InformationsquelleAutor Nico
4

Statiquement v/s typées dynamiquement langues
- Les langages statiquement typés sont ceux dans lesquels le type de la vérification est effectuée au moment de la compilation, ce qui signifie aussi que dans les langages statiquement typés chaque variable a un type et elle ne change pas au cours. Maintenant, en revanche, typées dynamiquement les langues sont ceux dans lesquels le type de la vérification est effectuée lors de l'exécution, et il n'y a pas de vérification de type au moment de la compilation, ce qui signifie aussi que dans typées dynamiquement langues, il peut ou peut ne pas être associée à un type avec une des variables, et si un type est associée, alors il pourrait être un type générique comme “var” en JS qui détiennent à la fois une chaîne de caractères et le nombre.
  - “Les implémentations de manière dynamique, de type vérifié les langues en général d'associer à chaque exécution de l'objet avec un type de balise (c'est à dire, une référence à un type) contenant des informations de type. Ce runtime type d'information (RTTI) peut également être utilisé pour mettre en œuvre la distribution dynamique, la liaison tardive, vers le bas de la coulée, de réflexion, et des fonctionnalités similaires.”
- Même si la langue est statiquement typé, encore, il peut être typées dynamiquement fonctionnalité, ce qui signifie qu'une sorte de vérification de type à l'exécution. Ceci est utile dans le casting de types.
  - “Un certain nombre d'informations utiles et de programmation commune des fonctionnalités du langage ne peut être vérifiée de manière statique, comme le casting. Ainsi, de nombreuses langues ont à la fois statique et dynamique, le type de la vérification; le type statique checker vérifie ce qu'il peut, et de la dynamique des vérifications de vérifier le reste.”
- “Certains langages permettent d'écrire du code qui n'est pas de type sécurisé. Par exemple, en C, les programmeurs peuvent librement jeté une valeur entre deux types qui ont la même taille.”
- Avantage de “statiquement” tapé langues sont les suivantes:
  - Depuis plus d'un type de vérification est effectué au moment de la compilation afin d'interprète ou de l'exécution peut exécuter à pleine vitesse, sans se soucier des types.
  - Elle conduit à moins d'exception d'exécution ou à des erreurs liés au type, parce que la plupart du type de vérification est effectué au moment de la compilation.
- Avantage de “dynamique” tapé langues sont les suivantes:
  - Ils pouvaient nous aider dans extrêmement prototypage rapide, car le développeur n'a pas besoin de comprendre le type de système afin de dev peut vaguement créer des variables et de l'exécuter, et cela conduit à de très prototypage rapide.
- Liste de statiquement et dynamiquement typé langues:
  - De manière statique:
    
    Java
    
    C (le C est un langage statiquement typé, mais de moindre importance “fortement” tapé par rapport à Java, car il permet à plus de conversions implicites)
    
    C++
    
    C#
  - Dynamiquement:
    
    PERL
    
    PHP
    
    Python
    
    JavaScript
    
    Ruby
- Type de vérification est une fonctionnalité de sécurité important. Supposons que, il n'y a pas de vérification de type, et une méthode accepte un objet de type “compte bancaire”, qui a une méthode appelée comme “creditAccount(BankAccountDetails)”, maintenant, au moment de l'exécution si 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 de “creditAccount(BankAccountDetails)” et il sera exécuté, étant donné que nous parlons de langage orienté objet en raison de la programmation orientée objet prend en charge le “polymorphisme” et voici ce que nous discutons n'est rien mais “polymorphisme”. Donc, en gros, un langage orienté objet (ce qui en gros signifie qu'il prend en charge le “polymorphisme”) qui n'a pas de vérification de type fort peut conduire à des problèmes de sécurité.
Fortement v/s faiblement typé langues
- Langages fortement typés sont ceux dans lesquels les conversions implicites ne sont autorisés que si il y a une perte de précision. Par exemple, en Java, vous pouvez lancer un “int long” parce qu'il n'y ait 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 l'faiblement typé langues, les conversions implicites sont permis, même si il y a une perte de précision.
- Je pense que typées dynamiquement la langue peut aussi être un langage fortement typé si “au moment de l'exécution”, il n'autorise pas les conversions implicites dans lequel il y a une perte de précision.
Bonnes nouvelles lectures
- vous avez cité "maintenant, lors de l'exécution si 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 de “creditAccount(BankAccountDetails)” -- si vous avez déjà dépassé le mécanisme qui pourrait avoir bloqué de passage d'un objet alors comment vérifier le type va vous arrêter d'appeler cette méthode dans le cas d'un langage statiquement typé ?
- Qu'entendez-vous par "* si vous avez déjà dépassé le mécanisme qui pourrait avoir bloqué de passage d'un objet*"?
- comme vous l'avez mentionné, c'est un important dispositif de sécurité, et aussi que vous pourriez passer un objet de votre classe avec la même méthode , de sorte qu'il implique pour moi que cela semble être une vulnérabilité lorsque vous tentez de percer quelqu'un d'autre code et si vous parlez dans le contexte du code qui vous appartient à vous que plus d'un problème de performances que celle liée à la sécurité , n'est-ce pas ?
- Il n'y a aucun aspect de performance, vous devez le voir à partir du contexte de polymorphisme, alors vous serez en mesure de comprendre l'aspect sécurité de cela, j'ai mentionné cela dans le même paragraphe.
InformationsquelleAutor hagrawal
1

Les langages statiquement typés généralement vous obliger à déclarer les types de variables, qui est ensuite vérifié au moment de la compilation afin de 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é pour déduire le type de la variable à partir de la droite d'une expression ou d'paramètres réels, dans la pratique, la plupart des langages statiquement typés exiger types de variables à être explicitement déclaré.

Typées dynamiquement langues ne nécessitent généralement pas de déclarations de variables d'avoir des types, et ils en déduisent les types de variables en fonction du type calculé comme un résultat de l'évaluation de la droite de chaque instruction d'affectation ou les paramètres d'un appel de fonction. Puisque la variable peut être donné plusieurs postes au cours de sa vie, son type peut changer au fil du temps et c'est pourquoi il est appelé "typées dynamiquement". 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 moteur d'exécution d'informations de type (RTTI) du système.

Éléments de statiquement et dynamiquement typé langues peuvent être combinés. Par exemple, C# supporte à la fois statique et dynamique, les variables de type objet et les langages orientés généralement en faveur des bas-coulée de la hiérarchie des types. Les langages statiquement typés généralement de fournir les différentes façons de contourner la vérification de type, par exemple à l'aide de la coulée, la réflexion et la dynamique de l'invocation.

Forte vs Faible Typage se réfère à un continuum de combien la langue s'efforce de prévenir les bogues dus à l'utilisation d'une variable comme si elle était un type est en fait un autre type. Par exemple, les deux C et Java sont des langages à typage statique, mais Java utilise beaucoup plus le type de la vérification que le C. Le C suivant le code est heureux de compiler et d'exécuter, et de mettre une valeur aléatoire dans la variable b au moment de l'exécution, probablement la cause d'un bug:
```
char *a = "123";
int b = (int)a;
```
L'équivalent de code Java produira une erreur de compilation, ce qui est généralement préférable:
```
String a = "123"
int b = (int)a;
```
InformationsquelleAutor Danger

Vous devez vous connecter pour publier un commentaire.

Statiquement v/s typées dynamiquement langues

Fortement v/s faiblement typé langues

Bonnes nouvelles lectures