{"id":41214,"date":"2026-03-11T09:23:01","date_gmt":"2026-03-11T09:23:01","guid":{"rendered":"https:\/\/www.railscarma.com\/?p=41214"},"modified":"2026-03-11T09:27:52","modified_gmt":"2026-03-11T09:27:52","slug":"maitriser-les-chaines-de-caracteres-multilignes-en-ruby-un-guide-complet","status":"publish","type":"post","link":"https:\/\/www.railscarma.com\/fr\/blog\/maitriser-les-chaines-de-caracteres-multilignes-en-ruby-un-guide-complet\/","title":{"rendered":"Ma\u00eetriser les cha\u00eenes multilignes en Ruby : Un guide complet"},"content":{"rendered":"
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Dans le monde de la programmation, les cha\u00eenes de caract\u00e8res constituent des \u00e9l\u00e9ments fondamentaux pour le traitement des donn\u00e9es textuelles. Ruby, connu pour sa syntaxe \u00e9l\u00e9gante et ses fonctionnalit\u00e9s adapt\u00e9es aux d\u00e9veloppeurs, offre une prise en charge robuste des cha\u00eenes de caract\u00e8res, notamment la possibilit\u00e9 de manipuler sans effort des cha\u00eenes multilignes. Les cha\u00eenes multilignes permettent aux d\u00e9veloppeurs de repr\u00e9senter du texte s'\u00e9tendant sur plusieurs lignes sans avoir \u00e0 concat\u00e9ner manuellement des cha\u00eenes d'une seule ligne ni \u00e0 ins\u00e9rer manuellement des caract\u00e8res de saut de ligne. Cette fonctionnalit\u00e9 est particuli\u00e8rement utile dans des cas tels que l'int\u00e9gration de mod\u00e8les HTML, l'\u00e9criture de requ\u00eates SQL, la g\u00e9n\u00e9ration de fichiers de configuration, ou m\u00eame la cr\u00e9ation d'extraits de code po\u00e9tiques.<\/span><\/p>

Ma\u00eetriser les cha\u00eenes multilignes en Ruby est essentiel pour tout d\u00e9veloppeur souhaitant \u00e9crire un code \u00e9pur\u00e9, lisible et facile \u00e0 maintenir. Cet article explore en profondeur ce concept, en passant en revue les diff\u00e9rentes m\u00e9thodes permettant de cr\u00e9er et de manipuler des cha\u00eenes multilignes, ainsi que leurs avantages, leurs pi\u00e8ges potentiels et les bonnes pratiques \u00e0 adopter. Nous aborderons tous les aspects, de la syntaxe de base aux techniques avanc\u00e9es, en s'appuyant sur de nombreux exemples pour illustrer les points cl\u00e9s. \u00c0 la fin de cet article, vous saurez parfaitement comment tirer parti des cha\u00eenes multilignes pour am\u00e9liorer vos projets Ruby. Que vous soyez un d\u00e9butant qui s'initie \u00e0 Ruby ou un programmeur exp\u00e9riment\u00e9 cherchant \u00e0 perfectionner ses comp\u00e9tences, ce guide vous apportera des informations pr\u00e9cieuses.<\/span><\/p>

La gestion des cha\u00eenes de caract\u00e8res en Ruby a \u00e9volu\u00e9 au fil des versions, avec des am\u00e9liorations en termes de lisibilit\u00e9 et de flexibilit\u00e9. Par exemple, Ruby 2.3 a introduit les \u00ab heredocs \u00bb entre accolades, qui g\u00e8rent automatiquement l\u2019indentation, rendant ainsi le code encore plus intuitif. Dans les derni\u00e8res versions de Ruby (jusqu\u2019\u00e0 Ruby 3.3 et au-del\u00e0), ces fonctionnalit\u00e9s restent au c\u0153ur du langage, garantissant la r\u00e9trocompatibilit\u00e9 tout en apportant des am\u00e9liorations.<\/span><\/p>

Les bases des cha\u00eenes de caract\u00e8res en Ruby<\/b><\/h3>

Avant d\u2019aborder les cha\u00eenes multilignes, il est utile de rappeler les principes fondamentaux des cha\u00eenes de caract\u00e8res en Ruby. Les cha\u00eenes sont des s\u00e9quences de caract\u00e8res encadr\u00e9es par des guillemets simples (\u2018) ou doubles (\u201c). Les cha\u00eenes entre guillemets simples sont litt\u00e9rales, ce qui signifie qu\u2019elles ne prennent pas en charge l\u2019interpolation ni les s\u00e9quences d\u2019\u00e9chappement autres que \u2018 et \\. Les cha\u00eenes entre guillemets doubles, en revanche, permettent l\u2019interpolation \u00e0 l\u2019aide de #{expression} et prennent en charge un large \u00e9ventail de s\u00e9quences d\u2019\u00e9chappement telles que \\n pour le saut de ligne, \\t pour la tabulation et \\u pour les caract\u00e8res Unicode.<\/span><\/p>

Par exemple:<\/span><\/p>

rubis<\/span>
single = 'Bonjour, le monde !'<\/span>
double = \"Bonjour, #{name} !\"<\/span><\/pre>
Cette distinction est essentielle, car les cha\u00eenes multilignes s'appuient sur ces principes. Lorsque le texte doit s'\u00e9tendre sur plusieurs lignes, l'utilisation des guillemets simples devient fastidieuse. Imaginez que vous \u00e9criviez un paragraphe : ins\u00e9rer un \\n \u00e0 chaque fois encombrerait le code. C'est l\u00e0 qu'interviennent les constructions multilignes, qui offrent un moyen plus naturel d'exprimer un texte plus long.<\/span><\/p>
Les cha\u00eenes multilignes ne sont pas une exclusivit\u00e9 de Ruby : de nombreux langages, tels que Python (guillemets triples), JavaScript (litt\u00e9raux de mod\u00e8le) et Perl (here documents), proposent des fonctionnalit\u00e9s similaires. Cependant, les impl\u00e9mentations de Ruby se distinguent par leur polyvalence et leur int\u00e9gration \u00e0 la nature orient\u00e9e objet du langage. En Ruby, les cha\u00eenes de caract\u00e8res sont des instances de la classe `String`, h\u00e9ritant de m\u00e9thodes telles que `gsub`, `strip` et `split`, qui s'appliquent \u00e9galement aux variantes multilignes.<\/span><\/p>
D\u00e9finition des cha\u00eenes multilignes : approches simples<\/b><\/h3>
La mani\u00e8re la plus simple de cr\u00e9er une cha\u00eene multiligne consiste \u00e0 utiliser des guillemets doubles et \u00e0 ins\u00e9rer explicitement des caract\u00e8res de nouvelle ligne. Cette m\u00e9thode est simple, mais peut s'av\u00e9rer peu pratique pour les textes plus longs.<\/span><\/p>
rubis<\/span>
multiline = \"Voici la premi\u00e8re ligne.\\nVoici la deuxi\u00e8me ligne.\\nEt voici la troisi\u00e8me ligne.\"<\/span>
affiche sur plusieurs lignes<\/span><\/pre>
Sortir:<\/strong>
<\/span>Voici la premi\u00e8re ligne.
<\/span>Voici la deuxi\u00e8me ligne.
<\/span>Et voici la troisi\u00e8me ligne.<\/span><\/p>
Bien qu'efficace, cette approche n\u00e9cessite une gestion manuelle des sauts de ligne, ce qui peut entra\u00eener des erreurs de mise en forme. Une alternative consiste \u00e0 utiliser la concat\u00e9nation de cha\u00eenes avec l'op\u00e9rateur + ou << (op\u00e9rateur \u00ab shovel \u00bb), mais cela rend souvent le code moins lisible :<\/span><\/p>
rubis<\/span>
multiline = \"C'est la premi\u00e8re ligne.\\n\" +<\/span>
 \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\" Voici la deuxi\u00e8me ligne.\\n \" +<\/span>
 \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\" Et voici la troisi\u00e8me ligne. \"<\/span><\/pre>
Ou encore en utilisant les \u00ab heredocs \u00bb, que nous aborderons ensuite, pour une meilleure lisibilit\u00e9. Ces m\u00e9thodes de base conviennent pour de courts textes sur plusieurs lignes, mais s'av\u00e8rent insuffisantes dans des cas complexes impliquant des indentations ou de longs blocs de texte.<\/span><\/p>
Heredocs : l'outil incontournable pour le texte sur plusieurs lignes<\/b><\/h3>
Heredocs<\/span><\/a> (abr\u00e9viation de \u201c here documents \u201d) constituent le m\u00e9canisme par excellence de Ruby pour d\u00e9finir des cha\u00eenes de caract\u00e8res multilignes. Ils permettent de sp\u00e9cifier un d\u00e9limiteur et d'\u00e9crire le texte librement jusqu'\u00e0 ce que ce d\u00e9limiteur soit \u00e0 nouveau rencontr\u00e9. La syntaxe commence par << suivi du d\u00e9limiteur (souvent en majuscules, comme EOF ou END).<\/span><\/p>
rubis<\/span>
multiline = <<EOF<\/span>
Il s'agit d'un heredoc.<\/span>
Il peut s'\u00e9tendre sur plusieurs lignes.<\/span>
L'interpolation fonctionne si l'on utilise <<EOF (entre guillemets doubles).<\/span>
La valeur de 2 + 2 est #{2 + 2}.<\/span>
Fin de fichier<\/span>
affiche sur plusieurs lignes<\/span><\/pre>
Sortir:
<\/strong>Il s'agit d'un heredoc.
<\/span>Il peut s'\u00e9tendre sur plusieurs lignes.
<\/span>L'interpolation fonctionne si l'on utilise <<EOF (entre guillemets doubles).
<\/span>La valeur de 2 + 2 est 4.<\/span><\/p>
Par d\u00e9faut, les herdocs se comportent comme des cha\u00eenes entre guillemets doubles et prennent en charge l\u2019interpolation et les s\u00e9quences d\u2019\u00e9chappement. Pour obtenir un comportement similaire \u00e0 celui des guillemets simples (sans interpolation), utilisez <<\u2018EOF\u2019 ou <<-EOF en pla\u00e7ant le d\u00e9limiteur entre guillemets simples.<\/span><\/p>
L'une des principales fonctionnalit\u00e9s est la possibilit\u00e9 d'utiliser des \u00ab heredocs \u00bb avec tirets (<<-EOF), ce qui permet d'indenter le d\u00e9limiteur de fermeture et d'am\u00e9liorer ainsi l'alignement du code :<\/span><\/p>
rubis<\/span>
def some_method<\/span>
 \u00a0<<-EOF<\/span>
 \u00a0\u00a0\u00a0Heredoc avec indentation.<\/span>
 \u00a0\u00a0\u00a0Cette balise de fermeture EOF peut \u00eatre indent\u00e9e.<\/span>
 \u00a0Fin de fichier<\/span>
fin<\/span><\/pre>
Cela s'av\u00e8re particuli\u00e8rement utile dans les m\u00e9thodes ou les classes o\u00f9 l'indentation est importante pour la lisibilit\u00e9. Cependant, les \u00ab heredocs \u00bb traditionnels incluent des espaces en d\u00e9but de cha\u00eene, ce qui n'est pas toujours souhaitable.<\/span><\/p>
Heredocs \u00ab ondul\u00e9s \u00bb : gestion moderne de l'indentation<\/b><\/h3>
Introduits dans Ruby 2.3, les heredocs avec tiret (<<~EOF) r\u00e9solvent le probl\u00e8me d'indentation en supprimant automatiquement les espaces en d\u00e9but de ligne, en se basant sur la ligne la moins indent\u00e9e. Cela les rend parfaits pour int\u00e9grer des extraits de code, du YAML ou du JSON sans traitement suppl\u00e9mentaire.<\/span><\/p>
rubis<\/span>
multiline = <<~EOF<\/span>
 \u00a0Cette ligne comporte deux espaces.<\/span>
 \u00a0\u00a0\u00a0Celui-ci en a quatre.<\/span>
 \u00a0Retour \u00e0 deux.<\/span>
Fin de fichier<\/span>
affiche sur plusieurs lignes<\/span><\/pre>
Sortir:
<\/strong>Cette ligne comporte deux espaces.
<\/span>\u00a0\u00a0Celui-ci en a quatre.
<\/span>Retour \u00e0 deux.<\/span><\/p>
L'op\u00e9rateur tilde (~) garantit que la cha\u00eene est \u201d d\u00e9indent\u00e9e \u00bb, en supprimant les espaces de d\u00e9but courants. Cette fonctionnalit\u00e9 a r\u00e9volutionn\u00e9 la mani\u00e8re dont les d\u00e9veloppeurs g\u00e8rent les cha\u00eenes multilignes, r\u00e9duisant ainsi le recours \u00e0 des m\u00e9thodes de post-traitement telles que gsub(\/^\\s+\/, \u201d).<\/span><\/p>
Les heredocs \u00ab ondul\u00e9s \u00bb prennent toujours en charge l'interpolation, ce qui les rend polyvalents pour le contenu dynamique. Par exemple, dans le d\u00e9veloppement web avec des frameworks tels que Rails, ils sont couramment utilis\u00e9s pour les mod\u00e8les d'e-mails ou les partiels de vue.<\/span><\/p>
Notation en pourcentage : %Q et %q pour la flexibilit\u00e9<\/b><\/h3>
Ruby propose une autre fa\u00e7on de d\u00e9finir des cha\u00eenes multilignes \u00e0 l'aide de la notation en pourcentage, par exemple %Q{} ou %q[]. Ces cha\u00eenes sont similaires \u00e0 celles entre guillemets doubles ou simples, mais permettent d'utiliser des d\u00e9limiteurs personnalis\u00e9s, ce qui s'av\u00e8re pratique lorsque la cha\u00eene contient des guillemets ou d'autres caract\u00e8res sp\u00e9ciaux.<\/span><\/p>
rubis<\/span>
multiline = %Q{<\/span>
Il s'agit d'une cha\u00eene de caract\u00e8res sur plusieurs lignes.<\/span>
Il utilise des accolades comme d\u00e9limiteurs.<\/span>
Interpolation : #{Time.now}<\/span>
}<\/span><\/pre>
Les d\u00e9limiteurs peuvent \u00eatre n'importe quels caract\u00e8res non alphanum\u00e9riques, comme %Q|texte| ou %Q[texte]. Pour les versions sans interpolation, utilisez %q.<\/span><\/p>
Cette notation est particuli\u00e8rement utile pour les cha\u00eenes contenant des guillemets imbriqu\u00e9s :<\/span><\/p>
rubis<\/span>
html = %Q{<div class="container">Bonjour, " monde " !<\/div>}<\/span><\/pre>
La notation en pourcentage offre une alternative aux heredocs lorsque vous avez besoin d'un plus grand contr\u00f4le sur les d\u00e9limiteurs, m\u00eame si les heredocs sont g\u00e9n\u00e9ralement pr\u00e9f\u00e9r\u00e9s pour les textes tr\u00e8s longs en raison de leurs marqueurs de d\u00e9but et de fin explicites.<\/span><\/p>
Interpolation et contenu dynamique<\/b><\/h3>
L'un des atouts de Ruby r\u00e9side dans l'interpolation de cha\u00eenes, qui permet d'int\u00e9grer de mani\u00e8re transparente des expressions au sein de cha\u00eenes entre guillemets doubles ou \u00e9quivalentes. Dans les contextes multilignes, cela permet de cr\u00e9er des mod\u00e8les tr\u00e8s puissants.<\/span><\/p>
Vous pouvez envisager de cr\u00e9er un fichier de configuration :<\/span><\/p>
rubis<\/span>
config = <<~CONFIG<\/span>
 \u00a0serveur : #{ENV['SERVER_HOST']}<\/span>
 \u00a0port : #{3000}<\/span>
 \u00a0base de donn\u00e9es :<\/span>
 \u00a0\u00a0\u00a0nom : #{db_name}<\/span>
 \u00a0\u00a0\u00a0utilisateur : #{db_user}<\/span>
CONFIG<\/span><\/pre>
Cette fonctionnalit\u00e9 dynamique est d'une utilit\u00e9 inestimable dans la programmation de scripts, o\u00f9 des variables ou des appels de m\u00e9thodes peuvent venir compl\u00e9ter la cha\u00eene de caract\u00e8res. Il convient toutefois de faire preuve de prudence avec les donn\u00e9es fournies par l'utilisateur afin d'\u00e9viter les vuln\u00e9rabilit\u00e9s li\u00e9es \u00e0 l'injection ; veillez \u00e0 toujours valider les donn\u00e9es.<\/span><\/p>
Pour des mod\u00e8les plus complexes, la biblioth\u00e8que ERB (Embedded Ruby) de Ruby permet de traiter des cha\u00eenes de caract\u00e8res multilignes contenant du code int\u00e9gr\u00e9 :<\/span><\/p>
rubis<\/span>
require 'erb'
<\/span>
template = <<~ERB<\/span>
 \u00a0Bonjour,  !<\/span>
 \u00a0Votre score est .<\/span>
ERB<\/span><\/pre>
\u00a0<\/p>
renderer = ERB.new(template)<\/span>
puts renderer.result(binding)\u00a0 <\/span># En supposant que \u00ab nom \u00bb et \u00ab score \u00bb soient d\u00e9finis<\/span><\/i><\/p>
Cela permet de transformer les cha\u00eenes de caract\u00e8res multilignes en v\u00e9ritables mod\u00e8les, couramment utilis\u00e9s dans les applications web.<\/span><\/p>
Gestion des indentations et techniques de d\u00e9capage<\/b><\/h3>
La gestion des indentations dans les cha\u00eenes de caract\u00e8res multilignes est un probl\u00e8me courant. Outre les \u00ab heredocs \u00bb ondul\u00e9s, vous pouvez utiliser String#strip_heredoc (une extension Rails, mais qui peut \u00eatre impl\u00e9ment\u00e9e en Ruby pur) ou proc\u00e9der \u00e0 un retrait manuel.<\/span><\/p>
Une m\u00e9thode personnalis\u00e9e pourrait se pr\u00e9senter comme suit :<\/span><\/p>
rubis<\/span>
classe String<\/span>
 \u00a0def strip_heredoc<\/span>
 \u00a0\u00a0\u00a0gsub(\/^<\/span>#{scan(\/^\\s*\/).min_by(&:length)}\/, '')<\/span><\/i>
 \u00a0fin<\/span>
fin<\/span><\/pre>
\u00a0<\/p>
multiline = <<~EOF.strip_heredoc<\/span>
 \u00a0Texte en retrait.<\/span>
 \u00a0\u00a0\u00a0Encore plus d'indentation.<\/span>
 \u00a0Moins.<\/span>
Fin de fichier<\/span><\/p>
Cela garantit un r\u00e9sultat propre. Dans Ruby 3.0 et versions ult\u00e9rieures, la m\u00e9thode `String#strip` supprime \u00e9galement les sauts de ligne en d\u00e9but et en fin de cha\u00eene, mais pour l'indentation, il est pr\u00e9f\u00e9rable d'utiliser des solutions personnalis\u00e9es ou des heredocs ondul\u00e9s.<\/span><\/p>
Cas d'utilisation dans des applications concr\u00e8tes<\/b><\/h3>
Les cha\u00eenes multilignes s'av\u00e8rent tr\u00e8s utiles dans divers domaines. En d\u00e9veloppement web, elles sont utilis\u00e9es pour les extraits de code HTML :<\/span><\/p>
rubis<\/span>
html = <<~HTML<\/span>
 \u00a0<html><\/span>
 \u00a0\u00a0\u00a0<body><\/span>
 \u00a0\u00a0\u00a0\u00a0\u00a0<p>Bonjour, le monde !<\/p><\/span>
 \u00a0\u00a0\u00a0<\/body><\/span>
 \u00a0<\/html><\/span>
HTML<\/span><\/pre>
Dans le cadre des interactions avec les bases de donn\u00e9es, pour les requ\u00eates SQL :<\/span><\/p>
rubis<\/span>
requ\u00eate = <<~SQL<\/span>
 \u00a0SELECT * FROM utilisateurs<\/span>
 \u00a0L\u00c0 O\u00d9 \u00e2ge > #{min_\u00e2ge}<\/span>
 \u00a0ORDER BY nom ;<\/span>
SQL<\/span><\/pre>
Faites attention aux attaques par injection SQL ; utilisez plut\u00f4t des requ\u00eates pr\u00e9par\u00e9es.<\/span><\/p>
En mati\u00e8re de script, les cha\u00eenes multilignes peuvent contenir des commandes de shell ou des configurations. Lors des tests, elles sont tr\u00e8s utiles pour simuler des donn\u00e9es ou des r\u00e9sultats attendus.<\/span><\/p>
Dans le d\u00e9veloppement de jeux vid\u00e9o ou l'art ASCII, les cha\u00eenes multilignes conservent leur mise en forme :<\/span><\/p>
rubis<\/span>
art = <<~ART<\/span>
 \u00a0\/\\<\/span>
 \/\u00a0 \\<\/span>
\/____\\<\/span>
ART<\/span><\/pre>
Ces exemples mettent en \u00e9vidence leur aspect pratique dans divers \u00e9cosyst\u00e8mes Ruby tels que Rails, Sinatra ou encore les scripts autonomes.<\/span><\/p>
Bonnes pratiques pour l'utilisation des cha\u00eenes multilignes<\/b><\/h3>
Pour optimiser l'efficacit\u00e9 :<\/span><\/p>
  1. Choisissez la bonne m\u00e9thode<\/b>: Utilisez les \u00ab heredocs \u00bb pour les textes longs et la notation en pourcentage pour les cha\u00eenes comportant de nombreux d\u00e9limiteurs.<\/span><\/li>
  2. Je pr\u00e9f\u00e8re les her\u00e9docs ondul\u00e9s<\/b>: \u00c0 partir de Ruby 2.3, l'indentation est g\u00e9r\u00e9e automatiquement.<\/span><\/li>
  3. \u00c9viter une interpolation excessive<\/b>: Pour des raisons de s\u00e9curit\u00e9 et de lisibilit\u00e9, limitez les \u00e9l\u00e9ments dynamiques.<\/span><\/li>
  4. Veillez \u00e0 ce que le texte reste lisible<\/b>: Alignez les s\u00e9parateurs et veillez \u00e0 la coh\u00e9rence de la mise en forme.<\/span><\/li>
  5. R\u00e9sultats des tests<\/b>: Afficher ou examiner des cha\u00eenes de caract\u00e8res multilignes pour v\u00e9rifier leur mise en forme.<\/span><\/li>
  6. Utilisez l'encodage \u00e0 bon escient<\/b>: Pr\u00e9cisez l'encodage si vous utilisez des caract\u00e8res non ASCII, par exemple <<~EOF:UTF-8.<\/span><\/li><\/ol>
    Le respect de ces principes garantit un code propre.<\/span><\/p>
    Les pi\u00e8ges les plus courants et comment les \u00e9viter<\/b><\/h3>
    Parmi les \u00e9cueils, on peut citer :<\/span><\/p>