Comment travailler avec les chaînes de caractères en Ruby

Introduction

A string is a sequence of one or more characters that may consist of letters, numbers, or symbols.

Les chaînes de caractères en Ruby sont des objets, et contrairement à d’autres langages, les chaînes de caractères sont mutables, ce qui signifie qu’elles peuvent être modifiées sur place au lieu de créer de nouvelles chaînes.

Vous utiliserez des chaînes de caractères dans presque tous les programmes que vous écrirez. Les chaînes de caractères vous permettent d’afficher et de communiquer avec vos utilisateurs en utilisant du texte. En fait, la page que vous êtes en train de lire en ce moment est composée de chaînes de caractères affichées sur votre écran via votre navigateur web. Les chaînes de caractères sont l’un des éléments fondamentaux les plus importants de la programmation.

Dans ce tutoriel, vous apprendrez à travailler avec les chaînes de caractères en Ruby. Vous allez créer des chaînes de caractères, les afficher à l’écran, les stocker dans des variables, les concaténer et apprendre à gérer les caractères spéciaux tels que les sauts de ligne, les apostrophes et les guillemets doubles.

Création et Affichage de Chaînes de Caractères

Les chaînes de caractères existent soit entre des guillemets simples ' ou des guillemets doubles " en Ruby, donc pour créer une chaîne de caractères, enfermez une séquence de caractères dans l’un ou l’autre :

'This is a string in single quotes.'

"This is a string in double quotes."

Vous pouvez choisir d’utiliser des guillemets simples ou doubles. Dans la plupart des cas, cela n’aura pas d’importance tant que vous restez cohérent. Cependant, l’utilisation de guillemets doubles vous permet d’effectuer une interpolation de chaîne, comme vous le verrez dans ce tutoriel.

Pour afficher une chaîne dans votre programme, vous pouvez utiliser la méthode print:

print "Let's print out this string."

La méthode print affiche la chaîne exactement telle qu’elle est écrite.

Essayez. Créez un nouveau programme Ruby appelé print.rb à l’aide de votre éditeur de texte et utilisez la méthode print pour imprimer trois chaînes:

print 'This is the first string.'
print 'This is the second string.'
print 'This is the third string.'

Enregistrez le fichier et exécutez le programme:

ruby print.rb

Vous verrez la sortie suivante:

Output
This is the first string.This is the second string.This is the third string.

Au lieu des trois chaînes imprimées sur leurs propres lignes, toutes les trois chaînes ont été imprimées ensemble sur une seule ligne. La méthode print imprime la chaîne à l’écran, mais si vous vouliez chaque chaîne sur sa propre ligne, vous devriez ajouter vous-même un caractère de saut de ligne.

Si vous voulez que les trois chaînes soient sur des lignes séparées, utilisez plutôt la méthode puts. Modifiez votre programme pour utiliser puts au lieu de print:

puts 'This is the first string.'
puts 'This is the second string.'
puts 'This is the third string.'

Maintenant, exécutez à nouveau le programme et vous verrez cette sortie:

Output
This is the first string.
This is the second string.
This is the third string.

La méthode puts imprime la chaîne que vous spécifiez, mais ajoute également un caractère de saut de ligne à la fin de la chaîne pour vous.

Stockage des chaînes dans des variables

Les variables sont une référence nommée à un emplacement dans la mémoire de l’ordinateur. Vous utilisez des variables pour stocker des données et les récupérer ultérieurement.

Pour stocker une chaîne dans une variable, définissez le nom de la variable et attribuez-lui la valeur de la chaîne :

my_string = 'This is my string'

Ensuite, pour récupérer la valeur, utilisez le nom de la variable :

print my_string

Pour tester vous-même cela, créez le fichier string_variables.rb dans votre éditeur avec la commande suivante :

nano string_variables.rb

Ensuite, ajoutez le code suivant :

my_name = "Sammy the Shark"
my_age = "none of your business"

puts my_name
puts my_age

Ce programme définit deux variables : my_name et my_age. Chaque variable est assignée à une chaîne. Nous utilisons ensuite la méthode puts pour afficher chaque chaîne sur sa propre ligne.

