Attention ! Billet en cours de rédaction.
Pour ceux qui veulent commencer rapidement à développer une application Ruby On Rails, il est important d’avoir quelques notions de Ruby et connaître égelement les conventions de nommage des variables, classes, etc…
Une classe se définit comme ceci :
Le nom d’une classe doit commencer par une majuscule et si le nom d’une classe est composé de plusieurs mots, il faut mettre une majuscule à chaque nouveaux mots.
exemple :
Document Parser => DocumentParser
Ensuite, en Ruby, il existe plusieurs type de variable. Il existe :
- les variables locales
- les variables d’instance
- les variables de classe
- les variables globales
Les variables locales
Les variables locales se définissent tout simplement à l’aide d’un nom en minuscule et si il est composé de plusieurs mots les espaces entre ceux-ci sont transformés par des underscore ’_’.
exemple :
1
2
3
4
|
[...]
user_login = "pointcom"
person = {:username => "pointcom", :address => "12 rue de la mare"}
[...] |
Les variables d’instance
Ces variables sont précédés d’un ’@’ et respectent la même règle que les variables locales.
1
2
3
4
5
6
7
8
9
10
11
12
|
class Person
@nb_people = 0
def initialize(firstname, lastname)
@nb_people += 1
@firstname = firstname
@lastname = lastname
end
def greeting
"Bonjour #{@firstname} #{@lastname}, votre identifiant est le #{@nb_people}"
end
end |
Execution du code :
1
2
3
4
5
6
|
p = Person.new("mathieu", "fosse")
p.greeting
=> "Bonjour mathieu fosse, votre identifiant est le 1 !"
p = Person.new("dave", "thomas")
p.greeting
=> "Bonjour dave thomas, votre identifiant est le 1 !" |
On s’apperçoit donc que les variables @firstname et @lastname sont bien partagées entre les différentes méthodes de la même instance. On s’apperçoit également que la variable @nb_people reste à 1 car entre deux instances différente cette variable n’est pas partagée.
Pour rémédier à celà il faut utiliser une variable de classe.
Les variables de classe
Cette variable a la particularité d’être visible dans l’ensemble des instances d’une même classe.
Prenons l’exemple précédent :
1
2
3
4
5
6
7
8
9
10
11
12
|
class Person
@@nb_people = 0
def initialize(firstname, lastname)
@@nb_people += 1
@firstname = firstname
@lastname = lastname
end
def greeting
"Bonjour #{@firstname} #{@lastname}, votre identifiant est le #{@@nb_people}"
end
end |
Execution du code :
1
2
3
4
5
6
|
p = Person.new("mathieu", "fosse")
p.greeting
=> "Bonjour mathieu fosse, votre identifiant est le 1 !"
p = Person.new("dave", "thomas")
p.greeting
=> "Bonjour dave thomas, votre identifiant est le 2 !" |
Cette fois-ci la variable @@nb_people est bien partagée entre les deux instances.
Les types
Contrairement à JAVA qui utilise des typages fort, Ruby lui utilise des typages dynamiques (ou Duck Typing).
C’est à dire que à l’inverser de JAVA (par exemple) il ne faut pas définir la variable avec un type (déclaration) avant de lui affecter une valeur (affectation).
Clairement le Duck Typing (la typage canard) se définit comme celà :
Si votre objet marche comme un canard et fait “coin coin” comme un canard alors c’est un canard !
Exemple :
Affectation de différentes variable de différents types de données :
1
2
3
4
5
|
firstname = "mathieu"
note = 12.5
nb_people = 135
config = {:adapter => "sqlite3", :database => "db/development.sqlite3"}
people = ["renaud", "christophe"] |
Affichage du type (de la classe) auquel appartient la variable :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
firstname.class
=> String
note.class
=> Float
nb_people.class
=> Fixnum
config.class
=> Hash
people.class
=> Array |
On peut tout de même définir la classe à laquelle appartient une variable comme cela :
1
2
3
|
firstname = String.new
config = Hash.new
people = Array.new |
les méthodes
Les méthodes se définissent comme cela :
1
2
3
4
5
6
7
8
|
class MaClasse
def initilialize
end
def ma_methode
puts "coucou"
end
end |
La méthode ma_methode est une méthode d’instance. Une méthode d’instance signifie que cette méthode ne peut être appelée que lorsque un objet MaClasse a été instancié.
Exemple :
Pour appeler cette méthode il faut faire :
1
2
3
|
ma_classe = MaClasse.new
ma_classe.ma_methode
=> "coucou" |
Alors que ceci ne va pas appeler cette méthode :
1
2
|
MaClasse.ma_methode
=> NoMethodError: undefined method `ma_methode' for MaClasse:Class |
Une erreur est notifiée car le dernier appel à la méthode ma_methode supposerai que cette méthode est statique or elle est dynamique puisque c’est une méthode d’instance.
Les méthode statique se définissent comme cela :
1
2
3
4
5
6
7
8
9
10
11
12
|
class MaClasse
def initilialize
end
def ma_methode
puts "coucou"
end
def self.ma_methode_statique
puts "bonjour"
end
end |
Le mot self représente la classe elle même (comme le this en JAVA). Ceci permet (dans notre cas) de préciser que notre méthode sera statique.
Si vous avez beaucoup de méthodes statiques dans votre classe vous pouvez écrire le code suivant :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
class MaClasse
def initilialize
end
def ma_methode
puts "coucou"
end
def class << self
def ma_methode_statique
puts "bonjour"
end
def ma_methode_statique2
[...]
end
def ma_methode_statique3
[...]
end
def ma_methode_statique4
[...]
end
end
end |
L’héritage
L’héritage en ruby.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Language
def orientation
"Left to Right"
end
end
class FrenchLanguage < Language
end
class EnglishLanguage < Language
end
class HebrewLanguage < Language
def orientation
"Right to Left"
end
end |
Le mixin
Le Mixin est une particularité de Ruby
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
module TranslationSystem
def translate
[...]
end
end
class Language
include TranslationSystem
def orientation
"Left to Right"
end
end
class FrenchLanguage < Language
end
class EnglishLanguage < Language
end
class HebrewLanguage < Language
def orientation
"Right to Left"
end
end |
Ruby est un langage très dynamique
Exemples :
