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

946

J'entends beaucoup dire que les nouveaux langages de programmation sont typés dynamiquement, mais qu'est-ce que cela signifie réellement lorsque nous disons qu'un langage est typé dynamiquement vs statiquement?

Rachel
la source
25
Bonne question mais votre réponse acceptée n'est pas la bonne réponse.
Jon Harrop
42
pouvez-vous faire référence à quelque chose qui est correct alors?
Sagiruddin Mondal
@EricLeschinski Je pense que les tests unitaires aident maintenant avec ce problème et les langages typés dynamiquement tels que JavaScript peuvent être codés avec l'assurance qu'il tiendra, le rendant ainsi éligible pour le développement de logiciels d'entreprise, ne pensez-vous pas?
pixel 67
8
Au mieux, ces tests unitaires se détériorent avec le temps et sont désactivés par des collègues qui tentent d'améliorer la sécurité de l'emploi, au pire, ils ne sont jamais écrits en premier lieu. C'est comme suggérer à un mécanicien professionnel d'utiliser du ruban adhésif sur les voitures de son client. Oui junior, utiliser du ruban adhésif pour ce travail de transmission est une bonne idée ... pour vous.
Eric Leschinski
2
Je sais que cette question a 10 ans, mais d'après ce que j'ai lu dans les commentaires, vous devriez probablement passer à accepter la réponse de "Christopher Tokar".
Rev1.0

Réponses:

854

Langues typées statiquement

Un langage est typé statiquement si le type d'une variable est connu au moment de la compilation. Pour certains langages, cela signifie qu'en tant que programmeur, vous devez spécifier le type de chaque variable (par exemple: Java, C, C ++); d'autres langages offrent une certaine forme d' 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 de nombreux bugs triviaux sont détectés à un stade très précoce.

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

Langues typées dynamiquement

Une langue est typée dynamiquement si le type est associé à des valeurs d'exécution, et non nommé variables / champs / etc. Cela signifie que vous, en tant que programmeur, pouvez écrire un peu plus rapidement car vous n'avez pas besoin de spécifier les types à chaque fois (sauf si vous utilisez un langage de type statique 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 retrouver à chercher un bogue qui est dû à l'interpréteur qui interprète mal le type d'une variable. Heureusement, les scripts ont tendance à être petits, donc les bogues n'ont pas tant d'endroits à cacher.

La plupart des langages typés dynamiquement vous permettent de fournir des informations de type, mais ne l'exigent pas. Un langage qui est en cours de développement, Rascal , adopte une approche hybride permettant le typage dynamique au sein des fonctions mais imposant un typage statique pour la signature de fonction.

Pas d'hommes
la source
6
@NomeN Pouvez-vous nommer un langage typé dynamiquement qui implémente l'inférence de type HM?
Pete Kirkham
88
"Un langage est typé dynamiquement si le type d'une variable est interprété lors de l'exécution": Non. Un langage est typé dynamiquement si le type est associé à des valeurs au moment de l'exécution, et non nommé variables / champs / etc.
Paul Biggar
15
Un typage incorrect et statique signifie "qu'une valeur de référence est manifestement (ce qui n'est pas la même qu'au moment de la compilation) contrainte en ce qui concerne le type de la valeur qu'elle peut désigner, et que l'implémentation du langage, qu'il s'agisse d'un compilateur ou d'un interprète , applique et utilise autant que possible ces contraintes. " cité de: c2.com/cgi/wiki?StaticTyping qui, comment je le comprends, est correct.
Matthias Wolf
6
La chose la plus évidente au sujet des systèmes de types de Java, C, C ++, Pascal et de nombreux autres langages «industriels» largement utilisés n'est pas qu'ils sont typés statiquement, mais qu'ils sont explicitement typés. En d'autres termes, ils nécessitent beaucoup de déclarations de type. (Dans le monde des langages moins explicitement typés, où ces déclarations sont facultatives, elles sont souvent appelées «annotations de type».) Cela n'a rien à voir avec les types statiques. suite ..
Vipresh
7
Les premières langues à typage statique ont été explicitement typées par nécessité. Cependant, les algorithmes d'inférence de type - des techniques pour regarder le code source sans déclaration de type du tout, et décider quels sont les types de ses variables existent depuis de nombreuses années maintenant. Le langage ML, qui l'utilise. Haskell, qui l'améliore, a maintenant environ 15 ans. Même C # adopte maintenant l'idée, ce qui suscitera beaucoup de sourcils et donnera sans aucun doute lieu à des affirmations selon lesquelles il est «faiblement typé». suite ...
Vipresh
399

Les langages de programmation à typage statique vérifient le type (c'est-à-dire le processus de vérification et d'application des contraintes des types) au moment de la compilation plutôt qu'au moment de l' exécution .

Les langages de programmation typés dynamiquement vérifient le type au moment de l' exécution plutôt qu'au moment de la compilation .

Exemples de langages typés statiquement: - Java, C, C ++

Exemples de langages typés dynamiquement: - Perl, Ruby, Python, PHP, JavaScript

Christopher Tokar
la source
19
Je pense que c'est la meilleure réponse. En particulier, la réponse acceptée est largement inexacte dans les faits.
Jon Harrop
1
@JonHarrop De quelles manières spécifiquement?
1252748
21
@thomas: "Cela signifie qu'en tant que programmeur, vous pouvez écrire un peu plus vite car vous n'avez pas besoin de spécifier le type à chaque fois". Vous n'avez pas besoin de spécifier le type à chaque fois avec une saisie statique si vous avez une inférence de type. Voir SML, OCaml, F #, Haskell ...
Jon Harrop
1
Dans les langages prog typés statiquement, la vérification de type est effectuée avant l'exécution, mais pas exactement au moment de la compilation.
Luiz Felipe
307

Voici un exemple contrastant comment 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 au moment de l'exécution, et donc:

silly(2)

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

silly(-1)

Produit

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

car la ligne correspondante a été exécutée.

Aller d'autre part fait 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)
}

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