Enregistrez le fichier avec CTRL + X puis y, puis exécutez le programme :

ruby string_variables.rb

Vous verrez la sortie suivante :

Output
Sammy the Shark
none of your business

En assignant des chaînes à des variables, vous pouvez éviter de taper la même chaîne encore et encore chaque fois que vous voulez l’utiliser, ce qui facilite le travail et la manipulation des chaînes dans vos programmes.

Regardons maintenant comment assembler des chaînes pour créer de nouvelles chaînes.

Concaténation de chaînes

La concaténation signifie joindre deux chaînes ou plus pour créer une nouvelle chaîne. Pour concaténer, nous utilisons l’opérateur de concaténation, représenté par le symbole +. Le symbole + est également l’opérateur d’addition lorsqu’il est utilisé avec des opérations arithmétiques.

Voici comment vous concaténeriez les chaînes sammy et shark ensemble:

"sammy" + "shark"

Cela produirait la sortie suivante:

Output
sammyshark

La concaténation joint les chaînes bout à bout, les combinant et produisant une toute nouvelle valeur de chaîne. Si vous voulez avoir un espace entre les mots sammy et shark, vous devez inclure cet espace dans l’une des chaînes, comme ceci:

"sammy " + "shark"

Maintenant, vous n’écrirez pas vraiment du code de cette manière dans un programme, mais vous devrez souvent mélanger des chaînes et des variables, et c’est là que la concaténation intervient.

Voici un exemple:

color = "Blue"
print "My favorite color is " + color

Cela donnerait en sortie Ma couleur préférée est le bleu. Notez que nous avons laissé un espace après le mot est dans la chaîne afin que la sortie ait un espace entre la chaîne et la valeur de la variable dans la sortie.

Vous pouvez concaténer plusieurs chaînes de cette manière. Créez le fichier concatenation.rb et ajoutez ce code:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts "My name is " + my_name + " and my age is " + my_age + "."

Ce programme définit deux variables: my_name et my_age, chacune avec sa propre chaîne assignée, comme vous l’avez déjà fait. Mais cette fois, au lieu d’imprimer les valeurs, nous imprimons une chaîne qui utilise la concaténation pour imprimer ces valeurs avec un peu plus de contexte.

Lorsque vous exécutez ce programme, vous verrez la sortie suivante:

Output
My name is Sammy the Shark and my age is none of your business.

Dans ce petit programme, vous avez utilisé la concaténation pour insérer des variables dans cette chaîne.

Lorsque vous combinez deux ou plusieurs chaînes via la concaténation, vous créez une nouvelle chaîne que vous pouvez utiliser dans tout votre programme, donc vous voudrez peut-être attribuer la chaîne que vous avez créée à une nouvelle variable que vous pourrez utiliser plus tard :

my_name = "Sammy the Shark"
my_age = "none of your business"

 # attribuer la chaîne concaténée à une variable 
output = "My name is " + my_name + " and my age is " + my_age + "."

 # Imprimer la sortie. 
puts output

Dans un petit programme comme celui-ci, l’utilisation d’une variable supplémentaire output est probablement inutile. Mais dans de plus grands programmes, vous voudrez peut-être créer une chaîne en utilisant la concaténation que vous utiliserez à plusieurs endroits. Il est également bon de séparer le traitement des données tel que la concaténation et l’arithmétique de la sortie, car éventuellement vos programmes deviendront plus importants et vous voudrez séparer la logique et la sortie en fichiers ou composants distincts pour les rendre plus faciles à gérer.

Assurez-vous de ne pas utiliser l’opérateur + entre deux types de données différents. Vous ne pouvez pas concaténer des chaînes et des entiers ensemble, par exemple.

Pour voir ce qui se passe, créez un nouveau programme appelé strings_and_integers.rb avec le contenu suivant :

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

Cette fois, nous avons my_name qui contient la chaîne Sammy the Shark et my_number qui contient l’entier 27. Nous savons que 27 n’est pas une chaîne car il n’est pas entouré de guillemets. Il n’a pas non plus de point décimal, donc nous savons que c’est un entier.

Si vous exécutez le programme :

ruby strings_and_ints.rb

Vous verrez ce message d’erreur :

