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

typé Statiquement langages de programmation n'type de vérification (le processus de vérification et de faire respecter les contraintes de types) au moment de la compilation, par opposition à l'exécution.

les langages de programmation dactylographiés dynamiquement effectuent une vérification de type à l'exécution plutôt qu'à la compilation.

voici un exemple qui contraste la façon dont Python (dynamically typed) et Go (statically typed) gèrent une erreur de type:

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

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

silly(2)

fonctionne parfaitement bien, et produit la production attendue Hi . L'erreur n'est soulevée que si la ligne problématique est touchée:

silly(-1)

produit

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

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

Passer de l'autre côté ne la 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)
}

Le ci-dessus ne compile pas, avec l'erreur suivante:

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

simplement dit de cette façon: dans un langage statiquement typé les types de variables sont 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";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

en revanche: dans un langage dynamiquement typé types de variables sont dynamique , ce qui signifie qu'après avoir défini une variable à un type, vous pouvez la modifier. C'est parce que dactylographier est associé à la valeur qu'il 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

donc, il est préférable de penser aux variables dans les langages dactylographiés dynamiquement comme juste des pointeurs génériques à des valeurs dactylographiées.

pour résumer, type décrit (ou aurait dû décrire) les variables de 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 versus une langue avec des variables dynamiquement typées IMHO.

les langages Statiquement typés sont généralement les langages compilés, donc, les compilateurs vérifier les types (parfait de sens? comme les types ne sont pas autorisés à être changés plus tard à l'heure d'exécution).

