La sécurité de type signifie que le compilateur validera les types lors de la compilation et émettra une erreur si vous essayez d'affecter le type incorrect à une variable.
Quelques exemples simples:
// Fails, Trying to put an integer in a string
String one = 1;
// Also fails.
int foo = "bar";
Ceci s'applique également aux arguments de méthodes, puisque vous leur passez des types explicites:
int AddTwoNumbers(int a, int b)
{
return a + b;
}
Si j'ai essayé d'appeler ça en utilisant:
int Sum = AddTwoNumbers(5, "5");
Le compilateur émettrait une erreur car je passe une chaîne ("5") et attend un entier.
Dans un langage mal typé, tel que javascript, je peux effectuer les opérations suivantes:
function AddTwoNumbers(a, b)
{
return a + b;
}
si je l'appelle comme ça:
Sum = AddTwoNumbers(5, "5");
Javascript convertit automatiquement le 5 en chaîne et renvoie "55". Cela est dû au fait que javascript utilise le signe + pour la concaténation de chaînes. Pour le rendre sensible au type, vous devez faire quelque chose comme:
function AddTwoNumbers(a, b)
{
return Number(a) + Number(b);
}
Ou éventuellement:
function AddOnlyTwoNumbers(a, b)
{
if (isNaN(a) || isNaN(b))
return false;
return Number(a) + Number(b);
}
si je l'appelle comme ça:
Sum = AddTwoNumbers(5, " dogs");
Javascript convertit automatiquement le 5 en chaîne et les ajoute pour rendre "5 chiens".
Tous les langages dynamiques ne sont pas aussi tolérants que javascript (en fait, un langage dynamique n'implique pas implicitement un langage dessiné (voir Python)), certains d'entre eux vous donneront une erreur d'exécution lors de la conversion d'un type invalide.
Bien que pratique, il vous ouvre de nombreuses erreurs qui peuvent facilement être omises et identifiées uniquement en testant le programme en cours d'exécution. Personnellement, je préfère que mon compilateur me dise si j'ai commis cette erreur.
Revenons maintenant à C # ...
C # prend en charge une fonctionnalité de langage appelée covariance , cela signifie que vous pouvez remplacer un type de base par un type enfant sans générer d'erreur, par exemple:
public class Foo : Bar
{
}
Ici, j'ai créé une nouvelle classe (Foo) qui sous-classe Bar. Je peux maintenant créer une méthode:
void DoSomething(Bar myBar)
Et appelez-le en utilisant soit un Foo, soit un Bar comme argument, les deux fonctionneront sans provoquer d'erreur. Cela fonctionne car C # sait que toute classe enfant de Bar implémentera l'interface de Bar.
Cependant, vous ne pouvez pas faire l'inverse:
void DoSomething(Foo myFoo)
Dans cette situation, je ne peux pas transmettre Bar à cette méthode, car le compilateur ne sait pas que Bar implémente l'interface de Foo. En effet, une classe enfant peut (et sera généralement) très différente de la classe parent.
Bien sûr, maintenant je suis loin du fond de la question initiale, mais c'est tout bon de savoir :)
La sécurité de type ne doit pas être confondue avec le typage statique/dynamique ou le typage fort/faible.
Un langage de type sécurisé est un langage dans lequel les seules opérations que l'on peut exécuter sur des données sont celles qui sont tolérées par le type des données. Autrement dit, si vos données sont de type X et que X ne prend pas en charge l'opération y, le langage ne vous autorisera pas à exécuter y(X).
Cette définition ne définit pas de règles sur quand ceci est coché. Cela peut être à la compilation (typage statique) ou à l'exécution (typage dynamique), généralement par le biais d'exceptions. Cela peut être un peu des deux: certains langages statiquement typés vous permettent de convertir des données d’un type à un autre, et la validité des conversions doit être vérifiée au moment de l’exécution (imaginez que vous essayez de convertir une Object en Consumer - le compilateur n'a aucun moyen de savoir si c'est acceptable ou non).
La sécurité de type ne signifie pas nécessairement non plus fortement typée - certaines langues sont notoirement faiblement typées, mais on peut tout de même dire que le type est sans danger. Prenons le cas de Javascript, par exemple: son système de typage est aussi faible qu’il est, mais reste strictement défini. Il permet la diffusion automatique des données (par exemple, des chaînes en unités), mais dans le cadre de règles bien définies. À ma connaissance, il n’existe aucun cas où un programme Javascript se comportera de manière indéfinie, et si vous êtes assez malin (je ne le suis pas), vous devriez être capable de prédire ce qui se passera lors de la lecture du code Javascript.
C est un exemple de langage de programmation non typable: la lecture/écriture d’une valeur de tableau en dehors des limites du tableau a un comportement non défini par spécification . Il est impossible de prédire ce qui va arriver. C est une langue qui a un système de types, mais qui n’est pas sécurisée.
Beaucoup de réponses ici confondent la sécurité de type avec le typage statique et le typage dynamique. Un langage typé dynamiquement (comme Smalltalk) peut également être sûr pour le type.
Une réponse courte: une langue est considérée comme étant de type sûr si aucune opération ne conduit à un comportement indéfini. Beaucoup considèrent l'exigence de conversions de types explicites nécessaire pour qu'un langage soit strictement, car les conversions automatiques peuvent parfois conduire à des comportements bien définis mais inattendus/non intuitifs.
La sécurité de type n'est pas simplement une contrainte de temps de compilation, mais une contrainte run time . Je pense que même après tout ce temps, nous pouvons ajouter plus de clarté à cela.
Il existe 2 problèmes principaux liés à la sécurité de type. Mémoire ** et type de données (avec les opérations correspondantes).
Mémoire**
Une char nécessite généralement 1 octet par caractère ou 8 bits (dépend du langage, des caractères Unicode des magasins Java et C # nécessitant 16 bits) . Une int nécessite 4 octets ou 32 bits (généralement).
Visuellement:
char: |-|-|-|-|-|-|-|-|
int : |-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-|
Un langage de type safe ne permet pas à un int d'être inséré dans un caractère à run-time (cela devrait générer une sorte de conversion de classe ou une exception de mémoire insuffisante). Toutefois, dans un type de langage non sécurisé, vous écraseriez les données existantes dans 3 octets de mémoire adjacents supplémentaires.
int >> char:
|-|-|-|-|-|-|-|-| |?|?|?|?|?|?|?|?| |?|?|?|?|?|?|?|?| |?|?|?|?|?|?|?|?|
Dans le cas ci-dessus, les 3 octets à droite sont écrasés. Par conséquent, tous les pointeurs vers cette mémoire (par exemple, 3 caractères consécutifs) qui s'attendent à obtenir une valeur de caractère prévisible seront désormais remplis. Cela provoque un comportement undefined dans votre programme (ou pire, éventuellement dans d'autres programmes en fonction de la façon dont le système d'exploitation alloue de la mémoire - très peu probable de nos jours).
** Bien que ce premier problème ne concerne pas techniquement le type de données, le type de langage sûr le corrige de manière inhérente et décrit visuellement le problème à ceux qui ne sont pas au courant de l'apparence "d'allocation de mémoire".
Type de données
La question de type plus subtile et directe est où deux types de données utilisent la même allocation de mémoire. Prenez un int vs un unsigned int. Les deux sont 32 bits. (Il pourrait tout aussi bien s'agir d'un caractère [4] et d'un int, mais le problème le plus courant est uint vs. int).
|-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-|
|-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-| |-|-|-|-|-|-|-|-|
Un type de langage non sécurisé permet au programmeur de référencer une plage de 32 bits correctement allouée, mais lorsque la valeur d'un entier non signé est lue dans l'espace d'un entier (ou inversement), nous avons à nouveau un comportement undefined. Imaginez les problèmes que cela pourrait causer dans un programme bancaire:
"Mec! J'ai découvert 30 $ et maintenant il me reste 65 506 $ !!"
Bien sûr, les programmes bancaires utilisent des types de données beaucoup plus volumineux. ;) LOL!
Comme d'autres l'ont déjà souligné, le prochain problème concerne les opérations de calcul sur les types. Cela a déjà été suffisamment couvert.
Vitesse vs sécurité
La plupart des programmeurs d’aujourd’hui n’ont jamais à s’inquiéter de ce genre de chose à moins d’utiliser quelque chose comme C ou C++. Ces deux langages permettent aux programmeurs de violer facilement la sécurité de type au moment de l'exécution (référencement direct en mémoire) malgré les efforts déployés par les compilateurs pour réduire le risque au minimum. CEPENDANT, tout n’est pas mauvais.
Une des raisons pour lesquelles ces langages sont si rapides en calcul est qu'ils ne sont pas surchargés par la vérification de la compatibilité des types lors d'opérations d'exécution telles que, par exemple, Java. Ils supposent que le développeur est un bon être rationnel qui ne veut pas ajouter une chaîne et un int ensemble et pour cela, le développeur est récompensé par sa rapidité/efficacité.
Une explication d’une majeure en arts libéraux, et non d’une spécialité:
Lorsque les gens disent qu'une langue ou une fonction linguistique est digne de sécurité, cela signifie que la langue vous aidera à ne pas transmettre, par exemple, quelque chose qui n'est pas un entier à une logique qui attend un entier.
Par exemple, en C #, je définis une fonction comme suit:
void foo(int arg)
Le compilateur va alors m'empêcher de faire ceci:
// call foo
foo("hello world")
Dans d'autres langages, le compilateur ne m'arrêterait pas (ou il n'y en avait pas ...), donc la chaîne serait transmise à la logique et il se passerait probablement quelque chose de mal.
Tapez les langues sûres essayez d’attraper plus de choses au "moment de la compilation".
En revanche, avec les langages sécurisés, lorsque vous avez une chaîne telle que "123" et que vous souhaitez l'utiliser comme un int, vous devez écrire plus de code pour convertir la chaîne en int, ou lorsque vous avez comme 123 et que vous voulez l'utiliser dans un message du type "La réponse est 123", vous devez écrire plus de code pour le convertir/le convertir en chaîne.
Un langage de programmation qui respecte le type signifie les choses suivantes:
- Vous ne pouvez pas lire à partir de variables non initialisées
- Vous ne pouvez pas indexer les tableaux au-delà de leurs limites
- Vous ne pouvez pas effectuer de transtypages non vérifiés
Pour une meilleure compréhension, regardez la vidéo ci-dessous qui montre le code en type langage sûr (C #) et NON en langage sûr (javascript).
http://www.youtube.com/watch?v=Rlw_njQhkxw
Maintenant pour le long texte.
Le type de sécurité signifie éviter les erreurs de type. Une erreur de type se produit lorsque le type de données d'un type est affecté à un autre type, par exemple, et que nous obtenons des résultats indésirables.
Par exemple, JavaScript n'est pas un langage de type sécurisé. Dans le code ci-dessous, «num» est une variable numérique et «str» est une chaîne. Le javascript me permet de faire “num + str”, maintenant GUESS fera l’arithmétique ou la concaténation.
Maintenant, pour le code ci-dessous, les résultats sont «55», mais le point important est la confusion créée par le type d'opération qu'il va effectuer.
Cela se produit parce que javascript n'est pas un langage sûr. Cela permet de définir un type de données sur un autre type sans restrictions.
<script>
var num = 5; // numeric
var str = "5"; // string
var z = num + str; // arthimetic or concat ????
alert(z); // displays “55”
</script>
C # est un langage sans danger. Il ne permet pas d'affecter un type de données à un autre type de données. Le code ci-dessous n'autorise pas l'opérateur “+” sur différents types de données.
Type-safe signifie que, par programme, le type de données d'une variable, d'une valeur renvoyée ou d'un argument doit correspondre à un certain critère.
En pratique, cela signifie que 7 (un type entier) est différent de "7" (un caractère cité de type chaîne).
PHP, Javascript et d’autres langages de script dynamiques sont généralement faiblement typés, en ce sens qu’ils convertiront un (chaîne) "7" en un (entier) 7 si vous essayez d’ajouter "7" + 3, bien que parfois vous deviez le faire. explicitement (et Javascript utilise le caractère "+" pour la concaténation).
C/C++/Java ne comprendra pas cela ou concaténera le résultat en "73" à la place. La sécurité de type empêche ces types de bogues dans le code en rendant explicite l'exigence de type.
Le type de sécurité est très utile. La solution au "7" + 3 ci-dessus serait de taper cast (int) "7" + 3 (égal à 10).
Essayez cette explication sur ...
TypeSafe signifie que les variables sont vérifiées statiquement pour une affectation appropriée au moment de la compilation. Par exemple, consder une chaîne ou un entier. Ces deux types de données différents ne peuvent pas être affectés de manière croisée (vous ne pouvez pas affecter un entier à une chaîne ni affecter une chaîne à un entier).
Pour le comportement non-typé, considérez ceci:
object x = 89;
int y;
si vous essayez de faire ceci:
y = x;
le compilateur génère une erreur indiquant qu'il ne peut pas convertir un System.Object en Integer. Vous devez le faire explicitement. Une façon serait:
y = Convert.ToInt32( x );
L'affectation ci-dessus n'est pas typée. Une affectation dactylographiée est l'endroit où les types peuvent être directement assignés les uns aux autres.
Les collections non typées abondent dans ASP.NET (par exemple, les collections application, session et viewstate). La bonne nouvelle à propos de ces collections est que (en minimisant les considérations relatives à la gestion de plusieurs états de serveur), vous pouvez placer à peu près n'importe quel type de données dans l'une des trois collections. La mauvaise nouvelle: comme ces collections ne sont pas dactylographiées, vous devrez attribuer ces valeurs correctement lorsque vous les récupérerez.
Par exemple:
Session[ "x" ] = 34;
fonctionne bien. Mais pour réattribuer la valeur entière, vous devez:
int i = Convert.ToInt32( Session[ "x" ] );
Découvrez à propos des génériques comment ce service vous aide à implémenter facilement des collections typesafe.
C # est un langage typé mais recherchez des articles sur C # 4.0; des possibilités dynamiques intéressantes se profilent (est-ce une bonne chose que C # obtienne essentiellement Option Strict: Off ... nous verrons).
Type-Safe est un code qui accède uniquement aux emplacements de mémoire auxquels il est autorisé à accéder, et uniquement de manière bien définie et autorisée. Le code de sécurité de type ne peut pas exécuter d'opération sur un objet non valide pour cet objet. Les compilateurs de langage C # et VB.NET produisent toujours un code de type sûr, qui est vérifié comme étant de type lors de la compilation JIT.
Type-safe signifie que l'ensemble des valeurs pouvant être affectées à une variable de programme doit correspondre à des critères bien définis et testables. Les variables de type sûr conduisent à des programmes plus robustes, car les algorithmes qui manipulent les variables peuvent faire confiance au fait que la variable ne prendra qu’un ensemble de valeurs bien défini. Cette confiance garantit l'intégrité et la qualité des données et du programme.
Pour de nombreuses variables, l'ensemble des valeurs pouvant être affectées à une variable est défini au moment de l'écriture du programme. Par exemple, une variable appelée "couleur" peut être autorisée à prendre les valeurs "rouge", "vert" ou "bleu" et jamais aucune autre valeur. Pour d'autres variables, ces critères peuvent changer au moment de l'exécution. Par exemple, une variable appelée "couleur" peut uniquement prendre des valeurs dans la colonne "nom" d'un tableau "Couleurs" dans une base de données relationnelle, où "rouge," vert "et" bleu "sont trois valeurs. pour "nom" dans le tableau "Couleurs", mais une autre partie du programme informatique peut éventuellement être ajoutée à cette liste pendant l'exécution du programme et la variable peut prendre les nouvelles valeurs après leur ajout au tableau Couleurs .
De nombreux langages à caractère typé donnent l’illusion de "typage" en insistant sur la définition stricte des types pour les variables et en permettant uniquement à une variable de se voir attribuer des valeurs du même "type". Cette approche pose quelques problèmes. Par exemple, un programme peut avoir une variable "yearOfBirth" qui correspond à l'année de naissance d'une personne et il est tentant de le transtyper sous la forme d'un entier court. Cependant, ce n'est pas un entier court. Cette année, il s'agit d'un nombre inférieur à 2009 et supérieur à -10000. Cependant, cet ensemble augmente de 1 chaque année au fur et à mesure de l'exécution du programme. Faire de cela un "short int" n'est pas adéquat. Pour rendre cette variable compatible avec le type, vous avez besoin d’une fonction de validation au moment de l’exécution qui garantit que le nombre est toujours supérieur à -10000 et inférieur à l’année civile suivante. Aucun compilateur ne peut appliquer de tels critères, car ces critères sont toujours des caractéristiques uniques du domaine problématique.
Les langages utilisant le typage dynamique (ou typage de canard, ou typage de manifeste) tels que Perl, Python, Ruby, SQLite et Lua n'ont pas la notion de variables typées. Cela oblige le programmeur à écrire une routine de validation au moment de l’exécution pour chaque variable afin de s’assurer qu’elle est correcte ou d’endurer les conséquences d’exceptions d’exécution inexpliquées. D'après mon expérience, les programmeurs de langages à typage statique tels que C, C++, Java et C # sont souvent persuadés que les types définis statiquement sont tout ce dont ils ont besoin pour obtenir les avantages de la sécurité de type. Ce n'est tout simplement pas vrai pour de nombreux programmes informatiques utiles, et il est difficile de prédire si cela est vrai pour un programme informatique particulier.
Le long et le court .... Voulez-vous la sécurité du type? Si c'est le cas, écrivez des fonctions d'exécution pour vous assurer que, lorsqu'une valeur est affectée à une variable, celle-ci est conforme à des critères bien définis. L'inconvénient est que cela rend très difficile l'analyse de domaine pour la plupart des programmes informatiques car vous devez définir explicitement les critères de chaque variable de programme.
Concept:
Pour être très simple, Tapez Safe comme les significations, assurez-vous que le type de la variable doit être sûr comme
- aucun type de données incorrect, par exemple. ne peut pas enregistrer ou initialiser une variable de type chaîne avec un entier
- Les index hors limites ne sont pas accessibles
- Autoriser uniquement l'emplacement de mémoire spécifique
il s'agit donc de la sécurité des types de stockage en termes de variables.