Quelle est la différence entre un langage fortement typé et un langage statiquement typé?

C'est souvent mal compris, permettez-moi de clarifier les choses.

Statique/Dynamique De Frappe

Le typage statique est où le type est lié à la variable. Les Types sont vérifiées au moment de la compilation.

Typage dynamique est où le type est lié à la valeur. Les Types sont vérifiées au moment de l'exécution.

Donc en Java par exemple:

String s = "abcd";

s sera "jamais" être un String. Au cours de sa vie, il peut pointer vers différents Strings (depuis s est une référence en Java). Il peut avoir un null de la valeur, mais il ne sera jamais à se référer à un Integer ou un List. C'est le typage statique.

En PHP:

$s = "abcd";          //$s is a string
$s = 123;             //$s is now an integer
$s = array(1, 2, 3);  //$s is now an array
$s = new DOMDocument; //$s is an instance of the DOMDocument class

Que le typage dynamique.

De Force Et De Faiblesse De Frappe

(Modifier alerte!)

Typage fort est une phrase avec pas globalement d'accord sur le sens. La plupart des programmeurs qui utilisent ce terme pour désigner autre chose que le typage statique de l'utiliser pour déduire qu'il existe un type de discipline qui est appliquée par le compilateur. Par exemple, CLU a un solide système de type qui ne permettent pas de code client pour créer une valeur de type abstrait, sauf par les constructeurs fournis par le type. C est un peu fort type de système, mais il peut être "détourné" à un degré, parce que un programme peut toujours fonte d'une valeur d'un type pointeur vers une valeur d'un autre type de pointeur. Ainsi, par exemple, en C, vous pouvez prendre une valeur retournée par malloc() et joyeusement le jeter aux FILE*, et le compilateur n'essayez pas de vous arrêter—ou même vous avertir que vous faites quelque chose de louche.

(L'original de la réplique a dit quelque chose à propos d'une valeur de "ne pas changer de type au moment de l'exécution". J'ai connu la langue de nombreux concepteurs et les rédacteurs de compilateur et n'ont pas connu un seul qui a parlé de l'évolution des valeurs de type au moment de l'exécution, sauf peut-être certains très avancée de la recherche dans le type de systèmes, où il est connu sous le nom de "fort problème de mise à jour".)

Typage faible implique que le compilateur de ne pas appliquer un typage discpline, ou peut-être que l'application peut être facilement contourné.

L'origine de cette réponse d'un amalgame typage faible avec conversion implicite (parfois aussi appelé "implicite de la promotion"). Par exemple, en Java:

String s = "abc" + 123; //"abc123";

Ce code est un exemple de l'implicite de la promotion: 123 est implicitement converti en une chaîne de caractères avant d'être concaténé avec "abc". Il peut être soutenu que le compilateur Java réécrit le code comme:

String s = "abc" + new Integer(123).toString();

Envisager un classique PHP "commence par" problème:

if (strpos('abcdef', 'abc') == false) {
  //not found
}

L'erreur ici est que strpos() renvoie l'index de la correspondance, de 0. 0 est contrainte booléenne false et donc, la condition est vrai. La solution est d'utiliser === au lieu de == pour éviter la conversion implicite.

Cet exemple montre comment une combinaison de conversion implicite et typage dynamique peut conduire à des programmeurs égarer.

De la comparer à Ruby:

val = "abc" + 123

qui est une erreur à l'exécution, car en Ruby la objet 123 est pas implicitement converti juste parce qu'il arrive à être transmis à un + méthode. En Ruby, le programmeur doit faire la conversion explicite:

val = "abc" + 123.to_s

