Accueil | Documentations | Association | RubyFrance | Communauté | À propos de Ruby

Chaînes de caractères

Ruby traite les chaînes de caractères aussi bien que les nombres. Une chaîne peut être entre guillemets (”...”) ou entre apostrophes (’...’).

ruby> "abc" 
  "abc" 
ruby> 'abc'
  "abc"

Guillemets et apostrophes ont des effets différents dans certains cas. Une chaîne entre guillemets permet d’utiliser des séquences d’échappement en mettant un anti-slash devant les caractères voulus, et l’évaluation d’expressions incluses dans la chaîne et entourées de #{}. Une chaîne entre apostrophes ne permet pas tout ça et ne dit rien que ce qu’elle montre. Exemples :

ruby> print "anbnc","n" 
a
b
c
  nil
ruby> print 'anbnc',"n" 
anbnc
  nil
ruby> "n" 
  "n" 
ruby> 'n'
  "\n" 
ruby> "001" 
  "001" 
ruby> '001'
  "\001" 
ruby> "abcd #{53} efg" 
  "abcd 15 efg" 
ruby> var = " abc " 
  " abc " 
ruby> "1234#{var}5678" 
  "1234 abc 5678"

Le traitement des chaînes par Ruby est plus intelligent et plus intuitif que celui de C. Par exemple, on peut concaténer des chaînes avec + et répéter une chaîne n fois avec * :

ruby> "foo" + "bar" 
  "foobar" 
ruby> "foo" * 2
  "foofoo"

Concaténer des chaînes est beaucoup plus pénible en C parce qu’il faut gérer explicitement l’allocation mémoire correspondante :

char *s = malloc(strlen(s1)+strlen(s2)+1);
strcpy(s, s1);
strcat(s, s2);
/ ... */
free(s);

Au contraire, avec ruby, on n’a pas à se soucier de la place occupée par une chaîne. On ne s’occupe pas du tout de la gestion de la mémoire.

Voici plusieurs choses qu’on peut faire avec les chaînes.

  • Concaténation :
ruby> word = "fo" + "o" 
  "foo"
  • Répétition :
ruby> word = word * 2
  "foofoo"
  • Extraction de caractères (notez que les caractères sont des entiers pour ruby) :
ruby> word[0]
  102            # 102 est le code ASCII pour `f' 
ruby> word[-1]
  111            # 111 est le code ASCII pour `o'

(Les indices positifs indiquent des positions à partir du début de la chaîne, les indices négatifs à partir de la fin.)

  • Extraction de sous-chaînes :
ruby> herb = "parsley" 
  "parsley" 
ruby> herb[0,1]
  "p" 
ruby> herb[-2,2]
  "ey" 
ruby> herb[0..3]
  "pars" 
ruby> herb[-5..-2]
  "rsle"
  • Test d’égalité :
ruby> "foo"  "foo" 
  true
ruby> "foo"  "bar" 
  false

Maintenant, mettons ces éléments au travail. Voici un jeu “Quel mot est-ce ?” — mais le mot « jeu » est peut-être un peu excessif pour ce qui suit ;-)


 # sauver ceci en devine.rb
 mots = ['foobar', 'baz', 'quux']
 secret = mots[rand(3)]

 print "Devine ? " 
 while devine = STDIN.gets
  devine.chop!
  if devine == secret
    print "Tu gagnes!n" 
    break
  else
    print "Dommage, tu perds.n" 
  end
  print "Devine ? " 
 end
 print "Le mot était ", secret, ".n"

Pour l’instant ne vous souciez pas trop du détail du code. Voici ce que produit une exécution.

% ruby guess.rb
Devine? foobar
Dommage, tu perds.
Devine? quux
Dommage, tu perds.
Devine? ^D
Le mot était baz.

(J’aurais pu faire mieux, vu la probabilité de 1/3…)

Guide de l’utilisateur

Précédent : GDU : Des exemples simples Suivant : GDU : Expressions régulières