En Ruby, tout est un objet — y compris les nombres, les chaînes de caractères, nil, true/false, et même les classes elles-mêmes. Chaque valeur a des méthodes que vous pouvez appeler, et il n'y a pas de types primitifs (contrairement à Java/C# avec leurs primitives de type valeur). Cette cohérence est une partie fondamentale de la conception de Ruby.
42.even? # true — Integer is an object with methods
42.times { ... } # call a method on a number
(-5).abs # 5
3.14.round # 3
nil.to_s # "" — even nil is an object (NilClass)
nil.nil? # true
true.class # TrueClass — booleans are objects too
"hello".length # strings are objects
Contrairement aux langages avec des types primitifs, en Ruby 42 est un objet complet (une instance d'Integer) — vous appelez des méthodes directement sur lui (42.even?, 42.times). Même nil, true et false sont des objets avec leurs propres classes et méthodes.
String.class # Class — a class is itself an object (an instance of Class)
42.class # Integer
42.class.class # Class
Integer.ancestors # [Integer, Numeric, Comparable, Object, ...] — the class hierarchy
Même les classes sont des objets (instances de Class) — ce qui active la puissante métaprogrammation de Ruby (vous pouvez manipuler les classes à l'exécution).
42.is_a?(Object) # true — everything ultimately descends from Object
# the hierarchy: BasicObject → Object → ... → your value
# so EVERY object shares common methods (class, methods, respond_to?, etc.)
# because everything is an object, the same patterns work everywhere
[1, 2, 3].map(&:to_s) # call to_s on each
any_value.respond_to?(:upcase) # ask any object if it has a method
Comprendre que « tout est un objet » est fondamental pour saisir la conception et la cohérence de Ruby, et c'est l'une des caractéristiques déterminantes du langage.
Contrairement aux langages avec des types primitifs (Java/C# où les nombres et booléens sont des primitives de type valeur, pas des objets), Ruby traite tout — les nombres, les chaînes, nil, les booléens, et même les classes elles-mêmes — comme des objets avec des méthodes que vous pouvez appeler.
Cette pure cohérence orientée objet a des implications pratiques : vous pouvez appeler des méthodes directement sur n'importe quelle valeur (42.even?, nil.to_s, 42.times), les mêmes patterns orientés objet fonctionnent uniformément sur toutes les valeurs (pas de gestion spéciale pour les « primitives »), et chaque objet partage les méthodes communes héritées de Object.
De façon critique, le fait que les classes soient elles-mêmes des objets (instances de Class) est ce qui active la puissante métaprogrammation de Ruby — vous pouvez inspecter et manipuler les classes à l'exécution, ce qui sous-tend une grande partie de la flexibilité de Ruby et des frameworks comme Rails.
Comprendre ce principe explique pourquoi le code Ruby peut appeler des méthodes sur n'importe quoi, pourquoi le langage se sent si cohérent et uniforme, et comment la métaprogrammation est possible.
C'est une fondation conceptuelle fondamentale qui distingue Ruby des langages avec dualité primitive/objet, et la comprendre est essentielle pour comprendre la cohérence élégante de Ruby, son style d'appel de méthodes sur tout, et ses capacités de métaprogrammation — ce qui la rend importante, une connaissance fondamentale pour travailler avec le langage et un point fréquent qui capture la nature distinctement orientée objet de Ruby.