Comparant PHP et Ruby est une bonne illustration ici. Les deux sont typées dynamiquement langues, mais PHP a beaucoup de conversions implicites et Ruby (peut-être surprenant si vous n'êtes pas familier avec elle) ne l'est pas.

Statique/Dynamique vs Forts/Faibles

Le point ici est que la statique/dynamique de l'axe est indépendant de la force et de faiblesse de l'axe. Les gens confondent probablement en partie parce que la forte vs faible frappe n'est pas seulement moins clairement défini, il n'y a pas de réel consensus sur exactement ce qui est signifié par les forts et les faibles. Pour cette raison, de force et de faiblesse de frappe est beaucoup plus d'une nuance de gris plutôt que noir ou blanc.

Donc, pour répondre à votre question: une autre façon de regarder ce qui est surtout correcte est-à-dire que le typage statique est le type de compilation de sécurité et de typage fort est runtime type de sécurité.

La raison pour cela est que les variables dans un langage statiquement typé ont un type qui doit être déclaré et peut être vérifié au moment de la compilation. Un typage fort de langue a des valeurs qui ont un type au moment de l'exécution, et il est difficile pour le programmeur de subvertir le système de type sans un contrôle dynamique.

Mais il est important de comprendre qu'une langue peut être Statique/Strong Statique/Faible, Dynamique/Strong ou Dynamique Faible.

Fortement typé signifie qu'il y a des restrictions entre les conversions entre les types. Typé statiquement signifie que les types ne sont pas dynamiques - vous ne pouvez pas changer le type d'une variable une fois qu'il a été créé.

Typage fort probablement signifie que les variables ont un type défini et qu'il y a des règles strictes concernant 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 est une chaîne de caractères, alors la règle stricte ne peut être que A+B n'est pas valide.

Le typage statique signifie probablement que les types sont attribués au moment de la compilation (ou son équivalent pour les non-langages compilés) et ne peut pas changer pendant l'exécution du programme.

Noter que ces catégories ne sont pas mutuellement exclusives, en effet, je m'attends à ce qu'ils se produisent souvent ensemble. De nombreuses fortement typées langues sont également statiquement typé.

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.

Réponse est déjà donnée ci-dessus. D'essayer de différencier forte vs semaine et statique vs dynamique concept.

Ce qui est Fortement typé VS Faiblement typé?

Fortement Typé: il ne Sera pas automatiquement converti en un autre type de

En Aller ou Python comme des langages fortement typés "2" + 8 de soulever un type d'erreur, parce qu'ils ne permettent pas "de contrainte de type".

Faiblement (vaguement) Tapé: Sera automatiquement converti en un type à l'autre:
Faiblement typé langages comme JavaScript ou Perl ne va pas faire une erreur et dans ce cas javascript, des résultats '28' et perl entraînera 10.

Perl Exemple:

my $a = "2" + 8;
print $a,"\n";

L'enregistrer main.pl et exécuter perl main.pl et vous obtiendrez à la sortie 10.

Ce qui est Statique VS Dyamic type?

Dans la programmation, progammer définir le typage statique et dynamique de frappe à l'égard du point auquel les types de variables sont contrôlées. Langages à typage statique sont ceux dans lesquels le type de la vérification est effectuée au moment de la compilation, alors que les langages à typage dynamique sont ceux dans lesquels le type de la vérification est effectuée au moment de l'exécution.

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

Qu'est-ce que cela signifie?

En Aller, il vérifie tapé avant l'exécution (statique à vérifier). Ce à dire qu'il ne concerne pas seulement traduit et le type de contrôles de code en cours d'exécution, mais il va parcourir tout le code et le type d'erreur pourrait être levée avant le code est à même de les exécuter. Par exemple,

package main

import "fmt"

func foo(a int) {
    if (a > 0) {
        fmt.Println("I am feeling lucky (maybe).")
    } else {
        fmt.Println("2" + 8)
    }
}

func main() {
    foo(2)
}

Enregistrer ce fichier dans le main.aller et l'exécuter, vous obtiendrez la compilation a échoué message).

go run main.go
# command-line-arguments
./main.go:9:25: cannot convert "2" (type untyped string) to type int
./main.go:9:25: invalid operation: "2" + 8 (mismatched types string and int)

Mais ce cas n'est pas valable pour Python. Par exemple bloc de code suivant va exécuter pour la première foo(2) appel et échoue pour la deuxième foo(0) appel. C'est parce que Python est dynamiquement typé, il ne traduit et vérifie le code d'exécution sur. Le bloc else ne s'exécute jamais pour les foo(2), donc "2" + 8 est n'a même jamais regardé et pour les foo(0) appel il va essayer d'exécuter ce bloc et a échoué.

def foo(a):
    if a > 0:
        print 'I am feeling lucky.'
    else:
        print "2" + 8
foo(2)
foo(0)

Vous verrez suivant la sortie

python main.py
I am feeling lucky.
Traceback (most recent call last):
  File "pyth.py", line 7, in <module>
    foo(0)
  File "pyth.py", line 5, in foo
    print "2" + 8
TypeError: cannot concatenate 'str' and 'int' objects