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

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

Typées dynamiquement les langages de programmation ne la vérification de type à au moment de l'exécution par opposition à au moment de la compilation.

Simplement mis de cette façon: dans un statiquement typé langue variables de types sont 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";  //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 typées dynamiquement langue variables de types sont dynamique, du sens une fois que vous définissez une variable d'un type, vous POUVEZ le modifier. C'est parce que la saisie 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

Donc, il est préférable de penser en termes de variables typées dynamiquement langues comme juste pointeurs génériques à des valeurs typées.

Pour résumer, type décrit (ou devraient avoir décrit) les variables dans la langue plutôt que de la langue elle-même. Il aurait pu être mieux utilisé comme un langage statiquement typé variables contre un langage dynamiquement typé variables à mon humble avis.

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

Typées dynamiquement langues, sont généralement interprétées, ce type de vérification (le cas échéant) se produit au moment de l'exécution, lorsqu'ils sont utilisés. Bien sûr, cela apporte de la performance de coût, et est l'une des raisons de langages dynamiques (par exemple, python, ruby, php) ne s'adaptent pas aussi bon que le tapé ceux (java, c#, etc.). À partir d'un autre point de vue, les langages statiquement typés ont plus d'un coût de démarrage: fait de vous l'habitude d'écrire plus de code, plus de code. Mais qui paie plus tard au large.

La bonne chose est les deux côtés sont d'emprunt caractéristiques de l'autre côté. Tapé langues sont en train d'intégrer plus de fonctions dynamiques, par exemple, les génériques et les bibliothèques dynamiques en c#, et de la dynamique des langues, y compris plus de la vérification de type, par exemple, les annotations de type python, ou HACK variante de PHP, qui ne sont généralement pas de base de la langue et utilisable sur demande.

Quand il s'agit de sélection de la technologie, ni le côté 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 la flexibilité. il suffit de choisir le bon outil pour le travail, et assurez-vous de vérifier ce qui est disponible dans les termes de la face avant d'envisager un transfert.

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

Dans le lambda calcul non typé, tous les termes sont des lambda-termes, et la seule opération qui peut être effectuée sur un terme est en l'appliquant à un autre terme. Par conséquent, toutes les opérations de toujours se traduire soit par une récursivité infinie ou un lambda terme, mais jamais de signaler une erreur.

Cependant, nous étions à augmenter le lambda calcul non typé primitif, des nombres et des opérations arithmétiques, puis nous avons pu effectuer absurde des opérations, par exemple l'ajout de deux lambda termes: (λx.x) + (λy.y). On pourrait dire que la seule sane chose à faire est de signaler une erreur lorsque cela se produit, mais pour être en mesure de le faire, chaque valeur doit être marqué avec un indicateur qui indique si le terme est un lambda terme ou un nombre. L'opérateur d'addition va alors vérifier qu'en effet, les deux arguments sont étiquetés comme des numéros, et si ils ne le sont pas, un signal d'erreur. Notez que ces balises sont pas types, parce que les types sont des propriétés de programmes, pas de valeurs produites par ces programmes.

Uni-typée langue qui fait cela est appelé dynamiquement typé.

Des langages tels que JavaScript, Python et Ruby sont tous uni-typé. Encore une fois, la typeof opérateur en JavaScript et le type fonction en Python ont des noms trompeurs; ils renvoient les mots-clés associés avec le opérandes, pas leurs types. De même, dynamic_cast en C++ et instanceof en Java ne pas faire de ce type de contrôles.

Compilé vs Interprété

"Lorsque le code source est traduit par"

• Code Source: code d'Origine (généralement tapé par un humain dans un ordinateur)
• Traduction: la Conversion de code source dans quelque chose d'un ordinateur peut lire (c'est à dire en code machine)
• Au Moment de l'exécution: Période, lorsque le programme est en cours d'exécution (après la compilation, si compilé)
• Langage compilé: Code traduit avant l'exécution
• Langage interprété: Code traduit à la volée, lors de l'exécution

---

Tapant

"Quand les types sont vérifiés"

