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

StackOverflow https://stackoverflow.com/questions/1517582

Question

J'entends beaucoup que de nouveaux langages de programmation sont dynamiquement typés, mais qu'est-ce que cela signifie réellement quand nous disons une langue est typé dynamiquement par rapport à statiquement typé?

Était-ce utile?

La solution

langages typés statiquement

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

L'avantage principal est que tous les types de contrôles peuvent être effectués par le compilateur, et donc beaucoup de bugs triviaux sont pris à un stade très précoce.

Exemples: C, C ++, Java, Rust, Go, Scala

Les langages typés dynamiquement

Une langue est typé dynamiquement si le type est associée à des valeurs d'exécution, et non le nom des variables / champs / etc. Cela signifie que vous en tant que programmeur peut écrire un peu plus vite parce que vous ne devez spécifier les types chaque fois (à moins d'utiliser un langage statiquement typé avec inférence de type ).

Exemples: Perl, Ruby, Python, PHP, JavaScript

La plupart des langages de script ont cette fonctionnalité car il n'y a pas de compilateur pour faire la vérification de type statique de toute façon, mais vous pouvez vous trouver la recherche d'un bug qui est dû à l'interprète du type de mal interpréter une variable. Heureusement, les scripts ont tendance à être petits bugs ont pas beaucoup d'endroits pour se cacher.

La plupart langages typés dynamiquement ne vous permettent de fournir des informations de type, mais ne nécessitent pas. Une langue qui est en cours d'élaboration, Rascal , une approche hybride permettant la saisie dynamique au sein des fonctions, mais l'application statique la saisie de la signature de la fonction.

Autres conseils

langages de programmation typés statiquement ne la vérification des types (à savoir le processus de vérification et de faire respecter les contraintes de types) à compilation par opposition à run-time .

langages de programmation typés dynamiquement ne vérification des types lors run-time par opposition à compilation .

Voici un exemple comment Python contraste (dynamique typé) et Go (statiquement typé) gérer une erreur de type: 

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

Python ne vérification de type à l'exécution, et donc: 

silly(2)

fonctionne parfaitement bien, et produit la Hi de sortie prévue. Erreur ne se pose si la ligne problématique est frappé: 

silly(-1)

Produit 

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

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

Allez d'autre part ne vérification de type à 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)

Il suffit de mettre cette façon: dans les types de Variables langage typé statiquement sont statique , ce qui signifie une fois que vous définissez une variable à un type, vous ne pouvez pas le changer. C'est parce que la frappe est associée à la variable plutôt que la valeur qu'elle fait référence.

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 typé dynamiquement Les types de variables sont dynamique , ce qui signifie après avoir défini une variable à un type, vous pouvez le changer. C'est parce que la frappe est associée à la valeur qu'elle suppose plutôt que 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

Alors, il est préférable de penser à des variables dans les langues dynamiquement typés comme seulement des pointeurs génériques aux valeurs tapé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. Cela aurait pu être mieux utilisé comme une langue avec des variables statiquement typé par rapport une langue avec des variables dynamiquement typés à mon humble avis.

