====== Aide-mémoire Ruby ====== ===== Commentaires ===== * Simple : # Ceci est un commentaire * De plusieurs lignes :


=begin
Ceci est un commentaire
de plusieurs lignes
=end

===== Documentation ===== Pour accéder à la documentation locale d'une méthode d'instance : ri classe.méthode ou ri classe#méthode Sur le même principe, en ce qui concerne les méthodes de classe : ri classe::méthode Et, bien sûr, ça fonctionne pour une classe donnée : ri classe ===== Chaînes ===== Obtenir le code d'un caractère : code_car_x = ?x Écrire de manière formatée autre que les fonctions *printf : puts "Hello %s !" % "julp" Interpolation de variables :


nom = 'julp'
puts "Hello #{nom}"

Les caractères de nouvelle ligne (\n) et échappés (\t par exemple) ne sont uniquement interprétés lorsque la chaîne est délimitée par des doubles quotes. Autres méthodes pour définir une chaîne de caractères : * %//un_caractère// ... //un_caractère//. Exemple : string = %!foo bar! * %Q (équivalents des doubles), %q (simples) et %x (pour `) : string = %Q{foo bar} * Syntaxe Heredoc :

string = <


===== Entiers =====

Elever un nombre x à la puissance n :
x ** n


===== Itérations et autres structures de contrôle =====

Lorsqu'on écrit :
while not condition do
Il vaut mieux remplacer while par until :
until condition do

Même chose pour if avec unless.

La forme do/while :

begin
  # ...
end while condition


Affectation avec une structure case :

lang = "de"

dog = case lang
  when "en": "dog"
  when "es": "perro"
  when "fr": "chien"
  when "de": "Hund"
  else      "dog"
end
puts dog # "Hund"



===== Expressions régulières =====

Définition, deux possibilités :
  * /motif/option(s)
  * %r!motif!

Opérateurs :
  * Correspondance : =~
  * Non-correspondance : !~

Options :
  * \A : début de chaîne
  * \z : fin de chaîne
  * \Z : fin de chaîne ou avant un caractère de nouvelle ligne
  * (?#commentaire) : un commentaire
  * (?=...) : specify position with pattern
  * (?!...) : specify position with pattern negation
  * (?>...) : matches independent pattern without backtracking
  * (?imx) : toggles i, m, or x options on  
  * (?-imx) : toggles i, m, or x options off  
  * (?imx:..) : toggles i, m, or x options on within parentheses  
  * (?-imx:..) : toggles i, m, or x options off within parentheses  
  * (?ix-ix: ) : turns on (or off) i and x options within this noncapturing group


===== Les tableaux =====

Syntaxe alternative à la constitution d'un tableau de termes : %w
trimestre1 = %w[ Janvier Février Mars ]

Opérateurs "spécifiques" :
  * a + b : concaténation des deux tableaux (les éléments communs apparaitront plusieurs fois)

a = %w[a b c]
b = %w[c d e]
a + b # => ["a", "b", "c", "c", "d", "e"]

  * a - b : différence des deux tableaux
a - b # => ["a", "b"]
  * a & b : intersection des deux tableaux
a & b # => ["c"]
  * a | b : union des deux tableaux (les éléments communs n'apparaitront qu'une seule fois)
a | b # => ["a", "b", "c", "d", "e"]


===== Les classes =====

Définition des méthodes getter/setter par méta-programmation :
  * attr_reader nom_variable_instance1, ... : se charge uniquement du getter
  * attr_writer : du setter seulement
  * attr_accessor : des deux

L'héritage s'indique comme ci-dessous :

class Fille < Parent
  # ...
end



===== Les exceptions =====

^ C++                ^ Java               ^ Ruby          ^
| try { ... }        | try { ... }        | begin ... end |
| catch(...) { ... } | catch(...) { ... } | rescue        |
| -                  | finally            | ensure        |
| throw              | throw              | raise         |

x = 12
y = 0
r = 0
begin
    r = x / y
rescue ZeroDivisionError
    puts "You tried to divide by zero."
ensure
    return r
end



===== Récapitulatif des "modificateurs" =====

Soit ''foo = 'bar'' :

^ Lettre ^ Exemple ^ Signification ^
| ''%q(...)'' | ''%q[abc #{foo}]'' donne ''%%'abc #{foo}'%%'' | Equivaut à une chaîne délimitée par des quotes simples (pas d'interpolation et les séquences d'échappement comme ''\n'' restent littérales) |
| ''%Q(...)'' ou ''%(...)'' | ''%'' donne ''%%'abc bar'%%'' | Equivaut à une chaîne délimitée par des quotes doubles (il y a interpolation et substitution des séquences d'échappement) |
| ''%w(...)'' | ''%w[abc #{foo}]'' donne ''[ 'abc', '#{foo}' ]'' | Un tableau de chaînes correspondant aux "mots", sans aucune substitution |
| ''%W(...)'' | ''%W[abc #{foo}]'' donne ''[ 'abc', 'bar' ]'' | Un tableau de chaînes correspondant aux "mots", après éventuelles substitutions |
| ''%i(...)'' | ''%i[abc #{foo}]'' donne ''[ :abc, :'#{foo}' ]'' | Un tableau de symboles correspondant aux "mots", sans aucune substitution |
| ''%I(...)'' | ''%I[abc #{foo}]'' donne ''[ :abc, :bar ]'' | Un tableau de symboles correspondant aux "mots", après éventuelles substitutions |
| ''%x(...)'' | ''%x'' donne (sur un système Unixoïde) ''bar'' | Exécute la commande système, après éventuelles substitutions |
| ''%r(...)'' | ''%r@a/b@i'' équivaut à ''%%/a\\/b/i%%'' | Une autre forme pour définir une expression régulière, pratique quand le slash peut figurer dans le motif et ainsi éviter d'avoir à l'échapper |
| ''%s(...)'' | ''%s'' donne '':'abc #{foo}''' | Une autre forme pour écrire un symbole qui ne serait pas directement valide. Aucune substitution n'a lieu avec ce "modificateur" |


===== Les blocs =====

Mettre prématurément fin à un bloc : ''next''. Exemple, ne garder que les nombres impairs en excluant 5 :
1.upto(10).reject do |n|
    next true if 5 == n
    n.even?
end