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

Question

En outre, peut-on supposer l'existence de l'autre?

Answer 1

  

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

Un langage typé statiquement dispose d'un système de type qui est vérifié au moment de la compilation par la mise en œuvre (un compilateur ou un interprète). Le contrôle de type rejette certains programmes et des programmes qui passent le contrôle viennent généralement avec des garanties; par exemple, des garanties de compilateur de ne pas utiliser entier instructions arithmétiques sur des nombres à virgule flottante.

Il n'y a pas d'accord réel sur ce que « fortement typé » signifie, bien que la définition la plus largement utilisée dans la littérature professionnelle est que dans un « fortement typé » la langue, il est impossible pour le programmeur au travail autour des restrictions imposées par le système de type. Ce terme est utilisé presque toujours pour décrire langues statiquement typés.

statique vs dynamique

L'opposé de typé statiquement est « dynamiquement typé », ce qui signifie que

1. Valeurs utilisées au moment de l'exécution sont classés en types.
2. Il existe des restrictions sur la façon dont ces valeurs peuvent être utilisées.
3. Lorsque ces restrictions sont violés, la violation est signalée comme une erreur de type (dynamique).

Par exemple, Lua , un langage typé dynamiquement, a un type de chaîne, un type de numéro, et un type booléen , entre autres. Dans Lua chaque valeur appartient à exactement un type, mais ce n'est pas une exigence pour toutes les langues dynamiquement tapées. Dans Lua, il est permis de concaténer deux chaînes, mais il est permis de concaténer une chaîne et une valeur booléenne.

Fort vs faible