5 + '3' est un exemple d'un type d'erreur dans fortement typé langues comme l'Aller et Python, parce qu'ils ne permettent pas "de contrainte de type" -> la capacité pour une valeur de changement de type, dans certains contextes, tels que la fusion des deux types. Faiblement typé de langages tels que JavaScript, ne va pas faire une erreur de type (résultats en '53').

• Statique: Types vérifié avant l'exécution
• Dynamique: Types vérifié à la volée, lors de l'exécution

---

Les définitions de "Static & Compilé" et "Dynamique & Interprété" sont assez similaires...mais n'oubliez pas qu'il est "quand les types sont vérifiés" vs "lorsque le code source est traduit".

, Vous aurez le même type d'erreurs, indépendamment de savoir si le langage est compilé ou interprété! Vous avez besoin de séparer ces termes sur le plan conceptuel.

---

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 dynamiquement typé, il ne traduit et vérifie le code d'exécution sur. Le else bloc n'est jamais exécuté, de sorte 5 + '3' est n'a même jamais regardé!

Et si c'était statiquement typés?

Un type d'erreur pourrait être levée avant le code est à même de les exécuter. Il remplit toujours la vérification de type avant l'exécution, même si elle est interprétée.

Que s'il a été compilé?

La else bloc seraient traduits/a regardé avant de les exécuter en temps, mais parce que c'est dynamiquement typé, il ne renvoie pas d'erreur! Dynamiquement typé langues ne pas vérifier les types jusqu'à l'exécution, et que la ligne ne s'exécute jamais.

---

Aller 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 la course (statique) et le type d'erreur est immédiatement attiré! Les types seraient toujours être vérifiée avant l'exécution si elle a été interprétée, d'avoir le même résultat. Si c'était dynamique, il ne serait pas de jeter des erreurs, même si le code s'être regardé lors de la compilation.

---

Performance

Un langage compilé aura de meilleures performances au moment de l'exécution si c'est statiquement typé (vs dynamiquement); connaissance des types permet à la machine d'optimisation de code.

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

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

Noter que compilés et les langages statiquement typés aura un délai avant l'exécution de la traduction et de la vérification de type, respectivement.

---

Plus De Différences

Le typage statique captures erreurs dès le début, au lieu de les trouver en cours d'exécution (particulièrement utile pour les programmes plus longs). C'est plus "strict" en ce qu'elle ne permet pas pour les erreurs de type de n'importe où dans votre programme et empêche souvent les variables de changement de type, ce qui protège contre les erreurs non intentionnelles.

num = 2
num = '3' //ERROR

Typage dynamique est plus souple, que certains apprécient. Il permet en général pour les variables de changer de type, ce qui peut entraîner des erreurs inattendues.

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

(int a; un peut prendre uniquement les valeurs de type entier au moment de l'exécution)

Exemples: C, C++, Java

Typées dynamiquement langues: les variables peuvent recevoir des valeurs différentes 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 à l'exécution)

Exemples: Ruby, Python.

Les langages statiquement typés comme C++, Java et typées Dynamiquement des langages comme Python ne diffèrent que dans les conditions de l'exécution du type de la variable.
Statiquement typé langues ont statique type de données de la variable, ici le type de données est contrôlée lors de la compilation si le débogage est beaucoup plus simple...alors que typées Dynamiquement langues ne font pas la même, le type de données est cochée dont l'exécution du programme et, partant, le débogage est un peu difficile.

En outre, ils ont une très petite différence et peut être mise en relation avec fortement typé et faiblement typé langues. Un langage fortement typé ne vous autorise pas à utiliser un type comme un autre, par exemple. Le C et le C++ ...alors que faiblement typé langages permettent par exemple.python

Le Typage Statique:
Les langages tels que Java et Scala sont statiques tapé.

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

pour ex. int x; x = 10;

Système.out.println(x);

Typage Dynamique:
Perl est une dynamique tapé langue.

Variables n'ont pas besoin d'être initialisé avant qu'ils soient utilisés dans le code.

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