Dactylographie dynamique. LikBez en tapant dans les langages de programmation Taping dynamique est meilleur que strict

Cet article contient le minimum nécessaire de ces choses que vous avez juste besoin de savoir sur la frappe, afin de ne pas appeler la dynamique de frappe par le mal, la LISP est une langue plantureuse et un langage C avec une dactylographie stricte.

Dans la version complète, une description détaillée de tous types de dactylographie, assaisonnée avec des exemples de code, des références aux langages de programmation populaires et des images explicites.

Je recommande de lire d'abord une brève version de l'article, puis avec désir et complète.

Version brève version

Les langages de programmation de la caractérisation sont fabriqués pour diviser en deux grands camps - dactylographiés et non de type (plantureuse). Pour la première fois, par exemple, C, Python, Scala, PHP et Lua incluent, et la seconde est la langue d'assembleur, en avant et en brainfuck.

Étant donné que la «caractérisation conventionnelle» est intrinsèquement simple comme un embouteillage, il n'est pas divisé en une autre espèce. Mais les langues dactylographiées sont divisées en plusieurs autres catégories d'intersection:

Typographie statique / dynamique. La statique est déterminée par le fait que les types finaux de variables et fonctions sont définis au stade de la compilation. Ceux. Déjà, le compilateur est sûr à 100% du type où se trouve. En tapant dynamique, tous les types sont déjà trouvés lors de l'exécution du programme.
Exemples:
Statique: c, java, c #;
Dynamique: Python, JavaScript, Ruby.
Une caractéristique forte / faible (disent parfois parfois stricte / non-ARC). Un fort typage est attribué par le fait que la langue ne vous permet pas de mélanger différents types d'expressions et ne convertit pas automatiquement les conversions implicites, par exemple, vous ne pouvez pas déduire de l'ensemble de cordes. Les langues avec une typisation faible Effectuez une variété de transformations implicites automatiquement, même si la perte de précision ou la conversion peut survenir dans les ambiguïtés.
Exemples:
Fort: Java, Python, Haskell, Lisp;
Faible: C, JavaScript, Visual Basic, PHP.
Caractérisation explicite / implicite. Les langues dactylographiées explicites se distinguent par le fait que le type de nouvelles variables / fonctions / leurs arguments doit être spécifié explicitement. En conséquence, des langues avec une typisation implicite décalent cette tâche sur le compilateur / interprète.
Exemples:
Explicit: C ++, D, C #
Implicite: php, lua, javascript

Il convient également de noter que toutes ces catégories se croiser, par exemple, la langage C ont une faiblesse de la faiblesse de la typique explicite et que la langue python est une forte dynamique implicite.

Cependant, pas moins que des langues provenant de tyistations statiques et dynamiques en même temps. Bien que prospère, je dirai que je suis ici, ils existent vraiment, mais à ce sujet plus tard.

Version détaillée

Si une brève version ne semblait pas assez, bonne. Pas étonnant que j'écris un détaillé? La principale chose est que, dans une brève version, il était tout simplement impossible de s'adapter à toutes les informations utiles et intéressantes et que les détaillés seraient trop longs que tout le monde pouvait la lire, pas fatiguant.

Caractérisation de base

Dans les langages de programmation à boutons - toutes les entités sont considérées comme des séquences de bits simplement, des longueurs différentes.

La typification de la BESTIPA est généralement inhérente au niveau bas (assembleur, vitesses) et ésotérique (Brainfuck, HQ9, Piet) Langues. Cependant, elle, avec les inconvénients, présente des avantages.

Avantages

Vous permet d'écrire sur un niveau minimum maximum, et le compilateur / interprète n'interférera pas avec aucun type de types. Vous êtes libre de produire des opérations sur tous les types de données.
Le code résultant est généralement plus efficace.
Transparence des instructions. Avec la connaissance de la langue, il ne fait aucun doute que l'un ou l'autre code représente.

désavantages

Complexité. Il est souvent nécessaire de présenter des valeurs complètes, telles que des listes, des lignes ou des structures. Il peut y avoir des inconvénients.
Pas de chèques. Toute action sans signification, telle que la soustraction d'un pointeur à un tableau du symbole, sera considérée comme complètement normale, qui est envahie par des erreurs d'emploi.
Faible abstraction. Travailler avec tout type de données complexe n'est pas différent de travailler avec des chiffres, c'est bien sûr créer beaucoup de difficultés.

Une optimisation forte de barbarie?

Oui, il existe. Par exemple, dans la langue des assembleurs (pour l'architecture X86 / X86-64, je ne connais pas d'autres personnes) Vous ne pouvez pas assembler le programme si vous essayez de télécharger sur les données du registre CX (16 bits) du registre RAX (64 bits ).

mOV CX, EAX; Temps d'assemblage d'erreur

Donc, il s'avère que la frappe toujours dans l'assemblé? Je crois que ces chèques ne suffisent pas. Et votre avis, bien sûr, ne dépend que sur vous.

Typage statique et dynamique

L'essentiel est que la distinction distingue statique (statique) de dactylographie de dynamique (dynamique) que tous les types de types sont effectués au stade de la compilation et non à l'étape d'exécution.

Certaines personnes peuvent sembler que la typographie statique est trop limitée (en fait, c'est que cela se débarrasse depuis longtemps de certaines méthodes). De même manière que les langues dactylographiées dynamiquement sont un jeu avec le feu, mais quelles fonctionnalités sont-elles allouées? Les deux espèces ont-elles une chance d'existence? Sinon, pourquoi il y a beaucoup plus que des langues typiques statiquement et dynamiquement?

Trouvons-le.

Avantages de la typographie statique

Les chèques de type ne se produisent qu'une seule fois - à la phase de compilation. Et cela signifie que nous n'aurons pas besoin de savoir constamment si nous essayons de diviser le numéro sur la chaîne (et de donner l'erreur ou de transformer).
Vitesse de performance. Il ressort clairement du point précédent que les langues typées statiquement sont presque toujours plus rapides que dynamiquement dactylographiées.
Avec quelques conditions supplémentaires, il vous permet de détecter des erreurs potentielles au stade de la compilation.

Avantages de la dactylographie dynamique

Facile à créer des collections universelles - un tas de tous et tout cela se pose rarement un tel besoin, mais lorsque la typographie dynamique se produit pour aider).
Facilité de décrire des algorithmes généralisés (par exemple, trier un tableau qui fonctionnera non seulement sur la liste des entiers, mais également sur la liste de réels et même sur la liste des lignes).
Facile dans le développement - Les langues de tylilation dynamique sont généralement très bonnes afin de commencer la programmation.

Programmation généralisée

Eh bien, l'argument le plus important pour la dactylographie dynamique est la commodité de décrire des algorithmes généralisés. Imaginons un problème - nous avons besoin d'une fonction de recherche pour plusieurs tableaux (ou des listes) - par le tableau d'entiers, en fonction du réseau de caractères réels et de matrices de caractères.

Comment allons-nous le résoudre? Je le résolvez sur la 3ème langue différente: une avec dactylographie dactylographie et deux avec statique.

Algorithme de recherche Je prendrai l'un des buste les plus simples. La fonction recevra l'élément souhaité, la matrice elle-même (ou la liste) et renvoie l'index de l'élément ou, si l'élément n'est pas trouvé - (-1).

Solution dynamique (Python):

DEF Rechercher (requis_élément, liste): Pour (index, élément) en énumérant (liste): Si Element \u003d\u003d Obligatoire_Element: retour Index retour (-1)

Comme vous pouvez le constater, tout est simple et aucun problème avec le fait que la liste peut contenir au moins des nombres, même s'il n'y a pas d'autres tableaux. Très bon. Allons plus loin - je décide de cette tâche sur c!

Solution statique (c):

Non signé int wind_int (intchrographement_element, intora, taille intégrée non signée) (pour (non signé INT I \u003d 0; i< size; ++i) if (required_element == array[i]) return i; return (-1); } unsigned int find_float(float required_element, float array, unsigned int size) { for (unsigned int i = 0; i < size; ++i) if (required_element == array[i]) return i; return (-1); } unsigned int find_char(char required_element, char array, unsigned int size) { for (unsigned int i = 0; i < size; ++i) if (required_element == array[i]) return i; return (-1); }

Eh bien, chaque fonction est individuellement similaire à la version de Python, mais pourquoi y a-t-il trois? Est-ce vraiment une programmation statique?

Oui et non. Il existe plusieurs techniques de programmation, dont une fois que nous considérons maintenant. C'est ce qu'on appelle la programmation généralisée et la langue C ++ le supporte bien. Regardons la nouvelle version:

Solution statique (programmation généralisée, C ++):

Modèle. Sans signé int Recherche (t requis_element, std :: vecteur tableau) (pour non signé INT I \u003d 0; i< array.size(); ++i) if (required_element == array[i]) return i; return (-1); }