Le contraire de « fortement typé » est « faiblement typé », ce qui signifie que vous pouvez contourner le système de type. C est notoirement faiblement typé parce que tout type de pointeur peut être converti en tout autre type de pointeur simplement par coulée. Pascal était destiné à être fortement typé, mais un oubli dans la conception (d'enregistrements variants non marqués) a introduit une faille dans le système de type, donc techniquement il est faiblement typé. Des exemples de langues vraiment fortement typé comprennent CLU, Standard ML et Haskell. Standard ML a en fait remaniées à plusieurs reprises pour éliminer les failles dans le système de type qui ont été découverts après la langue a été largement déployée.

Qu'est-ce qui se passe vraiment ici?

, il se ensemble avéré être pas utile de parler de « forte » et « faible ». Que ce soit un système de type a une échappatoire est moins importante que le nombre exact et la nature des lacunes, comment ils sont susceptibles de venir dans la pratique, et quelles sont les conséquences de l'exploitation d'une faille. Dans la pratique, il est préférable d'éviter les termes "forte" et "faible" tout à fait , parce que

• Amateurs les amalgamer souvent avec "statique" et "dynamique".

• Apparemment « typage faible » est utilisé par certaines personnes à parler du parent ou absence prévalence de conversions implicites.

• Les professionnels ne peuvent pas se mettre d'accord sur exactement ce que signifient les termes.

• il est peu probable d'informer ou d'éclairer l'ensemble de votre public.

La triste vérité est que quand il s'agit de taper des systèmes, « forte » et « faible » n'ont pas un accord universel sur le sens technique. Si vous voulez discuter de la force relative du type systèmes, il est préférable de discuter exactement quelles sont les garanties et ne sont pas fournis. Par exemple, une bonne question à poser est la suivante: « est chaque valeur d'un type donné (ou classe) garantie à avoir été créé en appelant l'un des constructeurs de ce type? » En C, la réponse est non. Dans CLU, F #, et Haskell est oui. C ++ Je ne suis pas sûr, je voudrais savoir.

En revanche, typage statique signifie que les programmes sont vérifiés avant d'être exécuté , et un programme peut être rejeté avant qu'il ne commence. dynamique taper signifie que les types de valeurs sont vérifiés pendant exécution, et un malopération typé pourrait provoquer le programme d'arrêter ou signaler sinon une erreur au moment de l'exécution. Une raison principale pour le typage statique est d'exclure des programmes qui pourraient avoir ces « erreurs de type dynamique ».

  

Est-ce que l'un implique l'autre?

Au niveau de pédant, non, parce que le mot « fort » n'a pas vraiment quoi que ce soit moyen. Mais dans la pratique, les gens font presque toujours l'une des deux choses:

• Ils (à tort) l'utilisation « forte » et « faible » signifie « statique » et « dynamique », auquel cas ils (à tort) utilisent « fortement typé » et « statiquement typés » de façon interchangeable.

• Ils utilisent « fort » et « faible » pour comparer les propriétés des systèmes de type statique. Il est très rare d'entendre parler de quelqu'un d'un système de type dynamique « forte » ou « faible ». À l'exception des FORTH, qui ne je ne pense pas vraiment avoir une sorte de système de type, d'un langage typé dynamiquement où peut être subverti le système de type. Trier de par définition, ces contrôles sont Bulit dans le moteur d'exécution, et chaque opération est vérifié pour la santé mentale avant d'être exécuté.

De toute façon, si une personne appelle un langage « fortement typé », cette personne est très susceptible de parler d'un langage typé statiquement.

Answer 2

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

statique / dynamique Taper

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

dynamique frappe est où le type est lié à la valeur . Les types sont vérifiés au moment de l'exécution.

en Java par exemple:

String s = "abcd";

s sera "toujours" ê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 une valeur null, mais il ne sera jamais référence à un Integer ou List. C'est 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 typage dynamique.

Taper fort / faible

(alerte Modifier!)

typage fort est une expression largement sans accord sur le sens. La plupart des programmeurs qui utilisent ce terme pour signifier autre chose que l'utilisation statique de frappe à entendre qu'il existe une discipline de type qui est appliquée par le compilateur. Par exemple, CLU dispose d'un système de type fort qui ne permet pas de code client pour créer une valeur de type abstrait, sauf à l'aide des constructeurs fournis par le type. C dispose d'un système de type un peu fort, mais il peut être « perverti » dans une certaine mesure parce qu'un programme peut toujours associer une valeur d'un type de pointeur à une valeur d'un autre type de pointeur. Ainsi, par exemple, en C, vous pouvez prendre une valeur retournée par malloc() et joyeusement jeté à FILE*, et le compilateur ne pas essayer d'arrêter de vous-même ou vous avertir que vous faites quelque chose de louche.

(La réponse initiale a dit quelque chose au sujet d'une valeur « ne change pas le type à l'exécution. » Je connais de nombreux concepteurs de langage et les écrivains du compilateur et n'ont pas connu qui a parlé de l'évolution des valeurs de type à l'exécution, sauf peut-être un peu très avancé la recherche dans les systèmes de type, lorsque cela est connu comme le « problème de mise à jour forte ».)

typage faible implique que le compilateur n'impose pas de discpline de frappe, ou peut-être que l'application peut facilement être subverti.

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

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

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

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

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

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

L'erreur est ici que revient strpos() l'indice du match, étant 0. 0 est contraint dans false booléenne et donc la condition est en fait vrai. La solution est d'utiliser === au lieu de == pour éviter la conversion implicite.

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

Comparez cela à Ruby:

val = "abc" + 123

qui est une erreur d'exécution parce que dans Ruby objet 123 est pas converti implicitement juste parce qu'il arrive à passer à une méthode de +. En Ruby le programmeur doit faire la conversion explicite:

val = "abc" + 123.to_s

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

statique / dynamique vs fort / faible

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

Pour répondre à votre question:. Une autre façon de regarder ce que de la plupart du temps correct est-à-dire que le typage statique est le type de compilation sécurité et typage fort est la sécurité de type exécution

La raison est que les variables dans un langage typé statiquement ont un type qui doit être déclarée et peuvent être vérifiées 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 / ou forte dynamique / faible.

Answer 3

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

• fortement typé par rapport à faiblement typé
• par rapport à statiquement typé dynamiquement typé

fortement typé des moyens, un ne seront pas convertis automatiquement d'un type à l'autre. typé est Faiblement le contraire: Perl peut utiliser une chaîne comme "123" dans un contexte numérique, en la convertissant automatiquement dans le int 123. Un langage fortement typé comme python ne le fera pas.

typé statiquement moyens, les chiffres de compilation sur le type de chaque variable au moment de la compilation. Les langages typés dynamiquement ne figurent que les types de variables lors de l'exécution.

Answer 4

fortement typé signifie qu'il ya des restrictions entre les conversions entre types. Statiquement typé 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éé.

Answer 5

Les données Coercion ne signifie pas nécessairement faiblement typé parce que parfois son sucre syntacical:

L'exemple ci-dessus de Java étant faiblement typé en raison de

String s = "abc" + 123;

est-ce pas par exemple faiblement typé, car son fait vraiment:

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

contrainte de données est pas non plus faiblement typé si vous construisez un nouvel objet. Java est un très mauvais exemple de typé faiblement (et toute langue qui a une bonne réflexion sera très probablement pas être faiblement typé). Parce que le temps d'exécution de la langue sait toujours ce que le type est (l'exception peut-être des types natifs).

Ceci est différent C. C est l'un des meilleurs exemples de typé faiblement. Le moteur d'exécution n'a aucune idée si 4 octets est un nombre entier, une structure, un pointeur ou un 4 caractères.

Le temps d'exécution de la langue définit vraiment si oui ou non son faiblement typé sinon son opinion vraiment juste.

EDIT: Après plus pensé que ce n'est pas nécessairement vrai que le temps d'exécution ne doit pas avoir tous les types réifiées dans le système d'exécution à un système fortement typées. Haskell et ML ont une telle analyse de la statique complète qu'ils peuvent le potentiel des informations de type OMMISSIONS de l'exécution.

Answer 6

On ne signifie pas l'autre. Pour une langue à statiquement tapé cela signifie que les types de toutes les variables sont connues ou estimées au moment de la compilation.

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

Answer 7

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

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

Notez que ces classifications ne sont pas mutuellement exclusifs, en effet, je les attendre à se souvent ensemble. De nombreuses langues fortement typés sont également typés statiquement.

Et notez que lorsque j'utilise le mot « probablement » est parce qu'il ya pas de définition universellement acceptée de ces termes. Comme vous avez déjà vu des réponses à ce jour.

Answer 8

  

réponse est déjà donnée ci-dessus. Essayer de faire la différence entre une forte vs semaine et statique vs concept dynamique.

Ce qui est fortement typé VS typé Faiblement?

fortement typées: ne sera pas converti automatiquement d'un type à l'autre

Dans Go ou Python comme un langage fortement typé « 2 » + 8 soulèveront une erreur de type, car ils ne permettent pas de « contrainte de type ».

Faiblement (vaguement) dactylographié: Sera automatiquement convertie en un type à l'autre: langues JavaScript comme tapées Faiblement ou Perl ne jetteront pas une erreur et dans ce javascript de cas de 28 'et perl résultats résulteront 10.

Perl Exemple:

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

Enregistrer pour main.pl et exécuter perl main.pl et vous obtiendrez la sortie 10.

Qu'est-ce que le type statique VS Dyamic?

En programmation, progammer définir le typage statique et dynamique frappe par rapport à l'endroit où sont vérifiées les types de variables. Les langages typés statiques sont ceux dans lesquels la vérification du type se fait à la compilation, alors que les langages typés dynamiques sont celles dans lesquelles la vérification du type se fait à l'exécution.

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

Qu'est-ce que cela signifie?

Go il vérifie avant tapés exécution (vérification statique). Cela signifie non seulement le code, il traduit et contrôles de type-il est l'exécution, mais il va scanner à travers tout le code et l'erreur de type jetterait avant que le code est même exécuté. 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 main.go et l'exécuter, vous obtiendrez la compilation a échoué un message à cet effet.

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 est pas valable pour Python. Par exemple après un bloc de code pour exécuter premier appel foo (2) et échouera pour la deuxième foo (0) appel. Il est parce que Python est typé dynamiquement, il se traduit uniquement et un code de type contrôles qu'il est exécuté sur. Le bloc autre exécute jamais pour foo (2), de sorte que « 2 » + 8 est même jamais regardé et foo (0) appellent essaiera 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 ci-dessous 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