En Ruby, todo es un objeto — incluyendo números, strings, nil, true/false, e incluso las clases mismas. Cada valor tiene métodos que puedes llamar sobre él, y no hay tipos primitivos (a diferencia de Java/C# con sus primitivos de tipo valor). Esta consistencia es una parte fundamental del diseño 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
A diferencia de lenguajes con tipos primitivos, en Ruby 42 es un objeto completo (una instancia de Integer) — puedes llamar métodos directamente sobre él (42.even?, 42.times). Incluso nil, true y false son objetos con sus propias clases y métodos.
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
Incluso las clases son objetos (instancias de Class) — lo que permite la poderosa metaprogramación de Ruby (puedes manipular clases en tiempo de ejecución).
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
Comprender que "todo es un objeto" es fundamental para entender el diseño y la consistencia de Ruby, y es una de las características definitorias del lenguaje.
A diferencia de lenguajes con tipos primitivos (Java/C# donde los números y booleanos son primitivos de tipo valor, no objetos), Ruby trata todo — números, strings, nil, booleanos, e incluso las clases mismas — como objetos con métodos que puedes llamar.
Esta consistencia puramente orientada a objetos tiene implicaciones prácticas: puedes llamar métodos directamente sobre cualquier valor (42.even?, nil.to_s, 42.times), los mismos patrones orientados a objetos funcionan uniformemente en todos los valores (sin manejo especial para "primitivos"), y cada objeto comparte métodos comunes heredados de Object.
Críticamente, el hecho de que las clases sean en sí mismas objetos (instancias de Class) es lo que permite la poderosa metaprogramación de Ruby — puedes inspeccionar y manipular clases en tiempo de ejecución, lo que sustenta gran parte de la flexibilidad de Ruby y marcos como Rails.
Comprender este principio explica por qué el código Ruby puede llamar métodos sobre cualquier cosa, por qué el lenguaje se siente tan consistente y uniforme, y cómo la metaprogramación es posible.
Es una base conceptual fundamental que distingue a Ruby de lenguajes con dualidades primitivo/objeto, y comprenderla es esencial para entender la elegante consistencia de Ruby, su estilo de llamada de métodos sobre todo, y sus capacidades de metaprogramación — convirtiéndola en conocimiento importante y fundamental para trabajar con el lenguaje y un punto frecuente que captura la naturaleza distintiva orientada a objetos de Ruby.