Question Quelle est la différence entre les langues typées statiquement et dynamiquement?


J'entends souvent dire que les nouveaux langages de programmation sont dynamiquement typés, mais que signifie-t-il réellement quand on dit qu'un langage est typé dynamiquement ou typé statiquement?


682
2017-10-04 22:36


origine


Réponses:


Langues statiquement typées

Un langage est typé statiquement si le type d'une variable est connu au moment de la compilation. Pour certaines langues, cela signifie que vous, en tant que programmeur, devez spécifier le type de chaque variable (par exemple: Java, C, C ++); d'autres langues offrent une forme de inférence de type, la capacité du système de type à déduire le type d'une variable (par exemple: OCaml, Haskell, Scala, Kotlin)

Le principal avantage ici est que toutes sortes de vérifications peuvent être effectuées par le compilateur, et donc beaucoup de bogues triviaux sont détectés à un stade très précoce.

Langues dynamiquement typées

Un langage est dynamiquement typé si le type est associé à des valeurs d'exécution, et non nommé variables / fields / etc. Cela signifie que vous, en tant que programmeur, pouvez écrire un peu plus vite car vous n'avez pas besoin de spécifier des types à chaque fois (sauf si vous utilisez un langage typé statiquement avec inférence de type). Exemple: Perl, Ruby, Python

La plupart des langages de script ont cette fonctionnalité car il n'y a pas de compilateur pour effectuer une vérification de type statique de toute façon, mais vous pouvez vous retrouver à la recherche d'un bogue dû à l'interprétation erronée du type d'une variable par l'interpréteur. Heureusement, les scripts ont tendance à être petits donc les bugs n'ont pas autant d'endroits à cacher.

La plupart des langages typés dynamiquement vous permettent de fournir des informations de type, mais ne l'exigent pas. Une langue en cours de développement, Coquin, adopte une approche hybride permettant une typage dynamique dans les fonctions mais imposant un typage statique pour la signature de la fonction.


600
2017-10-04 23:11



Les langages de programmation typés statiquement effectuent une vérification de type (le processus de vérification et d'application des contraintes des types) au moment de la compilation, par opposition à l'exécution.

Les langages de programmation dynamiquement typés effectuent une vérification de type au moment de l'exécution, par opposition à Compile-time.


259
2017-10-05 14:12



Voici un exemple contrastant avec la façon dont Python (typé dynamiquement) et Go (typé statiquement) gèrent une erreur de type:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

Python vérifie le type lors de l'exécution, et donc:

silly(2)

Fonctionne parfaitement bien et produit la sortie attendue Hi. L'erreur n'est levée que si la ligne problématique est atteinte:

silly(-1)

Produit

TypeError: unsupported operand type(s) for +: 'int' and 'str'

parce que la ligne pertinente a été effectivement exécutée.

D'un autre côté, fait une vérification de type au moment de la compilation:

package main

import ("fmt"
)

func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}

func main() {
    silly(2)
}

Ce qui précède ne compilera pas, avec l'erreur suivante:

invalid operation: "3" + 5 (mismatched types string and int)

230
2018-01-06 02:49



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

Par exemple en Java:

String str = "Hello";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

Où d'autre part: dans un langage dynamiquement typé les types de variables sont dynamique, ce qui signifie qu'après avoir défini une variable sur un type, vous pouvez la modifier. C'est parce que la saisie est associée à la valeur qu'elle suppose plutôt qu'à la variable elle-même.

Par exemple en Python:

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

Ainsi, il est préférable de penser aux variables dans les langues dynamiquement typées  juste des pointeurs génériques  aux valeurs typées.

Pour résumer, type décrit (ou aurait dû décrire) les variables dans la langue plutôt que la langue elle-même. Il aurait pu être mieux utilisé comme une langue avec des variables statiquement typées contre un langage avec des variables typées dynamiquement A MON HUMBLE AVIS.