invalid operation: "3" + 5 (mismatched types string and int)
Akavall
la source
5
Merci pour l'exemple bien rangé. Je suppose donc que tous les langages de script sont typés dynamiquement, car ils ne sont pas compilés?
CᴴᴀZ
8
Oui. tous les langages de script sont typés dynamiquement, car ce n'est pas un compilateur pour faire la vérification de type statique de toute façon. Ce point a été illustré dans cet article sitepoint.com/typing-versus-dynamic-typing .
Shashi
9
Scala peut être utilisé comme langage de script et il est typé statiquement! #discussion @Shashi
Sagiruddin Mondal
3
@Shashi Compilation ne signifie pas typé statiquement. Haskell peut être interprété avec runhaskell, par exemple.
BalinKingOfMoria réintègre les CM le
2
Le langage de script ne signifie PAS non plus un langage interprété. TypeScript est statiquement typé, compilé / transpilé, mais un langage de script.
metalim
161

Autrement dit, dans un langage à typage statique, les types de variables sont statiques , ce qui signifie qu'une fois que vous avez défini une variable sur un type, vous ne pouvez pas la modifier. En effet, 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 à typage dynamique, les types de variables sont dynamiques , 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 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

Il est donc préférable de considérer les variables dans les langages typés dynamiquement comme de simples pointeurs génériques vers des valeurs typées.

Pour résumer, tapez 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 langue avec des variables typées statiquement contre une langue avec des variables typées dynamiquement IMHO.

Les langages typés statiquement sont généralement des langages compilés, ainsi, les compilateurs vérifient les types (c'est parfaitement logique, car les types ne peuvent pas être modifiés ultérieurement au moment de l'exécution).

