Share
Dans cette série, nous nous penchons pour le débutant sur les langages à typage dynamique (ou faiblement typés) et sur la manière dont leur manque de typage puissant peut avoir un impact positif et négatif sur notre programmation..
Comme mentionné dans le premier article, cette série est spécifiquement destinée aux débutants ou à ceux qui n'ont pas beaucoup d'expérience avec les langues faiblement typées. Autrement dit, si vous programmez à la fois dans des langages fortement typés et / ou faiblement typés et que vous êtes familiarisé avec la contrainte de type et les pièges pouvant survenir lors de certaines opérations, cette série risque de ne pas vous intéresser beaucoup.
D'un autre côté, si vous êtes un débutant dans l'écriture de code ou que vous entrez dans une langue typée de manière dynamique à partir d'une autre langue, cette série s'adresse spécifiquement à vous. En fin de compte, l’objectif est de définir la contrainte de type, de montrer son fonctionnement, puis d’en examiner les pièges..
Selon Wikipédia, la contrainte est définie comme suit:
En informatique, la conversion de types, la conversion de types et la contrainte sont deux manières différentes, implicites ou explicites, de transformer une entité d'un type de données en un autre..
Ou peut-être d'une manière plus simple, vous pouvez définir ceci comme comment vous prenez un type de données et le convertissez en un autre. Le problème, c’est qu’il ya une ligne de démarcation entre conversion et contrainte.
En règle générale, j'ai tendance à penser à coercition comment un interprète ou un compilateur détermine le type de comparaison à effectuer, alors que conversion est un changement de type explicite que nous, en tant que programmeur, écrivons dans notre code.
Regardons cela plus en détail.
Disons, par exemple, que vous avez une chaîne nommée Exemple et sa valeur est '5'. Dans les langues statiquement typées, vous pouvez transtyper cette valeur avec la valeur de la chaîne et la convertir en int à travers un certain nombre de méthodes différentes.
Supposons que nous avons un Entier objet avec un analyse méthode. La méthode accepte une chaîne et renvoie la valeur de la chaîne dans le type de données entier. Le code pour le faire peut ressembler à quelque chose comme ceci:
exemple de chaîne = '5'; Integer myInt = new Integer (); int intExample = myInt.parseInt (exemple); / * intExample a maintenant la valeur 5 (pas '5') * et l'exemple fait toujours référence à la chaîne '5' * /
Bien entendu, la syntaxe variera d’une langue à l’autre, et il existe sont autres façons de convertir une valeur, mais cela vous donne une idée de la manière de convertir explicitement un type en un autre.
Une autre façon de procéder consiste à utiliser un opérateur de transtypage. Bien que la mise en œuvre de l'opération varie d'une langue à l'autre, la plupart des programmeurs qui ont travaillé avec des langages de style C le reconnaîtront probablement comme suit:
int myInt = (int) exemple;
En règle générale, le transtypage est généralement effectué en plaçant le type en lequel vous souhaitez convertir la variable entre parenthèses avant la variable elle-même. Dans l'exemple ci-dessus, myInt contiendra maintenant 5, plutôt que '5' et Exemple tiendra toujours '5'.
Comme indiqué, c'est quelque chose qui se fait normalement dans le contexte des langages compilés
Cela laisse encore la question de savoir comment la contrainte de type diffère de la conversion de type. Bien que la contrainte pouvez se produire dans des langages compilés, il est plus probable que cela se produise dans des langages interprétés ou dans des langages à typage dynamique.
En outre, il est plus que probable que la coercition de caractères se produise chaque fois qu'une comparaison est effectuée entre des objets de types différents ou lorsqu'une opération ou une évaluation est effectuée avec des variables de types différents..
Par exemple, supposons qu'en JavaScript nous avons deux variables - Le nom de, iAge - où Le nom de fait référence au nom d'une personne et iAge fait référence à l'âge d'une personne. Les variables, à titre d'exemple, utilisent la notation hongroise simplement pour indiquer que l'une stocke une chaîne et l'autre un entier..
Notez que c'est ne pas un argument pour ou contre la notation hongroise - c'est un sujet pour un autre post. Il est utilisé ici pour indiquer clairement le type de valeur que chaque variable est stockée afin de faciliter le suivi du code..
Nous allons donc aller de l'avant et définir nos variables et leurs valeurs:
var sName = 'John Doe'; var iAge = 32;
Nous pouvons maintenant examiner quelques exemples de la manière dont la contrainte de type fonctionne dans le contexte d’un langage interprété. Voici deux exemples de fonctionnement de la contrainte de type:
Jetons un coup d'oeil à un exemple de chacun:
/ ** * La comparaison d'un nombre à un booléen * donnera la valeur booléenne * de 'false'. * / var result = iAge == true; / ** * Les chaînes de concaténation et les nombres * contraindront le nombre à une chaîne. * * "John Doe a 32 ans." * / var bio = sName + 'est' + iAge + 'ans.';
Ces exemples sont relativement simples. Le premier est logique car il est impossible de comparer un nombre à une valeur booléenne.
Dans le deuxième exemple, notez que nous prenons une chaîne, la concaténons avec un autre jeu de chaînes et utilisons également le nombre dans l'opération de concaténation. Dans ce cas, le nombre est converti en chaîne, puis concaténé avec le reste des mots..
Il s'agit d'un type de contrainte: lorsque vous prenez une variable d'un type et que vous convertissez sa valeur en un autre type lors de l'exécution d'une opération ou d'une évaluation.
Le fait est que ces deux exemples sont très simplistes. Examinons un peu plus pour montrer comment fonctionne la contrainte, du moins en JavaScript, lors de l'exécution d'opérations de concaténation:
var un, deux, résultat; // un et deux font référence aux valeurs de chaîne de '1' et '2' un = '1'; deux = '2'; // le résultat contiendra la chaîne '12'; résultat = un + deux; // redéfinir deux pour qu'ils soient égaux au nombre '2' deux = 2; // concaténer une chaîne et un nombre donne une chaîne // le résultat contiendra '12'; résultat = un + deux; // redéfinir un en tant que nombre un = 1; // ensuite concaténer (ou somme) les deux valeurs // résultat sera 3 result = un + deux
Il y a deux choses importantes à noter:
Accentsconagua
+ l'opérateur est surchargé. Cela signifie que lorsqu'il travaille avec des chaînes, il les enchaîne, mais lorsqu'il travaille avec des nombres, il les additionne.Pour aller plus loin dans l'exemple, ajoutons une autre variable, un ensemble d'opérations priorisé, puis examinons le résultat:
var un, deux, arbre, résultat; un = '1'; deux = 2; trois = 3; // résultat est '123' résultat = un + deux + trois; // résultat est '15' résultat = un + (deux + trois);
Remarque dans le deuxième exemple, deux et Trois sont ajoutée ensemble parce qu'ils sont les deux nombres et alors le résultat est concaténé avec un parce que c'est une ficelle.
Nous avons mentionné précédemment qu'il existe un cas particulier pour les nombres et les valeurs booléennes, du moins en JavaScript. Et comme c'est le langage que nous utilisons pour examiner la contrainte de type et que c'est un langage fréquemment utilisé dans le développement Web moderne, jetons un coup d'œil à.
Dans le cas de JavaScript, notez que 1 est considéré comme une valeur de "vérité" et 0 est concerné pour être une "falsey" valeur. Ces mots sont choisis comme tels car les valeurs peuvent servir de chiffres, mais seront également évalués pour vrai ou faux lors d'une comparaison.
Jetons un coup d'oeil à quelques exemples de base:
var bTrue, bFalse, iZero, iOne, résultat; bTrue = true; bFalse = false; iZero = 0; iOne = 1; // result contient la valeur booléenne de false result = bTrue == iZero; // result contient la valeur booléenne de true result = bTrue == iOne; // result contient la valeur booléenne de false result = bFalse == iOne; // result contient la valeur booléenne de true result = bFalse == iZero;
Notez que dans les exemples ci-dessus, les valeurs numériques sont contraint en valeurs entières par nature de la comparaison qui est faite.
Mais que se passe-t-il si nous comparons une valeur booléenne de vrai ou faux à une valeur de chaîne de un ou zéro?
var bTrue, bFalse, sTrue, sFalse, résultat; bTrue = true; bFalse = false; sTrue = '1'; sFalse = '0'; // résultat est vrai résultat = bTrue == sTrue; // résultat est faux résultat = bTrue == sFalse; // le résultat est faux; resultat = bFalse == sTrue; // le résultat est vrai result = bFalse == sFalse;
À ce stade, les choses peuvent commencer à devenir vraiment déroutantes parce que nous comparons une valeur de chaîne d'un nombre qui est 1 à une valeur booléenne de vrai et nous obtenons un résultat booléen, et le booléen est vrai.
Avoir un sens? Nous y reviendrons un peu plus en détail dans le prochain article, mais je voulais commencer par en présenter les bases..
C'est à ce moment que les langages à typage dynamique peuvent commencer à causer des maux de tête aux développeurs. Heureusement, il existe des moyens d'écrire du code plus strict que ce que nous avons précédemment et qui donne des résultats précis.
De plus, certains langages à typage dynamique contiennent également des valeurs pour indéfini et pour nul. Celles-ci maintiennent également des valeurs de "vérité" et de "falsey" qui, à leur tour, affectent la manière dont nous traitons les comparaisons.
Dans le dernier article de la série, nous allons examiner comment des valeurs telles que indéfini et nul comparez-les avec d'autres valeurs et comparez-les et examinez certaines stratégies que nous pouvons mettre en œuvre pour rendre notre code plus résistant aux contraintes de type incorrect et pour le rendre plus lisible.
S'il s'agit de votre première incursion dans des langues à typage dynamique ou du type coercition et que vous avez des questions, des commentaires ou des réactions, n'hésitez pas à laisser un commentaire dans le flux ci-dessous.!