Output
strings_and_ints.rb:4:in `+': no implicit conversion of Integer into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

L’erreur no implicit conversion of Integer into String signifie que Ruby ne peut concaténer qu’une chaîne de caractères à une chaîne de caractères existante.

strings_and_ints.rb:4:in `+': no implicit conversion of Fixnum into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

Nous pourrions modifier notre programme et placer le nombre 27 entre guillemets ("27") afin qu’il soit déclaré comme une chaîne de caractères plutôt que comme un entier. Ou nous pouvons convertir le nombre en une chaîne de caractères lors de la création de la chaîne, comme ceci:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number.to_s

La méthode .to_s convertit l’entier en une chaîne de caractères. C’est une meilleure approche, car elle nous permet de conserver notre nombre en tant qu’entier dans notre programme. Nous avons seulement besoin qu’il soit une chaîne de caractères lorsque nous l’imprimons, mais nous pouvons vouloir qu’il soit un entier si nous devons l’utiliser dans d’autres parties de la logique de notre programme.

Exécutez à nouveau le programme et vous verrez Sammy the Shark27 imprimé à l’écran.

Convertir des nombres en chaînes de caractères pour les concaténer est quelque chose que vous rencontrerez fréquemment lorsque vous travaillez avec des codes postaux, des devises, des numéros de téléphone et d’autres données numériques que vous souhaitez afficher à l’écran aux côtés de texte.

La concaténation est puissante, mais elle peut être délicate. Si vous oubliez accidentellement l’un des opérateurs +, vous pouvez obtenir une erreur de syntaxe. Et si vous devez joindre des chaînes avec des variables contenant des nombres, vous devez convertir les variables en chaînes. Ruby fournit une autre façon d’injecter des valeurs de variable dans une chaîne, appelée interpolation de chaîne qui résout ces deux problèmes.

Utilisation de l’interpolation de chaîne

En concaténant des chaînes et des variables, la sortie peut être difficile à lire et à déboguer. L’interpolation de chaîne résout ce problème en vous permettant d’incorporer des expressions dans une chaîne encadrée de guillemets doubles.

Au lieu d’écrire ceci :

"My name is " + my_name + "!"

Vous pouvez faire ceci :

"My name is #{my_name}!"

Au lieu de terminer la chaîne et d’utiliser l’opérateur +, vous encadrez la variable avec la syntaxe #{}. Cette syntaxe indique à Ruby d’évaluer l’expression et de l’injecter dans la chaîne.

Essayez-le. Créez un nouveau programme appelé interpolation.rb et ajoutez ce code :

my_name = "Sammy the Shark"
my_age = "none of your business"

output = "My name is #{my_name} and my age is #{my_age}."

puts output

Il s’agit du même programme que celui que vous avez déjà écrit, mais cette fois nous utilisons l’interpolation de chaîne pour créer la sortie.

L’interpolation de chaîne a un autre avantage : elle peut convertir automatiquement les valeurs numériques en chaînes. Vous vous souvenez de votre programme strings_and_integers.rb ? Ouvrez à nouveau ce fichier dans votre éditeur, mais modifiez la dernière ligne pour qu’elle ressemble à ce qui suit :

my_name = "Sammy the Shark"
my_number = 27

# utilisez l'interpolation au lieu de la concaténation
print "My name is #{my_name} and my favorite number is #{my_number}."

Ruby convertira automatiquement my_number en une chaîne de caractères, et votre programme affichera la sortie suivante lorsque vous l’exécuterez:

Output
My name is Sammy the Shark and my favorite number is 27.

L’interpolation de chaînes est puissante et pratique. C’est également la méthode préférée pour concaténer des chaînes avec des variables.

Littéraux de chaînes et valeurs de chaînes

Remarquez que toutes les chaînes que vous avez créées sont encloses entre guillemets dans le code, mais la sortie imprimée réelle n’inclut pas les guillemets.

Il y a une distinction lorsqu’on se réfère à chacun de ceux-ci. Un littéral de chaîne est la chaîne telle qu’elle est écrite dans le code source, y compris les guillemets. Une valeur de chaîne est ce que vous voyez dans la sortie, et n’inclut pas les guillemets.

Ceci est un littéral de chaîne:

"Sammy the Shark"

La valeur de la chaîne serait Sammy the Shark.

Dans la plupart des cas, vous n’aurez pas à vous soucier de cette différence, sauf si vous voulez utiliser des caractères spéciaux comme des guillemets ou des apostrophes dans vos chaînes.

Échappement des guillemets et des apostrophes dans les chaînes

En raison du fait que les guillemets sont utilisés pour indiquer des chaînes, vous devrez faire un peu plus d’efforts si vous voulez des apostrophes et des guillemets dans les chaînes.

Si vous tentez d’utiliser une apostrophe au milieu d’une chaîne entre guillemets simples, comme ceci :

'This isn't what I wanted.'

L’apostrophe dans n'est termine la chaîne, comme vous pouvez le voir avec la coloration étrange dans cet exemple. Par conséquent, l’interpréteur Ruby tentera d’analyser le reste de la chaîne prévue comme du code et vous obtiendrez une erreur.

Vous rencontrerez la même situation si vous utilisez des guillemets doubles dans une chaîne enfermée dans des guillemets doubles :

"Sammy says, "Hello!""

Dans cet exemple, la double guillemet fermante devant Bonjour termine la chaîne, et la double guillemet après Bonjour ! crée une nouvelle chaîne qui n’a pas de guillemet double correspondant pour la terminer, donc Ruby affichera une erreur.

Pour éviter ce problème, vous avez plusieurs options. Premièrement, vous pouvez utiliser la syntaxe alternative pour créer des chaînes ; si vous devez utiliser des guillemets doubles dans la chaîne, utilisez des guillemets simples pour définir la chaîne, et vice versa. Vous pourriez également échapper les guillemets, ou vous pourriez utiliser une syntaxe Ruby différente pour définir les chaînes. Examinons chaque approche.

Option 1 : Utiliser la Syntaxe de Chaîne Alternative

La façon la plus simple de contourner ces problèmes est d’encadrer votre chaîne de caractères avec des guillemets simples lorsque votre chaîne doit inclure des guillemets doubles, et d’encadrer votre chaîne de caractères avec des guillemets doubles lorsque votre chaîne doit utiliser des guillemets simples.

Au lieu de définir cette chaîne avec des guillemets simples :

'This isn't what I wanted.'

Définissez-la avec des guillemets doubles :

"This isn't what I wanted."

Et au lieu d’utiliser des guillemets doubles pour définir cette chaîne :

"Sammy says, "Hello!""

Utilisez des guillemets simples :

'Sammy says, "Hello!"'

L’utilisation de cette syntaxe alternative peut vous sortir de quelques problèmes rapidement, mais cela ne fonctionnera pas toujours. Par exemple, aucune des approches ne fonctionnera pour cette chaîne :

"Sammy says, "I'm a happy shark!""

Dans cet exemple, le guillemet double de fermeture devant I'm perturbe vraiment les choses. Cela termine la première chaîne, puis Ruby rencontre l’apostrophe dans I'm, ce qui commence une nouvelle chaîne avec la valeur m a happy shark!"". Mais cette nouvelle chaîne n’a pas de guillemet simple correspondant pour la terminer. Et utiliser des guillemets simples pour encadrer la chaîne introduit un problème similaire :

'Sammy says, "I'm a happy shark!"'

Cette fois, l’apostrophe dans I'm termine la chaîne.

L’utilisation de cette syntaxe alternative peut également rendre votre code incohérent. Passer constamment entre les syntaxes de chaînes peut être déroutant. Nous pouvons échapper aux caractères pour contourner ce problème.

Option 2 : Échapper aux caractères dans les chaînes

Le caractère barre oblique inverse (\), souvent appelé le caractère d’échappement dans les chaînes, empêchera Ruby d’interpréter le caractère suivant dans la chaîne littéralement.

Voici notre chaîne problématique, encodée entre guillemets doubles, avec des guillemets doubles à l’intérieur :

"Sammy says, "I'm a happy shark!""

Créez un nouveau programme Ruby appelé quoting.rb et ajoutez ce code au fichier :

