Les objets et les classes en Ruby

Le langage Ruby offre des possibilités de méta-programmation importantes.
Il exploite au mieux la souplesse que lui confère son caractéristique de langage interprété. Ce concept est poussé dans se que l'on appelle le 'duck typing' : le typage canard. A l'inverse de Java qui propose un typage dynamique, Ruby met en avant le typage dynamique. Ce n'est pas votre typage qui dicte votre comportement mais l'inverse. si marche comme un canard et si tu nage comme un canard , alors tu peux etre comme considéré un canard. Le duck typing va plus loin que ca, car il permet de modifier des comportements en cours d'exécution.

Commençons par la mise en place des objets en Ruby.
Si je pars des déclarations suivantes:

class Ma_class
def ma_methode
@x1= 1
end
end

Par irb -r maclasse.rb

Je teste :

objet1= Ma_class.new
=> #

objet1.ma_methode
=> 1
objet1.instance_variables
["@x1"]
p objet1
<Ma_class:0xb7c8483c @x1=1>
                                                                         

ainsi un objet est une référence vers une classe et un tableau associatif de variables. Tant qu'une variable n'est pas initialisée ou utilisée , l'objet n'en fait pas mention.

On peut continuer à explorer le contenu des objets et des classes par les méthodes :
class , superclass ou instance_methods(false)
Ici le 'false' indique de ne lister que les methodes propres à une classe (non héritées) . La méthode included_modules liste les modules utilisés.


Cela donne :

Ma_class.superclass
=> Object

> Ma_class.class

=> Class

> Ma_class.instance_variables

=> []

Class.superclass

=> Module

Module.class

=> Class

> Module.superclass

=> Object

Ma_class.instance_methods(false)

=> ["ma_methode"]

Object.class                                                                                 
=> Class

En remontant toute la chaine on obtient le schéma suivant:(clic pour élargir)




Il n'y a pas de grande difference en ruby entre une classe et un module. Tous les deux sont implémentés de la même façon. Par contre il n'est pas possible d'instancier un module. Les modules sont utilisés pour gérer des espaces de nommage et surtout pour réaliser du 'mixing' cad : Ajouter d'autres comportements (classes) à des classes. Exemple : dans une classe l'ajout de 'include enumerable' lui fournit une vingtaine de méthodes supplémentaires.

La méthode ancestors donne:

Ma_class.ancestors

#=> [Ma_class, Object, Kernel]

Que vient faire Ici Kernel ? . En fait ruby ajoute une pseudo classe équivalente au module kernel. Pour trouver une méthodes, ruby parcours le chemin 'rigth and up' (A droite et en haut) , les modules sont mappés sur des pseudos classes afin de se trouver sur le chemin de recherche des méthodes.

En ruby 1.9 le système est légèrement modifié par l'introduction d'une classe
'BasicObject' au sommet de la pile.

Il reste à résoudre le mystère suivant: Où sont stockés les méthodes singletons ?
La réponse srea donné sur un post consacré aux Eigenclasses en ruby.

Pour voir le post dans son contexte :http://germanlinux.blogspot.com/2009/11/les-objets-et-le-classes-en-ruby.html