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 #{5*3} 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⁰ 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