print "Sammy says, "I'm a happy shark!""

Exécutez le programme :

ruby quoting.rb

Et vous verrez cette sortie :

Output
quoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "Sammy says, "I'm a happy shark!""
^

Pour corriger l’erreur, utilisez la barre oblique inverse devant les guillemets doubles internes :

print "Sammy says, \"I'm a happy shark!\""

Ensuite, exécutez à nouveau le programme et vous verrez la sortie attendue :

Sammy says, "I'm a happy shark!"

Remarquez que vous n’avez pas besoin d’échapper à l’apostrophe dans cet exemple, car il n’y a pas de conflit. Vous devez uniquement échapper aux guillemets qui pourraient perturber Ruby.

Vous pouvez éviter complètement d’échapper aux guillemets en utilisant une syntaxe différente pour définir les chaînes.

Option 3: Utilisation d’une syntaxe alternative pour les chaînes

Jusqu’à présent, vous avez utilisé des guillemets pour définir les limites de vos chaînes. Vous pouvez créer des chaînes en Ruby en utilisant d’autres caractères également. Vous pouvez définir le délimiteur, ou le caractère que vous souhaitez utiliser pour encadrer votre chaîne, en le spécifiant après un signe de pourcentage, comme ceci :

%$Sammy says, "I'm a happy shark!"$

Cette syntaxe échappera automatiquement les chaînes intégrées pour vous. La chaîne réelle ressemble à ceci :

"Sammy says, \"I'm a happy shark!\""

Cependant, changer le délimiteur signifie que vous devez échapper le délimiteur si vous avez besoin de l’utiliser. Dans ce cas, si vous deviez utiliser un signe dollar dans votre chaîne, vous devriez échapper le signe dollar littéral dans la chaîne.

Pour éviter cela, vous pouvez également utiliser des paires d’accolades, de crochets carrés ou de parenthèses comme délimiteurs. Les accolades sont les plus courantes:

%{Sammy says, "I'm a happy shark!"}

Ces formes prennent toutes en charge l’interpolation de chaînes si vous en avez besoin.

droplets = 5
print %{Sammy says, "I just created #{droplets} droplets!"}

Vous verrez également %Q{} et %q{} utilisés pour définir des chaînes dans les programmes Ruby. La syntaxe %Q{} fonctionne exactement comme les chaînes entre guillemets doubles, ce qui signifie que vous n’avez pas besoin d’échapper aux guillemets doubles, et vous pourrez utiliser l’interpolation de chaînes:

droplets = 5
print %Q{Sammy says, "I just created #{droplets} droplets!"}

La syntaxe %q{} fonctionne exactement comme les chaînes entre guillemets simples:

%q{Sammy says, "I'm a happy shark!"}

Vous pourriez voir la syntaxe %q et %Q utilisée avec des parenthèses ou des crochets carrés dans certains programmes au lieu d’accolades.

Comme vous pouvez le voir, il existe de nombreuses façons de créer des chaînes en Ruby. Quelle que soit la méthode que vous choisissez, soyez cohérent dans votre code. Vous constaterez que les méthodes %Q{} et %{} sont les plus courantes.

Maintenant que vous savez comment gérer les caractères spéciaux, examinons comment gérer les chaînes longues et les caractères de nouvelle ligne.

Chaînes longues et caractères de nouvelle ligne

Il y a des moments où vous voudrez peut-être insérer un caractère de saut de ligne ou un retour chariot dans votre chaîne. Vous pouvez utiliser les caractères d’échappement \n ou \r pour insérer un saut de ligne dans le code :

output = "This is\na string\nwith newlines"
puts output

Ce programme produirait cette sortie :

Output
This is
a string
with newlines

Cela fonctionne techniquement pour obtenir notre sortie sur plusieurs lignes. Cependant, écrire une chaîne très longue sur une seule ligne deviendra rapidement très difficile à lire et à manipuler. Il existe quelques solutions.

Tout d’abord, vous pouvez utiliser l’opérateur de concaténation pour diviser la chaîne sur plusieurs lignes :

output = "This is a\n" +
"longer string\n" +
"with newlines."
puts output

Cela concatène simplement trois chaînes ensemble, similaire à ce que vous avez déjà fait.

