Ruby Language
Cordes

Syntaxe

• 'Une chaîne' // crée une chaîne via un littéral entre guillemets simples
• "Une chaîne" // crée une chaîne via un littéral entre guillemets
• String.new ("Une chaîne")
• % q (Une chaîne) // syntaxe alternative pour créer des chaînes entre guillemets simples
• % Q (Une chaîne) // syntaxe alternative pour créer des chaînes entre guillemets

Différence entre les littéraux de chaîne entre guillemets simples et entre guillemets

La principale différence est que les littéraux de String guillemets doubles prennent en charge les interpolations de chaînes et l'ensemble complet des séquences d'échappement.

Par exemple, ils peuvent inclure des expressions Ruby arbitraires par interpolation:

# Single-quoted strings don't support interpolation
puts 'Now is #{Time.now}'
# Now is #{Time.now}

# Double-quoted strings support interpolation
puts "Now is #{Time.now}"
# Now is 2016-07-21 12:43:04 +0200

Les chaînes entre guillemets prennent également en charge l' ensemble des séquences d'échappement, y compris "\n" , "\t" ...

puts 'Hello\nWorld'
# Hello\nWorld

puts "Hello\nWorld"
# Hello
# World

... tandis que les chaînes entre guillemets simples ne prennent pas en charge les séquences d'échappement, en mettant en évidence le jeu minimal nécessaire pour les chaînes entre guillemets simples: guillemets simples et barres obliques inverses, respectivement '\'' et '\\' .

Créer une chaîne

Ruby propose plusieurs méthodes pour créer un objet String . La méthode la plus courante consiste à utiliser des guillemets simples ou doubles pour créer un " littéral de chaîne ":

s1 = 'Hello'
s2 = "Hello"

La principale différence est que les littéraux de chaîne entre guillemets sont un peu plus flexibles car ils supportent l'interpolation et certaines séquences d'échappement de barre oblique inverse.

Il existe également plusieurs autres manières possibles de créer un littéral de chaîne en utilisant des délimiteurs de chaîne arbitraires. Un délimiteur de chaîne arbitraire est un % suivi d'une paire de délimiteurs correspondants:

%(A string)
%{A string}
%<A string>
%|A string|
%!A string!

Enfin, vous pouvez utiliser les séquences %q et %Q , équivalentes à ' et " ":

