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

En outre, l’un implique-t-il l’autre?

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

    Un langage de type statique a un système de type qui est vérifié au moment de la compilation par l’implémentation (un compilateur ou un interpréteur). La vérification de type rejette certains programmes et les programmes qui réussissent la vérification sont généralement assortis de garanties. Par exemple, le compilateur garantit de ne pas utiliser d’instructions arithmétiques sur des nombres à virgule flottante.

    Il n’y a pas de véritable accord sur ce que “fortement typé” signifie, bien que la définition la plus utilisée dans la littérature professionnelle soit que dans un langage “fortement typé”, le programmeur ne peut contourner les ressortingctions imposées par le système de types. . Ce terme est presque toujours utilisé pour décrire les langages statiquement typés.

    Statique vs dynamic

    Le contraire de la saisie statique est “typé dynamicment”, ce qui signifie que

    1. Les valeurs utilisées à l’exécution sont classées en types.
    2. Il existe des ressortingctions sur la façon dont ces valeurs peuvent être utilisées.
    3. Lorsque ces ressortingctions sont violées, la violation est signalée comme une erreur de type (dynamic).

    Par exemple, Lua , un langage à typage dynamic, a entre autres un type de chaîne, un type de nombre et un type booléen. Dans Lua, chaque valeur appartient à un seul type, mais ce n’est pas une exigence pour tous les langages à typage dynamic. Dans Lua, il est permis de concaténer deux chaînes, mais il n’est pas permis de concaténer une chaîne et un booléen.

    Fort vs faible

    Le contraire de “fortement typé” est “faiblement typé”, ce qui signifie que vous pouvez contourner le système de types. C est notoirement faiblement typé car tout type de pointeur est convertible en n’importe quel autre type de pointeur simplement par casting. Pascal était destiné à être fortement typé, mais un oubli dans la conception (enregistrements de variantes non étiquetées) a introduit une faille dans le système de caractères, ce qui le rend techniquement faible. Les exemples de langages vraiment fortement typés incluent CLU, Standard ML et Haskell. La norme ML a en effet subi plusieurs révisions pour éliminer les failles du système de types découvertes après le déploiement du langage.

    Qu’est-ce qui se passe vraiment ici?

    Dans l’ensemble, il n’est pas très utile de parler de “fort” et de “faible”. La question de savoir si un système de type a une faille est moins importante que le nombre exact et la nature des lacunes, la probabilité qu’elles apparaissent dans la pratique et les conséquences de l’exploitation d’une faille. En pratique, il vaut mieux éviter les termes “fort” et “faible” , car

    • Les amateurs les confondent souvent avec “statique” et “dynamic”.

    • Apparemment, le “typage faible” est utilisé par certaines personnes pour parler de la prévalence relative ou de l’absence de conversions implicites.

    • Les professionnels ne peuvent pas s’entendre sur la signification exacte des termes.

    • Dans l’ensemble, il est peu probable que vous informiez ou éclairiez votre public.

    La sortingste vérité est que quand il s’agit de taper des systèmes, «fort» et «faible» n’ont pas un sens technique universellement accepté. Si vous voulez discuter de la force relative des systèmes de type, il est préférable de discuter avec précision des garanties fournies et non fournies. Par exemple, une bonne question à poser est la suivante: “chaque valeur d’un type donné (ou d’une classe) est-elle garantie d’avoir été créée en appelant l’un des constructeurs de ce type?” En C la réponse est non. Dans CLU, F # et Haskell, c’est oui. Pour C ++, je ne suis pas sûr – j’aimerais savoir.

    En revanche, le typage statique signifie que les programmes sont vérifiés avant d’être exécutés et qu’un programme peut être rejeté avant le démarrage. Le typage dynamic signifie que les types de valeurs sont vérifiés lors de l’ exécution et qu’une opération mal typée peut entraîner l’arrêt du programme ou signaler une erreur au moment de l’exécution. L’une des principales raisons du typage statique est d’exclure les programmes susceptibles de comporter de telles “erreurs de type dynamic”.

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

    Sur un plan pédant, non, car le mot “fort” ne veut rien dire. Mais dans la pratique, les gens font presque toujours l’une des deux choses suivantes:

    • Ils utilisent (à tort) «fort» et «faible» pour signifier «statique» et «dynamic», auquel cas ils utilisent (à tort) «fortement typé» et «statiquement typé» de manière 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 quelqu’un parler d’un système de type dynamic “fort” ou “faible”. Sauf pour FORTH, qui n’a pas vraiment de système de type, je ne peux pas penser à un langage dynamic dans lequel le type de système peut être altéré. Par définition, ces contrôles sont intégrés au moteur d’exécution, et chaque opération est vérifiée avant d’être exécutée.

    De toute façon, si une personne appelle une langue “fortement typée”, cette personne est très susceptible de parler d’un langage typé statiquement.

    C’est souvent mal compris alors laissez-moi clarifier.

    Statique / Dactylographie dynamic

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

    Le typage dynamic est l’endroit où le type est lié à la valeur . Les types sont vérifiés au moment de l’exécution.

    Donc en Java par exemple:

    Ssortingng s = "abcd"; 

    s sera “pour toujours” une Ssortingng . Au cours de sa vie, il peut indiquer différentes Ssortingng (car s est une référence en Java). Il peut avoir une valeur null mais il ne se référera jamais à un Integer ou à une List . C’est le typage statique.

    En PHP:

     $s = "abcd"; // $s is a ssortingng $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 le typage dynamic.

    Taper fort / faible

    (Modifier l’alerte!)

    Le typage fort 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 imposé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 type de système assez fort, mais il peut être “subverti” à un certain degré 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 renvoyée par malloc() et la convertir joyeusement en FILE* , et le compilateur ne tentera pas de vous arrêter ou même de vous avertir que vous faites quelque chose de mal.

    (La réponse originale disait quelque chose à propos d’une valeur “ne changeant pas de type à l’exécution”. J’ai connu beaucoup de concepteurs de langages et de compilateurs et n’en connaissais aucun qui parlait de valeurs changeant de type à l’exécution, sauf peut-être systèmes connus sous le nom de “problème de forte mise à jour”.)

    Un typage faible implique que le compilateur n’applique pas un axe de frappe, ou peut-être que cette application peut facilement être altérée.

    L’original de cette réponse a associé un typage faible à une conversion implicite (parfois appelée “promotion implicite”). Par exemple, en Java:

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

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

     Ssortingng s = "abc" + new Integer(123).toSsortingng(); 

    Considérons 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, étant 0. 0 est contraint à booléen false et donc la condition est réellement vraie. La solution consiste à utiliser === au lieu de == pour éviter les conversions implicites.

    Cet exemple illustre comment une combinaison de conversion implicite et de typage dynamic peut induire les programmeurs en erreur.

    Comparez cela à Ruby:

     val = "abc" + 123 

    ce qui est une erreur d’exécution parce que dans Ruby, l’ object 123 n’est pas implicitement converti simplement parce qu’il est passé à une méthode + . Dans Ruby, le programmeur doit rendre la conversion explicite:

     val = "abc" + 123.to_s 

    Comparer PHP et Ruby en est une bonne illustration. Les deux sont des langages typés dynamicment mais PHP a beaucoup de conversions implicites et Ruby (peut-être étonnamment si vous ne le connaissez pas) ne le fait pas.

    Statique / Dynamique vs Fort / Faible

    Le point ici est que l’axe statique / dynamic est indépendant de l’axe fort / faible. Les gens les confondent probablement en partie parce que le typage fort vs faible est non seulement moins clairement défini, mais qu’il n’ya pas vraiment de consensus sur ce que l’on entend par fort et par faible. Pour cette raison, le typage fort / faible est bien plus une nuance de gris que de noir ou de blanc.

    Donc, pour répondre à votre question, une autre façon de voir cela est de dire que le typage statique est une sécurité de type compilation et que le typage fort est une sécurité de type runtime.

    La raison en est que les variables dans un langage de type statique 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 vérification dynamic.

    Mais il est important de comprendre qu’une langue peut être statique / forte, statique / faible, dynamic / forte ou dynamic / faible.

    Fortement typé signifie qu’il existe des ressortingctions entre les conversions entre types. La saisie statique signifie que les types ne sont pas dynamics – vous ne pouvez pas modifier le type d’une variable une fois qu’elle a été créée.

    La coercition des données ne signifie pas nécessairement un typage faible, car parfois son sucre syntacique:

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

     Ssortingng s = "abc" + 123; 

    N’est-ce pas un exemple faiblement typé car sa fait vraiment:

     Ssortingng s = "abc" + new Integer(123).toSsortingng() 

    La coercition des données n’est pas non plus faiblement typée si vous construisez un nouvel object. Java est un très mauvais exemple de typage faible (et tout langage ayant une bonne reflection ne sera probablement pas faiblement typé). Parce que le runtime de la langue sait toujours quel est le type (l’exception peut être des types natifs).

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

    Le runtime du langage définit vraiment si oui ou non son typage faiblement typé est son opinion vraiment juste.

    EDIT: Après avoir pensé plus loin, ceci n’est pas forcément vrai, car il n’est pas nécessaire que tous les types d’exécution du système d’exécution soient un système fortement typé. Haskell et ML ont une parsing statique si complète qu’elles peuvent potentiellement générer des informations de type ommit à partir du runtime.

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

    • fortement typé vs. faiblement typé
    • Typiquement statiquement vs typé dynamicment

    Fortement typé signifie, a ne sera pas automatiquement converti d’un type à un autre. À l’opposé, Perl peut utiliser une chaîne comme "123" dans un contexte numérique, en le convertissant automatiquement dans l’int 123 . Un langage fortement typé comme python ne le fera pas.

    En mode typé statiquement , le compilateur calcule le type de chaque variable au moment de la compilation. Les langages à typage dynamic déterminent uniquement les types de variables à l’exécution.

    Un typage fort signifie probablement que les variables ont un type bien défini et qu’il existe des règles ssortingctes sur la combinaison de variables de types différents dans les expressions. Par exemple, si A est un entier et B est un flottant, la règle ssortingcte concernant A + B pourrait être que A est converti en un flottant et que le résultat est renvoyé sous forme de flottant. Si A est un entier et B une chaîne, la règle ssortingcte pourrait ê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 langues non compilées) et ne peuvent pas être modifiés pendant l’exécution du programme.

    Notez que ces classifications ne s’excluent pas mutuellement, en effet, je m’attendrais à ce qu’elles se produisent fréquemment. De nombreuses langues fortement typées sont également typées 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 l’avez déjà vu dans les réponses jusqu’à présent.

    L’un n’implique pas l’autre. Pour qu’une langue soit typée statiquement, cela signifie que les types de toutes les variables sont connus ou déduits au moment de la compilation.

    Un langage fortement typé ne vous permet pas d’utiliser un type comme un autre. C est un langage faiblement typé et constitue un bon exemple de ce que les langages fortement typés ne permettent pas. En C, vous pouvez transmettre un élément de données de type incorrect et il ne se plaindra pas. Dans des 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 comstackr si l’argument transmis à une fonction ne correspond pas étroitement au type attendu. D’un autre côté, un langage très faiblement typé peut produire des résultats imprévisibles ou effectuer une conversion de type implicite.