Les langages typés statiquement sont généralement compilées langues, ainsi, les compilateurs vérifient les types (font bon sens parfait? Que les types ne sont pas autorisés à changer plus tard au moment de l'exécution).

Les langages typés dynamiquement sont généralement interprétées, tapez donc la vérification (le cas échéant) se produit au moment de l'exécution quand ils sont utilisés. Bien sûr, cela apporte un certain coût de performance, et est l'une des raisons pour les langages dynamiques (par exemple, Python, Ruby, PHP) n'échelle pas aussi bon que les tapées (java, c #, etc.). Dans une autre perspective, les langages typés ont statiquement plus d'un coût de démarrage: vous fait écrire habituellement plus de code, le code plus difficile. Mais qui paie plus tard au large.

La bonne chose est les deux côtés sont caractéristiques empruntent de l'autre côté. langues dactylographiés intègrent des fonctionnalités plus dynamiques, par exemple, les génériques et les bibliothèques dynamiques c # et langages dynamiques incluent plus de vérification de type, par exemple, les annotations de type en python, ou HACK variante de PHP, qui sont généralement pas au coeur de la langue et utilisable sur demande.

En ce qui concerne la sélection de la technologie, ni côté a une supériorité intrinsèque sur l'autre. Il est juste une question de préférence si vous voulez plus de contrôle pour commencer ou la flexibilité. il suffit de choisir le bon outil pour le travail, et assurez-vous de vérifier ce qui est disponible en termes de face avant d'envisager un interrupteur.

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

  

Le typage statique

     

Un langage de programmation est dit utiliser   typage statique lors de la vérification de type est   effectué au cours de la compilation en tant que   par opposition à l'exécution. En typage statique,   types sont associés à des variables   pas des valeurs. Les langages typés statiquement   inclure Ada, C, C ++, C #, JADE, Java,   Fortran, Haskell, ML, Pascal, Perl   (Par rapport à distinguer   scalaires, les tableaux et hachages   Scala) et des sous-routines. typage statique   est une forme limitée de programme   la vérification (voir la sécurité de type):   Par conséquent, il permet de nombreux types   erreurs à être pris au début de la   cycle de développement. type statique   dames évaluent uniquement le type   information qui peut être déterminé à   la compilation, mais sont en mesure de vérifier   que les conditions vérifiées pour tenir   toutes les exécutions possibles du   programme, ce qui élimine la nécessité de   le type répétition vérifie chaque fois que la   programme est exécuté. L'exécution du programme   peuvent également être plus efficace (à savoir   plus rapide ou prendre mémoire réduite) par   en omettant des contrôles de type exécution et   permettant à d'autres optimisations.

     

Parce qu'ils évaluent les informations de type   lors de la compilation, et par conséquent manquer   les informations de type qui est seulement   disponible à l'exécution, type statique   dames sont conservatrices. Elles vont   rejeter certains programmes qui peuvent être   bien comportés au moment de l'exécution, mais   ne peut pas être déterminée statiquement être   bien typé. Par exemple, même si un   expression toujours   la valeur TRUE au moment de l'exécution, un   programme contenant le code 

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

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

     

Le plus largement utilisé statiquement typé   langues ne sont pas de type formellement en sécurité.   Ils ont des « lacunes » dans le   spécification du langage de programmation   permettant aux programmeurs d'écrire du code   la vérification qui affranchit   effectuée par un correcteur de type statique et   afin répondre à un éventail plus large de problèmes.   Par exemple, Java et C style plus   langues ont le type calembour, et   Haskell a des caractéristiques telles   unsafePerformIO: De telles opérations peuvent   être dangereux lors de l'exécution, en ce sens qu'ils peuvent   provoquer un comportement indésirable en raison de   la saisie incorrecte des valeurs lorsque le   programme fonctionne.

     

typage dynamique

     

Un langage de programmation est dite   typé dynamiquement, ou tout simplement « dynamique »,   lorsque la majorité de sa vérification de type   est effectuée au moment d'exécution, par opposition à   à la compilation. Dans le typage dynamique,   types sont associés à des valeurs non   les variables. Les langages typés dynamiquement   inclure Groovy, JavaScript, Lisp, Lua,   Objective-C, Perl (par rapport à   types définis par l'utilisateur, mais pas intégré   types), PHP, Prolog, Python, Ruby,   Smalltalk et Tcl. Par rapport à l'électricité statique   dactylographie, typage dynamique peut être plus   souple (par exemple en permettant à des programmes   générer des types et des fonctionnalités à base   sur les données d'exécution), mais à la   frais de moins d'une garantie a priori.   En effet, un typage dynamique   la langue accepte et tente de   exécuter certains programmes qui peuvent être   jugé comme non valide par un type statique   vérificateur.

     

typage dynamique peut conduire à l'exécution   erreurs de type qui est, lors de l'exécution, un   la valeur peut avoir un type inattendu, unDakota du Nord   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 qui est,   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 linguistiques tapées, Dynamiquement   par rapport à leur statiquement typé   cousines, font moins de « compilation »   contrôles sur le code source (mais   vérifier, par exemple, que le programme   est syntaxiquement correcte). Exécution   chèques peuvent être potentiellement plus   sophistiqué, car ils peuvent utiliser   des informations dynamiques, ainsi que tout   information qui était présent lors de   compilation. D'autre part,   des contrôles d'exécution affirment seulement que   conditions tiennent dans un particulier   exécution du programme, et ceux-ci   les contrôles sont répétés pour chaque   exécution du programme.

     

Développement en typé dynamiquement   langues est souvent pris en charge par   pratiques de programmation tels que l'unité   essai. Le test est une pratique clé   le développement de logiciels professionnels, et   est particulièrement important dans   Les langages typés dynamiquement. Dans   pratique, les essais effectués pour assurer   le fonctionnement du programme correct peut détecter un   éventail beaucoup plus large d'erreurs que statique   vérification de type, mais peut au contraire pas   recherche aussi complète pour la   les erreurs que les deux tests et statiques   le type de contrôle sont en mesure de détecter.   Le test peut être incorporé dans le   cycle de logiciel de construction, auquel cas il   peut être considéré comme une « compilation »   vérifier, en ce que l'utilisateur du programme sera   ne pas avoir à exécuter manuellement ces tests.

     

Références

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

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

Dans le calcul typées lambda, 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 entraînent toujours soit une récursion infinie ou un terme lambda, mais jamais signalent une erreur.

Cependant, si nous augmentons le calcul de typées lambda avec des nombres primitifs et des opérations arithmétiques, nous pourrions effectuer des opérations insensées, comme l'ajout de deux termes lambda ensemble: (λx.x) + (λy.y). On pourrait faire valoir que la seule chose sensée à faire est de signaler une erreur lorsque cela se produit, mais pour être en mesure de le faire, chaque valeur doit être étiquetée avec un indicateur qui indique si le terme est un terme lambda ou un numéro. L'opérateur d'addition vérifie ensuite que les deux arguments sont en effet étiquetés comme chiffres, et si elles ne sont pas, signaler une erreur. Notez que ces balises sont pas types, car les types sont propriétés des programmes, et non des valeurs produites par ces programmes.

Une langue uni typée qui fait cela est appelé typé dynamiquement.

Les langages tels que JavaScript, Python et Ruby sont uni-typé. Encore une fois, l'opérateur typeof en JavaScript et la fonction type en Python ont des noms trompeurs; ils retournent les balises associées aux opérandes, pas leurs types. De même, dynamic_cast en C ++ et en Java instanceof faire pas faire des contrôles de type.

Compilé par rapport Interprété

"Lorsque le code source est traduit"

  • code source : Code d'origine (généralement tapé par un être humain dans un ordinateur)
  • Traduction : la conversion du code source en quelque chose d'un ordinateur peut lire (à savoir le code machine)
  • Run-Time : période lorsque le programme est en cours d'exécution des commandes (après la compilation, si compilé)
  • Compilé Langue : Code traduit avant l'exécution
  • Interprété Langue : Code traduit à la volée, lors de l'exécution

Taper

"Quand les types sont vérifiés"

5 + '3' est un exemple d'une erreur de type dans fortement typé langues telles que Go et Python, car ils ne permettent pas de « contrainte de type » -> la capacité d'une valeur de changer le type de certains contextes tels que la fusion de deux types. langues, telles que JavaScript, ne jetterai pas une erreur de type (résultats dans '53').

  • statique : Types vérifiés avant l'exécution
  • dynamique : Types vérifiés à la volée, lors de l'exécution

Les définitions de « statique et Compilé » et « Dynamic & Interprété » sont assez similaires ... mais rappelez-vous qu'il est « quand les types sont contrôlés » par rapport « lorsque le code source est traduit ».

Vous obtiendrez les mêmes erreurs de type indépendamment du fait que la langue est compilé ou interprété ! Vous devez séparer ces termes sur le plan conceptuel.

Python Exemple

Dynamique, Interprété 

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

silly(2)

Parce que Python est à la fois interprété et typé dynamiquement, il se traduit uniquement et le code de type contrôles qu'il est exécuté sur. Le bloc else exécute jamais, si 5 + '3' est même jamais regardé!

s'il a été typé statiquement?

Une erreur de type serait jeté avant que le code est exécuté même. Il effectue encore la vérification de type avant l'exécution même si elle est interprétée.

s'il a été compilé?

Le bloc else serait traduit / examiné avant l'exécution, mais parce qu'il est typé dynamiquement, il ne serait pas jeter une erreur! langues dactylographiés ne vérifient Dynamiquement pas les types jusqu'à l'exécution, et que la ligne n'exécute.

Go Exemple

statique, Compilé 

package main

import ("fmt"
)

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

func main() {
  silly(2)
}

Les types sont vérifiés avant d'exécuter (statique) et l'erreur de type est pris immédiatement! Les types seraient toujours vérifiés avant l'exécution si elle a été interprétée, ayant le même résultat. Si elle était dynamique, il ne jette aucune erreur, même si le code serait examinée lors de la compilation.

Performance

