[Ruby] Les chaînes de caractères

[Sephi-Chan]

Les chaînes de caractères

• Déclaration et affichage
  
• Utiliser des délimiteurs personnalisés
  
• La syntaxe Here documents
  
• Un peu d'arithmétique
  

Déclaration et affichage

Une chaîne de caractère est représentée par une suite de caractères (d'où le nom) entourée de guillemets doubles (") ou simples('). Ces guillemets servent à dire à Ruby qu'il à affaire à une chaîne.

Que se passe-t-il, si on omet ces guillemets ?

nourriture = Jambon

Code :

variables.rb:1: uninitialized constant Jambon (NameError)

Une erreur est générée !

En effet, Ruby est allé chercher la constante (et non une variable, puisque son nom commence par une majuscule) Jambon qui n'existe pas !

Et si je veux mettre des guillemets dans ma chaîne ? Comment Ruby va savoir que ce n'est pas pour dire que la chaîne s'arrête ?

Pour cela, il y a plusieurs alternatives : utiliser des guillemets simples pour entourer une chaîne qui inclut des guillemets doubles (et inversement), ou bien échapper les guillemets inclus dans la chaîne. Cela veut dire qu'on va faire perdre aux guillemets leur sens aux yeux de Ruby. Pour échapper un caractère, on utilise un anti-slash (\).

puts "Romain \"Sephi-Chan\" Tribes" # Romain "Sephi-Chan" Tribes

puts 'Romain "Sephi-Chan" Tribes' # Romain "Sephi-Chan" Tribes

Et si je veux mettre des \ dans ma chaîne de caractères ?

Et bien… On échappe le caractère d'échappement !

puts "Pour échapper un caractère, on utilise un \."

puts "Pour échapper un caractère, on utilise un \\."

puts "Pour échapper un caractère, on utilise un \\\\."

Code :

Pour échapper un caractère, on utilise un .
Pour échapper un caractère, on utilise un \.
Pour échapper un caractère, on utilise un \\.