D'accord! Il ne semble pas beaucoup plus difficile que la version sur Python et en même temps n'ayant pas eu à écrire beaucoup. De plus, nous avons obtenu la mise en œuvre pour tous les tableaux et non seulement pour le 3ème nécessaire pour résoudre le problème!

Cette version semble être exactement ce dont vous avez besoin - nous obtenons à la fois des plus de frappe statique et certains avantages sont dynamiques.

C'est génial que ce soit généralement possible, mais peut-être encore mieux. Premièrement, la programmation généralisée peut être plus pratique et plus belle (par exemple dans HASKELLL). Deuxièmement, en plus de la programmation généralisée, il est également possible d'appliquer un polymorphisme (le résultat sera pire), la surcharge des fonctions (de la même manière) ou des macros.

Statistiques en dynamique

Il est également nécessaire de mentionner que de nombreuses langues statiques vous permettent d'utiliser la dactylographie dynamique, par exemple:

C # prend en charge la dynamique pseudo-type.
F # prend en charge le sucre de syntaxe sous la forme d'un opérateur?, Sur la base de laquelle l'imitation de la typage dynamique peut être mise en œuvre.
Haskell - Le typage dynamique est fourni par le module Data.Dynamic.
Delphi - à travers un type spécial de variante.

En outre, certaines langues dactylographiées dynamiquement vous permettent de profiter de la typographie statique:

Lisp Common Lisp - Types Déclaration.
Perl - de la version 5.6, assez limitée.

Typisius fort et faible

Les langues avec une tape forte ne permettent pas de mélanger l'essence de différents types dans des expressions et n'effectuez aucune transformation automatique. Ils sont également appelés "langues avec une dactylographie stricte". Tête anglaise pour cela - Typage fort.

Les langues faiblement définies, au contraire, en matières grasses, de sorte que le programmeur mélange différents types d'une expression et le compilateur lui-même résultera d'un seul type. Ils appellent également "des langues avec une typisation sans démarrage". Le terme anglais pour cela est faible en tapant.

La typisation faible est souvent confondue avec dynamique, ce qui est complètement incorrect. Une langue dactylographiée dynamiquement peut être faible et fortement typée.

Cependant, peu de ceux qui attachent la valeur de la rigueur de la dactylographie. Il est souvent affirmé que si la langue est statistique typée, vous pouvez attraper beaucoup d'erreurs potentielles lors de la compilation. Ils vous mentent!

La langue devrait avoir davantage de dactylographie. Et la vérité, si le compilateur, au lieu d'un message d'erreur, ajoutera simplement une ligne à un numéro ou ce qui est encore pire, la déduction d'un massif est une autre, quelle est l'utilisation des types que tous les "chèques" être à la phase de compilation? C'est vrai - la typographie statique faible est encore pire que la forte dynamique! (C'est mon avis)

Alors qu'en est-il de faible tymisius n'a pas assez de plus? Cela ressemble peut-être à cela, mais malgré le fait que je suis d'accord avec un partisan complet de la frappe forte, cela présente également des avantages.

Veut savoir quoi?

Avantages de la frappe forte

Fiabilité - vous obtiendrez une exception ou une erreur de compilation, au lieu de comportement incorrect.
Vitesse - Au lieu de transformations cachées pouvant être assez chères, il est nécessaire de les écrire clairement, ce qui entraîne un programmeur au moins de savoir que cette section du code peut être lente.
Comprendre le travail du programme - à nouveau, au lieu de types d'imprégnés, le programmeur écrit tout moi-même, ce qui signifie que signifie à peu près que la comparaison de la chaîne et le nombre ne se produit pas en soi.
NOTE - Lorsque vous écrivez la conversion manuellement, vous savez exactement ce que vous convertissez et quoi. Vous comprendrez également toujours que de telles transformations peuvent entraîner une perte de précision et des résultats incorrects.

Les avantages de la typographie faible

Facilité d'utilisation d'expressions mixtes (par exemple, des entiers et des nombres réels).
Abstraction de taper et de se concentrer sur la tâche.
Brève enregistrement.

D'accord, nous avons compris, il s'avère avoir une caractéristique faible, il y a aussi des avantages! Y a-t-il des moyens de déplacer les avantages de la faiblesse de la caractérisation?

Il s'avère que même deux.

Clarification implicite des types, dans des situations non ambiguës et sans perte de données

Wow ... assez longtemps. Permettez-moi de continuer à le couper à la "transformation implicite limitée" alors que signifie la situation et la perte de données sans ambiguïté?

Une situation sans ambiguïté est une transformation ou une opération dans laquelle l'essence est immédiatement comprise. Par exemple, l'ajout de deux nombres est une situation sans ambiguïté. Et la transformation du nombre en une matrice est NON (il est possible de créer un tableau d'un élément, éventuellement un tableau, avec des éléments aussi longs, remplis d'éléments par défaut, et le nombre peut être converti dans la chaîne, puis en. un tableau de caractères).

La perte de données est encore plus facile. Si nous convertissons un nombre réel de 3,5 en tout - nous perdrons une partie des données (en fait, cette opération est également ambiguë - comment arrondira-t-elle? Aussi? De manière petite? Déposez la partie fractionnée?).

Les transformations dans des situations ambiguës et la conversion avec la perte de données sont très très mauvaises. Il n'y a rien de pire dans la programmation.