Les langages typé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 lorsqu'ils sont utilisés. Bien sûr, cela entraîne un certain coût de performance et est l'une des raisons pour lesquelles les langages dynamiques (par exemple, python, ruby, php) ne sont pas aussi bons que ceux typés (java, c #, etc.). D'un autre point de vue, les langages typés statiquement ont plus de coût de démarrage: vous obligent généralement à écrire plus de code, un code plus dur. Mais cela rapporte plus tard.

La bonne chose est que les deux parties empruntent des fonctionnalités de l'autre côté. Les langages typés incorporent des fonctionnalités plus dynamiques, par exemple, les génériques et les bibliothèques dynamiques en c #, et les langages dynamiques incluent plus de vérification de type, par exemple, les annotations de type en python ou la variante HACK de PHP, qui ne sont généralement pas au cœur du langage et utilisables sur demande.

En ce qui concerne le choix de la technologie, aucun côté n'a une supériorité intrinsèque sur l'autre. C'est juste une question de préférence si vous voulez plus de contrôle pour commencer ou de flexibilité. choisissez simplement 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 changement.

mehmet
la source
8
Cela a beaucoup de sens. Je pense que cela explique au moins le raisonnement derrière les noms beaucoup mieux que les autres réponses ici.
JamEngulfer
Selon cette référence, Python est à la fois un langage typé statiquement et dynamiquement: wiki.python.org/moin/… Quelqu'un sait-il pourquoi?
modulitos
1
Lucas, Au contraire, le document répète que Python est à la fois fortement et dynamiquement typé. Où avez-vous vu ça? Pouvez-vous citer?
mehmet du
2
Je pense que cette réponse communique le mieux le concept de la manière la plus simple. Beaucoup d'autres réponses tentent de décrire de manière abstraite le concept, mais échouent à certains détails. Je préfère voir cette réponse en haut de la liste.
Hawkeye
5
La plupart des autres réponses ont créé plus de questions dans mon esprit. Celui-ci les a tous effacés. Cette réponse devrait vraiment être au top IMHO
Hami Torun
39

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

Typage statique

On dit qu'un langage de programmation utilise un typage statique lorsque la vérification de type est effectuée pendant la compilation plutôt que pendant l'exécution. Dans le typage statique, les types sont associés à des variables et non à des valeurs. Les langages typés statiquement incluent Ada, C, C ++, C #, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (en ce qui concerne la distinction des scalaires, des tableaux, des hachages et des sous-routines) et Scala. Le typage statique est une forme limitée de vérification de programme (voir sécurité du type): en conséquence, il permet de détecter de nombreuses erreurs de type au début du cycle de développement. Les vérificateurs de type statiques évaluent uniquement les informations de type qui peuvent être déterminées au moment de la compilation, 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 la nécessité de répéter les vérifications de type à chaque exécution du programme. L'exécution du programme peut également être rendue plus efficace (c'est-à-dire plus rapide ou en prenant moins de mémoire) en omettant les vérifications de type d'exécution et en permettant d'autres optimisations.

Étant donné qu'ils évaluent les informations de type lors de la compilation et manquent donc d'informations de type qui ne sont disponibles qu'au moment de l'exécution, les vérificateurs de type statiques sont conservateurs. Ils rejetteront certains programmes qui peuvent se comporter correctement au moment de l'exécution, mais qui ne peuvent pas être statiquement déterminés comme étant bien typés. Par exemple, même si une expression a 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é comme mal typé, car une analyse statique ne peut pas déterminer que la branche else ne sera pas prise. [1] Le comportement conservateur des vérificateurs de type statique est avantageux lorsqu'il est évalué à faux rarement: un vérificateur de type statique peut détecter des erreurs de type dans des chemins de code rarement utilisés. Sans vérification de type statique, même les tests de couverture de code avec une couverture de code à 100% peuvent être incapables de trouver de telles erreurs de type. Les tests de couverture de code peuvent ne pas détecter de telles erreurs de type car la combinaison de tous les emplacements où des valeurs sont créées et de tous les emplacements où une certaine valeur est utilisée doit être prise en compte.

Les langues à typage statique les plus utilisées ne sont pas formellement sûres. Ils ont des "failles" dans la spécification du langage de programmation permettant aux programmeurs d'écrire du code qui contourne la vérification effectuée par un vérificateur de type statique et ainsi de résoudre un plus large éventail de problèmes. Par exemple, Java et la plupart des langages de style C ont une punition de type, et Haskell a des fonctionnalités telles que unsafePerformIO: ces opérations peuvent être dangereuses au moment de l'exécution, en ce qu'elles peuvent provoquer un comportement indésirable en raison d'une saisie incorrecte des valeurs lors de l'exécution du programme.

Saisie dynamique

Un langage de programmation est dit être typé dynamiquement, ou simplement «dynamique», lorsque la majorité de sa vérification de type est effectuée au moment de l'exécution plutôt qu'au moment de la compilation. En typage dynamique, les types sont associés à des valeurs et non à des variables. Les langages typés dynamiquement incluent Groovy, JavaScript, Lisp, Lua, Objective-C, Perl (en ce qui concerne les types définis par l'utilisateur mais pas les types intégrés), PHP, Prolog, Python, Ruby, Smalltalk et Tcl. Par rapport au typage statique, le typage dynamique peut être plus flexible (par exemple en permettant aux programmes de générer des types et des fonctionnalités basés sur des données d'exécution), mais au prix de moins de garanties a priori. Cela est dû au fait qu'un langage typé dynamiquement accepte et tente d'exécuter certains programmes qui peuvent être considérés comme invalides par un vérificateur de type statique.

La frappe dynamique peut entraîner des erreurs de type à l'exécution, c'est-à-dire qu'à l'exécution, une valeur peut avoir un type inattendu et une opération non logique pour ce type est appliquée. Cette opération peut se produire longtemps après l'endroit où l'erreur de programmation a été commise, c'est-à-dire l'endroit où le mauvais type de données est passé dans un endroit qu'il ne devrait pas avoir. Cela rend le bug difficile à localiser.

Les systèmes de langage à typage dynamique, comparés à leurs cousins ​​à typage statique, effectuent moins de vérifications "au moment de la compilation" sur le code source (mais vérifieront, par exemple, que le programme est syntaxiquement correct). Les vérifications au moment de l'exécution peuvent potentiellement être plus sophistiquées, car elles peuvent utiliser des informations dynamiques ainsi que toute information présente lors de la compilation. D'un autre côté, les vérifications d'exécution affirment uniquement que les conditions sont respectées dans une exécution particulière du programme, et ces vérifications sont répétées pour chaque exécution du programme.

Le développement dans des langages typés dynamiquement est souvent soutenu par des pratiques de programmation telles que les tests unitaires. Les tests sont une pratique clé dans le développement de logiciels professionnels et sont particulièrement importants dans les langages typés dynamiquement. En pratique, les tests effectués pour garantir le bon fonctionnement du programme peuvent détecter une gamme d'erreurs beaucoup plus large que la vérification de type statique, mais à l'inverse, ils ne peuvent pas rechercher de manière aussi complète les erreurs que les tests et la vérification de type statique sont capables de détecter. Les tests peuvent être incorporés dans le cycle de construction du logiciel, auquel cas ils peuvent être considérés comme une vérification "au moment de la compilation", dans la mesure où l'utilisateur du programme n'aura pas à exécuter manuellement de tels tests.

Références

  1. Pierce, Benjamin (2002). Types et langages de programmation. MIT Appuyez sur. ISBN 0-262-16209-1.
Jacob
la source
75
L'idée principale de SO est de construire un corpus de connaissances, pas de fournir des liens vers d'autres endroits. Vous devriez au moins essayer de faire un extrait du wiki qui répond à la question.
NomeN
5
Cela semblait juste redondant car c'est un lien vers wikipedia et non un site Web transitoire, mais je m'en souviendrai la prochaine fois.
Jacob
2
d'une manière ou d'une autre, je ne peux toujours pas penser à un exemple dans un langage typé dynamiquement où un type n'est pas clair au moment de la compilation mais doit être compris au moment de l'exécution. Pourriez-vous m'en fournir?
Novellizator
3
@Novellizator Ancien commentaire, mais imaginez un scénario dans lequel certaines données sont récupérées à partir d'un serveur distant, puis ces données sont utilisées pour sélectionner une propriété d'un objet. Ex: myObject[remoteDataName]. Ensuite, il n'y a aucun moyen de savoir quelle propriété il choisira ou même s'il s'agit d'une propriété valide.
Mike Cluck
14

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 le pensent). Cependant, certaines langues n'ont qu'un seul type. Celles-ci sont appelées langues uni-typées. Un exemple d'une telle langue est le calcul lambda non typé.