les langages dactylographiés dynamiquement 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 quand 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 se dimensionnent pas aussi bien que les langages dactylographiés (java, c#, etc.). D'un autre point de vue, les langages statiquement typés ont plus d'un coût de démarrage: vous fait habituellement écrire plus de code, code plus dur. Mais qui paie plus tard au large.

la bonne chose est que les deux côtés empruntent des caractéristiques de l'autre côté. Les langages typés incorporent plus de fonctionnalités 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 variante de HACK de PHP, qui ne sont généralement pas au cœur du langage et utilisables à la demande.

en ce qui concerne le choix de la technologie, aucune des deux parties n'a de 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 de 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 l'opposé avant de considérer un commutateur.

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

typage Statique

un langage de programmation est dit utiliser le typage statique lors de la vérification de type est effectué pendant la compilation opposition à l'exécution. En dactylographie statique, les types sont associés à des variables pas de valeurs. Les langages statiquement typés include Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (à l'égard de la distinction les scalaires, les tableaux, les hachages et les subroutines) et Scala. Dactylographie statique est une forme limitée de programme vérification (voir sécurité du type)): en conséquence, il permet de nombreux types les erreurs à déceler au début de la cycle de développement. Type statique les vérificateurs n'évaluent que le type informations qui peuvent être déterminées à compilent le temps, mais sont capables 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é. L'exécution du programme peut également être rendu plus efficace (c'est à dire plus rapide ou en réduisant la mémoire) par omettre les contrôles de type d'exécution et permettre d'autres optimisations.

parce qu'ils évaluent l'information sur le type lors de la compilation, et donc l'absence type information qui est seulement disponible à l'exécution, de type statique les dames sont conservatrices. Ils rejeter certains programmes qui peuvent être bien comportés à au moment de l'exécution, mais qui ne peut pas être déterminé statiquement à bien typé. Par exemple, même si un expression toujours renvoie la valeur true au moment de l'exécution, un programme contenant le code

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

sera rejeté comme mal dactylographié, parce que une analyse statique ne peut pas déterminer que l'autre branche ne pas être occupé.[1] le comportement conservateur des pions de type statique est avantageux lors de l' false rarement: Un le vérificateur de type statique peut détecter type erreurs dans les chemins de code rarement utilisés. Sans contrôle de type statique, même essais de couverture avec code à 100% la couverture peut être pas en mesure de trouver ces les erreurs de type. Essais de couverture du Code mai ne pas détecter de telles erreurs de type car la combinaison de tous les lieux où les valeurs sont créées et toutes les endroits où une certaine valeur est utilisée doit être pris en compte.

Le plus largement utilisé type statique les langues ne sont pas formellement de type sûr. Ils ont "des failles" dans le langage de programmation spécification permettant aux programmeurs d'écrire du code qui contourne la vérification effectué par un vérificateur de type statique et donc, aborder un plus large éventail de problèmes. Par exemple, Java et la plupart des c-style les langues ont le punning de type, et Haskell présente les caractéristiques suivantes: unsafePerformIO: de telles opérations peuvent être dangereux lors de l'exécution, en ce qu'ils peuvent causer un comportement indésirable dû à mauvaise saisie des valeurs lorsque le le programme s'exécute.

typage Dynamique

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

le typage dynamique peut donner lieu à une exécution type les erreurs-qui est, au moment de l'exécution, un la valeur peut avoir un type inattendu, et une opération sans sens pour ce type est appliqué. Cette opération peut se produire longtemps après l'endroit où erreur de programmation a été faite-est, l'endroit où le mauvais type de données passé dans un endroit où il ne devrait pas avoir. Cela rend le bug difficile à situer.

systèmes linguistiques dactylographiés dynamiquement, par rapport à leur typage statique cousins, faites moins de "compilation-time"" vérifie sur le code source (mais vérifier, par exemple, que le programme est syntaxiquement correct). Au moment de l'exécution les contrôles peuvent être plus sophistiqué, car ils peuvent utiliser des informations dynamiques ainsi que information qui était présente pendant compilation. Sur l'autre main, d'exécution vérifie seulement affirmer que conditions de détenir dans un particulier l'exécution du programme, et ces les contrôles sont répétés pour chaque l'exécution du programme.

Développement dans typées dynamiquement les langues sont souvent soutenues par les pratiques de programmation telles que l'unité test. Les tests sont une pratique clé dans le développement de logiciels professionnels; est particulièrement important dans les langages dactylographiés dynamiquement. Dans pratique, les tests effectués pour s'assurer le bon fonctionnement du programme peut détecter gamme d'erreurs beaucoup plus large que statique contrôle de type, mais à l'inverse ne peut pas recherche aussi complète pour le erreurs que les essais et statiques type vérification 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 "moment de la compilation" vérifier, dans le programme utilisateur il n'est pas nécessaire d'effectuer ces essais manuellement.

Références

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

la terminologie" dynamically typed " est malheureusement trompeuse. Toutes les langues sont statiquement typées, et les types sont des propriétés d'expressions (et non de valeurs comme certains le pensent). Cependant, certaines langues n'ont qu'un seul type. Ces langages sont appelés langages Uni-typés. Un exemple d'une telle langue est le type lambda calcul.

dans le calcul lambda non typé, tous les termes sont lambda Termes, et la seule opération qui peut être effectuée sur un terme est de l'appliquer à un autre terme. Par conséquent, toutes les opérations donnent toujours lieu soit à une récursion infinie, soit à un terme lambda, mais ne signalent jamais d'erreur.

cependant, si nous devions augmenter le calcul lambda non typé avec des nombres primitifs et des opérations arithmétiques, alors nous pourrions effectuer des opérations absurdes, en ajoutant deux termes lambda ensemble: (λx.x) + (λy.y) . On pourrait argumenter que la seule chose saine à faire est de signaler une erreur lorsque cela se produit, mais pour pouvoir le faire, chaque valeur doit être marquée avec un l'indicateur qui indique si le terme est un lambda terme ou un nombre. L'opérateur d'addition vérifiera alors que les deux arguments sont marqués comme des nombres, et s'ils ne le sont pas, signalera une erreur. Notez que ces étiquettes sont des types et non , parce que les types sont des propriétés des programmes, et non des valeurs produites par ces programmes.

un langage uni-typé qui fait cela est appelé dynamiquement typé.

les langues telles que JavaScript, Python et Ruby sont tous Uni-typés. Encore une fois, l'opérateur typeof en JavaScript et la fonction type en Python ont des noms trompeurs; ils renvoient les étiquettes associées aux opérandes, pas leurs types. De même, dynamic_cast en C++ et instanceof en Java font et non font des vérifications de type.

langues statiquement typées-vérification de type au moment de la compilation et le type ne peut pas changer. (Ne vous inquiétez pas mignon avec la conversion de type de commentaires, une nouvelle variable de référence est créé).

langues dactylographiées dynamiquement vérification de type à l'exécution et le type d'une variable peut être modifié à l'exécution.

définitions douces et simples, mais répondant au besoin: Les langages statiquement typés lient le type à une variable pour toute sa portée (Seg: SCALA) Les langages dactylographiés dynamiquement lient le type à la valeur réelle référencée par une variable.

compilé vs. interprété

"Lorsque le code source est traduit par"

• Source Code : code Original (habituellement dactylographié par un humain dans un ordinateur)
• traduction : conversion du code source en quelque chose qu'un ordinateur peut lire (c.-à-d. code machine)
• Run-Time : période pendant laquelle le programme exécute des commandes (après compilation, si compilée)
• langage compilé : Code traduit avant l'exécution
• langue D'interprétation : Code traduit à la volée, lors de l'exécution

Dactylographie

"Quand les types sont vérifiés"

5 + '3' est un exemple d'erreur de type dans fortement dactylographié des langages comme Go et Python, parce qu'ils ne permettent pas la "coercition de type" -> la capacité pour une valeur de changer de type dans certains contextes tels que la fusion de deux types. faiblement dactylographié les langues, telles que JavaScript, ne vont pas jeter une erreur de type (résultats dans '53' ).

• Statique : Types vérifié avant l'exécution
• dynamique : Types contrôlés la volée, lors de l'exécution

les définitions de "Static & Compiled" et "Dynamic & Interpreted" sont assez similaires...mais rappelez-vous que c'est "quand les types sont cochés" contre "quand le code source est traduit".

vous obtiendrez les mêmes erreurs de type que la langue soit compilée ou interprétée ! Vous devez séparer ces termes conceptuellement.

Exemple Python

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 dactylographié dynamiquement, il ne traduit et contrôle que le code qu'il exécute. Le bloc else ne s'exécute jamais, donc 5 + '3' n'est jamais regardé!

et si elle était dactylographiée statiquement?

une erreur de type serait jetée avant le code est à même de les exécuter. Il effectue toujours la vérification de type avant l'exécution, même s'il est interprété.

et si ça avait été compilé?

le bloc else serait traduit/regardé avant l'exécution, mais parce qu'il est dactylographié dynamiquement il ne lancerait pas une erreur! Les langages dactylographiés dynamiquement ne vérifient pas les types avant l'exécution, et cette ligne n'exécute jamais.

Aller De L'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 l'exécution (statique) et l'erreur de type est immédiatement Attrapée! Les types seraient encore vérifiés avant l'exécution si elle était interprétée, avec le même résultat. S'il était dynamique, il ne jetterait aucune erreur, même si le code serait regardé pendant la compilation.

Performance

un langage compilé aura une meilleure performance à l'exécution si elle est statiquement typée (par rapport à dynamiquement); connaissance des types permet l'optimisation de code machine.

ont de meilleures performances à l'exécution intrinsèquement parce qu'ils n'ont pas besoin de vérifier les types de manière dynamique lors de l'exécution (il vérifie avant l'exécution).

de même, les langues compilées sont plus rapides à l'exécution car le code a déjà été traduit au lieu d'avoir besoin de "interpréter"/traduire à la volée.

notez que les langues compilées et statiquement dactylographiées auront un délai avant d'être exécutées pour la traduction et la vérification de type, respectivement.

Plus De Différences

saisie statique des erreurs tôt, au lieu de les trouver pendant l'exécution (particulièrement utile pour les programmes longs). Il est plus "strict" en ce qu'il ne permettra pas d'erreurs de type n'importe où dans votre programme et empêche souvent les variables de changer de type, ce qui se défend contre les erreurs involontaires.

num = 2
num = '3' // ERROR

la dactylographie dynamique est plus souple, ce que certains apprécient. Il permet généralement aux variables de changer de type, ce qui peut entraîner des erreurs imprévues.

• dans un langage statiquement typé, 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 même, la variable ne peut être assignée qu'à une valeur qui est une instance du type connu/spécifié.
• dans un langage dynamiquement dactylographié, une variable n'a pas de type, et sa valeur pendant l'exécution peut être n'importe quoi de n'importe quelle forme et forme.

fort typage signifie probablement que les variables ont un type bien défini et qu'il existe des règles strictes sur la combinaison de variables de différents types dans les expressions. Par exemple, si A est un entier et B est un float, alors la règle stricte sur A+B peut être que l'Un est converti en float et le résultat retourné comme un float. Si A est un entier et B une chaîne, alors la règle stricte pourrait être que A+B n'est pas valide.

statique taper signifie probablement que les types sont assignés au moment de la compilation (ou son équivalent pour les langues non compilées) et ne peuvent pas changer pendant l'exécution du programme.

remarquez que ces classifications ne s'excluent pas mutuellement, en fait je m'attendrais à ce qu'elles se produisent souvent ensemble. Beaucoup de langues fortement typées sont aussi statiquement typées.

Et remarque que lorsque j'utilise le mot "probablement" c'est parce qu'il n'y a pas universellement accepté les définitions de ces termes. Comme vous avez déjà vu les réponses jusqu'à présent.

simplement dit de cette façon: dans un langage statiquement typé le type est statique , ce qui signifie 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 modifier. 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 implicites de type (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. 

attendu 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.

langues statiquement typées : chaque variable et expression est déjà connue au moment de la compilation.

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

Par Exemple: C, C++, Java

langues dactylographiées dynamiquement : varialbes peut recevoir différentes valeurs à l'exécution et le type est défini à l'exécution.

(var a; un pouvez prendre n'importe quel type de valeurs à l'exécution)

Par Exemple: Ruby, Python.

les langages statiquement typés comme C++, Java et les langages dynamiquement typés comme Python ne diffèrent que par l'exécution du type de la variable. statically typed les langues ont un type de données statique pour la variable, ici le type de données est vérifié lors de la compilation, donc le débogage est beaucoup plus simple...alors que les langues dactylographiées dynamiquement ne font pas la même chose, le type de données est vérifié qui exécute le programme et donc le débogage est un peu difficile.

en outre, ils ont une très petite différence et peuvent être liés avec fortement typé et faiblement typé langues. Un langage fortement typé ne vous permet pas d'utiliser un type comme un autre par exemple. Le C et le C++ ...alors que les langues faiblement typées permettent par exemple:python

langage dynamiquement typé permet de prototyper rapidement des concepts d'algorithme sans avoir à se demander quels types de variables doivent être utilisés (ce qui est une nécessité dans langage statiquement typé e).

Dans un typé statiquement langue , chaque nom de variable est lié à la fois 1.à un type (au moment de la compilation, au moyen d'une déclaration de données) 2.à un objet. La liaison d'un objet est facultatif - si un nom n'est pas liée à un objet, le nom est dit nulle. Dans un langage dynamiquement dactylographié , chaque nom de variable est (sauf s'il est nul) lié seulement à un objet.

les noms sont liés aux objets au moment de l'exécution par des moyens des instructions de cession, et il est possible de lier un nom à des objets de différents types pendant l'exécution du programme.

Typage Statique: Les langues telles que Java et Scala sont statiques.

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

pour ex. int x; x = 10;

.hors.println (x);

Typage Dynamique: Perl est un langage dynamique dactylographié.

n'ont pas besoin d'être initialisées avant sont utilisés en code.

y=10; Utilisez cette variable dans la dernière partie du code