Si vous ne me croyez pas, apprenez la langue PL / I ou cherchez simplement sa spécification. Il a des règles pour la transformation entre tous types de données! C'est juste l'enfer!

D'accord, rappelons la conversion implicite limitée. Y a-t-il des langues? Oui, par exemple, à Pascal, vous pouvez convertir un entier en un vrai, mais pas vice versa. Les mécanismes similaires sont également en C #, groovy et LISP commun.

Eh bien, j'ai dit qu'il y avait toujours un moyen d'obtenir quelques avantages de la faiblesse de la typification dans une langue forte. Et oui, c'est et appelé le polymorphisme des concepteurs.

Je vais l'expliquer sur l'exemple d'une langue merveilleuse Haskell.

Les concepteurs polymorphes sont apparus à la suite de l'observation, que les transformations implicites les plus sûres sont nécessaires lors de l'utilisation de littéraux numériques.

Par exemple, dans l'expression PI + 1, je ne veux pas écrire PI + 1.0 ou PI + Float (1). Je veux écrire juste pi + 1!

Et cela se fait à Haskell, en raison du fait que le littéral 1 n'a pas de type spécifique. Ce n'est ni vrai ni complexe. C'est juste un nombre!

En conséquence, lors de la rédaction d'une fonction Sum XY simple, déplaçant tous les nombres de X à Y (avec incrément dans 1), nous obtenons plusieurs versions - Somme pour les entiers, somme pour réelle, somme pour rationnel, somme pour les nombres complexes et même la somme. Pour tous ces types numériques que vous avez eux-mêmes identifiés.

Bien sûr, cette réception n'est enregistrée que lorsque vous utilisez des expressions mixtes avec des littéraux numériques, ce n'est que le sommet de l'iceberg.

Ainsi, on peut dire que la meilleure sortie sera en équilibre au bord de la typographie forte et faible. Mais alors que l'équilibre parfait ne tient aucune langue, je suis donc plus enclin à des langues fortement typées (telles que Haskell, Java, C #, Python), et non à faiblement tapé (comme C, JavaScript, Lua, Php).

Caractérisation explicite et implicite

La langue avec une typisation explicite suppose que le programmeur doit spécifier les types de variables et fonctions annoncées. Terme d'anglais pour cela - dactylographie explicite.

Le langage avec une typisation implicite, au contraire, vous propose d'oublier les types et de transférer la tâche des types de sortie sur le compilateur ou l'interprète. Terme anglaise pour cela - Typage implicite.

Au début, il est possible de décider que la typage implicite équivaut à dynamique et explicitement statique, mais nous verrons que ce n'est pas le cas.

Y a-t-il des avantages de chaque espèce, et encore une fois, existe-t-il des combinaisons et existe-t-il des langues avec le soutien des deux méthodes?

Avantages de la typisation explicite

La présence de la fonction de signature (par exemple, Int Add (int, int)) vous permet de déterminer sans aucun problème que la fonction fait.
Le programmeur écrit immédiatement comment le type de valeur peut être stocké dans une variable spécifique, qui supprime la nécessité de la mémoriser.

Les avantages de la typage implicite

Réduction des enregistrements - DEF Ajouter (x, y) est clairement plus court que INT X, INT Y).
Résistance aux changements. Par exemple, si la fonction variable temporaire était la même type que l'argument d'entrée, dans une langue explicitement dactylographiée lorsque le type d'argument est modifié, le type de variable temporaire sera également modifié.

On peut constater que les deux approches ont à la fois les avantages et les inconvénients (et qui attendaient autre chose?), Trouvons donc des moyens de combiner ces deux approches!

Caractérisation explicite

Sans explicitement spécifier le type Ajouter (x, y) \u003d x + y - Indication explicite du type Ajouter :: (entier, entier) -\u003e Integer Ajouter (x, y) \u003d x + y

Remarque: je voulais utiliser une fonction non marquée, et a également l'intention d'enregistrer une signature privée au lieu d'ajouter plus d'add Ajouter :: (Nombre de) -\u003e A -\u003e A -\u003e A, car Je voulais montrer l'idée, sans expliquer la syntaxe Haskell "A.

Hmm Comme on voit, c'est très beau et court. L'enregistrement de fonction ne prend que 18 caractères sur une ligne, y compris des espaces!

Cependant, la sortie automatique des types est une chose assez complexe et même dans une langue aussi cool en tant que haskell, elle ne fait parfois pas gérer. (Par exemple, la limite de monomorphisme peut être obtenue)

Y a-t-il des langues avec une typisation explicite de la défaillance et de la nécessité implicite? Kon.
eony.

Caractérisation implicite

Dans la nouvelle norme de langue C ++ appelée C ++ 11 (précédemment appelée C ++ 0x), le mot-clé automatique a été saisi, grâce auquel vous pouvez effectuer la sortie du compilateur, en fonction du contexte:

Comparons: // Indication manuelle du type non signé INT A \u003d 5; non signé INT B \u003d A + 3; // sortie automatique du type non signé int A \u003d 5; AUTO B \u003d A + 3;

Pas mal. Mais le dossier n'était pas très réduit. Voyons un exemple avec les itérateurs (si vous ne comprenez pas, n'ayez pas peur, l'essentiel est de noter que l'enregistrement est très réduit par la conclusion automatique):

// type d'indication manuelle type std :: vecteur VEC \u003d RandomVector (30); Pour (std :: vecteur :: const_terator it \u003d vec.cbegin (); ...) (...) // la sortie automatique de type auto Vec \u003d RandomVector (30); Pour (auto it \u003d vec.cbegin (); ...) (...)

Wow! C'est une réduction. Ok, mais est-il possible de faire quoi que ce soit dans l'esprit Haskell, où le type de valeur de retour dépendra des types d'arguments?

Et encore une fois la réponse est oui, grâce au mot-clé DeclType en combinaison avec Auto:

// Indication manuelle du type INT DIVIDE (INT X, INT O) (...) // Sortie automatique du type Auto Divide (int x, int y) -\u003e déclinger (x / y) (...)

Il peut sembler que cette forme d'enregistrement n'est pas très bonne, mais en combinaison avec la programmation généralisée (modèles / génériques), la saisie implicite ou la sortie automatique des types crée des merveilles.

Quelques langues de programmation pour cette classification

Je donnerai une petite liste de langues populaires et écrivez comment ils sont divisés par chaque catégorie de "tyisations".

JavaScript - Ruby dynamique / faible / implicite - dynamique / grave / python implicite - dynamique / grave / Java implicite - statique / grave / explicite PHP - dynamique / faible / implicite C - statique / faible / explicite C ++ - statique / semi- SYL / Explicit Perl - dynamique / faible / implicite objectif-c - statique / faible / explicite C # - statique / grave / explicite HASKELL - STATIQUE / STROND / IMPLICIT COMMUN LISP - Dynamique / grave / implicite

Peut-être que j'avais tort quelque part, surtout avec cl, php et obj-C, si vous avez une opinion différente dans n'importe quelle langue - écrivez dans les commentaires.

Conclusion

D'accord. Ce sera bientôt léger et je pense qu'il n'y a rien de plus sur la typisation. Oh comment? Thème sans fond? Y a-t-il beaucoup de peu fiable? Je demande dans les commentaires, partagez des informations utiles.

