Share
Pour ceux qui programment depuis très longtemps, vous avez probablement utilisé plusieurs langages de programmation. Étant donné le paysage logiciel actuel, il est également probable que vous ayez travaillé avec des langages fortement typés et des langages faiblement typés..
C'est-à-dire que vous avez travaillé dans des langages de programmation qui vous obligent à spécifier le type de données de vos variables, ce que vos fonctions renverront, etc., et vous avez travaillé dans des langages de programmation qui ne nécessite pas que vous définissiez explicitement cette information.
Si vous savez exactement de quoi je parle, les articles de cette série ne vous intéressent probablement pas; Cependant, si vous débutez dans la programmation ou si vous commencez à utiliser un nouveau langage typé de manière dynamique (ou faiblement typé), vous devez noter un certain nombre d'éléments intéressants en ce qui concerne l'utilisation de types de données..
Dans cette série, nous allons examiner les langages dynamiques, comment les variables sont définies, comment leurs types de données sont déduits et sont différents de leurs équivalents statiques, et comment éviter certains des principaux écueils liés à l'utilisation de ces langues.
Avant de nous pencher sur les pièges de la coercition de types et que vous êtes probablement confrontés à leurs pièges, il est important de comprendre ce que sont les types de données et leur différence entre les langages fortement typés et les langages dynamiquement typés.
De manière générale, il est plus probable que vous trouviez des langages fortement typés dans la famille des langages de programmation compilés. Cela inclut des langues comme C et C++.
Cependant, là sont exceptions.
Certaines langues sont compilées sous une forme de bytecode ou d'un type de langue intermédiaire et sont ensuite traitées par un interprète. Java est l'un de ces langages. Ces langues sont fortement typées. Ils sont également compilés. Mais ils ne sont pas nécessairement compilés dans des exécutables binaires, mais des codes octets interprétés par un logiciel tiers..
Je sais que cela semble un peu déroutant, alors peut-être qu'un code aidera à clarifier cela. Dans les langages fortement typés, vous déclarez toujours le type de données qu'une variable va représenter.
Par exemple:
string example = "Le renard brun rapide saute par-dessus le chien paresseux."; int nombre = 42; double caisse = 99,99; booléen existe = vrai;
Bien que le code soit suffisamment simple pour être explicite, remarquez qu'il indique des variables contenant des chaînes, des types numériques et des valeurs booléennes..
Dans les langues fortement typées, vous devez également indiquer le type d'informations renvoyé par une fonction. Prenons les exemples suivants:
chaîne publique getGreeting () return "Hello world!"; public boolean isAlive () return true; public void doQuelque chose () pour (int i = 0; i < 10; i++ ) // Perform something
Notez que dans l'exemple ci-dessus, la fonction finale a un type de retour de vide. Cela signifie que la fonction ne revient pas n'importe quoi. Quand nous commencerons à regarder les langages dynamiques, nous verrons en quoi cela diffère.
Évidemment, ces méthodes sont extrêmement simples, mais elles sont suffisantes pour faire valoir un point: les langages fortement typés ont des variables et des fonctions dont le type de données est défini explicitement.
En ce qui concerne les langages à typage dynamique, il est possible de définir des variables et de créer des fonctions avec un certain luxe..
Dans les exemples précédents, la variable Exemple ne peut tenir qu'un chaîne. Cela signifie qu'il ne peut contenir un nombre à virgule flottante ou une valeur booléenne - cela doit tenir une ficelle. Dans les langages à typage dynamique, ce n'est pas le cas.
Au lieu de cela, les variables peuvent faire référence à une chaîne en un point du cycle de vie du programme, un entier en un autre point et une valeur booléenne en un autre point. Bien sûr, cela peut être déroutant si certaines normes de codage ne sont pas adoptées, mais cela dépasse le cadre de ce point..
Le fait est que les variables définies dans des langages à typage dynamique peuvent faire référence à différents types de données via l'exécution d'un programme..
Par exemple:
var exemple; example = "Le renard brun rapide saute par-dessus le chien paresseux."; exemple = 42; exemple = 99.99; exemple = vrai;
Notez que ces variables n'ont pas de type de données - elles sont simplement déclarées comme type var et sont ensuite définies selon les besoins. Certaines langues définissent les variables différemment de ce que vous voyez ci-dessus, mais il ne s'agit pas de montrer comment une langue le fait par rapport à l'autre. C'est pour montrer que les variables ne font simplement pas référence à un type de données spécifique.
Les fonctions fonctionnent de la même manière. C'est-à-dire que, plutôt que de définir le type de retour des données, vous définissez simplement la fonction et lui faites renvoyer une valeur..
function getGreeting () return "Bonjour le monde!"; function isAlive () return true; function doQuelque chose () pour (var i = 0; i < 10; i++ ) // Perform something
De nouveau, différentes langues nécessiteront que les fonctions soient définies de différentes manières (par exemple, certaines langues n’utilisent pas la une fonction mot-clé mais utilisez plutôt le def mot-clé), mais l'essentiel est qu'il n'est pas nécessaire d'indiquer explicitement le type de données qui sera renvoyé par la fonction.
Cela peut être un outil vraiment puissant. Cependant, il peut également être difficile de lire le code, de comprendre ce que retournera la fonction et / ou de configurer le code externe pour appeler les fonctions (comme dans le cas de comparaisons, de conditionnelles, etc.). sur).
C'est pourquoi les normes de codage et les conventions de dénomination claires sont importantes. Encore une fois, cependant, c'est un sujet qui sort du cadre de cette série.
Maintenant que nous avons rapidement examiné la façon dont les langages fortement typés et les langages dynamiquement typés gèrent les variables, les fonctions et les types de données en général, nous pouvons maintenant nous intéresser au fonctionnement de la contrainte de type dans le contexte plus large des applications écrites de manière dynamique. langues tapées.
Plus précisément, nous examinons comment nous pouvons utiliser les performances à notre avantage et comment introduire éventuellement des bogues en évitant d’être explicitement clairs dans notre code. Donc, à partir du prochain article, nous allons faire exactement cela.
En attendant, veuillez ajouter tous les commentaires, questions et commentaires généraux au flux ci-dessous.!
Accentsconagua