Statique/Dynamique vs Fort/Faible

https://stackoverflow.com/questions/2351190

23-09-2019
|

Question

Je vois ces termes répandus partout dans la programmation et j'ai une vague idée de ce qu'ils signifient.Une recherche me montre que de telles choses ont en fait été demandées partout dans le débordement de pile.Pour autant que je sache, la saisie statique/dynamique dans les langues est subtilement différente de la saisie forte/faible, mais cette différence m'échappe.Différentes sources semblent utiliser des significations différentes ou même utiliser les termes de manière interchangeable.Je ne trouve pas d'endroit qui parle des deux et qui explique réellement la différence.Ce qui serait bien, c'est que quelqu'un puisse expliquer cela clairement ici pour moi et le reste du monde.

La solution

statique / dynamique Taper est sur lorsque informations de type est acquis (soit au moment de la compilation ou à l'exécution)
typage fort / faible est sur comment strictement les types se distinguent (par exemple, si la langue essaie de faire une conversion implicite de chaînes en nombres).

Voir la pour des informations plus détaillées.

Autres conseils

Vous avez découvert une petite place dans la terminologie que les amateurs utilisent pour parler des langages de programmation. Ne pas utiliser les termes « forte » et « faible » en tapant , parce qu'ils ne disposent pas d'un universellement d'accord sur le sens technique. 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. typage dynamique signifie que les types de valeurs sont vérifiés pendant exécution , et une opération mal tapé pourrait provoquer le programme pour arrêter ou autrement signaler une erreur lors de l'exécution . Une raison principale pour le typage statique est d'exclure des programmes qui pourraient avoir ces « erreurs de type dynamique ».

typage fort signifie généralement qu'il y a aucune lacune dans le système de type, tandis que typage faible désigne le type de système peut être renversé (viciant aucune garantie). Les termes sont souvent utilisés de manière incorrecte signifie typage statique et dynamique. Pour voir la différence, pensez C: la langue est de type vérifié au moment de la compilation (de typage statique), mais il y a beaucoup de lacunes; vous pouvez très bien associer une valeur de tout type à un autre type de la même taille --- en particulier, vous pouvez lancer librement types de pointeur. Pascal était une langue qui était destiné à être fortement typé, mais avait une échappatoire célèbre imprévue:. Un enregistrement variant sans balise

Implémentations de acquièrent souvent un langage fortement typé échappatoires au fil du temps, le plus souvent de sorte qu'une partie du système d'exécution peut être mis en œuvre dans la langue de haut niveau. Par exemple, Objective Caml a une fonction appelée Obj.magic qui a pour effet d'exécution de simplement retourner son argument, mais au moment de la compilation convertit une valeur quelconque à l'un des tout autre type. Mon exemple préféré est Modula-3, dont les concepteurs appelé leur LOOPHOLE de construction type de coulée.

Cela dit, vous ne pouvez pas compter sur deux personnes en utilisant les mots « fort » et « faible » exactement de la même manière. Donc les éviter.

Il suffit de le mettre de cette façon: dans un langage typé statiquement type est statique , ce qui signifie une fois que vous définissez une variable à un type, vous ne pouvez changer. C'est parce que la frappe est associée à la variable plutôt que la valeur qu'elle fait référence.

Par exemple, en Java:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

Alors que dans un langage typé dynamiquement le type est dynamique , ce qui signifie après avoir défini une variable à un type, vous pouvez le changer. C'est parce que la frappe est associée à la valeur plutôt que la variable.

Par exemple en Python:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

D'autre part, le frappe fort / faible dans une langue est liée à des conversions de type implicite (en partie prises de @ réponse de Dario):

Par exemple en Python:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly.

alors qu'en PHP:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

Le typage statique permet de vérifier le bon type à la compilation. Les langages typés statiquement sont généralement compilées et sont interprétées Les langages typés dynamiquement. Par conséquent, les langues peuvent vérifier dynamicly tapées taper au moment de l'exécution.

signifie typage faible que le type d'un objet peut varier en fonction du contexte. Par exemple, dans un langage faiblement typé la chaîne « 123 » peut être considéré comme le numéro 123 si vous ajoutez un autre numéro à elle. Des exemples de langues avec typage faible sont bash, awk et PHP.

Un autre type de langage faiblement typé est C, où les données à une adresse de mémoire peuvent être traités comme un type différent par coulée.

Dans un langage fortement typé changer le type d'un objet n'a pas - un int est toujours un entier et d'essayer de l'utiliser comme une chaîne se traduira par une erreur. Java et Python sont fortement typés.

La différence entre le typage dynamique et statique est lorsque les règles de type sont appliquées. Dans un langage typé statiquement le type de chaque variable et paramètre doit être déclaré dans la source et est appliquée au moment de la compilation. Dans un langage typé dynamiquement les types ne sont vérifiés quand ils sont utilisés lors de l'exécution. Donc, Java est statiquement typé et Python est typé dynamiquement.

Toutefois, les limites peuvent être un peu floue à certains moments. Par exemple, bien que Java est statiquement typé, chaque fois que vous utilisez la réflexion ou d'un moule (par exemple lors de l'utilisation des conteneurs d'objets), ils vous reportent la vérification de type à l'exécution.

De même langues les plus fortement typé sera toujours convertir automatiquement entre les entiers et les flotteurs (et dans certaines langues abitrary bigints de précision).

Aujourd'hui, des recherches sur ce sujet, je suis tombé sur ce grand article http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Il éclairci beaucoup de choses pour moi et je pensais qu'il peut ajouter à quelques-unes des grandes réponses ci-dessus.

typage fort:

Probablement les systèmes du type moyen le plus courant sont classés est « forte » ou « faible ». Cela est regrettable, car ces mots ont presque pas ce qui signifie du tout. Il est, dans une certaine mesure, possible de comparer deux langues avec des systèmes de type très similaires, et désigner un comme ayant le plus fort de ces deux systèmes. Au-delà, les mots ne veulent rien dire du tout.

Types statiques et dynamiques

Ceci est presque la seule classification commune des systèmes de type   qui a un sens réel. En fait, il est la signification est   souvent sous-estimé [...] systèmes de type dynamiques et statiques sont   deux choses complètement différentes, dont les objectifs se trouvent en partie   chevauchement.

Un système de type statique est un mécanisme par lequel un compilateur examine   le code source et attribue des étiquettes (appelées « types ») à des morceaux de la   la syntaxe et les utilise pour en déduire quelque chose sur ce programme   comportement. Un système de type dynamique est un mécanisme par lequel un compilateur   génère un code de garder une trace du type de données (par coïncidence, également   appelé son « type ») utilisé par le programme. L'utilisation du même mot   « Type » dans chacun de ces deux systèmes est, bien sûr, pas vraiment tout à fait   pure coïncidence; mais il est mieux comprise comme ayant une sorte de faible   importance historique. D'excellents résultats de confusion d'essayer de trouver un   vision du monde dans lequel « type » signifie vraiment la même chose à la fois   systèmes. Il ne fonctionne pas.

Types explicites / implicites:

Lorsque ces termes sont utilisés, ils se réfèrent à la mesure dans laquelle un compilateur raisonner sur les types statiques de parties d'un programme. Tout les langages de programmation ont une certaine forme de raisonnement sur les types. Certains ont plus que d'autres. ML et Haskell ont des types implicites, qui ne (Ou très peu, en fonction de la langue et des extensions en cours d'utilisation) type déclarations sont nécessaires. Java et Ada ont des types très explicites, et on est constamment les déclarant types de choses. Toutes les ci-dessus ont (Relativement, par rapport à C et C ++ par exemple) fort de type statique systèmes.

De Scott langage de programmation Pragmatique , page 3ème édition 291, nous avons

La vérification de type est le processus de veiller à ce qu'un programme obéit à la   Les règles de compatibilité du type de langue. Une violation des règles est connue   comme un choc de type. Une langue est dite fortement typé si elle   interdit, d'une manière que la mise en œuvre de la langue peut appliquer, la   application d'une opération sur un objet qui n'a pas pour but de   soutenir cette opération. Une langue est dite statiquement typé si   il est fortement typé et le contrôle de type peut être effectué à la compilation   temps. Au sens strict du terme, quelques langues sont statiquement   tapé. Dans la pratique, les TERMIS souvent appliquées aux langues dans lesquelles   plus la vérification de type peut être effectué au moment de la compilation, et le reste peut   être effectuée au moment de l'exécution.

Quelques exemples: Ada est fortement typé, et pour la plupart   statiquement typé (certaines contraintes de type doivent être contrôlés lors de l'exécution   temps). Une mise en œuvre Pascal peut aussi faire la plupart de sa vérification de type   au moment de la compilation, bien que la langue est pas tout à fait fortement typé:   d'enregistrements variants non marqués (à discuter dans la section 7.3.4) sont ses   seule échappatoire. C89 est beaucoup plus fortement typé que son   dialectes prédécesseurs, mais beaucoup moins fortement typé que   Pascal. Ses lacunes comprennent les syndicats, un nombre variable de subroutineswith   des paramètres et l'interopérabilité des pointeurs et des réseaux (pour être   discuté à la section 7.7.1). C rarement Implémentations de vérifier   quoi que ce soit au moment de l'exécution.

Dynamique (exécution) Typage est une forme de liaison tardive, et tend   se trouvent dans des langues autres problèmes retardent jusqu'à l'exécution comme   bien. Lisp et Smalltalk sont dynamiquement (si fortement) tapé. Plus   langages de script sont également typés dynamiquement; quelques-uns (par exemple, python et   Ruby) sont fortement typés. Langues avec la portée dynamique sont généralement   typé dynamiquement (ou non tapé du tout): si le compilateur ne peut pas   identifier l'objet auquel un nom fait référence, il ne peut généralement pas déterminer   le type de l'objet soit.

Donc, en termes simples, le typage statique / dynamique fait référence au moment où la vérification de type se produit: la compilation pour le typage statique, et le temps d'exécution pour les langages dynamiques. De même, le typage fort / faible se réfère à la façon agressive une langue est dans l'application de son système de type.

J'ai essayé de traduire la description de Scott dans un diagramme agréable, que je l'ai posté ci-dessous.

Je pense que les autres collègues ont fait un bon travail esp. expliquant la différence entre le typage statique et dynamique. Mais aussi loin que fort et typage faible est concerné, il faut dire qu'il y Les différentes interprétations / vues.

Voici deux exemples:

Certains disent que Haskell est fortement typé, parce que vous n'êtes pas autorisé à faire tout conversions de type.
D'autres (par exemple le point de vue de Dario) dire une langue qui permet de convertir implicitement de chaîne au numéro sur le but est faiblement typé, mais même d'autres appellent cette frappe juste canard.

Les deux déclarations mettent en évidence pas les extrêmes opposés d'un système de type, mais les aspects complètement différents. Donc, je me joins à l'opinion de M. Ramsey ne pas utiliser les termes « forte » et « faible » pour distinguer entre les systèmes de type.

Langages typés statiquement ou dynamiquement

Les langages à typage statique sont ceux dans lesquels la vérification de type est effectuée au moment de la compilation, cela signifie donc également que dans les langages à typage statique, chaque variable a un type et celui-ci ne change pas au cours du cours. Maintenant, en revanche, les langages typés dynamiquement sont ceux dans lesquels la vérification de type est effectuée au moment de l'exécution, et il n'y a pas de vérification de type au moment de la compilation, cela signifie donc également que dans les langages typés dynamiquement, il peut ou non y avoir un type associé à une variable, et si un type est associé, il peut s'agir d'un type générique comme « var » dans JS qui vaut à la fois pour une chaîne et un nombre.
- «Les implémentations de langages à vérification de type dynamique associent généralement chaque objet d'exécution à une balise de type (c'est-à-dire une référence à un type) contenant ses informations de type.Ces informations de type d'exécution (RTTI) peuvent également être utilisées pour implémenter la répartition dynamique, la liaison tardive, la diffusion descendante, la réflexion et des fonctionnalités similaires.
Même si le langage est typé statiquement, il pourrait néanmoins avoir une fonctionnalité typée dynamiquement, ce qui signifie essentiellement qu'une sorte de vérification de type au moment de l'exécution également.Ceci est utile pour la conversion de types.
- « Un certain nombre de fonctionnalités utiles et courantes du langage de programmation ne peuvent pas être vérifiées de manière statique, comme la diffusion descendante.Ainsi, de nombreux langages auront une vérification de type à la fois statique et dynamique ;le vérificateur de type statique vérifie ce qu'il peut, et les vérifications dynamiques vérifient le reste.
«Certains langages permettent d'écrire du code dont le type n'est pas sécurisé.Par exemple, en C, les programmeurs peuvent librement convertir une valeur entre deux types quelconques de même taille.
Les avantages des langages typés « statiquement » sont les suivants :
- Étant donné que la plupart des vérifications de type sont effectuées au moment de la compilation, l'interpréteur ou le runtime peuvent fonctionner à pleine vitesse, sans se soucier des types.
- Cela entraîne un nombre moindre d'exceptions d'exécution ou d'erreurs liées au type, car la plupart de la vérification du type est effectuée au moment de la compilation.
Les avantages des langages typés « dynamiquement » sont les suivants :
- Ils pourraient aider à un prototypage extrêmement rapide, car le développeur n'a pas besoin de comprendre le système de types pour pouvoir créer des variables et l'exécuter de manière lâche, ce qui conduit à un prototypage très rapide.
Liste des langages typés statiquement et dynamiquement:
- Statiquement :
  - Java
  - C (C est un langage typé statiquement mais moins « fortement » typé que Java car il permet des conversions plus implicites)
  - C++
  - C#
- Dynamiquement :
  - PERLE
  - PHP
  - Python
  - Javascript
  - Rubis
La vérification de type est une fonctionnalité de sécurité importante. Supposons qu'il n'y ait pas de vérification de type et qu'une méthode accepte un objet de type « BankAccount » qui a une méthode appelée « creditAccount (BankAccountDetails) », maintenant au moment de l'exécution, s'il n'y a pas de vérification de type, je peux alors transmettre mon propre objet. classe qui a la même méthode « creditAccount(BankAccountDetails) » et elle sera exécutée, étant donné que nous parlons d’un langage orienté objet car la POO prend en charge le « polymorphisme » et ici ce dont nous discutons n’est que du « polymorphisme ».Ainsi, fondamentalement, un langage orienté objet (ce qui signifie essentiellement qu’il prend en charge le « polymorphisme ») qui ne dispose pas d’une vérification de type solide peut entraîner des problèmes de sécurité.

Langages fortement typés vs langages faiblement typés

Les langages fortement typés sont ceux dans lesquels les conversions implicites ne sont pas autorisées en cas de perte de précision.Par exemple, en Java, vous pouvez convertir un "int en long" car il n'y a pas de perte de précision, mais vous ne pouvez pas "implicitement" convertir un "long en int" car il y aurait une perte de précision.En revanche, dans les langages faiblement typés, les conversions implicites sont autorisées même en cas de perte de précision.
Je pense qu'un langage typé dynamiquement peut aussi être un langage fortement typé si « au moment de l'exécution » il ne permet pas les conversions implicites dans lesquelles il y a une perte de précision.

Bonnes lectures complémentaires

nécessitent généralement langages typés statiquement vous de déclarer les types de variables, qui est ensuite vérifiée au moment de la compilation pour réduire les erreurs. Le mot « statique » dans « statiquement typé » fait référence à « l'analyse de code statique », qui est le processus d'examen du code avant de l'exécuter. Bien qu'il soit possible pour un langage typé statiquement pour déduire le type de la variable du côté droit d'une expression ou paramètres réels, dans la pratique la plus typé langues exigent statiquement types de variables être explicitement déclarés.

Les langages typés dynamiquement ne nécessitent généralement pas de déclarations variables d'avoir des types, et ils déduire types de variables en fonction du type calculé à la suite de l'évaluation du côté droit de chaque instruction d'affectation ou les paramètres réels à un appel de fonction. Étant donné que la variable peut être donné plusieurs missions sur sa durée de vie, son type peut changer au fil du temps, ce qui est pourquoi il est appelé « typé dynamiquement ». En outre, l'environnement d'exécution a besoin de garder une trace du type courant pour chaque variable, de sorte que le type est lié à la valeur plutôt que la déclaration variable. Cela peut être considéré comme un système d'information de type d'exécution (RTTI).

Les éléments de langages typés statiquement et dynamiquement peuvent être combinés. Par exemple, C # prend en charge statique et dynamique typée variables et des langages orientés objet support généralement vers le bas de la hiérarchie de coulée de type. Les langages typés statiquement fournissent divers moyens de vérification de type by-pass, par exemple en utilisant la coulée, la réflexion et l'invocation dynamique.

typage fort contre faible se réfère à un continuum de combien la langue essaie d'éviter les bugs dus à l'utilisation d'une variable comme si elle était un type quand il est en fait un autre type. Par exemple à la fois C et Java sont des langages à typage statique, mais Java utilise le contrôle de type beaucoup plus forte que ne C. Le code suivant C est heureux de compiler et exécuter, et mettre une valeur aléatoire dans la variable b lors de l'exécution, ce qui provoque le plus probablement bug:

char *a = "123";
int b = (int)a;

Le code Java équivalent produira une erreur de compilation, qui est généralement préférable:

String a = "123"
int b = (int)a;

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow