TOC

Comment travailler avec des cordes en rubis

introduction

Une chaîne est une séquence d’un ou de plusieurs caractères pouvant être constitués de lettres, de chiffres ou de symboles.

Strings in Ruby sont des objets et, contrairement à d’autres langages, les chaînes sont mutable, ce qui signifie qu’elles peuvent être modifiées à la place. au lieu de créer de nouvelles chaînes.

Vous utiliserez des chaînes dans presque tous les programmes que vous écrivez. Les chaînes vous permettent d’afficher et de communiquer avec vos utilisateurs à l’aide de texte. En fait, la page que vous lisez en ce moment est composée de chaînes affichées sur votre écran via votre navigateur Web. Les chaînes sont l’un des principes fondamentaux les plus importants de la programmation.

Dans ce tutoriel, vous apprendrez à utiliser les chaînes dans Ruby. Vous allez créer des chaînes, les afficher à l’écran, les stocker dans des variables, réunir plusieurs chaînes et apprendre à gérer des caractères spéciaux tels que les nouvelles lignes, les apostrophes et les guillemets.

Création et impression de chaînes

Les chaînes existent entre guillemets simples + '+ ou entre guillemets `+" + `en Ruby, donc pour créer une chaîne, placez 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, peu importe celui que vous choisissez, tant que vous êtes cohérent. Toutefois, l’utilisation de guillemets doubles vous permet d’effectuer une interpolation de chaîne, que vous apprendrez dans ce didacticiel.

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.

Essaye le. Create un nouveau programme Ruby appelé + print.rb + en utilisant votre éditeur de texte et utilisez `+ print + `pour imprimer trois chaînes:

print.rb

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

Enregistrez le fichier et lancez le programme:

ruby print.rb

Vous verrez le résultat suivant:

OutputThis 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, elles ont été imprimées ensemble sur une seule ligne. La méthode `+ print + 'affiche la chaîne à l’écran, mais si vous voulez que chaque chaîne soit sur sa propre ligne, vous devez ajouter un caractère de saut de ligne.

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

print.rb

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

Lancez à nouveau le programme et vous verrez cette sortie:

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

La méthode + met + affiche la chaîne que vous spécifiez, mais ajoute également un caractère de nouvelle ligne à la fin de la chaîne.

Stockage de chaînes dans des variables

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 affectez 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 le tester vous-même, créez le fichier + string_variables.rb + dans votre éditeur et ajoutez le code suivant:

string_variables.rb

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. Une variable est attribuée à chaque variable. Nous utilisons ensuite la méthode + met + pour imprimer chaque chaîne sur sa propre ligne.

Enregistrez le fichier et exécutez le programme:

ruby string_variables.rb

Vous verrez le résultat suivant:

OutputSammy the Shark
none of your business

En affectant des chaînes à des variables, vous pouvez éviter de taper la même chaîne à chaque fois que vous souhaitez l’utiliser, ce qui simplifie l’utilisation et la manipulation de chaînes dans vos programmes.

Voyons comment joindre des chaînes pour créer de nouvelles chaînes.

Concaténation de cordes

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

Voici comment concaténer les chaînes + sammy + et + shark +:

"sammy" + "shark"

Cela produirait la sortie suivante:

Outputsammyshark

La concaténation joint les chaînes de bout en bout pour les combiner et générer une nouvelle valeur de chaîne. Si vous voulez laisser un espace entre les mots + sammy + et + shark +, vous devez inclure cet espace dans l’une des chaînes, comme ceci:

"sammy " + "shark"

Vous n’écrivez pas vraiment un code comme celui-ci dans un programme, mais vous aurez souvent besoin de mélanger des chaînes et des variables, c’est là que la concaténation entre en jeu.

Voici un exemple:

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

Cela aurait pour résultat la 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 façon. Créez le fichier + concatenation.rb + et ajoutez ce code:

concaténation.rb

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_string +, chacune avec sa propre chaîne affectée, comme vous l’avez fait auparavant. Mais cette fois, au lieu d’imprimer les valeurs, nous imprimons une chaîne qui utilise la concaténation pour imprimer ces valeurs avec davantage de contexte.

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

OutputMy 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 chaînes ou plus par concaténation, vous créez une nouvelle chaîne que vous pouvez utiliser tout au long de votre programme. Vous pouvez ainsi affecter la chaîne que vous avez créée à une nouvelle variable que vous pourrez utiliser plus tard:

concaténation.rb

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

# assign concatenated string to variable
output = "My name is " + my_name + " and my age is " + my_age + "."

# Print the output.
puts output

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

Veillez à ne pas utiliser l’opérateur + entre deux types de données différents. Par exemple, vous ne pouvez pas concaténer des chaînes et des entiers.

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

strings_and_integers.rb

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

Cette fois, nous avons + mon_nom + qui contient la chaîne + Sammy le requin + et + mon_numéro + qui contient l’entier + 27 +. Nous savons que + 27 + n’est pas une chaîne car elle est entourée de guillemets. De plus, il n’a pas de point décimal, nous savons donc que c’est un entier.

Si vous exécutez le programme:

ruby strings_and_ints.rb

Vous verrez ce message d’erreur:

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

L’erreur + aucune conversion implicite d’Integer en String + signifie que Ruby ne peut concaténer qu’une chaîne avec la chaîne existante.

Nous pourrions modifier notre programme et placer le nombre` + 27 + entre guillemets ( + "27" + `) de manière à ce qu’il soit déclaré sous forme de chaîne au lieu d’un entier. Ou nous pouvons convertir le nombre en chaîne lorsque nous créons cette chaîne, comme ceci:

strings_and_integers.rb

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

La méthode + .to_s + convertit l’entier en chaîne. C’est une meilleure approche, car elle nous permet de conserver notre nombre sous la forme d’un entier dans notre programme. Nous avons seulement besoin que ce soit une chaîne lorsque nous l’imprimons, mais nous pouvons souhaiter que ce soit un entier si nous devons l’utiliser dans d’autres parties de la logique de notre programme.

Réexécutez le programme et vous verrez «+ Sammy the Shark27 +» imprimé à l’écran.

La conversion de nombres en chaînes à des fins de concaténation est une chose que vous rencontrerez fréquemment lorsque vous utilisez 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 à côté de texte.

La concaténation est puissante, mais elle peut être délicate. Si vous laissez 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 un autre moyen 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

Lors de la concaténation de chaînes et de variables, la sortie peut être difficile à lire et à mettre au point. L’interpolation de chaîne résout ce problème en vous permettant d’intégrer des expressions dans une chaîne entre guillemets.

Au lieu d’écrire ceci:

"My name is " + my_name + "!"

Tu peux le faire:

"My name is #{my_name}!"

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

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

interpolation.rb

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

C’est le même programme que vous avez déjà écrit, mais cette fois-ci, nous utilisons une interpolation de chaîne pour créer la sortie.

L’interpolation de chaîne présente un autre avantage: elle permet de convertir automatiquement des valeurs numériques en chaînes. Vous souvenez-vous de votre programme + strings_and_integers.rb +? Ouvrez à nouveau ce fichier dans votre éditeur, mais modifiez la dernière ligne pour obtenir le résultat suivant:

strings_and_integers.rb

my_name = "Sammy the Shark"
my_number = 27

# use interpolation instead of concatenation
print "My name is #{my_name} and my favorite number is #{my_number}."

Ruby convertira automatiquement + my_number + en chaîne et votre programme imprimera le résultat suivant lors de son exécution:

OutputMy name is Sammy the Shark and my favorite number is 27.

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

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

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

Il y a une distinction en se référant à chacun de ceux-ci. Une chaîne littérale est la chaîne telle qu’elle est écrite dans le code source, y compris les citations. Une valeur_string correspond à ce que vous voyez dans la sortie et n’inclut pas de citations.

C’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 ne devrez pas vous inquiéter de cette différence, sauf si vous souhaitez utiliser des caractères spéciaux tels que des guillemets ou des apostrophes dans vos chaînes.

Escaping Quotes and Apostrophes in Strings

Étant donné que les guillemets sont utilisés pour désigner les chaînes, vous devrez faire un peu plus de travail si vous voulez des apostrophes et des guillemets dans les chaînes.

Si vous essayez d’utiliser une apostrophe au milieu d’une chaîne entre guillemets simples, procédez comme suit:

'This isn't what I wanted.'

L’apostrophe dans + n’est pas + termine la chaîne, comme le montre l’étrange mise en surbrillance de cet exemple. En conséquence, l’interpréteur Ruby essaiera d’analyser le reste de la chaîne prévue sous forme de code et vous obtiendrez une erreur.

Vous rencontriez la même situation si vous utilisiez des guillemets dans une chaîne entre guillemets:

"Sammy says, "Hello!""

Dans cet exemple, la double guillemet fermante devant + Hello + met fin à la chaîne et la guillemet double après + Hello! + Crée une nouvelle chaîne sans citation double correspondante pour la terminer, donc Ruby va afficher une erreur.

Pour éviter ce problème, vous avez quelques options. Tout d’abord, 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 inversement. Vous pouvez aussi escape les guillemets, ou vous pouvez utiliser une syntaxe différente de Ruby pour définir les chaînes. Examinons chaque approche.

Option 1: Utiliser la syntaxe de chaîne alternative

Le moyen le plus simple de résoudre ces problèmes consiste à placer votre chaîne entre guillemets simples lorsque celle-ci doit comporter un guillemet double et à placer votre chaîne entre 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-le avec des guillemets:

"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 la syntaxe alternative peut vous aider à sortir de certains embouteillages rapides, mais cela ne fonctionnera pas toujours. Par exemple, aucune approche ne fonctionnera pour cette chaîne:

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

Dans cet exemple, la double citation de clôture devant + I’m + jette vraiment les choses. Ceci termine la première chaîne, puis Ruby rencontre l’apostrophe dans + je suis +, qui commence une nouvelle chaîne avec la valeur + m un requin heureux!" "+. Mais cette nouvelle chaîne n’a pas de guillemet simple correspondant pour la terminer. Et utiliser des guillemets simples pour entourer la chaîne pose un problème similaire:

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

Cette fois, l’apostrophe dans + I’m I’m + met fin à la chaîne.

L’utilisation de la syntaxe alternative peut également rendre votre code incohérent. Passer constamment d’une syntaxe à une autre peut être source de confusion. Nous pouvons échapper aux caractères pour résoudre ce problème.

Option 2: caractères d’échappement dans les chaînes

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

Voici notre chaîne problématique, codée entre guillemets, avec des guillemets à 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:

citant.rb

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

Exécutez le programme:

ruby quoting.rb

Et vous verrez cette sortie:

Outputquoting.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 inversée devant les guillemets intérieurs:

citant.rb

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

Puis relancez le programme et vous verrez le résultat attendu:

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

Notez que vous ne devez pas échapper à l’apostrophe dans cet exemple, car il n’y a pas de conflit. Vous avez seulement besoin d’échapper aux citations qui vont confondre Ruby.

Vous pouvez éviter d’échapper entièrement aux guillemets en utilisant une syntaxe différente pour définir des chaînes.

Option 3: Utiliser une syntaxe alternative pour les chaînes

Jusqu’à présent, vous utilisiez des guillemets pour définir les limites de vos chaînes. Vous pouvez également créer des chaînes dans Ruby en utilisant d’autres caractères. Vous pouvez définir le delimiter, ou le caractère que vous souhaitez utiliser pour entourer 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 aux chaînes incorporé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 le quitter si vous devez l’utiliser. Dans ce cas. si vous deviez utiliser un signe dollar dans votre chaîne, vous devrez échapper au signe dollar littéral dans la chaîne.

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

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

Ces formulaires prennent tous 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, ce qui signifie que vous n’êtes pas obligé d’exercer une double impasse, et que vous pourrez utiliser l’interpolation de chaîne:

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

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

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

Vous remarquerez peut-être la syntaxe +% q + et +% Q + utilisée avec des parenthèses ou des accolades carrées dans certains programmes au lieu des accolades.

Comme vous pouvez le constater, il existe de nombreuses façons de créer des chaînes dans Ruby. Quelle que soit la méthode choisie, 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, voyons comment gérer les chaînes longues et les caractères de nouvelle ligne.

Cordes longues et nouvelles lignes

Il peut arriver que vous souhaitiez insérer un caractère de nouvelle ligne ou un retour à la ligne dans votre chaîne. Vous pouvez utiliser les caractères d’échappement + \ n + ou + \ r + pour insérer une nouvelle ligne dans le code:

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

Ce programme produirait cette sortie:

OutputThis is
a string
with newlines

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

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

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

Cela ne fait que concaténer trois chaînes, semblables à ce que vous avez déjà fait.

Vous pouvez aussi 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 n’importe quelle syntaxe de chaîne alternative 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 nouvelle ligne (+ \ n +). Cette approche préserve les espaces, y compris l’indentation et les nouvelles lignes.

En conséquence, la sortie contiendra les sauts de ligne, ainsi que tous les caractères d’indentation, comme ceci:

OutputThis 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 à l’aide d’un _https: //en.wikipedia.org/wiki/Here_document [heredoc] _ ou de «ici document», terme utilisé pour les littéraux de chaînes multilignes dans les programmes. Voici comment vous avez écrit ce code:

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

Les marqueurs + << - END et` + END` indiquent le début et la fin de l’hérédoc.

Heredocs dans Ruby conserve également les caractères d’espacement, ce qui signifie que si vous indentez le code dans le code heredoc, l’indentation de tête est également conservée. Donc ce code:

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

serait imprimer avec deux espaces d’indentation.

Ruby 2.3 et les versions ultérieures fournissent la syntaxe «squiggly heredoc» qui supprime automatiquement cet espace blanc. Remplacez le tiret dans la définition heredoc par un tilde, ainsi + << - + 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:

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

Cela vous permet d’utiliser heredocs et de garder votre code bien en retrait.

Heredocs in Ruby prend également en charge l’interpolation de chaînes.

Comme vous pouvez le constater, il existe de nombreuses façons de gérer les nouvelles lignes et les chaînes multilignes dans Ruby. Vous rencontrerez toutes ces méthodes lorsque vous travaillerez avec du code Ruby existant, chaque projet ayant généralement son propre style. Dans votre propre code, choisissez le style qui vous convient et soyez cohérent.

Réplication de chaîne

Il peut arriver que vous deviez 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 de la multiplication. Lorsqu'il est utilisé avec une chaîne et un entier, ` * +` est l’opérateur de réplication _string, répétant une seule chaîne autant de fois que vous souhaitez utiliser l’entier que vous avez fourni.

Pour imprimer + Sammy + neuf fois, vous devez utiliser le code suivant:

print "Sammy" * 9

Ce code produit la sortie suivante:

OutputSammySammySammySammySammySammySammySammySammy

Vous pouvez l’utiliser pour créer de beaux dessins ASCII. Créez un fichier nommé + banner.rb + et ajoutez le code suivant:

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

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

Il produit cette sortie:

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

Ceci est juste un petit exemple de la façon dont vous pouvez obliger l’ordinateur à effectuer des tâches répétitives à votre place.

Conclusion

Dans ce tutoriel, vous avez appris à travailler avec le type de données String 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 géré les nouvelles lignes, les guillemets et les apostrophes. Vous avez ensuite utilisé une interpolation de chaîne pour faciliter le mélange de chaînes et de valeurs variables, et vous avez appris à répéter des chaînes.

Related