Introduction

​
Tout est objet en Ruby
Y compris l'objet nul nil (équivalent de None en Python)
On peut tester si un objet est nul grâce à la méthode .nil? Cette méthode renvoie un booléen : true ou false
On récupère la classe d'un objet grâce à la méthode .class
On récupère sa représentation grâce à la méthode .inspect
On peut le convertir en chaîne de caractère avec to_s
On peut tester l'appartenance d'un objet à une classe avec .is_a?
1.is_a?(Object)
=> true
On récupère l'id d'un objet avec la méthode .object_id. Deux objets différents ont en général deux identifiants différents. Un petit entier a un id fixe qui est égale à sa valeur * 2 + 1
La méthode .clone permet de créer une copie d'un objet
Tableaux
Bases
Tableau vide : Array.new ou []
Accès :
array = [1, 2, 3, 4, 5]
array[0]
# => 1
array.first
# => 1
array[-1]
# => 5
array.last
# => 5
array[1]
# => 2
array.at(2)
# => 3
array.fetch(234, :unknown)
# => :unknown
Slices : tableau[<indice>, <nombre>]
array[0, 1]
# => 1
array[1, 1000]
# => [2, 3, 4, 5]
array[17, 1]
# => nil
Objet range : itérateur incrémental
(1..5).to_a
# => [1, 2, 3, 4, 5]
(1...5).to_a
# => [1, 2, 3, 4]
Slices
array[0..2]
# => [1, 2, 3]
array[0...2]
# => [1, 2]
array[0..-1]
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
array[-2...-1]
# => [9, 10]
array[-2...-1]
# => [9]
Ajout / Suppression à la fin
array << 6
# => [1, 2, 3, 4, 5, 6]
array.push(7)
# => [1, 2, 3, 4, 5, 6, 7]
array << 8 << 9 << 10
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
array.pop
# => 10
array
# => [1, 2, 3, 4, 5, 6, 7, 8, 9]
Ajout / Suppression au début
array.unshfit(0)
# => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
array.shift
# => 0
array
# => [1, 2, 3, 4, 5, 6, 7, 8, 9]
Unpacking
a, b = [1, 2] # a=1 et b=2
a, b = [1, 2, 3] # a=1 et b=2
a, b = [[1, 2], 3] # a=[1, 2] et b=3
a, b = [1] # a=1 et b=nil
a, *b = [1, 2, 3] # a=1 et b=[2, 3]
a, = [1, 2] # a=1
a, b = b, a # a=b et b=a
Hash : dictionnaires
Création
d = {"one" => 1, "two" => 2} # clés String
d = {:one => 1, :two => 2} # clés symboles
d = {one => 1, two => 2} # syntaxe alternative pour des clés symboles
​
# en utilisant le constructeur
d = Hash.new
d[:one] = 1
d[:two] = 2
Accès
d[:one]
# => 1
d[:three]
# => nil
d.default = -1
d[:three]
# => -1
​
# on peut aussi définir la valeur par défaut lors de la construction
d = Hash.new(-1)
d[:one]
# => -1
​
d.fetch(:one)
# => KeyError (key not found: :one)
d.fetch(:one, -1)
# => -1
d[:one] = 1
d.fetch(:one)
# => 1
Chaînes de caractères
Définition
simple = 'a string called "Simple"'
double = "a string called 'Double'"
double_escaping = "Escaping is \"Simple\""
multiline = %{
I can handle both "simple"
and 'simple' quotes
}
multiline
# => "\nI can handle both \"simple\"\nand 'simple' quotes\n"
multiline.lines
# => 3
doc = <<EOS
Another delimiter
which does not start by a new line
EOS
doc.lines
# => 2
Concaténation et muabilité
hello = 'Hello '
world = "world"
hello + world
# => "Hello world"
hello
# => "Hello "
hello += world
hello
# => "Hello world"
hello << "!"
# => "Hello world!"
hello
# => "Hello world!"
Split et join
"Coucou toi".split
# => ["Coucou", "toi"]
"a:b:c".split(/:/) # /:/ est une regex
# => ["a", "b", "c"]
["Hello", "world"].join(" ")
"Hello world"
Inclusion de variables
var = "world"
"Hello #{var}"
# => "Hello world"
"Hello #{var.upcase}"
# => "Hello WORLD"
Opération avec regexp
"match me!"[/match/]
# => "match"
"match me!".scan(/\w+/)
# => ["match", "me"]
"match me!".sub(/^(\w)/) { $1.upcase }
# => "Match me!"
"match me!".gsub(/w+/) { $1.upcase }
# => "MATCH ME!"
Voir Regexp dans la doc Ruby​
Symboles
Les symboles ont un rôle d'identificateur, ce ne sont pas des chaînes de caractères, ils peuvent prendre le rôle d'enumeration
Syntaxe : préfixer le symbole de deux points : symbol = :foo
Les symboles peuvent être créés à partir de strings : "foo".to_sym
On peut utiliser les guillemets pour ajouter des espaces et des variables :
var = "world"
hw = :"Hello #{var}"
Méthodes
Les fonctions sont des méthodes globales
Définition
def ma_methode(a, b)
  a + b # la dernière expression est renvoyée
