Around The Web

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 :

1
2

class MaClasse
end

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

• 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 :

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 :