Cet article raconte la différence entre les langages statiquement dactylographiés et dynamiquement typées, considère les concepts de typage "fort" et "faible" et compare la puissance des systèmes de frappe dans différentes langues. Récemment, un mouvement clair est observé vers des systèmes de caractérisation plus stricts et plus puissants dans la programmation, il est donc important de comprendre ce que nous parlons quand ils parlent de types et de taper.

Type est une collection de valeurs possibles. Un entier peut posséder les valeurs de 0, 1, 2, 3, etc. Boolean peut être vrai ou faux. Vous pouvez trouver votre type, par exemple, le type "Daipe", dans lequel les valeurs de "donner" et "5" sont possibles et rien d'autre. Ce n'est pas une chaîne et non un nombre, c'est une nouvelle, un type séparé.

Les langues typées statiquement limitent les types de variables: le langage de programmation peut savoir, par exemple, que X est un entier. Dans ce cas, le programmeur est interdit de faire x \u003d vrai, ce sera un code incorrect. Le compilateur refusera de le compiler afin que nous ne puissions même pas exécuter un tel code. Une autre langue statiquement dactylographiée peut avoir d'autres capacités expressives, et aucun des types de types populaires ne peut exprimer notre type de plongée (mais beaucoup peuvent exprimer d'autres idées plus sophistiquées).

Les valeurs de marque de langues dactylographiques dynamiquement telles que: La langue sait que 1 est entier, 2 est un entier, mais il ne peut pas savoir que la variable X contient toujours un entier.

L'environnement d'exécution vérifie ces balises à des moments différents. Si nous essayons de plier deux valeurs, il peut vérifier si elles sont des chiffres, des lignes ou des tableaux. Ensuite, elle pliera ces valeurs, les gluit ou donnera une erreur en fonction du type.

Langues statiquement tycres

Langages statiques Types de contrôle dans le programme pendant la compilation, avant que le programme ne soit lancé. Tout programme dans lequel les types violent les règles de la langue sont considérés erronés. Par exemple, la plupart des langues statiques révéleront l'expression "A" + 1 (cmérologie C constitue une exception à cette règle). Le compilateur sait que "A" est une chaîne, et 1 est un entier, et que + ne fonctionne que lorsque la partie gauche et droite appartient à un type. Il n'a donc pas besoin d'exécuter le programme pour comprendre qu'il y a un problème. Chaque expression dans une langue typée statique fait référence à un type spécifique pouvant être déterminé sans démarrer le code.

De nombreuses langues typées statiquement nécessitent un type. La fonction de Java Public int ajouter (int x, int.) Prend deux entiers et retourne le troisième entier. D'autres langues typées statiquement peuvent déterminer le type automatiquement. La même fonction d'addition à Haskell ressemble à ceci: ajouter x y \u003d x + y. Nous n'indiquons pas les types de types, mais cela peut les définir vous-même, car il sait que + ne fonctionne que dans des chiffres, de sorte que X et Y doivent être des chiffres, la fonction AD prend deux nombres comme des arguments.

Cela ne réduit pas la "statique" des types de types. Le système de type dans HASKELL est célèbre pour sa statique, sa gravité et sa puissance, et dans tous ces fronts Haskell est en avance sur Java.

Langues dactylographiques dynamiquement

Les langues dactylographiées dactylographiées ne nécessitent pas de type spécifier, mais ne le déterminent pas non plus. Les types de variables sont inconnus au moment où ils ont des valeurs spécifiques lors du démarrage. Par exemple, une fonction en python

Def f (x, y): retour x + y

il peut plier deux entiers, des chaînes de colle, des listes, etc., et nous ne pouvons pas comprendre ce qui se passe exactement avant de commencer le programme. Peut-être à un moment donné, la fonction F sera causée à deux lignes et avec deux chiffres à un autre moment. Dans ce cas, X et Y contiennent des valeurs de types différents à des moments différents. Par conséquent, il est dit que les valeurs des langues dynamiques ont un type, mais des variables et des fonctions - non. La valeur de 1 est définitivement un entier, mais X et Y peuvent être n'importe quoi.

Comparaison