Dans le calcul lambda non typé, tous les termes sont des termes lambda 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 entraînent toujours une récursion infinie ou un terme lambda, mais ne signalent jamais d'erreur.

Cependant, nous avons été d'augmenter le calcul 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 soutenir que la seule chose sensée à faire est de signaler une erreur lorsque cela se produit, mais pour pouvoir 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érifiera alors qu'en effet les deux arguments sont étiquetés comme des nombres, et s'ils ne le sont pas, signalent une erreur. Notez que ces balises ne sont pas des types, car les types sont des propriétés de programmes et non des valeurs produites par ces programmes.

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

Les langages tels que JavaScript, Python et Ruby sont tous uni-typés. Encore une fois, l' typeofopérateur en JavaScript et la typefonction en Python ont des noms trompeurs; ils renvoient les balises associées aux opérandes, pas leurs types. De même, dynamic_casten C ++ et instanceofen Java, ne faites pas de vérification de type.

à droite
la source
7

Compilé vs interprété

"Lorsque le code source est traduit"

  • Code source : code original (généralement tapé par un humain dans un ordinateur)
  • Traduction : Conversion du code source en quelque chose qu'un ordinateur peut lire (par exemple, le code machine)
  • Exécution : période pendant laquelle le programme exécute des commandes (après la compilation, si compilé)
  • Langage compilé : code traduit avant l'exécution
  • Langage interprété : Code traduit à la volée, pendant l'exécution

Dactylographie

"Lorsque les types sont vérifiés"

5 + '3'est un exemple d'erreur de type dans les langages fortement typés tels que Go et Python, car ils ne permettent pas de "coercition de type" -> la possibilité pour une valeur de changer de type dans certains contextes tels que la fusion de deux types. Les langages mal typés , tels que JavaScript, ne génèrent pas d'erreur de type (résulte en '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 "Static & Compiled" et "Dynamic & Interpreted" sont assez similaires ... mais rappelez-vous que c'est "lorsque les types sont vérifiés" vs "lorsque 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 typé dynamiquement, il ne traduit et ne vérifie que le code sur lequel il s'exécute. Le elsebloc ne s'exécute jamais, il 5 + '3'n'est donc même jamais regardé!

Et s'il était typé statiquement?

Une erreur de type serait levée avant même que le code soit exécuté. Il effectue toujours une vérification de type avant l'exécution même s'il est interprété.

Et si c'était compilé?

Le elsebloc serait traduit / examiné avant l'exécution, mais comme il est typé dynamiquement, il ne générera pas d'erreur! Les langages typés dynamiquement ne vérifient pas les types jusqu'à l'exécution, et cette ligne ne s'exécute jamais.


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 l'exécution (statique) et l'erreur de type est immédiatement détectée! Les types seraient toujours vérifiés avant l'exécution s'ils étaient interprétés, ayant le même résultat. S'il était dynamique, il ne générerait aucune erreur même si le code était examiné lors de la compilation.


Performance

Un langage compilé aura de meilleures performances au moment de l'exécution s'il est typé statiquement (vs dynamiquement); la connaissance des types permet d'optimiser le code machine.

Les langages de type statique ont intrinsèquement de meilleures performances au moment de l'exécution car ils n'ont pas besoin de vérifier les types dynamiquement lors de l'exécution (il vérifie avant de s'exécuter).

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

Notez que les langues compilées et typées statiquement auront un délai avant de s'exécuter pour la traduction et la vérification de type, respectivement.


Plus de différences

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

num = 2
num = '3' // ERROR

La frappe dynamique est plus flexible, ce que certains apprécient. Il permet généralement aux variables de changer de type, ce qui peut entraîner des erreurs inattendues.

