Et l’un implique l’autre ?
Merci !
Réponses
Trop de publicités?
Quelle est la différence entre un langage fortement typé et un langage statiquement typé?
Un typage statique de la langue a un système de type qui est vérifié au moment de la compilation par la mise en œuvre (un compilateur ou l'interpréteur). La vérification de type rejette certains programmes, et les programmes qui passent à la case viennent généralement avec certaines garanties; par exemple, le compilateur garantit de ne pas utiliser l'arithmétique des nombres entiers instructions sur les nombres à virgule flottante.
Il n'y a pas vraiment de consensus sur ce que "fortement typé" signifie que, bien que la plus largement utilisée de la définition dans la littérature professionnelle, c'est que dans un "fortement typé" de la langue, il n'est pas possible pour le programmeur de contourner les restrictions imposées par le système de type. Ce terme est presque toujours utilisé pour décrire les langages statiquement typés.
Statique vs dynamique
À l'opposé de typage statique est "typées dynamiquement", ce qui signifie que
- Les valeurs utilisées lors de l'exécution sont classés en types.
- Il y a des restrictions sur la façon dont ces valeurs peuvent être utilisées.
- Lorsque ces restrictions sont violés, dont la violation est signalé comme un (dynamique) type d'erreur.
Par exemple, Lua, un typées dynamiquement la langue, a un type de chaîne, un type de numéro, et un type Booléen, entre autres. En Lua, chaque valeur appartient à exactement un type, mais ce n'est pas une exigence pour tous typées dynamiquement langues. En Lua, il est possible de concaténer deux chaînes de caractères, mais il n'est pas possible de concaténer une chaîne et d'un Booléen.
Forte vs faible
À l'opposé 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 est convertible à tout autre type de pointeur simplement par la coulée. Pascal était destiné à être fortement typé, mais un oubli dans la conception (sans étiquette variante records) a introduit une faille dans le système de type, donc, techniquement, il est faiblement typé. Exemples de vraiment langages fortement typés inclure CLU, Standard ML, et Haskell. Standard ML a en effet fait l'objet de plusieurs révisions pour supprimer les failles dans le système de type qui ont été découverts après la langue a été largement déployé.
Ce qui se passe réellement ici?
Dans l'ensemble, il s'avère être pas utile de parler de "fort" et "faible". Si un type de système a une faille est moins important que le nombre exact et la nature de ces failles, comment ils sont susceptibles de trouver 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 "forts" et "faibles" tout simplement, parce que
Les Amateurs souvent confondre avec "statique" et "dynamique".
Apparemment, "la faiblesse de frappe" est utilisé par certaines personnes pour parler de la relative de la prévalence ou de l'absence de conversions implicites.
Les professionnels ne peuvent pas s'entendre sur exactement ce que les termes signifient.
Dans l'ensemble, vous êtes peu probable de les informer ou de les éclairer votre auditoire.
La triste vérité est que, quand il s'agit de systèmes de type", "forte" et "faible" n'ont pas universellement d'accord sur la signification technique. Si vous voulez discuter de la force relative des systèmes de type, il est préférable de discuter exactement quelles sont les garanties et ne sont pas fournis. Par exemple, une bonne question à poser est celle-ci: "est chaque valeur d'un type donné (ou une classe) la garantie d'avoir été créé par l'appel de l'un de ce type de constructeurs?" En C, la réponse est non. Dans CLU, F#, et Haskell c'est oui. Pour le C++, je ne suis pas sûr—je voudrais savoir.
En revanche, le typage statique signifie que les programmes sont vérifiées avant d'être exécuté, et un programme peut être rejeté avant qu'il ne commence. Typage dynamique signifie que les types de valeurs sont vérifiées au cours de l'exécution, et un mal tapé l'opération pourrait provoquer le programme de stopper ou autrement signal une erreur au moment de l'exécution. Une des principales raisons pour le typage statique est la règle de programmes qui pourraient avoir de tels "dynamique des erreurs de type".
Ne l'un implique l'autre?
Sur un pédant niveau, non, parce que le mot "fort" ne veut pas vraiment dire quoi que ce soit. Mais dans la pratique, les gens presque toujours faire une de deux choses:
Ils ont (à tort) l'utilisation d'une "forte" et "faible" pour dire "statique" et "dynamique", dans ce cas, ils (à tort) sont à l'aide de "fortement typé" et "statiquement typé" de façon interchangeable.
Ils utilisent des "forts" et "faibles" pour comparer les propriétés de statique type de systèmes. Il est très rare d'entendre quelqu'un parler d'un "fort" ou "faible" système de type dynamique. Sauf pour l'arrière, ce qui n'a pas vraiment toute sorte de type de système, je ne peux pas penser à une typées dynamiquement langue, là où le type de système peut être contourné. En quelque sorte par définition, ces vérifications sont bulit dans le moteur d'exécution, et chaque opération obtient vérifié pour la santé mentale avant d'être exécuté.
De toute façon, si une personne appelle à une langue "fortement typé", cette personne est très probablement parler d'un langage statiquement typé.
cletus
Points
276888
Ceci est souvent mal compris alors, laissez-moi 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 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 la dynamique de la frappe.
De Force Et De Faiblesse De Frappe
(Edit alerte!)
Typage fort , c'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, 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 jette - 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".)
Le typage faible implique que le compilateur de ne pas appliquer un typage discpline, ou peut-être que l'application peut être facilement contourné.
L'original de cette réponse d'un amalgame typage faible avec la 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 l' 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 == afin d'éviter la conversion implicite.
Cet exemple montre comment une combinaison de conversion implicite et typage dynamique peut conduire à des programmeurs égarer.
Comparez cela à Ruby:
val = "abc" + 123
ce qui est une erreur à l'exécution, car en Ruby l' 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
La comparaison de 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 essentiellement 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.
Svetlozar Angelov
Points
10583
Adam Gent
Points
15055
Les données de la Contrainte ne signifie pas nécessairement faiblement typé parce que, parfois, ses syntacical sucre:
L'exemple ci-dessus de Java étant faiblement typé en raison de
String s = "abc" + 123;
N'est pas faiblement typé exemple car son vraiment en train de faire:
String s = "abc" + new Integer(123).toString()
Les données de la coercition est pas non plus faiblement typé si vous êtes en train de construire un nouvel objet. Java est un très mauvais exemple de faiblement typé (et toute langue qui a une bonne réflexion ne sera probablement pas être faiblement typé). Parce que l'exécution de la langue sait toujours ce que le type est (à l'exception peut-être des types natifs).
C'est à la différence de C. C est l'un des meilleurs exemples de l'faiblement typé. Le moteur d'exécution n'a aucune idée de si 4 octets est un entier, une structure, un pointeur ou un 4 caractères.
L'exécution de la langue qui définit vraiment si oui ou non ses faiblement typé sinon c'est vraiment juste une opinion.
EDIT: Après réflexion ce n'est pas nécessairement vrai que le runtime ne pas avoir tous les types de réifiée dans le système d'exécution à un typage fort du système. Haskell et ML ont aussi complètes d'analyse statique qu'ils puissent potentiel omettre des informations de type à partir de l'exécution.
Joe Cannatti
Points
2194
L’un n’implique pas l’autre. Pour une langue soit statiquement typé il signifie que les types de toutes les variables sont connues ou déduites au moment de la compilation.
Un fortement typée langue ne vous permet pas d’utiliser un type comme un autre. C est un langage faiblement typé et ne permettent pas un bon exemple de ce que langages fortement typés. En C, vous pouvez passer un élément de données de type incorrect et il ne va pas se plaindre. Vous ne pouvez pas dans les langages fortement typés.