Vous pouvez également simplement mettre les sauts de ligne directement dans la chaîne :

output = "This is a
longer string
with newlines"
puts output

Vous pouvez également utiliser l’une des syntaxes alternatives de chaînes pour créer des chaînes multilignes :

output = %{This is a
longer string
with newlines}
puts output

Dans ces deux exemples, notez que nous n’avons pas besoin des caractères de saut de ligne (\n). Cette approche préserve les espaces, y compris l’indentation et les sauts de ligne.

Par conséquent, la sortie contiendra les sauts de ligne, ainsi que toute l’indentation initiale, comme ceci :

Output
This is a
longer string
with newlines

Pour éviter cela, supprimez les espaces supplémentaires de votre code :

output = %{This is a
longer string
with newlines
}

Vous pouvez également créer des chaînes multilignes en utilisant un heredoc, ou « document ici », un terme utilisé pour les littéraux de chaînes multilignes dans les programmes. Voici comment vous écririez ce code :

output = <<-END
This is a
longer string
with newlines
END

Les marqueurs <<-END et END indiquent le début et la fin du heredoc.

Les heredocs en Ruby préservent également les caractères d’espacement, ce qui signifie que si vous indentez le code dans le heredoc, l’indentation initiale est également préservée. Ainsi, ce code:

output = <<-END
This is a
longer string
with newlines
END

imprimerait avec deux espaces d’indentation.

Ruby 2.3 et supérieur fournissent la syntaxe des « squiggly heredocs » qui supprime automatiquement cet espacement initial. Remplacez le trait d’union dans la définition du heredoc par un tilde, donc <<- devient <<~, comme ceci:

output = <<~END
This is a
longer string
with newlines
and the code is indented
but the output is not.
END

Cela produit la sortie suivante:

Output
This is a
longer string
with newlines
and the code is indented
but the output is not.

Cela vous permet d’utiliser les heredocs et de conserver votre code joliment indenté.

Les heredocs en Ruby prennent également en charge l’interpolation de chaînes de caractères.

Comme vous pouvez le voir, il existe de nombreuses façons de gérer les sauts de ligne et les chaînes de caractères multilignes en Ruby. Vous rencontrerez toutes ces méthodes lorsque vous travaillerez avec du code Ruby existant, car chaque projet tend à avoir son propre style. Dans votre propre code, choisissez le style qui vous convient et soyez cohérent.

Replication de Chaîne

Il peut arriver que vous ayez besoin d’utiliser Ruby pour répéter plusieurs fois une chaîne de caractères. Vous pouvez le faire avec l’opérateur *. Comme l’opérateur +, l’opérateur * a une utilisation différente lorsqu’il est utilisé avec des nombres, où il est l’opérateur pour la multiplication. Lorsqu’il est utilisé avec une chaîne et un entier, * est l’opérateur de réplication de chaîne, répétant une seule chaîne autant de fois que vous le souhaitez en utilisant l’entier que vous fournissez.

Pour imprimer Sammy neuf fois, vous utiliseriez le code suivant :

print "Sammy" * 9

Ce code produit la sortie suivante :

Output
SammySammySammySammySammySammySammySammySammy

Vous pouvez utiliser ceci pour créer une belle art ASCII. Créez un fichier appelé banner.rb et ajoutez le code suivant :

puts "=" * 15
puts "| Hello World |"
puts "=" * 15

Pouvez-vous imaginer ce que le programme produira avant de l’exécuter ?

Il produit cette sortie :

Output
===============
| Hello World |
===============

Ceci n’est qu’un petit exemple de comment vous pouvez faire effectuer des tâches répétitives à l’ordinateur pour vous.

Conclusion

Dans ce tutoriel, vous avez appris comment travailler avec le type de données de chaîne dans le langage de programmation Ruby. Vous avez créé de nouvelles chaînes, les avez concaténées avec d’autres chaînes, et avez manipulé les sauts de ligne, les guillemets et les apostrophes. Ensuite, vous avez utilisé l’interpolation de chaîne pour faciliter le mélange de chaînes et de valeurs de variables, et vous avez appris comment répéter des chaînes.