JBallin
la source
" Parce que Python est à la fois interprété et typé dynamiquement, il ne traduit et ne vérifie que le code sur lequel il s'exécute " - ce n'est pas vraiment le cas. Python (au moins l'implémentation de référence) compile tout votre code au moment de l'importation (vous pouvez également compiler des modules avant / sans les importer). Le compilateur introduit diverses optimisations (au moins dans la mesure où la nature dynamique de Python le permet).
Eli Korvigo
6

Langages typés statiquement : 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 lors de l'exécution)

Exemples: C, C ++, Java

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

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

Exemples: Ruby, Python.

Raman Gupta
la source
5

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

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

RESTfulGeoffrey
la source
4

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

user3627021
la source
3
  • Dans un langage à typage statique, 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 qu'à 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 pendant l'exécution peut être n'importe quelle forme et forme.
Chudong
la source
2

Les langages à typage statique comme C ++, Java et les langages à typage dynamique comme Python ne diffèrent qu'en termes d'exécution du type de la variable. Les langages à typage statique ont un type de données statique pour la variable, ici le type de données est vérifié pendant la compilation, donc le débogage est beaucoup plus simple ... tandis que le typage dynamique langages à ne font pas la même chose, le type de données est vérifié qui exécute le programme et donc le le débogage est un peu difficile.

De plus, ils ont une très petite différence et peuvent être liés à des langues fortement typées et faiblement typées . Une langue fortement typée ne vous permet pas d'utiliser un type comme un autre, par exemple. C et C ++ ... alors que les langages faiblement typés permettent par exemple de python

Akash sharma
la source
2

Typé statiquement

Les types sont vérifiés avant l'exécution afin que les erreurs puissent être détectées plus tôt.

Exemples = c ++

Typé dynamiquement

Les types sont vérifiés lors de l'exécution.

Exemples = Python

Atticus Denewmont
la source
2
Cela n'ajoute pas vraiment quelque chose qui n'est pas encore couvert par d'autres réponses, n'est-ce pas?
Robert
1
Oui, mais la plupart des réponses n'étaient pas très claires, je voulais donc une réponse facile à comprendre.
Atticus Denewmont du
1

Langages typés statiques (le compilateur résout les appels de méthode et compile les références):

  • généralement de meilleures performances
  • retour d'erreur de compilation plus rapide
  • meilleur support IDE
  • ne convient pas pour travailler avec des formats de données non définis
  • plus difficile de démarrer un développement lorsque le modèle n'est pas défini lorsque
  • temps de compilation plus long
  • dans de nombreux cas, il faut écrire plus de code

Langages typés dynamiques (décisions prises dans le programme en cours):

  • baisse des performances
  • développement plus rapide
  • certains bogues peuvent être détectés plus tard au moment de l'exécution
  • bon pour les formats de données non définis (méta-programmation)
MagGGG
la source
0

le langage typé dynamiquement permet de prototyper rapidement les concepts d'algorithme sans avoir à réfléchir sur les types de variables à utiliser (ce qui est une nécessité dans le langage typé statiquement ).

Pavan Kanajar
la source
-15

Typage statique: les langages tels que Java et Scala sont typés statiquement.

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);

Typage dynamique: Perl est un langage typé dynamique.

Les variables n'ont pas besoin d'être initialisées avant d'être utilisées dans le code.

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

Prakhyat
la source
2
Eh bien, cette réponse n'est pas tout à fait juste. Dans les deux langues, les variables doivent être initialisées avant d'être utilisées. Cependant, dans les langues typées dynamiquement, vous pouvez choisir de laisser de côté le type où il est utilisé.
darshan
Il semble que vous utilisiez abusivement le terme "variables", vous auriez dû dire "types" à la place.
Emir
Je dirais que Perl est typé statiquement: il a 3 types, scalar ( $), array ( @) et hash ( %). Le type d'une variable en Perl est connu au moment de la compilation et reste le même pour le reste de la durée de vie des variables.
CoffeeTableEspresso