julp

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Aide-mémoire Ruby ======

===== Commentaires =====

  * Simple : <code># Ceci est un commentaire</code>
  * De plusieurs lignes :<code ruby>
=begin
Ceci est un commentaire
de plusieurs lignes
=end
</code>


===== Documentation =====

Pour accéder à la documentation locale d'une méthode d'instance :
<code>ri classe.méthode</code>
ou
<code>ri classe#méthode</code>

Sur le même principe, en ce qui concerne les méthodes de classe :
<code>ri classe::méthode</code>

Et, bien sûr, ça fonctionne pour une classe donnée :
<code>ri classe</code>


===== Chaînes =====

Obtenir le code d'un caractère :
<code>code_car_x = ?x</code>

Écrire de manière formatée autre que les fonctions *printf :
<code ruby>puts "Hello %s !" % "julp"</code>

Interpolation de variables :
<code ruby>
nom = 'julp'
puts "Hello #{nom}"
</code>

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 : <code ruby>string = %!foo bar!</code>
  * %Q (équivalents des doubles), %q (simples) et %x (pour `) : <code ruby>string = %Q{foo bar}</code>
  * Syntaxe Heredoc : <code ruby>string = <<EOX # équivaut à des doubles quotes
foo
bar
EOX

string = <<"hamlet" # encore comme des doubles quotes
O my prophetic soul! My uncle!
hamlet

string = <<'ghost' # comme des simples quotes
Pity me not, but lend thy serious hearing
To what I shall unfold.
ghost

my_dir = <<`dir` # comme des back ticks
ls -l
dir

ind = <<-hello # pour indentation
    Hello, Matz!
hello</code>


===== Entiers =====

Elever un nombre x à la puissance n :
<code ruby>x ** n</code>


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

Lorsqu'on écrit :
<code ruby>while not condition do</code>
Il vaut mieux remplacer while par until :
<code ruby>until condition do</code>

Même chose pour if avec unless.

La forme do/while :
<code ruby>
begin
  # ...
end while condition
</code>

Affectation avec une structure case :
<code ruby>
lang = "de"

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


===== 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
<code ruby>trimestre1 = %w[ Janvier Février Mars ]</code>

Opérateurs "spécifiques" :
  * a + b : concaténation des deux tableaux (les éléments communs apparaitront plusieurs fois)
<code ruby>
a = %w[a b c]
b = %w[c d e]
a + b # => ["a", "b", "c", "c", "d", "e"]
</code>
  * a - b : différence des deux tableaux
<code ruby>a - b # => ["a", "b"]</code>
  * a & b : intersection des deux tableaux
<code ruby>a & b # => ["c"]</code>
  * a | b : union des deux tableaux (les éléments communs n'apparaitront qu'une seule fois)
<code ruby>a | b # => ["a", "b", "c", "d", "e"]</code>


===== 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 :
<code ruby>
class Fille < Parent
  # ...
end
</code>


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

^ C++                ^ Java               ^ Ruby          ^
| try { ... }        | try { ... }        | begin ... end |
| catch(...) { ... } | catch(...) { ... } | rescue        |
| -                  | finally            | ensure        |
| throw              | throw              | raise         |
<code ruby>
x = 12
y = 0
r = 0
begin
    r = x / y
rescue ZeroDivisionError
    puts "You tried to divide by zero."
ensure
    return r
end
</code>


===== 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 ''%(...)'' | ''%<abc #{foo}>'' 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<echo -n #{foo}>'' 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<abc #{foo}>'' 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 :
<code ruby>1.upto(10).reject do |n|
    next true if 5 == n
    n.even?
end</code>
julp

Outils pour utilisateurs

Outils du site

Outils de la page