end
​
# les affectations sont aussi des expressions
# équivalent à la précédente :
def ma_methode(a, b)
  sum = a + b
end
​
ma_methode(1, 2)
# => 3
ma_methode 1, 2 # pas besoin de parenthèses
# => 3
Valeur par défaut : def ma_methode(a, b=3)
Visibilité  : on peut rendre une méthode privée private def ma_methode ...
Paramètre nommés
def ma_methode(a: ,b: "with default")
  # a est obligatoire
  # b a une valeur par défaut
  [a, b]
end
ma_methode(a: "hey!")
# => ["hey!", "with default"]
​
# un paramètre nommé doit être passé avec son nom
ma_methode("hey!")
# => ArgumentError (
#      wrong number of arguments (
#        given 1, expected 0; 
#        required keyword: a))
Unpacking
def ma_methode(*args, **kwargs)
  [args, kwargs]
end
ma_methode(1, 2, 3, four: 4, five: 5, six: 6)
# => [[1, 2, 3], {:four=>4, :five=>5, :six=>6}]
Constantes
Chaque variable commençant par une majuscule est considérée comme une constante. MaConstante = "constante
Dès qu'on la modifie, Ruby nous envoie un warning already initialized constant MaConstante
Une classe hérite des constantes de ses parentes
class A
  C = 1
end
​
class B
  def my_c
    C
  end
end
​
B.new.my_c
# => 1
Une classe interne reprend les constantes de sa classe supérieure prioritairement à ses superclasses.
class Ext
  C = 2
  class Inner < A
    def my_c
      C
    end
  end
end
​
Ext::Inner.new.my_c
# => 2
Une classe définie relativement à une autre classe reprend les constantes de ses superclasses prioritairement. En fait, la portée de variable prend le pas sur l'héritage
class Ext::Relative < A
  def my_c
    C
  end
end
​
Ext::Relative.new.my_c
# => 1
Conditions
Affectation : Dans les deux cas suivants a vaut 1
a = if true then 1 else 2 end
a = true ? 1 : 2
Blocs
```ruby
if expr
faire qqch
end
if true
faire qqch
else
faire autre chose
end
### Unless : équivalent de `if !expr`
`a = unless false then 1 else 2 end # a=1`
### Affectation conditionnelle
`a = :new if true # a=:new `
`a = :other unless false`
`a = :err if false # a=nil`
### Mis à part `false`, et `nil`, toute expression est évaluée à `true`, y compris `0`, `[]` et `{}`.
## **Boucles**
### While
#### Basique
```ruby
i = 0
while i <= 10
  puts i # puts = print() en Python
  i += 1
end
Break : les 3 exemples sont équivalents
i = 0
while true
  if i > 10
    break
  end
  puts i
  i += 1
end
​
i = 0
while true
  break if i > 10
  puts i
  i += 1
end
​
i = 0
while true
  # break sauf si i <= 10
  break unless i <= 10
  puts i
  i += 1
end
Next : passer à l'itération suivante
i = 0
while i < 10
  i += 1
  next if i % 2 == 0
  puts i
end
​
# 1
# 3
# 5
# 7
# 9
In
for el in [:foo, :bar, :baz]
  puts el
end
​
# foo
# bar
# baz
# => [:foo, :bar, :baz]
Times
5.times do |x|
  puts x
end
​
# 0
# 1
# 2
# 3
# 4
# => 5

Dernière mise à jour 2yr ago

Introduction

Tout est objet en Ruby

Tableaux

Bases

Slices : `tableau[<indice>, <nombre>]`

Objet range : itérateur incrémental

Slices

Ajout / Suppression à la fin

Ajout / Suppression au début

Unpacking

`Hash` : dictionnaires

Création

Accès

Chaînes de caractères

Définition

Concaténation et muabilité

Split et join

Inclusion de variables

Opération avec regexp

Symboles

Méthodes

Les fonctions sont des méthodes globales

Définition

Valeur par défaut : `def ma_methode(a, b=3)`

Visibilité : on peut rendre une méthode privée `private def ma_methode ...`

Paramètre nommés

Unpacking

Constantes

Chaque variable commençant par une majuscule est considérée comme une constante. `MaConstante = "constante`

Dès qu'on la modifie, Ruby nous envoie un warning `already initialized constant MaConstante`

Une classe hérite des constantes de ses parentes

Une classe interne reprend les constantes de sa classe supérieure prioritairement à ses superclasses.

Une classe définie relativement à une autre classe reprend les constantes de ses superclasses prioritairement. En fait, la portée de variable prend le pas sur l'héritage

Conditions

Affectation : Dans les deux cas suivants `a` vaut 1

faire qqch

faire autre chose

In

Times