• Simple :

  # Ceci est un commentaire

• De plusieurs lignes :

  =begin
  Ceci est un commentaire
  de plusieurs lignes
  =end

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

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

Elever un nombre x à la puissance n :

x ** n

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"

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

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"]

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

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