La plupart des langues dynamiques émettront une erreur si les types sont utilisés de manière incorrecte (JavaScript est une exception donnée; il essaie de renvoyer la valeur pour toute expression, même si elle n'a pas de sens). Lorsque vous utilisez des langues dactylographiques dynamiquement, même une simple erreur du type "A" + 1 peut se produire dans un environnement de combat. Les langues statiques empêchent de telles erreurs, mais bien entendu, le degré de prévention dépend de la puissance du système de type.

Les langues statiques et dynamiques sont construites sur des idées fondamentalement différentes sur l'exactitude des programmes. Dans la langue dynamique "A" + 1, il s'agit du programme correct: le code sera lancé et une erreur apparaîtra dans l'environnement d'exécution. Cependant, dans la plupart des langues typées statiquement, l'expression "A" + 1 est non-programmer: Il ne sera pas compilé et ne sera pas lancé. Ceci est un code incorrect, ainsi qu'un ensemble de caractères aléatoires! &% ^ @ * &% ^ @ * - il s'agit d'un code incorrect. Il s'agit d'un concept supplémentaire d'exactitude et d'une incorrectivité n'a pas d'équivalent dans les langues dynamiques.

Caractérisation forte et faible

Les concepts de "forts" et "faibles" sont très ambigus. Voici quelques exemples d'utilisation:

Parfois "fort" signifie "statique".
C'est simple ici, mais il est préférable d'utiliser le terme "statique", car la plupart des utilisations et la comprennent.

Parfois, "fort" signifie "" ne fait pas une conversion de type implicite. "
Par exemple, JavaScript vous permet d'écrire "A" + 1, qui peut être appelé "Typisation faible". Mais presque toutes les langues fournissent un ou plusieurs niveaux de conversion implicite, ce qui vous permet de passer automatiquement d'entiers aux nombres de points flottants tels que 1 + 1.1. En réalité, la plupart des gens utilisent le mot «fort» pour déterminer la frontière entre une transformation acceptable et inacceptable. Il n'y a pas de frontière généralement acceptée, elles sont toutes inexactes et dépendent de l'opinion d'une personne donnée.

Parfois, «fort» signifie qu'il est impossible de contourner les règles strictes de taper dans la langue.

Parfois, "fort" signifie sans danger pour la mémoire (mémoire de sécurité).
C est un exemple de danger pour la mémoire linguistique. Si XS est un tableau de quatre chiffres, SI sera heureux d'exécuter le code XS ou XS, renvoyer une certaine valeur de la mémoire immédiatement pour XS.

Arrêtons-nous. C'est ainsi que certaines langues répondent à ces définitions. Comme vous pouvez le constater, seuls Haskell est "fort" dans tous les paramètres. La plupart des langues ne sont pas si claires.

("Quand" dans la colonne "Conversion implicite" signifie que la séparation entre le fort et le faible dépend de quelles transformations que nous considérons acceptables).

Souvent, les termes "forts" et "faibles" se réfèrent à une combinaison indéfinie de différentes définitions ci-dessus et d'autres définitions non présentées ici. Tout ce trouble rend les mots «fort» et «faible» pratiquement sans signification. Lorsque vous souhaitez utiliser ces termes, il est préférable de décrire le sens exactement. Par exemple, nous pouvons dire que "JavaScript retourne une valeur lorsque la chaîne est pliée avec le numéro, mais Python renvoie une erreur." Dans ce cas, nous ne passerons pas notre force sur les tentatives de venir à un accord sur les nombreuses valeurs du mot «fort». Ou même pire: nous allons arriver à un malentendu non résolu en raison de la terminologie.

Dans la plupart des cas, les termes «fort» et «faible» sur Internet sont des opinions peu claires et mal définies de personnes spécifiques. Ils sont utilisés pour appeler la langue "mauvaise" ou "bonne", et cet avis se transforme en jargon technique.

Typique forte: le système de type que j'aime et avec lequel je suis à l'aise.
Faible caractérisation: système de type qui me dérange ou avec lequel je ne suis pas à l'aise.

Typage progressif (typing progressif)

Puis-je ajouter des types statiques aux langues dynamiques? Dans certains cas - oui. Dans d'autres c'est difficile ou impossible. Le problème le plus évident est l'EVAL et d'autres possibilités similaires de langues dynamiques. Effectuer 1 + eval ("2") dans Python donne 3. Mais que donnera 1 + eval (read_from_the_network ())? Cela dépend du fait que sur le réseau au moment de l'exécution. Si vous obtenez un numéro, l'expression est correcte. Si la chaîne n'est pas. Il est impossible d'apprendre avant de commencer, il est donc impossible d'analyser le type de manière statique.

La solution insatisfaisante dans la pratique consiste à spécifier un type EVAL () tout ce qui rappelle à l'objet dans certaines langages de programmation orientés objet ou interface () dans Go: ce type à laquelle toute valeur satisfaite.

Toutes les valeurs ne sont pas limitées à rien, il disparaît donc la possibilité d'un système de type pour nous aider dans le code d'évaluation. Langues dans lesquelles il existe à la fois un système d'évaluation et de type doit refuser la sécurité de type avec chaque utilisation en évaluation.

Dans certaines langues, il existe une dactylographie facultative ou progressive (dactylographie progressive): elles sont dynamiques par défaut, mais vous permettent d'ajouter des annotations statiques. Python a récemment ajouté des types facultatifs; TypeScript est un complément sur JavaScript, qui comporte des types facultatifs; Le flux produit une analyse statique de l'ancien bon code sur JavaScript.

Ces langues fournissent certains des avantages de la typographie statique, mais ils ne donneront jamais de garanties absolues, comme des langues véritablement statiques. Certaines fonctions seront typiquement typées et certaines seront dactylographiées de manière dynamique. Le programmeur doit toujours connaître et craindre la différence.

Compilation de code typé statique

Lorsqu'une compilation d'un code typée statique est compilée, la syntaxe est vérifiée d'abord comme dans n'importe quel compilateur. Ensuite, les types sont vérifiés. Cela signifie que la langue statique peut d'abord se plaindre à une erreur syntaxique et, après sa fixation, placez-vous à 100 erreurs de typification. La correction de l'erreur de syntaxe n'a pas créé ces 100 erreurs de dactylographie. Le compilateur n'avait tout simplement pas la capacité de détecter des erreurs de type tant que la syntaxe n'a pas été corrigée.

Les compilateurs de langues statiques peuvent généralement générer un code plus rapide que des compilateurs dynamiques. Par exemple, si le compilateur sait que la fonctionnalité Ajouter des entiers, il peut utiliser l'instruction native du processeur central ADD. La langue dynamique vérifiera le type lors de l'exécution, en choisissant l'une des fonctions d'ajout en fonction des types (pliez des entiers ou des flotteurs ou de coller les chaînes ou, peut-être des listes?) Ou vous devez décider quelle erreur s'est produite et les types ne sont pas utilisés. correspondre les uns aux autres. Tous ces chèques occupent l'heure. Dans les langues dynamiques, différentes astuces sont utilisées pour optimiser, telles que la compilation JIT (juste-heure), dans laquelle le code sera recompanté lors de la réalisation de toutes les informations nécessaires sur les types d'informations. Cependant, aucune langue dynamique ne peut être comparée à des vitesses avec un code statique écrit de manière informe dans la langue comme la rouille.

Arguments en faveur des types statiques et dynamiques

Les supporters du système de type statique indiquent que, sans type de types, des erreurs simples peuvent entraîner des problèmes de production. Ceci, bien sûr, est vrai. Quiconque a utilisé une langue dynamique l'expérimentée.

Les partisans des langues dynamiques indiquent que dans de telles langues, il semble qu'il est plus facile d'écrire du code. Ceci est définitivement juste pour certains types de code, que nous écrivons de temps en temps, comme, par exemple, le code avec eval. Il s'agit d'une solution controversée pour le travail régulier et il est logique de rappeler le mot incertain "facilement". Rich Hicks a parfaitement parlé du mot "facilement" et sa connexion avec le mot "simplement". Après avoir vu ce rapport, vous comprendrez qu'il n'est pas facile d'utiliser le mot «facile». Fuck "facilité".

Les avantages et les inconvénients de systèmes de caractérisation statique et dynamique sont toujours mal étudiés, mais ils dépendent définitivement de la langue et de la tâche spécifique résolue.

JavaScript essaie de continuer à travailler, même si cela signifie une conversion sans signification (comme "A" + 1, donnant "A1"). Python à son tour tente d'être conservateur et retourne souvent des erreurs, comme dans le cas de "A" + 1.

Il existe différentes approches avec différents niveaux de sécurité, mais python et JavaScript sont tous deux typés de manière dynamique des langues.

Haskell ne permettra pas l'ajout d'entier et de flotter sans conversion explicite avant cela. Si et Haskell sont tous deux typés statiquement, malgré de telles différences.

Il existe de nombreuses variantes de langues dynamiques et statiques. Toute déclaration inconditionnelle du type "Langues statiques est meilleure que dynamique en matière de X" est presque garantie. Cela peut être vrai dans le cas de langues spécifiques, mais il vaut mieux dire «Haskell est meilleur que Python quand il s'agit de X».

Une variété de systèmes de dactylographie statiques

Jetons un coup d'œil aux deux exemples célèbres de langues typées statiquement: Go et Haskell. Dans le système de pointe, Go n'a pas de types généralisés, types avec des "paramètres" d'autres types. Par exemple, vous pouvez créer votre propre type pour les listes de myList, qui peuvent stocker toutes les données dont nous avons besoin. Nous voulons pouvoir créer des entiers mylist, des chaînes de myList et ainsi de suite, sans changer le code source de la myiste. Le compilateur doit suivre la dactylographie: s'il y a des entiers myList, nous ajouterons accidentellement une chaîne là-bas, le compilateur doit rejeter le programme.

Go a été spécialement conçu de manière à ce qu'il soit impossible de définir les types comme la mylist. La meilleure chose à faire est possible de créer une myList "interfaces vides": la myList peut contenir des objets, mais le compilateur ne connaît tout simplement pas leur type. Lorsque nous obtenons des objets de MyList, nous devons dire au compilateur de leur type. Si nous disons "je vais obtenir la chaîne", mais en réalité, la valeur est un nombre, alors il y aura une erreur d'exécution, comme dans le cas des langues dynamiques.

Il existe également de nombreuses autres caractéristiques présentes dans les langues modernes statiquement (ou même dans certains des années 1970). Les créateurs de The Go avaient leurs propres raisons pour ces solutions, mais l'opinion des personnes de la part de cette occasion peut parfois sembler sonner fortement.

Comparons maintenant avec Haskell, qui a un système de type très puissant. Si vous spécifiez le type de myList, le type de "liste des chiffres" est juste un entier myList. Haskell ne nous donnera aucune chance d'ajouter une chaîne à la liste et assurez-vous que nous ne mettrons pas un élément de la liste dans la variable de chaîne.

Haskell peut exprimer directement des idées beaucoup plus complexes par des types. Par exemple, num a \u003d\u003e myList a signifie "valeurs myList qui concernent un type de chiffres". Cela peut être une liste d'entier "OB, flotteur" OB ou de nombres décimaux avec une précision fixe, mais cela ne sera certainement jamais une liste de lignes, qui est vérifiée lors de la compilation.

Vous pouvez écrire la fonction Ajouter avec tous les types numériques. Cette fonctionnalité sera le type num A \u003d\u003e (A -\u003e A -\u003e A). Ça veut dire:

a peut être n'importe quel type numérique (num A \u003d\u003e).
La fonction prend deux arguments de type A et de retour de type A (A -\u003e A -\u003e A).

Le dernier exemple. Si le type de fonction est String -\u003e String, il prend la chaîne et renvoie la chaîne. Mais s'il s'agit de string -\u003e String io, il rend également une sorte d'entrée / de sortie. Il peut y accéder au disque sur le réseau, à lire du terminal, et ainsi de suite.

Si la fonction est dans le type ne pas Io, nous savons que cela ne fait aucune opération d'E / S. Dans l'application Web, par exemple, vous pouvez comprendre si la fonction de la base de données change simplement en regardant son type. Pas de dynamique et presque pas de langues statiques sur tel. Il s'agit d'une fonctionnalité de langues avec le système de frappe le plus puissant.

Dans la plupart des langues, nous devrions gérer la fonction et toutes les fonctions qui sont appelées à partir de là, etc., en essayant de trouver quelque chose qui change la base de données. C'est un processus fastidieux dans lequel il est facile de permettre une erreur. Et le système de type Haskell peut répondre à cette question simplement et garantis.

Comparez cette puissance avec Go, qui n'est pas capable d'exprimer une simple idée de la myiste, de ne pas mentionner la "fonction qui prend deux arguments et qu'ils sont à la fois numériques et un type, et qui rend l'entrée / la sortie".

L'approche Go simplifie les outils d'écriture de programmation à partir (en particulier, la mise en œuvre du compilateur peut être simple). De plus, il est nécessaire d'apprendre moins de concepts. Comment ces avantages sont comparables avec des restrictions significatives - une question subjective. Cependant, il est impossible de faire valoir que Haskell est plus difficile à explorer que d'aller et que le type de type de haskell est beaucoup plus puissant et que Haskell peut empêcher beaucoup plus de types de bogues lors de la compilation.

Go et Haskell sont des langues si différentes que leur regroupement dans une classe de "langues statiques" peut être trompeuse, malgré le fait que le terme est utilisé correctement. Si vous comparez les avantages pratiques de la sécurité, demandez-vous ensuite des langues dynamiques que de HASKELL »Y.

D'autre part, certaines langues dynamiques sont plus sûres que certaines langues statiques. (Python dans son ensemble est considéré comme beaucoup plus sûr que c). Lorsque je veux généraliser des langues statiques ou dynamiques en tant que groupes, n'oubliez pas d'énormes différences entre les langues.

Exemples spécifiques de différences dans les possibilités des systèmes de frappe

Dans des systèmes de frappe plus puissants, vous pouvez spécifier des restrictions sur des niveaux plus petits. Voici quelques exemples, mais ne vous habitez pas sur eux si la syntaxe est incompréhensible.

En allez, vous pouvez dire «la fonction Ajouter une opération prend deux entiers» A et Retour entier »:

Func Ajouter (x int, y int) int (retour x + y)

À Haskell, vous pouvez dire "la fonction prend quelconque Type numérique et renvoie le numéro du même type ":

F :: Num a \u003d\u003e A -\u003e A -\u003e A Ajouter x y \u003d x + y

Dans Idris, vous pouvez dire "la fonction prend deux entiers" et retourne entier, mais le premier argument devrait être inférieur au deuxième argument ":

Ajouter: (x: NAT) -\u003e (Y: NAT) -\u003e (automobile plus petit: lt x y) -\u003e NAT Ajouter x y \u003d x + y

Si vous essayez d'appeler la fonction Ajouter 2 1, où le premier argument est supérieur au second, le compilateur rejetera le programme. pendant la compilation. Il est impossible d'écrire un programme dans lequel le premier argument est supérieur à la seconde. Une langue rare a une telle opportunité. Dans la plupart des langues, ce test survient lors de l'exécution: nous écrirons quelque chose comme si x\u003e \u003d y: augmente quelqueerror ().

Dans HASKELL, il n'y a pas d'équivalent à un tel type que dans l'exemple avec Idris ci-dessus et il n'y a pas d'équivalent pour expérimenter Haskell ou un exemple avec Idris. En conséquence, IDRIS peut empêcher de nombreux bugs qui ne pourront pas prévenir Haskell et Haskell pourra empêcher de nombreux bugs qui vont remarquer. Dans les deux cas, des caractéristiques supplémentaires du système de frappe sont nécessaires, ce qui rendra la langue plus compliquée.

Systèmes de taper des langues statiques

Voici une liste approximative des systèmes de taper certaines langues dans la puissance croissante. Cette liste vous donnera une idée générale du pouvoir des systèmes, vous n'avez pas besoin de le traiter comme une vérité absolue. Les langues collectées dans un groupe peuvent différer beaucoup les unes des autres. Chaque système de caractérisation a ses propres problèmes et la plupart d'entre eux sont très complexes.

C (1972), allez (2009): Ces systèmes ne sont pas du tout puissants, sans le soutien des types généralisés. Il est impossible de définir le type de mychiste, ce qui signifierait la "liste des entiers", "Liste des chaînes", etc. Au lieu de cela, vous devrez faire une "liste de valeurs non ambiguës". Un programmeur doit signaler manuellement "Cette liste de liste" chaque fois que la chaîne est extraite de la liste, ce qui peut entraîner une erreur lors de l'exécution.
Java (1995), C # (2000): Les deux langues soutiennent des types généralisés, afin que vous puissiez dire myList Et obtenir une liste de lignes sur lesquelles le compilateur sait et peut surveiller l'observance des types de types. Les éléments de la liste auront le type de chaîne, le compilateur forcera les règles lors de la compilation de l'habitude, de sorte que les erreurs sont moins probables.
Haskell (1990), Rust (2010), Swift (2014): Toutes ces langues ont plusieurs fonctionnalités avancées, notamment des types généralisés, des types de données algébriques (ADTS) et des types de types ou de quelque chose de similaire (types de classes, caractéristiques (traits) et protocoles, respectivement). La rouille et Swift sont plus populaires que Haskell, et les grandes organisations sont promues (Mozilla et Apple, respectivement).
AGDA (2007), IDRIS (2011): Ces langues prennent en charge les types dépendants, vous permettant de créer des types comme "une fonction qui prend deux entiers x et y, où y est supérieur à X". Même la limite "y est supérieure à x" est forcée lors de la compilation. Lorsque vous effectuez Y, il ne sera jamais inférieur ou égal à X, tout ce qui se passe. Très subtil, mais des propriétés importantes du système peuvent être vérifiées de manière statique dans ces langues. Ils étudient très peu de programmeurs, mais ces langues provoquent leur énorme enthousiasme.

Il existe un mouvement clair vers des systèmes de caractérisation plus puissants, surtout si vous jugez la popularité des langues et non par le simple fait de l'existence de langues. Une exception bien connue est allée, ce qui explique pourquoi de nombreux partisans de langues statiques considèrent comme un recul.

Les deux groupes (Java et C #) sont des langues grandes, matures et largement utilisées.

Le groupe trois est sur le point d'entrer dans le courant dominant, avec un grand soutien de Mozilla (Rust) et de Pomme (Swift).

Le groupe quatre (Idris et AGDA) est loin du courant dominant, mais cela peut changer avec le temps. Les langues du groupe trois étaient loin du grand public il y a dix ans.

Cette page est invitée à combiner avec

Explication des raisons et discussions - Sur la page Wikipedia: à Union / 28 octobre 2009.
La discussion dure une semaine (ou plus si elle va lentement).
Date de discussion - 28 octobre 2009..
Si la discussion n'est pas requise (cas évidente), utilisez d'autres modèles.

Caractérisation stricte - L'une des options de travail avec des types de données, utilisées dans les langages de programmation.

La frappe stricte implique les conditions obligatoires suivantes:

Tout objet de données (variable, constante, expression) dans la langue a toujours un type strictement défini qui est fixé au moment de la compilation du programme (typographie statique) ou est déterminé lors de l'exécution (dactylographie dynamique).
Il est autorisé à attribuer une variable qu'une valeur comportant strictement le même type de données que la variable, les mêmes limitations s'appliquent aux paramètres de transmission et à renvoyer les résultats des fonctions.
Chaque opération nécessite les paramètres de types strictement définis.
La conversion de type implicite n'est pas autorisée (c'est-à-dire que le traducteur perçoit toute tentative d'utilisation de la valeur du type incorrect décrit pour une variable, un paramètre, des fonctions ou une opération, comme une erreur de syntaxe).

Avec avec précision, les exigences de la frappe stricte, même les mêmes quantités de valeurs et de types de données admissibles sont incompatibles. Si le programme doit attribuer une valeur d'un type de variable d'un autre type, cela peut être effectué, mais uniquement en appliquant explicitement une opération de transformation de type spéciale, ce qui fait généralement partie du langage de programmation (bien que cela ne soit pas possible. formellement, et fourni par des bibliothèques standard).

Le seul langage de programmation pratiquement utilisé avec une dactylographie stricte est l'enfer. Un nombre assez important de langages de programmation communs utilise une typographie statique non statique. Ces langues incluent, par exemple Pascal, Module-2, Java. Ils sont sûrs de décrire les types de variables, paramètres et fonctions, mais les types de types implicites sont autorisés - si la valeur d'un type est attribuée à la variable de l'autre, le compilateur génère automatiquement le code pour convertir la valeur à la valeur souhaitée. Tapez si seulement une telle conversion entraîne une perte de données. Par exemple, un entier peut être attribué par une variable déclarée sous forme de numéro de point flottant, et l'attribution inverse sans clarification de type explicite est interdite, car avec une probabilité élevée entraînera une erreur. Certaines langues ayant officiellement le concept de type de données, peuvent être considérées comme une inépite. Ces langues incluent classique C, dans laquelle, bien que la déclaration de types est requise, dans la réalité, tous les types de données sont une affectation compatible (compilations C modernes C limite cette liberté et la question au moins des avertissements avec des types de types dangereux).

Dans la théorie de la programmation, la frappe stricte est un élément indispensable d'assurer la fiabilité des logiciels développés. Avec une utilisation correcte (implicite que le programme est annoncé et distincte des types de données pour des valeurs logiquement incompatibles), il protège le programmeur des erreurs simples, mais difficiles associées au partage de valeurs logiquement incompatibles qui se produisent parfois simplement en raison de l'horloge élémentaire. De telles erreurs sont révélées au stade de la compilation du programme, alors que la capacité d'apporter implicitement presque tous les types les uns aux autres (comme par exemple, dans le SI classique), ces erreurs ne sont détectées que lorsque des tests, et tout n'est pas immédiatement. D'autre part, de nombreux programmeurs professionnels n'aiment pas la typisation stricte en raison de son inconvénient - il augmente le volume du programme et le temps de sa rédaction nécessite une étude plus approfondie du code, qui semble inutile.

Version brève version

Les langages de programmation de typisation sont de coutumes pour se diviser en deux grands camps - les types et néipelays (de base). Pour la première fois, par exemple, C, Python, Scala, PHP et Lua incluent, et la seconde est la langue d'assembleur, en avant et en brainfuck.

Statique / dynamique Caractérisation. La statique est déterminée par le fait que les types finaux de variables et fonctions sont définis au stade de la compilation. Ceux. Déjà, le compilateur est sûr à 100% du type où se trouve. En tapant dynamique, tous les types sont déjà trouvés lors de l'exécution du programme.
Exemples:
Statique: c, java, c #;
Dynamique: Python, JavaScript, Ruby.
Fort / faible Caractérisation (aussi disait parfois strict / non-ARC). Un fort typage est attribué par le fait que la langue ne vous permet pas de mélanger différents types d'expressions et ne convertit pas automatiquement les conversions implicites, par exemple, vous ne pouvez pas déduire de l'ensemble de cordes. Les langues avec une typisation faible Effectuez une variété de transformations implicites automatiquement, même si la perte de précision ou la conversion peut survenir dans les ambiguïtés.
Exemples:
Fort: Java, Python, Haskell, Lisp;
Faible: C, JavaScript, Visual Basic, PHP.
Explicite / non fait Caractérisation. Les langues dactylographiées explicites se distinguent par le fait que le type de nouvelles variables / fonctions / leurs arguments doit être spécifié explicitement. En conséquence, des langues avec une typisation implicite décalent cette tâche sur le compilateur / interprète.
Exemples:
Explicit: C ++, D, C #
Implicite: php, lua, javascript

Cependant, pas moins que des langues provenant de tyistations statiques et dynamiques en même temps. Bien que prospère, je dirai que je suis ici, ils existent vraiment, mais à ce sujet plus tard.

Version détaillée

Caractérisation de base

Dans les langages de programmation à boutons - toutes les entités sont considérées comme des séquences de bits simplement, des longueurs différentes.

Avantages

Vous permet d'écrire sur un niveau minimum maximum, et le compilateur / interprète n'interférera pas avec aucun type de types. Vous êtes libre de produire des opérations sur tous les types de données.
Le code résultant est généralement plus efficace.
Transparence des instructions. Avec la connaissance de la langue, il ne fait aucun doute que l'un ou l'autre code représente.

désavantages

Complexité. Il est souvent nécessaire de présenter des valeurs complètes, telles que des listes, des lignes ou des structures. Il peut y avoir des inconvénients.
Pas de chèques. Toute action sans signification, telle que la soustraction d'un pointeur à un tableau du symbole, sera considérée comme complètement normale, qui est envahie par des erreurs d'emploi.
Faible abstraction. Travailler avec tout type de données complexe n'est pas différent de travailler avec des chiffres, c'est bien sûr créer beaucoup de difficultés.

Une optimisation forte de barbarie?

MOV CX, EAX; Temps d'assemblage d'erreur

Donc, il s'avère que la frappe toujours dans l'assemblé? Je crois que ces chèques ne suffisent pas. Et votre avis, bien sûr, ne dépend que sur vous.

Typage statique et dynamique

Trouvons-le.

Avantages de la typographie statique

Les chèques de type ne se produisent qu'une seule fois - à la phase de compilation. Et cela signifie que nous n'aurons pas besoin de savoir constamment si nous essayons de diviser le numéro sur la chaîne (et de donner l'erreur ou de transformer).
Vitesse de performance. Il ressort clairement du point précédent que les langues typées statiquement sont presque toujours plus rapides que dynamiquement dactylographiées.
Avec quelques conditions supplémentaires, il vous permet de détecter des erreurs potentielles au stade de la compilation.
Accélération du développement avec support IDE (options de tamisage, évidemment pas appropriée par type).

Avantages de la dactylographie dynamique

Facile à créer des collections universelles - un tas de tous et tout cela se pose rarement un tel besoin, mais lorsque la typographie dynamique se produit pour aider).
Facilité de décrire des algorithmes généralisés (par exemple, trier un tableau qui fonctionnera non seulement sur la liste des entiers, mais également sur la liste de réels et même sur la liste des lignes).
Facile dans le développement - Les langues de tylilation dynamique sont généralement très bonnes afin de commencer la programmation.

Programmation généralisée

Comment allons-nous le résoudre? Je le résolvez sur la 3ème langue différente: une avec dactylographie dactylographie et deux avec statique.

Solution dynamique (Python):
DEF Rechercher (requis_élément, liste): Pour (index, élément) en énumérant (liste): Si Element \u003d\u003d Obligatoire_Element: retour Index retour (-1)

Solution statique (c):
non signé int wind_int (intchrographement_element, intora, taille intégrée non signée) (pour (non signé INT I \u003d 0; i< size; ++i) if (required_element == array[i]) return i; return (-1); } unsigned int find_float(float required_element, float array, unsigned int size) { for (unsigned int i = 0; i < size; ++i) if (required_element == array[i]) return i; return (-1); } unsigned int find_char(char required_element, char array, unsigned int size) { for (unsigned int i = 0; i < size; ++i) if (required_element == array[i]) return i; return (-1); }

Eh bien, chaque fonction est individuellement similaire à la version de Python, mais pourquoi y a-t-il trois? Est-ce vraiment une programmation statique?

Solution statique (programmation généralisée, C ++):
Modèle. Sans signé int Recherche (t requis_element, std :: vecteur tableau) (pour non signé INT I \u003d 0; i< array.size(); ++i) if (required_element == array[i]) return i; return (-1); }

Cette version semble être exactement ce dont vous avez besoin - nous obtenons à la fois des plus de frappe statique et certains avantages sont dynamiques.

Statistiques en dynamique

Il est également nécessaire de mentionner que de nombreuses langues statiques vous permettent d'utiliser la dactylographie dynamique, par exemple:

C # prend en charge la dynamique pseudo-type.
F # prend en charge le sucre de syntaxe sous la forme d'un opérateur?, Sur la base de laquelle l'imitation de la typage dynamique peut être mise en œuvre.
Haskell - Le typage dynamique est fourni par le module Data.Dynamic.
Delphi - à travers un type spécial de variante.

En outre, certaines langues dactylographiées dynamiquement vous permettent de profiter de la typographie statique:

Lisp Common Lisp - Types Déclaration.
Perl - de la version 5.6, assez limitée.

Alors vas y?

Typisius fort et faible

Les langues avec une tape forte ne permettent pas de mélanger l'essence de différents types dans des expressions et n'effectuez aucune transformation automatique. Ils appellent également des "langues avec une frappe stricte". Tête anglaise pour cela - Typage fort.

Les langues faiblement définies, au contraire, en matières grasses, de sorte que le programmeur mélange différents types d'une expression et le compilateur lui-même résultera d'un seul type. Aussi, ils sont appelés "langues avec une typisation sans démarrage". Le terme anglais pour cela est faible en tapant.

La typisation faible est souvent confondue avec dynamique, ce qui est complètement incorrect. Une langue dactylographiée dynamiquement peut être faible et fortement typée.

La langue devrait avoir davantage de dactylographie. Et la vérité, si le compilateur au lieu d'un message d'erreur ajoutez simplement une ligne au numéro, ou ce qui est encore pire, la déduction d'un tableau est différente, quelle est l'utilisation de tous les "chèques" des types seront Au stade de la compilation? C'est vrai - la typographie statique faible est encore pire que la forte dynamique! (C'est mon avis)

