Ruby est un langage de programmation bien connu. Il vise à améliorer la simplicité et la productivité. C’est également un langage de programmation entièrement orienté objet. De plus, Ruby est doté d'une syntaxe élégante qui est naturelle à lire et facile à écrire.
Toute programmation nécessite la gestion de différents types de données. Un type de données décrit une classe spécifique de données. Il indique à la machine comment elle doit gérer les données dans le programme. Les types de données sont essentiels pour déterminer ce qui peut être fait avec les données (y compris les opérations qui peuvent être effectuées). Dans ce tutoriel, nous allons plonger plus en détail dans les types de données disponibles dans Ruby. Nous explorerons également le typage dynamique. Grâce à cette fonctionnalité, Ruby peut déterminer automatiquement le type de données d'une variable sans la déclarer explicitement. Commençons !
Prérequis
Pour pratiquer et mettre en œuvre les étapes présentées dans ce guide, vous aurez besoin des composants suivants :
- Un système Linux correctement configuré. En savoir plus sur la configuration d'un serveur Ubuntu personnel sur CloudSigma.
- Un environnement de développement Ruby correctement configuré. Consultez la documentation officielle de l'installation de Ruby sur Ubuntu (via APT).
Types de données en Ruby
Ruby intègre tous les types de données courants que vous rencontrerez dans n'importe quel langage de programmation : entiers, flottants, chaînes de caractères, tableaux, symboles, hachages, etc. Ensuite, nous donnerons un aperçu de la manière de travailler avec les différents types de données de Ruby.
Étape 1 – Entiers
Tout comme en mathématiques, les entiers en programmation informatique sont des nombres entiers. La valeur peut être positive, négative ou égale à 0. La plage de valeurs est la suivante :
|
1 |
{-∞, …, -1, 0, 1, …, ∞} |
Il est temps d'essayer les entiers en Ruby. Le premier exemple consiste à afficher un entier simple à l'écran :
|
1 2 |
print 99 print "\n" |
Ensuite, nous allons travailler avec une variable entière. Ici, la variable sample_int contient une valeur entière (99) et la fonction print affiche la valeur de la variable à l'écran :
|
1 2 3 |
sample_int = 99 print sample_int print "\n" |
Nous pouvons également faire des mathématiques avec des entiers. L'exemple suivant montre une somme simple de deux nombres entiers :
|
1 2 3 |
sample_int = 99 + 100 print sample_int print "\n" |
Lorsque nous travaillerons avec de grands nombres, nous utiliserons souvent des virgules (,) pour faciliter la lecture. Par exemple, un million (1000000) s'écrit 1,000,000 pour une meilleure lisibilité. Bien que l'utilisation de virgules soit interdite, Ruby permet d'utiliser des tirets bas ( _) comme délimiteur. Jetez un œil à l'exemple suivant :
|
1 2 3 |
sample_int = 1_000_999 print sample_int print "\n" |
L'utilisation de tirets bas améliore la lisibilité du code, en particulier lors de la manipulation de grandes valeurs entières.
Étape 2 – Nombres à virgule flottante
Un nombre à virgule flottante (ou float en abrégé) représente un nombre réel. Semblable à la définition mathématique, les nombres réels peuvent être rationnels ou irrationnels. En Ruby, un float est essentiellement un nombre contenant un point décimal.
Essayons d'afficher une valeur flottante à l'écran :
|
1 2 |
print 55.66 print "\n" |
L'exemple suivant montre la déclaration d'une variable flottante :
|
1 2 3 |
sample_float = 55.66 print sample_float print "\n" |
Nous pouvons également effectuer diverses opérations mathématiques sur les valeurs et variables flottantes. L'exemple suivant montre une somme simple de deux nombres flottants :
|
1 2 3 |
sample_float = 55.66 + 99.222 print sample_float print "\n" |
Et si nous ajoutions un flottant et un entier ? La valeur résultante sera un flottant. Dans l'exemple suivant, bien que 55.0 soit un nombre entier, il est traité comme un flottant :
|
1 2 3 |
sample_float = 55.0 + 10 print sample_float print "\n" |
Étape 3 – Booléen
Les booléens représentent les valeurs de vérité de la branche logique des mathématiques. En Ruby, les types de données booléens sont représentés par deux valeurs : true et false:
-
Supérieur à
-
100 > 99: true
-
99 > 100: false
-
-
Inférieur à
-
500 < 999: true
-
999 < 500: false
-
-
Égal
-
10 == 10: true
-
9 == 99: false
-
Tout comme les nombres, nous pouvons également stocker un true ou false valeur dans une variable. L'exemple suivant illustre cette fonctionnalité :
|
1 2 3 |
result = 9 == 99 print result print "\n" |
Step 4 – Chaînes de caractères
En programmation, une chaîne de caractères est représentée comme une séquence de caractères (lettres, chiffres et symboles). En Ruby, les chaînes de caractères existent entre guillemets simples ( ') ou doubles ( "). Nous avons déjà traité en détail de l'utilisation des chaînes de caractères en Ruby, cette section sera donc courte.
L'exemple suivant est un programme de base hello world en Ruby :
|
1 |
print "hello world!\n" |
Nous pouvons également stocker des chaînes de caractères dans des variables. L'exemple suivant intègre également la concaténation de chaînes :
|
1 2 |
username = "Cloudsigma" print "hello, " + username + "!\n" |
Step 5 – Tableaux
Un tableau est une structure de données qui peut stocker une collection de taille fixe d'éléments du même type de données. Il peut également être conceptualisé comme une collection de variables du même type de données. C’est l'une des structures de données les plus fondamentales dans la plupart des langages de programmation modernes.
En Ruby, un tableau est défini comme suit :
|
1 |
[value_1, value_2, …, value_N] |
Il est possible de créer un tableau de n'importe quel autre type de données dont nous avons parlé jusqu'à présent (entier, flottant et chaînes de caractères). Voici quelques exemples :
-
Entier : [-5, 0, 5]
-
Flottant : [-9.99, -6.99, -3.99, 0, 3.99]
-
Chaîne de caractères : [“the”, “quick”, “brown”, “fox”]
L'exemple suivant implémente tous ces types de tableaux :
|
1 2 3 4 5 6 |
print [-5, 0, 5] print "\n" print [-9.99, -6.99, -3.99, 0, 3.99] print "\n" print ["the", "quick", "brown", "fox"] print "\n" |
Notez que lorsque la fonction print rencontre un tableau, elle affiche l'intégralité du tableau à l'écran. Pour plus de commodité, vous rencontrerez souvent des tableaux sous forme de variables. Mettons à jour le code :
|
1 2 3 4 5 6 7 8 9 10 |
array_int = [-5, 0, 5] print array_int print "\n" array_float = [-9.99, -6.99, -3.99, 0, 3.99] print array_float print "\n" array_string = ["the", "quick", "brown", "fox"] print array_string print "\n" |
Maintenant, nous pouvons travailler avec des éléments individuels des tableaux :
|
1 2 3 4 5 6 7 8 9 |
array_int = [-5, 0, 5] print array_int[2] print "\n" array_float = [-9.99, -6.99, -3.99, 0, 3.99] print array_float[1] print "\n" array_string = ["the", "quick", "brown", "fox"] print array_string[3] print "\n" |
Notez qu'en Ruby, la valeur de l'index des tableaux commence par 0.
Pour plus de commodité, les tableaux en Ruby sont fournis avec les méthodes .first et .last qui affichent le premier et le dernier élément :
|
1 2 3 4 |
array_float = [-9.99, -6.99, -3.99, 0, 3.99] puts array_float.first puts array_float.last print "\n" |
En Ruby, les tableaux ont une autre fonctionnalité intéressante. Ils peuvent contenir différents types de données en même temps. Por exemple, vous pouvez stocker des chaînes de caractères, des symboles et même d'autres tableaux :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
mixed_array = [ "hello", 99.99, "world", [ "the", "quick", "brown", "fox" ] ] print mixed_array print "\n" print mixed_array[3] print "\n" |
Étape 6 – Symboles
En Ruby, un symbol est un type de données spécial qui agit comme une étiquette ou un identifiant. Les symboles sont immuables, ce qui signifie qu’ils ne peuvent pas être modifiés. Les symboles apparaissent comme si l’on déclarait des variables sans aucune valeur.
Voici un exemple de symbole :
|
1 |
:time_zone |
Généralement, les symboles sont utilisés pour identifier quelque chose d'important. Pour d'autres situations, cependant, les chaînes de caractères sont amplement suffisantes.
Ruby, étant un langage orienté objet, traite tout comme un objet (y compris les chaînes de caractères) avec son emplacement mémoire unique, même si les chaînes sont identiques. Cependant, lorsque vous faites référence à un symbole, c’est le même objet partout dans le programme, le même emplacement mémoire.
Étape 7 – Tables de hachage
Une table de hachage est une collection de clés et de valeurs semblable à un dictionnaire. Souvent, les tables de hachage sont utilisées pour stocker des données connexes, par exemple, des informations sur un utilisateur.
Voici un exemple rapide de table de hachage. Nous avons créé une table de hachage user_info contenant le nom d'utilisateur et le mot de passe d'un utilisateur :
|
1 2 3 4 5 6 |
user_info = { "username" => "HelloWorld999", "password" => "password123" } print user_info print "\n" |
Pour récupérer les valeurs d'une paire clé-valeur, nous devons utiliser la clé. L'exemple suivant illustre ce processus :
|
1 2 3 4 5 6 7 |
user_info = { "username" => "HelloWorld999", "password" => "password123" } print user_info["username"] print "\n" |
Ruby permet également de définir une table de hachage en utilisant des syntaxes légèrement différentes ( : au lieu de =>):
|
1 2 3 4 5 6 |
user_info = { username: "HelloWorld999", password: "password123" } print user_info[:password] print "\n" |
Cette structure de syntaxe est similaire à la syntaxe utilisée dans d'autres langages, par exemple, JavaScript. Dans cette structure syntaxique, les clés sont définies comme des symboles. C’est pourquoi au lieu d'utiliser "username", nous utilisons : username pour accéder à la valeur.
Typage dynamique
Vous avez peut-être déjà remarqué que lors de la déclaration d'une variable, nous n'avons pas à attribuer explicitement un type de données. Au lieu de cela, la valeur de la variable détermine le type de données. Ruby utilise le typage dynamique où la vérification des types est effectuée au moment de l'exécution. En revanche, les types de données sont déterminés lors de la compilation dans les langages de programmation à typage statique (C/C++, par exemple).
Dans l'exemple suivant, toutes les valeurs attribuées à la variable dyn_var sont valides :
|
1 2 3 4 5 |
dyn_var = 123 dyn_var = 456.789 dyn_var = true dyn_var = "the quick brown fox" dyn_var |
Dans les langages à typage dynamique, nous sommes libres de réutiliser une variable existante pour stocker différents types de données. Ici, l'exemple précédent est mis à jour pour illustrer ce phénomène :
|
1 2 3 4 5 6 7 |
dyn_var = 123 puts dyn_var dyn_var = 456.789 dyn_var = true dyn_var = "the quick brown fox" puts dyn_var dyn_var |
Comme le montre cet exemple, chaque fois qu'une nouvelle valeur est attribuée, cela modifie le type de données de dyn_var à la volée. C’est utile lors de la conversion d'un type de données à un autre. L'exemple suivant le démontre :
|
1 2 3 4 |
print "enter length: " length = gets.chop length = length.to_f puts length |
Ici,
-
Comme les entrées au clavier sont des chaînes de caractères, length est d'abord une chaîne de caractères.
-
Comme la valeur souhaitée est un float, nous convertissons la valeur de la chaîne en float à l'aide de la méthode to_f.
-
En raison du changement de valeur, length se voit attribuer le type de données float. C'est ce que nous voyons lors de l'affichage de sa valeur à l'écran.
Que se passerait-il si nous essayions de mélanger deux types de données différents ? Ruby renverrait une erreur. Regardez :
|
1 |
print 9 + "77" |
Identification du type de données
En Ruby, tout est traité comme un objet. Chaque objet en Ruby est doté de la méthode class. Lorsqu'elle est appelée, cette méthode indique le type de données de la source. Voici quelques exemples d'utilisation de la class méthode :
|
1 2 3 4 |
puts 55.class puts (55.55).class puts true.class puts nil.class |
Une autre façon de déterminer le type de données consiste à utiliser la kind_of? méthode. Elle compare le type de données de l'objet avec le type de données demandé et renvoie une valeur booléenne. Découvrez-le dans l'exemple suivant :
|
1 2 |
puts 55.kind_of?(Float) puts 55.kind_of?(Integer) |
De même, il existe une autre méthode is_a? qui compare le type de données et renvoie une valeur booléenne. La seule différence est le nom de la méthode. Cependant, elle peut être préférable car elle est un peu plus facile à lire et à comprendre pour les développeurs. Mettez à jour l'exemple précédent avec is_a?:
|
1 2 |
puts 55.is_a?(Float) puts 55.is_a?(Integer) |
Dernières réflexions
Travailler avec n'importe quel langage de programmation nécessite une bonne compréhension des types de données qu'il prend en charge. Dans ce guide, nous avons exploré les types de données les plus courants utilisés dans la programmation Ruby. Nous avons présenté et illustré les entiers, les floats, les chaînes de caractères, les symboles, les booléens et les hashes (avec des exemples).
Consultez d'autres tutoriels de notre blog qui vous aideront à explorer Ruby :
- Installer Ruby on Rails avec RVM sur Ubuntu 20.04
- Configurer Ruby on Rails avec PostgreSQL
- Utiliser MySQL avec une application Ruby on Rails sur Ubuntu 21.04
- Explorer le PaaS CloudSigma : Comment utiliser les services d'hébergement PaaS Ruby ?
Bonne programmation !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.