Introduction
Lorsque vous écrivez des programmes, vous utilisez les types de données pour classer les données. Les types de données indiquent à l’ordinateur comment traiter les données dans votre programme. Ils déterminent également ce que vous pouvez faire avec les données, y compris les opérations que vous pouvez effectuer.
Une manière de comprendre les types de données est de considérer les différents types de données que nous utilisons dans le monde réel. Par exemple, nous utilisons des nombres entiers (0, 1, 2, …), des entiers (…, -1, 0, 1, …), et des nombres irrationnels (π).
En général, en mathématiques, nous pouvons combiner des nombres de types différents et obtenir une sorte de réponse. Par exemple, nous pouvons vouloir ajouter 5 à π :
5 + π
Nous pouvons soit garder l’équation comme réponse pour prendre en compte le nombre irrationnel, soit arrondir π à un nombre avec un nombre limité de décimales, puis additionner les nombres ensemble :
5 + π = 5 + 3.14 = 8.14
Mais si nous essayons d’évaluer des nombres avec un autre type de données, comme des mots, les choses commencent à perdre leur sens. Comment résoudrions-nous l’équation suivante ?
sky + 8
Ce n’est pas quelque chose que nous savons immédiatement comment résoudre. L’ordinateur ne le peut pas non plus car les données sont de deux types différents. « Sky » est un mot, et 8 est un nombre entier. Lorsque nous écrivons des programmes, nous devons faire attention à la manière dont nous attribuons des valeurs et comment nous les manipulons à travers des opérations telles que l’addition, la soustraction, la multiplication et d’autres.
Dans ce tutoriel, vous apprendrez les types de données les plus importants natifs à Ruby : entiers, flottants, chaînes de caractères, symboles, tableaux et hachages. Il ne s’agit pas d’une enquête exhaustive sur les types de données, mais cela vous aidera à vous familiariser avec les options disponibles dans vos programmes.
Vous explorerez ensuite la typage dynamique. Les programmes Ruby déterminent les types de données en fonction de ce que contiennent les variables, comprendre comment fonctionne le typage dynamique vous aidera à éviter des situations délicates dans vos propres programmes. Et comme les variables peuvent contenir n’importe quelle valeur, vous apprendrez à identifier le type de données d’une variable.
Commençons par voir comment travailler avec des nombres entiers en Ruby.
Entiers
Comme en mathématiques, les entiers en programmation informatique sont des nombres entiers qui peuvent être positifs, négatifs ou nuls (…, -1, 0, 1, …). Un entier est également couramment appelé un int.
Vous pouvez afficher un entier comme ceci :
print -25
Output-25
Vous pouvez également stocker l’entier dans une variable et ensuite imprimer la valeur en référençant la variable :
my_int = -25
print my_int
Output-25
Vous pouvez également effectuer des opérations mathématiques avec des entiers. Par exemple, vous pouvez calculer la somme de deux nombres et imprimer le résultat :
sum = 116 - 68
print sum
Output48
Lorsque nous écrivons des nombres plus grands, nous avons tendance à utiliser des virgules pour les rendre plus lisibles. Par exemple, nous écririons 1,000,000 pour « un million ». Vous ne pouvez pas utiliser de virgules dans votre code, mais Ruby vous permet d’utiliser le caractère souligné (_) pour rendre les grands nombres plus lisibles.
Essayez-le :
large_number = 1_234_567
print large_number
Vous verrez l’entier imprimé sans les soulignés :
Output1234567
Les soulignés vous permettent d’écrire un code plus lisible si vous devez représenter de grands nombres dans vos programmes.
En apprenant davantage sur le langage Ruby, vous aurez de nombreuses occasions de travailler avec des entiers. Regardons comment travailler avec nombres réels.
Nombres à virgule flottante
A floating-point number or a float represents a real number. Real numbers can be either a rational or an irrational number; numbers that contain a fractional part, such as 9.0 or -116.42. In other words, a float in a Ruby program is a number that contains a decimal point.
Vous pouvez imprimer des flottants en Ruby de la même manière que vous imprimez des entiers :
print 17.3
Output17.3
Vous pouvez également déclarer une variable et lui attribuer un flottant :
my_float = 17.3
print my_float
Output17.3
Et, tout comme avec les entiers, vous pouvez effectuer des opérations mathématiques avec les flottants en Ruby :
sum = 564.0 + 365.24
print sum
Output929.24
Si vous ajoutez un flottant à un entier en Ruby, vous obtiendrez un flottant :
sum = 564 + 365.24
print sum
Output929.24
Ruby considérera tout nombre écrit sans décimales comme un entier (comme dans 138) et tout nombre écrit avec des décimales comme un flottant (comme dans 138.0).
Ensuite, regardons les booléens en Ruby.
Types de données booléens
Les booléens sont utilisés pour représenter les valeurs de vérité associées à la branche logique des mathématiques, qui informe les algorithmes en informatique. En Ruby, nous représentons ce type de données avec l’une des deux valeurs, soit true soit false.
De nombreuses opérations en mathématiques nous donnent des réponses qui s’évaluent soit à vrai, soit à faux :
- plus grand que
- 500 > 100
true - 1 > 5
false - moins que
- 200 < 400
true - 4 < 2
false - égal
- 5 = 5
true - 500 = 400
false
Comme avec les nombres, vous pouvez stocker une valeur true ou false dans une variable :
result = 5 > 8
Ensuite, vous pouvez imprimer la valeur booléenne avec un appel à la fonction print() :
print result
Comme 5 n’est pas supérieur à 8, vous verrez le résultat suivant :
Outputfalse
À mesure que vous écrivez plus de programmes en Ruby, vous deviendrez plus familier avec le fonctionnement des booléens et comment différentes fonctions et opérations évaluant soit à true soit à false peuvent changer le cours du programme.
Ensuite, explorons comment travailler avec du texte dans nos programmes.
Chaînes de caractères
A string is a sequence of one or more characters, such as letters, numbers, and symbols. Strings primarily exist within either single quotes (') or double quotes (") in Ruby, so to create a string, enclose a sequence of characters in quotes, like this:
"This is a string in double quotes."
Le petit programme « Bonjour, monde ! » démontre comment une chaîne de caractères peut être utilisée en programmation informatique, car les caractères qui composent la phrase Bonjour, monde ! sont une chaîne de caractères.
print "Hello, World!"
Comme avec d’autres types de données, vous pouvez stocker des chaînes de caractères dans des variables :
output = "Hello, World!"
Et imprimer la chaîne en appelant la variable :
print output
OutputHello, World!
Tout comme les nombres, il existe de nombreuses opérations que nous pouvons effectuer sur les chaînes de caractères dans nos programmes afin de les manipuler pour obtenir les résultats que nous recherchons. Les chaînes de caractères sont importantes pour communiquer des informations à l’utilisateur, et pour que l’utilisateur communique des informations au programme.
Parfois, vous avez besoin de travailler avec des listes de données. C’est là que les tableaux sont utiles.
Tableaux
Un tableau peut contenir plusieurs valeurs dans une seule variable. Cela signifie que vous pouvez contenir une liste de valeurs dans un tableau et les parcourir. Chaque élément ou valeur qui se trouve dans un tableau est appelé un élément.
Les tableaux sont définis en spécifiant des valeurs entre crochets [ ], séparées par des virgules.
Un tableau d’entiers ressemble à ceci :
[-3, -2, -1, 0, 1, 2, 3]
A array of floats looks like this:
[3.14, 9.23, 111.11, 312.12, 1.05]
Voici une liste de chaînes de caractères :
['shark', 'cuttlefish', 'squid', 'mantis shrimp']
Comme pour les autres types de données, vous pouvez assigner un tableau à une variable :
sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']
Si nous imprimons la variable, le résultat ressemble exactement au tableau que nous avons créé :
print sea_creatures
['shark', 'cuttlefish', 'squid', 'mantis shrimp']
Vous accédez aux éléments individuels d’un tableau en utilisant un numéro d’index, en commençant par 0.
puts sea_creatures[0] # requin
puts sea_creatures[2] # calmar
Pour imprimer la dernière valeur, vous pouvez utiliser l’index -1. Ruby fournit également les méthodes .first et .last pour récupérer respectivement la première et la dernière entrée :
puts sea_creatures.first # requin
puts sea_creatures.last # crevette-mante
Les tableaux en Ruby peuvent contenir différents types de données. Vous pouvez stocker des chaînes de caractères, des symboles et même d’autres tableaux dans un tableau :
record = [
:en,
"Sammy",
42,
[
"coral",
"reef"
]
]
Les tableaux en Ruby sont mutables, ce qui signifie que vous pouvez ajouter des valeurs, supprimer des valeurs et même modifier des entrées dans le tableau.
Parfois, nous avons besoin d’un moyen d’étiqueter les choses dans un programme. C’est là que les symboles interviennent.
Symboles
A symbol is a special data type that acts like a label or an identifier in a Ruby program. Symbols are immutable, which means that they cannot be changed. A symbol looks like a variable declaration without a value. Here’s an example of a symbol:
:time_zone
En Ruby, vous utilisez généralement un symbole pour identifier quelque chose d’important, tandis que vous utilisez une chaîne de caractères pour le texte avec lequel vous devez travailler ou le manipuler. Chaque chaîne dans un programme Ruby est son propre objet, avec son propre emplacement unique en mémoire, même si les chaînes sont identiques.
Mais si vous référencez le même symbole plusieurs fois, vous référencez le même objet partout dans votre programme, ce qui signifie que vous référencez le même emplacement mémoire.
Vous verrez ce concept en action lorsque nous examinerons les hachages, qui vous permettent d’associer des clés à des valeurs.
Hachages
A hash is a dictionary-like collection of keys and values. These key-value pairs provide a useful way to store and access data. Hashes are often used to hold data that are related, such as the information about a user. You define a hash like this:
{"first_name" => "Sammy", "last_name" => "Shark"}
Vous pouvez attribuer des hachages à des variables comme les autres types de données:
user = {"first_name" => "Sammy", "last_name" => "Shark"}
Pour récupérer des valeurs du hachage utilisateur, vous utilisez la clé pour la valeur:
print user["first_name"] # "Sammy"
print user["last_name"] # "Requin"
Vous pouvez utiliser des symboles comme clés dans votre hachage au lieu de chaînes de caractères:
user = {:first_name => "Sammy", :last_name => "Shark"}
Utiliser des symboles comme clés de hachage est préférable chaque fois que possible. Chaque instance d’un symbole pointe vers le même objet, tandis que chaque instance d’une chaîne de caractères fait référence à un objet unique. Utiliser des symboles comme clés entraîne des performances légèrement meilleures et une utilisation moins importante de la mémoire.
Lorsque vous utilisez des symboles comme clés, vous utilisez des symboles pour récupérer les valeurs:
print user[:first_name] # "Sammy"
print user[:last_name] # "Requin"
Vous pouvez également utiliser une syntaxe légèrement différente lors de la définition du hash :
user = {first_name: "Sammy", last_name: "Shark"}
Cette syntaxe est similaire à celle utilisée en JavaScript et dans d’autres langues. Cette syntaxe définit les clés en tant que symboles, vous accéderiez donc aux entrées en utilisant :first_name et :last_name au lieu des chaînes "first_name" et "last_name".
Vous avez examiné plusieurs types de données, voyons maintenant comment Ruby fonctionne avec ces types.
Typage dynamique
En Ruby, vous ne déclarez pas explicitement un type de données avant d’attribuer une valeur ; l’attribution de la valeur détermine le type de données. Ruby utilise le typage dynamique, ce qui signifie que la vérification du type est effectuée à l’exécution plutôt qu’à la compilation, comme dans les langages utilisant le typage statique. Ruby détermine le type de données à partir des données stockées dans la variable. Cela est similaire aux types de données en Python et aux types de données en JavaScript.
La variable t dans l’exemple suivant peut être définie sur n’importe quel type de données disponible :
t = 42 # t is an Integer
t = "Sammy" # t is a String
t = :sammy # t is a Symbol
t = true # t is a boolean (true)
t # t is nil
Avec des langages à typage dynamique, vous pouvez réutiliser une variable existante pour contenir différents types de données.
Cela est utile lors de la conversion de données d’un type à un autre. Par exemple, vous pourriez avoir ce code qui demande à l’utilisateur une valeur numérique :
print "Please enter the length of the room: "
length = gets.chop
Les données que vous obtenez du clavier sont toujours une chaîne, donc pour effectuer des opérations mathématiques, vous devez convertir les données de la variable length en un nombre. Dans les langages à typage statique, où vous devez déclarer le type de données de la variable avant de lui attribuer une valeur, vous auriez besoin d’une nouvelle variable pour contenir les données converties. Mais en Ruby, parce qu’il est à typage dynamique, vous pouvez réutiliser la variable length si vous le souhaitez.
# Convertir le montant en Float.
length = length.to_f
La méthode to_f convertit la chaîne en un flottant. Ruby fournit également la méthode to_i pour convertir les chaînes en entiers, et la plupart des objets peuvent être convertis en chaînes en utilisant la méthode to_s:
42.to_s # "42"
(42.5).to_s # "42.5"
["Sammy", "Shark"].to_s # "[\"Sammy\", \"Shark\"]"
Ruby est typé de manière dynamique, mais il ne vous permet pas d’effectuer des opérations sur différents types de données sans les convertir en le même type. Par exemple, ce code entraînera une erreur :
print 5 + "5"
OutputTypeError: String can't be coerced into Integer
Tout comme ce code :
print "5" + 5
OutputTypeError: no implicit conversion of Integer into String
Si vous voulez ajouter les nombres ensemble pour obtenir 10, convertissez la chaîne en un entier. Si vous voulez les concaténer pour obtenir "55", convertissez l’entier en une chaîne.
Le typage dynamique offre une flexibilité, mais un inconvénient est que vous ne pouvez pas toujours être sûr du type de données avec lequel vous travaillez, puisque la variable peut contenir n’importe quel type disponible. Ruby fournit des moyens pour identifier le type de données.
Identification des types de données
En Ruby, presque tout est un objet. Entier, flottant, tableau, symbole et hachage sont tous des objets Ruby, et ils ont tous une méthode appelée class qui vous dira quel type ils sont. Même les booléens true et false, et la valeur nil sont des objets. Essayez-le vous-même:
42.class # Entier
(42.2).class # Flottant
["Sammy", "Shark"].class # Tableau
true.class # TrueClass
nil.class # NilClass
De plus, vous pouvez utiliser la méthode kind_of? pour vérifier un certain type de données, comme ceci:
42.kind_of?(Integer) # vrai
Ceci est particulièrement utile lorsque vous avez une variable et que vous voulez déterminer son type:
# quelque part dans le code...
sharks = ["Hammerhead", "Tiger", "Great White"]
...
# ailleurs...
sharks.kind_of?(Hash) # faux
sharks.kind_of?(Array) # vrai
Vous pouvez également utiliser ceci pour vérifier que les données provenant d’une source externe sont correctes:
if data.kind_of? String
data = data.to_f
end
Ruby fournit également la méthode is_a?, qui fait la même chose que kind_of?, mais peut être un peu plus facile à lire pour certains développeurs :
if data.is_a? String
data = data.to_f
end
Utiliser class, kind_of? et is_a? peut vous aider à vous assurer que vous travaillez avec le bon type de données. En apprenant plus sur Ruby, vous découvrirez d’autres façons de manipuler les données qui n’impliquent pas nécessairement de vérifier explicitement le type de données.
Conclusion
Vous utiliserez de nombreux types de données différents dans vos programmes Ruby. Vous avez maintenant une meilleure compréhension des principaux types de données disponibles dans les programmes Ruby.
Consultez ces tutoriels pour continuer votre exploration des types de données de Ruby :
Source:
https://www.digitalocean.com/community/tutorials/understanding-data-types-in-ruby