Ceci est souvent mal compris alors laissez-moi éclaircir.

Typage Statique/Dynamique

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

Typage Dynamique est où le type est lié à la valeur. Les Types sont vérifiés 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 des Strings différents (depuis s est une référence en Java). Il peut avoir une valeur null mais il ne fera jamais référence à 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

C'est du typage dynamique.

Typage Fort/Faible

(modifier l'alerte!)

Strong typing est une phrase sans signification largement acceptée. La plupart des programmeurs qui utilisent ce terme pour signifier autre chose que le typage statique l'utilisent pour impliquer qu'il existe une discipline de type qui est appliquée par le compilateur. Par exemple, CLU a un système de type fort qui ne permet pas au code client de créer une valeur de type abstrait, sauf en utilisant les constructeurs fournis par le type. C a un système de type assez fort, mais il peut être "subverti" dans une certaine mesure car un programme peut toujours convertir une valeur d'un type de pointeur en une valeur d'un autre type de pointeur. Ainsi, par exemple, en C, vous pouvez prendre une valeur retournée par malloc() et joyeusement jette - FILE*, et le compilateur n'essayez pas de vous arrêter-ou même avertir vous que vous faites quelque chose louche.

(la réponse originale disait quelque chose à propos d'une valeur "ne pas changer de type au moment de l'exécution". J'ai connu de nombreux concepteurs de langages et rédacteurs de Compilateurs et je n'en ai pas connu un qui a parlé de valeurs changeant de type au moment de l'exécution, sauf peut-être quelques recherches très avancées dans les systèmes de type, où cela est connu comme le "problème de mise à jour forte".)

Un typage faible implique que le compilateur n'applique pas une discpline de typage, ou peut-être que l'application peut être facilement contourné.

L'original de cette réponse a confondu le typage faible avec conversion implicite (parfois aussi appelée "promotion implicite"). Par exemple, en Java:

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

Ce code est un exemple de promotion implicite: 123 est implicitement converti en une chaîne avant d'être concaténé avec "abc". On peut soutenir que le compilateur Java réécrit ce code comme suit:

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

Considérons un PHP classique " commence par" problème:

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

L'erreur ici est que strpos() retourne l'index de la correspondance, de 0. 0 est contraint en booléen false et donc la condition est réellement vraie. La solution consiste à utiliser === au lieu de == pour éviter la conversion implicite.

Cet exemple illustre comment une combinaison de conversion implicite et de typage dynamique peut égarer les programmeurs.

Comparez cela à Ruby:

val = "abc" + 123

Qui est une erreur d'exécution car dans Ruby l'objet 123 est pas implicitement converti juste parce qu'il se trouve être passé à une méthode +. Dans Ruby, le programmeur doit rendre la conversion explicite:

val = "abc" + 123.to_s

Comparer PHP et Ruby est une bonne illustration ici. Les deux sont des langages typés dynamiquement mais PHP a beaucoup de conversions implicites et Ruby (peut-être étonnamment si vous n'êtes pas familier avec cela) ne le fait pas.

Statique / dynamique vs fort / faible

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

Donc, pour répondre à votre question: une autre façon de regarder cela qui est la plupart du temps correct est de dire que le typage statique est la sécurité du type de compilation et le typage fort est le type d'exécution sécurité.

La raison en est que les variables dans un langage typé statiquement ont un type qui doit être déclaré et peut être vérifié au moment de la compilation. Un langage fortement typé 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 une vérification dynamique.

Mais il est important de comprendre qu'une langue peut être statique/forte, statique/faible, dynamique/forte ou Dynamique/faible.

Fortement typé signifie qu'il existe 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éé.

La contrainte de données ne signifie pas nécessairement faiblement typée car parfois son sucre syntaxique:

L'exemple ci-dessus de Java étant faiblement typé à cause de

String s = "abc" + 123;

N'est pas un exemple faiblement typé parce que c'est vraiment faire:

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

La coercition des données n'est pas non plus faiblement typée si vous construisez un nouvel objet. Java est un très mauvais exemple de faiblement typé (et tout langage qui a une bonne réflexion ne sera probablement pas faiblement typé). Parce que l'exécution de la langue sait toujours quel est le type (l'exception peut être des types natifs).

C'est contrairement à C. C est l'un des meilleurs exemples de faiblement typé. Le runtime n'a aucune idée si 4 octets est un entier, une structure, un pointeur ou 4 caractères.

L'exécution du langage définit vraiment si oui ou non son faiblement typé sinon son opinion vraiment juste.

Modifier: après réflexion, ce n'est pas nécessairement vrai car le runtime n'a pas besoin d'avoir tous les types réifié dans le système d'exécution pour être un système fortement typé. Haskell et ML ont une analyse statique si complète qu'ils peuvent potentiellement omettre des informations de type à partir du runtime.

Les deux sont des pôles sur deux axes différents:

• fortement typé vs faiblement typé
• typé statiquement vs typé dynamiquement

Fortement typé signifie que a ne sera pas automatiquement converti d'un type à un autre. Faiblement typé est le contraire: Perl peut utiliser une chaîne comme "123" dans un contexte numérique, en la convertissant automatiquement en int 123. Un langage fortement typé comme python ne le fera pas.

Typé Statiquement signifie, le compilateur détermine le type de chaque variable au moment de la compilation. Les langages typés dynamiquement ne comprennent que les types de variables au moment de l'exécution.

Typage fort 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 est une chaîne, la règle stricte peut être que A + B n'est pas valide.

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

Notez que ces classifications ne sont pas mutuellement exclusives, en effet, je m'attendrais à ce qu'elles se produisent fréquemment ensemble. De nombreux langages fortement typés sont également typés statiquement.

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

L'Un n'implique pas l'autre. Pour qu'un langage soitstatiquement typé, cela signifie que les types de toutes les variables sont connus ou inférés au moment de la compilation.

Un fortement tapé la langue ne vous autorise pas à utiliser un type comme un autre. C est un langage faiblement typé et est un bon exemple de ce que les langues fortement typées ne permettent pas. En C, vous pouvez passer un élément de données du mauvais type et il ne se plaindra pas. Dans les langues fortement typées, vous ne pouvez pas.

En programmation informatique, les langages de programmation sont souvent appelés familièrement fortement typés ou faiblement typés. Ces termes n'ont pas de définition précise, mais en général, un langage fortement typé est plus susceptible de générer une erreur ou de refuser de compiler si l'argument passé à une fonction ne correspond pas étroitement au type attendu. D'autre part, un langage très faiblement typé peut produire des résultats imprévisibles ou effectuer une conversion de type implicite