puts %q(A string)
# A string
puts %q(Now is #{Time.now})
# Now is #{Time.now}

puts %Q(A string)
# A string
puts %Q(Now is #{Time.now})
# Now is 2016-07-21 12:47:45 +0200

%q séquences %q et %Q sont utiles lorsque la chaîne contient des guillemets simples, des guillemets doubles ou un mélange des deux. De cette façon, vous n'avez pas besoin d'échapper au contenu:

%Q(<a href="/profile">User's profile<a>)

Vous pouvez utiliser plusieurs délimiteurs différents, à condition qu'il y ait une paire correspondante:

%q(A string)
%q{A string}
%q<A string>
%q|A string|
%q!A string!

Concaténation de chaînes

Concaténer des chaînes avec l'opérateur + :

s1 = "Hello"
s2 = " "
s3 = "World"

puts s1 + s2 + s3
# => Hello World

s = s1 + s2 + s3
puts s
# => Hello World

Ou avec le << opérateur:

s = 'Hello'
s << ' '
s << 'World'
puts s
# => Hello World

Notez que l'opérateur << modifie l'objet sur le côté gauche.

Vous pouvez également multiplier les chaînes, par exemple

"wow" * 3
# => "wowwowwow"

Interpolation de chaîne

Le délimiteur à double guillemets " et la séquence %Q prennent en charge l’interpolation de chaînes à l’aide de #{ruby_expression} :

puts "Now is #{Time.now}"
# Now is Now is 2016-07-21 12:47:45 +0200

puts %Q(Now is #{Time.now})
# Now is Now is 2016-07-21 12:47:45 +0200

Manipulation de cas

"string".upcase     # => "STRING"
"STRING".downcase   # => "string"
"String".swapcase   # => "sTRING"
"string".capitalize # => "String"

Ces quatre méthodes ne modifient pas le récepteur d'origine. Par exemple,

str = "Hello"
str.upcase # => "HELLO"
puts str   # => "Hello"

Il existe quatre méthodes similaires qui effectuent les mêmes actions mais modifient le récepteur d'origine.

"string".upcase!     # => "STRING"
"STRING".downcase!   # => "string"
"String".swapcase!   # => "sTRING"
"string".capitalize! # => "String"

Par exemple,

str = "Hello"
str.upcase!  # => "HELLO"
puts str     # => "HELLO"

Remarques:

• avant Ruby 2.4, ces méthodes ne gèrent pas Unicode.

Fractionner une chaîne

String#split divise une String en un Array basé sur un délimiteur.

"alpha,beta".split(",")
# => ["alpha", "beta"]

Une String vide donne un Array vide:

"".split(",")
# => []

Un délimiteur sans correspondance génère un Array contenant un seul élément:

"alpha,beta".split(".")
# => ["alpha,beta"]

Vous pouvez également diviser une chaîne en utilisant des expressions régulières:

"alpha, beta,gamma".split(/, ?/)
# => ["alpha", "beta", "gamma"]

Le délimiteur est facultatif, par défaut une chaîne est divisée sur des espaces:

"alpha beta".split
# => ["alpha", "beta"] 

Joindre des chaînes

Array#join joint un Array dans une String , en fonction d'un délimiteur:

["alpha", "beta"].join(",")
# => "alpha,beta"

Le délimiteur est facultatif et sa valeur par défaut est une String vide.

["alpha", "beta"].join
# => "alphabeta"

Un Array vide génère une String vide, quel que soit le délimiteur utilisé.

[].join(",")
# => ""

Cordes multilignes

Le moyen le plus simple de créer une chaîne multiligne consiste à utiliser plusieurs lignes entre guillemets:

address = "Four score and seven years ago our fathers brought forth on this
continent, a new nation, conceived in Liberty, and dedicated to the
proposition that all men are created equal."

Le principal problème de cette technique est que si la chaîne contient une citation, elle va casser la syntaxe de la chaîne. Pour contourner le problème, vous pouvez utiliser un heredoc à la place:

puts <<-RAVEN
  Once upon a midnight dreary, while I pondered, weak and weary, 
  Over many a quaint and curious volume of forgotten lore— 
      While I nodded, nearly napping, suddenly there came a tapping, 
  As of some one gently rapping, rapping at my chamber door. 
  "'Tis some visitor," I muttered, "tapping at my chamber door— 
              Only this and nothing more." 
  RAVEN

Ruby prend en charge les documents de style shell avec <<EOT , mais le texte de fin doit démarrer la ligne. Cela gâche l'indentation du code, il n'y a donc pas beaucoup de raisons d'utiliser ce style. Malheureusement, la chaîne aura des indentations en fonction de la façon dont le code lui-même est en retrait.

Ruby 2.3 résout le problème en introduisant <<~ qui supprime les espaces de début excédentaires:

def build_email(address)
  return (<<~EMAIL)
    TO: #{address}

    To Whom It May Concern:

    Please stop playing the bagpipes at sunrise!
                     
    Regards,
    Your neighbor               
  EMAIL
end

Les chaînes de pourcentage fonctionnent également pour créer des chaînes multilignes:

%q(
HAMLET        Do you see yonder cloud that's almost in shape of a camel?
POLONIUS        By the mass, and 'tis like a camel, indeed.
HAMLET        Methinks it is like a weasel.
POLONIUS        It is backed like a weasel.
HAMLET        Or like a whale?
POLONIUS        Very like a whale
)

Il existe plusieurs moyens d'éviter les séquences d'interpolation et d'échappement:

• Guillemet simple au lieu de guillemet double: '\n is a carriage return.'

• Minuscule q dans une chaîne de pourcentage: %q[#{not-a-variable}]

• Citation unique de la chaîne de terminal dans un heredoc:

  <<-'CODE'
     puts 'Hello world!'
  CODE
  

Chaînes formatées

Ruby peut injecter un tableau de valeurs dans une chaîne en remplaçant les espaces réservés par les valeurs du tableau fourni.

"Hello %s, my name is %s!" % ['World', 'br3nt']
# => Hello World, my name is br3nt!

Les ['Hello', 'br3nt'] sont représentés par deux %s et les valeurs sont fournies par le tableau ['Hello', 'br3nt'] . L'opérateur % indique à la chaîne d'injecter les valeurs du tableau.

Remplacements de caractères de chaîne

La méthode tr renvoie une copie d'une chaîne où les caractères du premier argument sont remplacés par les caractères du second argument.

"string".tr('r', 'l') # => "stling"

Pour remplacer uniquement la première occurrence d'un motif avec une autre expression, utilisez la méthode sub

"string ring".sub('r', 'l') # => "stling ring"

Si vous souhaitez remplacer toutes les occurrences d'un motif par cette expression, utilisez gsub

"string ring".gsub('r','l') # => "stling ling" 

Pour supprimer des caractères, transmettez une chaîne vide pour le deuxième paramètre

Vous pouvez également utiliser des expressions régulières dans toutes ces méthodes.

Il est important de noter que ces méthodes ne renverront qu'une nouvelle copie d'une chaîne et ne modifieront pas la chaîne en place. Pour ce faire, vous devez utiliser le tr! , sub! et gsub! méthodes respectivement.

Comprendre les données dans une chaîne

Dans Ruby, une chaîne n'est qu'une séquence d' octets avec le nom d'un codage (tel que UTF-8 , US-ASCII , ASCII-8BIT ) qui spécifie comment interpréter ces octets en tant que caractères.

Les chaînes Ruby peuvent être utilisées pour contenir du texte (essentiellement une séquence de caractères), auquel cas le codage UTF-8 est généralement utilisé.

"abc".bytes  # => [97, 98, 99]
"abc".encoding.name  # => "UTF-8"

Les chaînes Ruby peuvent également être utilisées pour contenir des données binaires (une séquence d'octets), auquel cas le codage ASCII-8BIT est généralement utilisé.

[42].pack("i").encoding  # => "ASCII-8BIT"

Il est possible que la séquence d'octets d'une chaîne ne corresponde pas à l'encodage, ce qui entraîne des erreurs si vous essayez d'utiliser la chaîne.

"\xFF \xFF".valid_encoding? # => false
"\xFF \xFF".split(' ')      # ArgumentError: invalid byte sequence in UTF-8

Substitution de cordes

p "This is %s" % "foo"
# => "This is foo"

p "%s %s %s" % ["foo", "bar", "baz"]
# => "foo bar baz"

p "%{foo} == %{foo}" % {:foo => "foo" }
# => "foo == foo"

Voir String % docs et Kernel :: sprintf pour plus de détails.

La chaîne commence par

Pour trouver si une chaîne commence par un motif, le start_with? la méthode est pratique

str = "zebras are cool"
str.start_with?("zebras")      => true

Vous pouvez également vérifier la position du motif avec l' index

str = "zebras are cool"
str.index("zebras").zero?      => true

La chaîne se termine par

Pour trouver si une chaîne se termine par un motif, end_with? la méthode est pratique

str = "I like pineapples"
str.end_with?("pineaaples")      => false

Chaînes de positionnement

En Ruby, les chaînes peuvent être justifiées à gauche, justifiées à droite ou centrées

Pour justifier la chaîne, utilisez la méthode ljust . Cela prend deux paramètres, un entier représentant le nombre de caractères de la nouvelle chaîne et une chaîne représentant le motif à remplir.

Si l'entier est supérieur à la longueur de la chaîne d'origine, la nouvelle chaîne sera justifiée à gauche avec le paramètre de chaîne facultatif prenant l'espace restant. Si le paramètre de chaîne n'est pas donné, la chaîne sera remplie d'espaces.

str ="abcd"
str.ljust(4)          => "abcd"
str.ljust(10)         => "abcd      "

Pour justifier correctement une chaîne, utilisez la méthode rjust . Cela prend deux paramètres, un entier représentant le nombre de caractères de la nouvelle chaîne et une chaîne représentant le motif à remplir.

Si le nombre entier est supérieur à la longueur de la chaîne d'origine, la nouvelle chaîne sera justifiée à droite avec le paramètre de chaîne facultatif prenant l'espace restant. Si le paramètre de chaîne n'est pas donné, la chaîne sera remplie d'espaces.

str = "abcd"
str.rjust(4)          => "abcd"
str.rjust(10)         => "      abcd"

Pour centrer une chaîne, utilisez la méthode center . Cela prend deux paramètres, un entier représentant la largeur de la nouvelle chaîne et une chaîne avec laquelle la chaîne d'origine sera complétée. La chaîne sera alignée sur le centre.

str = "abcd"
str.center(4)          => "abcd"
str.center(10)         => "   abcd   "