In Ruby, everything is an object — including numbers, strings, nil, true/false, and even classes themselves. Every value has methods you can call on it, and there are no primitive types (unlike Java/C# with their value-type primitives). This consistency is a core part of Ruby's design.
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
Unlike languages with primitive types, in Ruby 42 is a full object (an Integer instance) — you call methods directly on it (42.even?, 42.times). Even nil, true, and false are objects with their own classes and methods.
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
Even classes are objects (instances of Class) — which is what enables Ruby's powerful metaprogramming (you can manipulate classes at runtime).
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
Understanding that "everything is an object" is fundamental to grasping Ruby's design and consistency, and it's one of the language's defining characteristics.
Unlike languages with primitive types (Java/C# where numbers and booleans are value-type primitives, not objects), Ruby treats everything — numbers, strings, nil, booleans, and even classes themselves — as objects with methods you can call.
This pure object-oriented consistency has practical implications: you can call methods directly on any value (42.even?, nil.to_s, 42.times), the same object-oriented patterns work uniformly across all values (no special handling for "primitives"), and every object shares common methods inherited from Object.
Critically, the fact that classes are themselves objects (instances of Class) is what enables Ruby's powerful metaprogramming — you can inspect and manipulate classes at runtime, which underpins much of Ruby's flexibility and frameworks like Rails.
Understanding this principle explains why Ruby code can call methods on anything, why the language feels so consistent and uniform, and how metaprogramming is possible.
It's a core conceptual foundation that distinguishes Ruby from languages with primitive/object dualities, and grasping it is essential for understanding Ruby's elegant consistency, its method-calling-on-everything style, and its metaprogramming capabilities — making it important, foundational knowledge for working with the language and a frequent point that captures Ruby's distinctive object-oriented nature.