Table des matières

Aide-mémoire Ruby

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

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 = <<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

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 `%(…)`	`%<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 :

1.upto(10).reject do |n|
    next true if 5 == n
    n.even?
end