Les langages typés statiquement sont généralement des langages compilés, donc les compilateurs vérifient les types (ils ont tout leur sens, car les types ne peuvent pas être changés plus tard au moment de l'exécution).

Les langages dynamiquement typés sont généralement interprétés, ainsi la vérification de type (le cas échéant) se produit au moment de l'exécution lorsqu'ils sont utilisés. Cela entraîne bien sûr des coûts de performance, et c'est l'une des raisons pour lesquelles les langages dynamiques (par exemple, python, ruby, php) ne sont pas aussi performants que les langages typés (java, c #, etc.). D'un autre point de vue, les langues statiquement typées ont plus d'un coût de démarrage: cela vous oblige généralement à écrire plus de code, plus de code. Mais ça paie plus tard.

La bonne chose est que les deux parties empruntent des caractéristiques de l'autre côté. Les langages dactylographiés intègrent des fonctionnalités plus dynamiques, par exemple, génériques et bibliothèques dynamiques en c #, et les langages dynamiques incluent plus de vérification de type, par exemple, annotations de type en python, ou HACK variant de PHP, qui ne sont généralement pas essentielles au langage. demande.

Quand il s'agit de la sélection de la technologie, aucune des deux parties n'a de supériorité intrinsèque sur l'autre. C'est juste une question de préférence si vous voulez plus de contrôle ou de flexibilité. Il suffit de choisir le bon outil pour le travail, et assurez-vous de vérifier ce qui est disponible en termes de l'opposé avant d'envisager un commutateur.


116
2017-11-30 17:28



http://en.wikipedia.org/wiki/Type_system

Typage statique

Un langage de programmation dit utiliser   typage statique lorsque la vérification de type est   effectuée pendant la compilation comme   opposé à l'exécution. En typage statique,   les types sont associés à des variables   pas de valeurs. Langues statiquement typées   inclure Ada, C, C ++, C #, JADE, Java,   Fortran, Haskell, ML, Pascal, Perl   (en ce qui concerne la distinction   scalaires, tableaux, hachages et   sous-programmes) et Scala. Typage statique   est une forme limitée de programme   vérification (voir type de sécurité):   en conséquence, il permet de nombreux types   erreurs à saisir au début de la   cycle de développement. Type statique   les vérificateurs évaluent seulement le type   informations qui peuvent être déterminées à   compiler le temps, mais sont en mesure de vérifier   que les conditions vérifiées sont valables pour   toutes les exécutions possibles du   programme, ce qui élimine le besoin de   répéter les vérifications de type chaque fois que le   le programme est exécuté. Exécution du programme   peut également être rendu plus efficace (c.-à-d.   plus rapide ou prenant moins de mémoire)   omettre les vérifications de type à l'exécution et   activer d'autres optimisations.

Parce qu'ils évaluent les informations de type   lors de la compilation, et donc le manque   tapez l'information qui est seulement   disponible à l'exécution, type statique   les dames sont conservatrices. Ils vont   rejeter certains programmes qui peuvent être   bien comporté à l'exécution, mais que   ne peut pas être déterminé statiquement   bien typé. Par exemple, même si un   expression toujours   évalue à vrai lors de l'exécution, un   programme contenant le code

if <complex test> then 42 else <type error>

sera rejeté comme mal typé, car   une analyse statique ne peut pas déterminer   que la branche d'autre ne sera pas   pris. [1] Le comportement conservateur   des vérificateurs de type statique est   avantageux quand   évalue à faux rarement: A   vérificateur de type statique peut détecter le type   des erreurs dans les chemins de code rarement utilisés.   Sans vérification de type statique, même   tests de couverture de code avec 100% de code   couverture peut être incapable de trouver une telle   erreurs de type. Les tests de couverture de code peuvent   ne parviennent pas à détecter de telles erreurs de type   parce que la combinaison de tous les lieux   où les valeurs sont créées et tous   endroits où une certaine valeur est utilisée   doit être pris en compte.

Le plus utilisé statiquement typé   les langues ne sont pas formellement de type sécurisé.   Ils ont des "failles" dans le   spécification du langage de programmation   permettant aux programmeurs d'écrire du code   cela contourne la vérification   effectuée par un vérificateur de type statique et   donc adresser un plus large éventail de problèmes.   Par exemple, Java et la plupart des styles C   les langues ont le type punning, et   Haskell a des caractéristiques telles que   dangereuxPerformIO: de telles opérations peuvent   être dangereux à l'exécution, en ce sens qu'ils peuvent   causer un comportement indésirable en raison de   typage incorrect des valeurs lorsque le   programme s'exécute.

Typage dynamique

Un langage de programmation est dit être   dynamiquement typé, ou juste "dynamique",   quand la majorité de sa vérification de type   est effectuée à l'exécution par opposition à   à la compilation. En dactylographie dynamique,   les types sont associés à des valeurs non   variables Langues dynamiquement typées   inclure Groovy, JavaScript, Lisp, Lua,   Objective-C, Perl (en ce qui concerne   types définis par l'utilisateur mais non intégrés   types), PHP, Prolog, Python, Ruby,   Smalltalk et Tcl. Par rapport à statique   taper, le typage dynamique peut être plus   flexible (par exemple en permettant aux programmes de   générer des types et des fonctionnalités basées   sur les données d'exécution), bien que   dépense de moins de garanties a priori.   C'est parce qu'un dactylographié dynamiquement   la langue accepte et tente de   exécuter certains programmes qui peuvent être   jugé invalide par un type statique   vérificateur.

Le typage dynamique peut entraîner l'exécution   tapez les erreurs, c'est-à-dire, à l'exécution, un   la valeur peut avoir un type inattendu, et   une opération absurde pour ce type   est appliqué. Cette opération peut se produire   longtemps après l'endroit où le   erreur de programmation a été faite, c'est-à-dire   l'endroit où le mauvais type de données   passé dans un endroit, il ne devrait pas   avoir. Cela rend le bug difficile à   Localiser.

Systèmes de langage dynamiquement typés,   par rapport à leur statiquement typé   cousins, faites moins de "compilation"   vérifie le code source (mais   vérifiez, par exemple, que le programme   est syntaxiquement correct). Run-time   les chèques peuvent potentiellement être plus   sophistiqué, car ils peuvent utiliser   informations dynamiques ainsi que tout   l'information qui était présente au cours   compilation. D'autre part,   les contrôles d'exécution affirment seulement que   les conditions tiennent dans un particulier   l'exécution du programme, et ceux-ci   les contrôles sont répétés pour chaque   l'exécution du programme.

Développement en typage dynamique   langues est souvent pris en charge par   pratiques de programmation telles que l'unité   essai. Les tests sont une pratique clé dans   développement de logiciels professionnels, et   est particulièrement important dans   langues dynamiquement typées. Dans   pratique, les tests effectués pour assurer   opération correcte du programme peut détecter un   beaucoup plus large gamme d'erreurs que statique   vérification de type, mais inversement ne peut pas   chercher aussi globalement pour le   les erreurs qui à la fois test et statique   vérification de type sont capables de détecter.   Les tests peuvent être incorporés dans le   cycle de construction du logiciel, auquel cas il   peut être considéré comme un "temps de compilation"   vérifier, en ce que l'utilisateur du programme   pas besoin d'exécuter manuellement de tels tests.

Les références

  1. Pierce, Benjamin (2002). Types et langages de programmation. MIT Appuyez sur.   ISBN 0-262-16209-1.

38
2017-10-04 22:37



La terminologie "typée dynamiquement" est malheureusement trompeuse. Toutes les langues sont typées statiquement, et les types sont des propriétés d'expressions (pas de valeurs comme certains pensent). Cependant, certaines langues ont un seul type. Ceux-ci sont appelés langues uni-typées. Un exemple d'un tel langage est le lambda-calcul non typé.

Dans le lambda-calcul non typé, tous les termes sont des termes lambda, et la seule opération qui peut être effectuée sur un terme est l'application à un autre terme. Par conséquent, toutes les opérations aboutissent toujours à une récursion infinie ou à un terme lambda, mais ne signalent jamais une erreur.

Cependant, si nous devions augmenter le lambda-calcul non typé avec des nombres primitifs et des opérations arithmétiques, alors nous pourrions effectuer des opérations absurdes, par exemple en ajoutant deux termes lambda ensemble: (λx.x) + (λy.y). On pourrait argumenter que la seule chose sensée à faire est de signaler une erreur quand cela arrive, mais pour être capable de le faire, chaque valeur doit être étiquetée avec un indicateur qui indique si le terme est un terme lambda ou un nombre. L'opérateur d'addition vérifie alors que les deux arguments sont marqués comme des nombres, et s'ils ne le sont pas, signalent une erreur. Notez que ces tags sont ne pas types, car les types sont des propriétés de programmes et non des valeurs produites par ces programmes.

Un langage uni-typé qui est appelé dynamiquement typé.

Les langages tels que JavaScript, Python et Ruby sont tous unis. Encore une fois, le typeof opérateur en JavaScript et le type fonction en Python ont des noms trompeurs; ils renvoient les tags associés aux opérandes, pas leurs types. De même, dynamic_cast en C ++ et instanceof en Java faire ne pas faire des vérifications de type.


14
2017-10-12 16:57



Le type typé statiquement les langues vérifient à la compilation et le type ne peut pas changer. (Ne soyez pas mignon avec des commentaires de type casting, une nouvelle variable / référence est créée).

La vérification typographique des langages typés dynamiquement à l'exécution et le type d'une variable peuvent être modifiés au moment de l'exécution.


5
2017-07-27 06:56



Définitions douces et simples, mais répondant au besoin: Les langues typées statiquement lient le type à une variable pour l'ensemble de sa portée (Seg: SCALA) Les langues typées dynamiquement lient le type à la valeur réelle référencée par une variable.


4
2017-11-29 06:37



  • Dans un langage typé statiquement, une variable est associée à un type connu à la compilation, et ce type reste inchangé tout au long de l'exécution d'un programme. De manière équivalente, la variable ne peut recevoir qu'une valeur qui est une instance du type connu / spécifié.
  • Dans un langage dynamiquement typé, une variable n'a pas de type et sa valeur durant l'exécution peut avoir n'importe quelle forme et forme.

3
2017-10-29 20:18