Quand vous utilisez des guillemets simples, les variables encadrées intégrées dans la chaîne (#{variable}, par exemple) ne sont pas interprétées ! De plus, les caractères spéciaux (comme \n pour un retour à la ligne) ne fonctionnent pas.



Utiliser des délimiteurs personnalisés

Si les guillemets ne vous conviennent pas, vous pouvez utiliser vos propres délimiteurs grâce à une notation spéciale. Voici cette notation, avec laquelle je vais utiliser le caractère @ comme délimiteur.

puts %q@Avec cette notation, pas besoin d'échapper mes caractères ! Je peux mettre des ", des ' ou des \ sans soucis !@

puts %Q@Avec cette notation non plus, je n'ai pas à me soucier des " et des ' ! Mais je dois tout de même échapper les \\ !@

Code :

Avec cette notation, pas besoin d'échapper mes caractères ! Je peux mettre des ", des ' ou des \ sans soucis !
Avec cette notation non plus, je n'ai pas à me soucier des " et des ' ! Mais je dois tout de même échapper les \ !

La différence entre %q et %Q, c'est que le premier se comporte comme une chaîne délimitée par des guillemets simples, alors que l'autre réagit comme si c'était une chaîne entourée de guillemets doubles.

Si vous choisissez un caractère comme (, { ou [, les délimiteurs inverses seront respectivement ), } et ].

N'oubliez pas la façon dont sont interprétées les variables selon que l'on utilise les guillemets simple ou doubles, ou que l'on utilise %q ou %Q !

Si on ne spécifie pas q ou Q, le comportement par défaut est celui de Q.

nourriture = "Jambon fumé"



puts 'Vive le #{nourriture} !'

puts %q@Vive le #{nourriture} !@



puts "Vive le #{nourriture} !"

puts %Q@Vive le #{nourriture} !@



puts %(Vive le #{nourriture} !)

Code :

Vive le #{nourriture} !
Vive le #{nourriture} !

Vive le Jambon fumé !
Vive le Jambon fumé !

Vive le Jambon fumé !

La syntaxe Here documents

Une syntaxe alternative permet d'éviter les problèmes d'échappement et d'insérer nos variables sans soucis. Elle est très utile dans le cas de grandes chaînes, notamment. On utilise pour cela un mot clé qui sera indiqué en début et en fin de bloc.

vehicule = "navire"

puts <<CHANSON

Il était un petit #{vehicule},

Qui n'avait jamais navigué.

CHANSON

Code :

Il était un petit navire,
Qui n'avait jamais navigué.

Un peu d'arithmétique

Et oui, avec le texte aussi ! On peut additionner des chaînes de caractères entre elles !

age = 20

nourriture = "pâté en croûte"



puts "Moi j'aime " + 'le pâté !'

puts "Mais je préfère le " + nourriture + "."

puts "J'ai " + age + " ans."

Code :

Moi j'aime le pâté !
Mais je préfère le pâté en croûte.
variables.rb:6:in `+': can't convert Fixnum into String (TypeError) from var.rb:6

Mais que se passe-t-il ? Mais que se passe-t-il ? Mais qu'est-ce qui se passe ?
J'ai dis que nous pouvions additionner des chaînes entre elles, age contient un nombre entier (Fixnum) !

Heureusement, il y a une solution. Les objets ont généralement une méthode qui permet de renvoyer leur contenu sous forme d'une chaîne de caractères. Cette méthode s'appelle to_s (pour to string).

puts "J'ai " + 20.to_s + " ans." # J'ai 20 ans.

En revanche, on peut multiplier une chaîne avec un entier !

puts %Q@C'est l'histoire d'un 0 qui rencontre un 8.

Le 0 s'exclame : " Tiens, t'as mis une ceinture ?\n\n"@

puts "Ah ! " * 3 + "Quelle blague hilarante !?"

Code :

C'est l'histoire d'un 0 qui rencontre un 8.
Le 0 s'exclame : "Tiens, t'as acheté une ceinture ?"

Ah ! Ah ! Ah ! Quelle blague hilarante !?

Et notez la priorité sur les opérations ! Amusant, n'est-ce pas ?


Sephi-Chan

[keke]

Ca aurait marché si on avait écrit

puts 3 * "Ha !"
au lieu de
puts "Ah !" * 3

Kéké qui ne voit pas encore bien l'intérêt de se langage mais qui va suivre tout tes tutoriaux, juste pour être sur de ne pas passer à côté de quelque chose.

[My Hotel]

Après avoir lu tous les tutos que tu as posté Sephi (y'en avait pas non plus 500), j'en redemande, pour le plaisir d'apprendre

Mais c'est vrai, que comme Kéké, je distingue pas beaucoup (pas du tout même) les avantages de Ruby par rapport à d'autres.

Tu devrais écrire un chapitre là dessus, parce que pour l'instant je préfère largement Java

[Allwise]

Le "string" * 3 signifie-t-il qu'avec Ruby, on peut librement surcharger les opérateurs ? ( si oui, on peut aussi surcharger les fonctions ? )
Ça, ce serait sympa

[Roworll]

C'est quand même hyper proche du Python (la multiplication de chaînes existant aussi sur ce langage).
J'avais aimé aussi en Python tout le travail possible sur les chaînes, du style

Code :

>>>s="Bonjour"
>>>s[2]
# affiche 'n'
>>>s[-2]
# affiche 'u'
>>>s[2:5]
# affiche 'njo'
>>>s[2:]
#affiche 'njour'
>>>s[:4]
#affiche 'Bonj'
>>>s[-3:]
#affiche 'our'

Je suppose que Ruby peut faire de même.

[Sephi-Chan]

Oui, Ruby propose sensiblement la même chose. Cf. String[]

a = "hello there"

a[1]                   #=> 101

a[1,3]                 #=> "ell"

a[1..3]                #=> "ell"

a[-3,2]                #=> "er"

a[-4..-2]              #=> "her"

a[12..-1]              #=> nil

a[-2..-4]              #=> ""

a[/[aeiou](.)\1/]      #=> "ell"

a[/[aeiou](.)\1/, 0]   #=> "ell"

a[/[aeiou](.)\1/, 1]   #=> "l"

a[/[aeiou](.)\1/, 2]   #=> nil

a["lo"]                #=> "lo"

a["bye"]               #=> nil

Sinon, on peut effectivement surcharger quelques opérateurs, oui.
En revanche, le langage étant dynamiquement typé, tu ne peux pas avoir plusieurs méthodes qui ont des arguments différents : la dernière méthode est utilisée.
En pratique, avec Rails, le plus souvent, on surcharge attribut=.

class Person

  def initialize(name)

    @name = name

  end



  def name=(name)

    @name = name

  end



  def name

    @name

  end

end



# La même en plus concis.

class Person

  attr_accessor :name

  

  def initialize(name)

    @name = name

  end

end

[Sephi-Chan]

J'ajoute un petit correctif concernant la notation permettant de s'affranchir de tout échappement de caractère.

Je rappelle cette notation (la coloration syntaxique du forum chie un peu avec cette notation…)) :

nourriture = "pâté"

puts %q(Moi j'aime le "#{nourriture}".) # Moi j'aime le "#{nourriture}".

puts %Q(Moi j'aime le "#{nourriture}".) # Moi j'aime le "pâté".

puts %Q@Moi j'aime le "#{nourriture}".@ # Moi j'aime le "pâté".

Petits rappels sur cette notation :

• La différence entre %q et %Q est que le premier — à l'image des guillemets simples — n'interprète pas les expressions.
  
• On peut utiliser n'importe quel délimiteur (dans le dernier exemple, j'utilise @). Dans le cas de caractères en paires (les parenthèses, les accolades et les crochets), il faut utiliser leur homologue fermant.
  

J'ai appris récemment qu'on pouvait se passer du symbole Q. Il s'agit du comportement par défaut.

Un exemple appliqué à Rails, dans une méthode de validation d'un modèle.

class Participation < ActiveRecord::Base

  belongs_to :user

  belongs_to :workgroup, :counter_cache => true

  

  validate ame_relation_does_not_exist_yet

  

  protected

  

  def same_relation_does_not_exist_yet

    participation_count = Participation.count :conditions => [

                                                'user_id = ? AND workgroup_id = ?',

                                                user_id,

                                                workgroup_id

                                              ]



    if participation_count > 0

      errors.add_to_base %("#{participation.user.login}" est déjà inscrit à l'atelier 

                           "#{participation.workgroup.title}")

    end

  end

end

Il me semble que cette notation bien sympathique est héritée de Perl.


Sephi-Chan