Un langage compilé aura de meilleures performances lors de l'exécution si elle est statiquement typé (par rapport dynamique); la connaissance des types permet d'optimiser le code de la machine.

Les langages typés statiquement ont de meilleures performances lors de l'exécution intrinsèque en raison de ne pas avoir besoin de vérifier les types dynamiquement lors de l'exécution (il vérifie avant la course).

De même, les langages compilés sont plus rapides lors de l'exécution que le code a déjà été traduit au lieu d'avoir à « interpréter » / traduire à la volée.

Notez que les deux compilé et langages typés seront statiquement un délai avant de lancer la traduction et vérification de type, respectivement.

Plus de différences

Le typage statique attire rapidement les erreurs, au lieu de les trouver lors de l'exécution (particulièrement utile pour les programmes longs). Il est plus « stricte » en ce qu'elle ne permettra pas à des erreurs de type partout dans votre programme et empêche souvent les variables de types changeants, qui défend plus contre les erreurs non intentionnelles. 

num = 2
num = '3' // ERROR

typage dynamique est plus flexible, certains apprécient. Il permet généralement des variables de changer les types, ce qui peut entraîner des erreurs inattendues.

type vérification des langages typés statiquement au moment de la compilation et le type ne peut pas changer. (Ne soyez pas mignon avec des commentaires de type-casting, est créé une nouvelle variable / référence).

type vérification des langues à l'exécution tapé Dynamiquement temps et le type d'une variable peut être modifiée à l'exécution.

Les langages typés statiquement : chaque variable et d'expression est déjà connue au moment de la compilation.

(int a; un ne peut prendre que des valeurs de type entier lors de l'exécution)

Exemples: C, C ++, Java

Les langages typés dynamiquement : les variables peuvent recevoir des valeurs différentes lors de l'exécution et leur type est défini au moment de l'exécution.

(var a; un peut prendre tout type de valeurs lors de l'exécution)

Exemples:. Ruby, Python

Doux et définitions simples, mais la nécessité montage: Les langages typés statiquement se fixe pour son périmètre du type à une variable (Seg: SCALA) Les langages typés dynamiquement lient le type à la valeur réelle référencée par une variable.

  • Dans un langage typé statiquement, une variable est associée à un type qui est connu au moment de 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 être affectée une valeur qui est une instance du type connu / spécifié.
  • Dans un langage typé dynamiquement, une variable n'a pas de type, et sa valeur lors de l'exécution peut être quelque chose de toute forme et de la forme.

Les langages typés statiquement comme C ++, Java et langages typés comme Dynamiquement Python ne diffèrent que de l'exécution du type de la variable.     typés statiquement langues ont le type de données statiques pour la variable, ici le type de données est vérifiée lors de la compilation si le débogage est beaucoup plus simple ... alors que typé dynamiquement langues ne font pas la même, le type de données est vérifiée qui exécute le programme et donc la mise au point est un peu difficile.

En outre, ils ont une très petite différence et peut être lié avec les langues fortement typés et faiblement typés . Un langage fortement typé ne vous permet pas d'utiliser un type comme un autre exemple. C et C ++ ... alors que des langues faiblement typés permettent eg.python

langage typé dynamiquement permet de prototyper rapidement des concepts d'algorithme sans les frais généraux d'environ penser à ce que les types de variables doivent être utilisés (ce qui est une nécessité dans statiquement typé languag e) .

statique langages typés (compilateur résout les appels de méthode et de compiler des références):

  • généralement de meilleures performances
  • plus rapide compilation des commentaires d'erreur
  • un meilleur support IDE
  • ne convient pas pour travailler avec des formats de données non défini
  • plus difficile de commencer un développement lorsque le modèle n'est pas défini quand
  • plus de temps de compilation
  • dans de nombreux cas nécessite d'écrire plus de code

Dynamique langues tapée (décisions prises dans le programme en cours d'exécution):

  • faible performance
  • un développement plus rapide
  • quelques bugs peuvent être détectés que plus tard en temps d'exécution
  • bon pour les formats de données non définies (programmation méta)

Saisie statique: Les langages tels que Java et Scala sont tapés statiques.

Les variables doivent être définies et initialisées avant d'être utilisées dans un code.

par ex. int x; x = 10;

System.out.println (x);

Dynamic Taper:  Perl est un langage typé dynamique.

Les variables avant d'être utilisées dans le code ne doivent pas être initialisés.

y = 10; utiliser cette variable dans la dernière partie de code

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top