Em Ruby, tudo é um objeto — incluindo números, strings, nil, true/false e até mesmo as próprias classes. Todo valor possui métodos que você pode chamar nele, e não existem tipos primitivos (ao contrário de Java/C#, com seus primitivos de tipo por valor). Essa consistência é uma parte central do design do 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
Ao contrário de linguagens com tipos primitivos, em Ruby 42 é um objeto completo (uma instância de Integer) — você chama métodos diretamente nele (42.even?, 42.times). Até nil, true e false são objetos com suas próprias classes e 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
Até as classes são objetos (instâncias de Class) — o que é justamente o que habilita a poderosa metaprogramação do Ruby (você pode manipular classes em tempo de execução).
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
Entender que "tudo é um objeto" é fundamental para compreender o design e a consistência do Ruby, e é uma das características que definem a linguagem.
Ao contrário de linguagens com tipos primitivos (Java/C#, onde números e booleanos são primitivos de tipo por valor, não objetos), Ruby trata tudo — números, strings, nil, booleanos e até as próprias classes — como objetos com métodos que você pode chamar.
Essa consistência puramente orientada a objetos tem implicações práticas: você pode chamar métodos diretamente em qualquer valor (42.even?, nil.to_s, 42.times), os mesmos padrões orientados a objetos funcionam de maneira uniforme em todos os valores (sem tratamento especial para "primitivos") e todo objeto compartilha métodos comuns herdados de Object.
O ponto crucial é que o fato de as classes serem elas mesmas objetos (instâncias de Class) é o que habilita a poderosa metaprogramação do Ruby — você pode inspecionar e manipular classes em tempo de execução, o que sustenta grande parte da flexibilidade do Ruby e de frameworks como o Rails.
Compreender esse princípio explica por que o código Ruby pode chamar métodos em qualquer coisa, por que a linguagem parece tão consistente e uniforme, e como a metaprogramação é possível.
É uma base conceitual central que distingue Ruby de linguagens com dualidades primitivo/objeto, e compreendê-la é essencial para entender a elegante consistência do Ruby, seu estilo de chamar-métodos-em-tudo e suas capacidades de metaprogramação — o que faz dela um conhecimento importante e fundamental para trabalhar com a linguagem e um ponto recorrente que captura a natureza orientada a objetos distintiva do Ruby.