Veut savoir quoi?

Avantages de la frappe forte

Fiabilité - vous obtiendrez une exception ou une erreur de compilation, au lieu de comportement incorrect.
Vitesse - Au lieu de transformations cachées pouvant être assez chères, il est nécessaire de les écrire clairement, ce qui entraîne un programmeur au moins de savoir que cette section du code peut être lente.
Comprendre le travail du programme - à nouveau, au lieu de types d'imprégnés, le programmeur écrit tout moi-même, ce qui signifie que signifie à peu près que la comparaison de la chaîne et le nombre ne se produit pas en soi.
NOTE - Lorsque vous écrivez la conversion manuellement, vous savez exactement ce que vous convertissez et quoi. Vous comprendrez également toujours que de telles transformations peuvent entraîner une perte de précision et des résultats incorrects.

Les avantages de la typographie faible

Facilité d'utilisation d'expressions mixtes (par exemple, des entiers et des nombres réels).
Abstraction de taper et de se concentrer sur la tâche.
Brève enregistrement.

D'accord, nous avons compris, il s'avère avoir une caractéristique faible, il y a aussi des avantages! Y a-t-il des moyens de déplacer les avantages de la faiblesse de la caractérisation?

Il s'avère que même deux.

Clarification implicite des types, dans des situations non ambiguës et sans perte de données

Wow ... assez longtemps. Permettez-moi de continuer à le réduire à la "transformation implicite limitée", alors que signifie la situation sans ambiguïté et la perte de données?