Les chaînes de caractères en Ruby

Parce qu’il est bon de se rafraichir la mémoire de temps en temps, aujourd’hui nous allons nous intéresser aux différentes possibilités que nous offre Ruby pour le formatage des chaînes de caractères.

Les chaînes de caractères servent à représenter des clés (dans une structure JSON par exemple) ou bien afficher du texte. Pour manipuler ces morceaux de texte, Ruby nous offre une pléthore de méthodes que je vous propose de voir/revoir dans ce billet.

Les deux types de représentation

Nous avons deux possibilités pour définir simplement une chaîne de caractères en Ruby : les simple quotes et les double quotes.

Ce qui différencie ces deux types, c’est que la représentation en simple quotes ne permet pas l’interpolation de code, tandis que son pendant en double quotes le permet.

Un petit exemple :

b = 'Bernard'

'Salut #{b}'
=> "Salut \#{b}"

"Salut #{b}"
=> "Salut Bernard"

Voici plusieurs manières d’évaluer du code dans une chaîne de caractères en Ruby :

• "chaine #{code}"
• "chaine %s" % [code]
• "chaine %{code}" % { code: 'chaine' }

Le premier exemple est de l’interpolation, tandis que les deux suivants sont du formatage. Le %s signifie que le remplacement de cette clé devra être une chaîne de caractères. %d par exemple devra être remplacé par un nombre. Mais ce sujet mérite sa propre section.

Les caractères d’échappements

On peut insérer dans une chaîne des caractères dit d’échappement. Ceux-ci sont précédés d’un \ et insèrent une tabulation ou bien un retour à la ligne.

Voici les plus courants :

• \" : double quotes (utilisé dans une chaînes de caractères à double quotes, pour rendre le caractère double quote et ne pas mettre fin à la chaîne de caractères)
• \' : simple quote (utilisé dans une chaînes de caractères à simple quotes, pour rendre le caractère simple quote et ne pas mettre fin à la chaîne de caractères)
• \\ : antislash
• \a : alerte (en général retranscrite par la console par un son)
• \b : suppression du caractère précédent
• \r : retour de chariot (fin de ligne)
• \n : retour à la ligne
• \s : espace
• \t : tabulation

Heredoc

Que dites-vous d’une petite passe sur la syntaxe Heredoc ? Souvent utilisée pour le formatage de requêtes SQL, elle commence par << suivi d’un identifiant. Tous les types de caractères suivant seront pris en compte, jusqu’à ce que l’identifiant soit réutilisé pour clore la chaîne.

Voyons quelques exemples :

puts <<SQL
SELECT name
     , age
FROM users
SQL

# donne
SELECT name
     , age
FROM users

L’identifiant ici est SQL et on peut constater que l’indentation est rendue telle que définie.

La syntaxe <<- est une variante à la syntaxe <<. Elle est plus permissive, car elle permet à l’identifiant fermant d’être indenté. Par exemple si l’on est dans une méthode définissant une chaîne de caractères avec la syntaxe Heredoc, et avec une indentation de deux espaces, alors l’identifiant fermant peut être placé à 4 espaces du début de la ligne. Sans le petit tiret, il faudrait qu’il soit placé en tout début. Un petit exemple :) :

  # sans le tiret
  def ma_requete
    puts <<SQL
      SELECT name
          , age
      FROM users
SQL
  end

  # avec le tiret
  def ma_requete
    puts <<-SQL
      SELECT name
          , age
      FROM users
    SQL
  end

Une seconde variante, avec la syntaxe <<~ permet quant à elle de retirer les espaces indésirables en début de ligne. Comme on l’a dit plus tôt, tous les caractères compris entre l’identifiant du début et celui de fin, sont pris en compte. Dans notre exemple précédent, nous avons indenté notre chaîne pour que le code soit clair et beau, mais le résultat va être le suivant :

    SELECT name
         , age
    FROM users

On retrouve nos espaces en début de chaque ligne… C’est donc pour palier à ce problème que la dernière syntaxe à été ajoutée à Ruby 2.3. En utilisant cette dernière, les espaces en début de lignes sont retirées !

Et cerise sur la gâteau, la syntaxe Heredoc permet l’interpolation de code !

Formatage des chaînes de caractères

Pour formater une chaîne de caractères, nous avons les deux méthodes format et sprintf, mais aussi les deux formes vues précédemment. Les méthodes ont cette forme : sprintf(string, [,arguments...]). Le premier argument est une chaîne de caractères commençant par %, suivie par des modificateurs. La séquence est de cette forme : %[flags][width][.precision]type.

Que dites-vous de quelques exemples ?

• "Un nombre : %d" % [123] => “Un nombre : 123”
• "Un nombre à virgule : %.2f" % [123] => “Un nombre à virgule : 123.00”
• "Un nombre sur 3 digits : %03d" % [23] => “Un nombre sur 3 digits : 023”
• "Afficher un nombre après un padding : %10d" % [23] => “Afficher un nombre après un padding :         23”

Ça devrait suffire pour les exemples. Remarquez que mes exemples sont orientés vers le formatage de chaînes de caractères comportant des nombres. C’est parce que c’est essentiellement destiné à ces cas de figures.

Vous pourrez retrouver la liste complète des modificateurs dans la documentation Ruby, ainsi que pas mal d’exemples.

Représentations avancées

Voyons maintenant ce que Ruby nous propose d’autre pour définir / représenter des chaînes de caractères, je vous présente la notation %. Elle se définit de la sorte : %[modifier][delimiter]. Et voici les différentes possibilités :

• %() : déclare une chaîne de caractères interpolable (sans modificateur)
• %q() : déclare une chaîne de caractères non interpolable
• %Q() : déclare une chaîne de caractères interpolable
• %r() : déclare une expression régulière interpolable
• %i() : déclare un tableau de symboles non interpolable (séparés par des espaces)
• %I() : déclare un tableau de symboles interpolable (séparés par des espaces)
• %w() : déclare un tableau de mots non interpolable (séparés par des espaces)
• %W() : déclare un tableau de mots interpolable (séparés par des espaces)
• %x() : déclare une commande shell interpolable
• %s() : déclare un symbole non interpolable

J’ai listé ici toute la liste des notations % (ça peut servir). J’ai utilisé ici des parenthèses comme délimiteur, mais il est tout à fait possible d’utiliser tout caractère non alphanumérique.

Conclusion

Avec Ruby on a que l’embarras du choix pour définir et représenter une chaîne de caractères. À nous de choisir en fonction de l’objectif et de nos préférences. D’autant plus que l’on a à disposition une liste importante de méthodes pour modifier et manipuler ces chaînes, avec une belle documentation bien détaillée et plein d’exemples.

L’équipe Synbioz.

Libres d’être ensemble.