In Ruby is alles een object — inclusief nummers, strings, nil, true/false, en zelfs klassen zelf. Elke waarde heeft methodes die je erop kunt aanroepen, en er zijn geen primitieve types (in tegenstelling tot Java/C# met hun value-type primitieven). Deze consistentie is een kernonderdeel van Ruby's ontwerp.
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
In tegenstelling tot talen met primitieve types, is 42 in Ruby een volledig object (een Integer instantie) — je roept methodes er rechtstreeks op aan (42.even?, 42.times). Zelfs nil, true en false zijn objecten met hun eigen klassen en methodes.
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
Zelfs klassen zijn objecten (instanties van Class) — wat Ruby's krachtige metaprogrammering mogelijk maakt (je kunt klassen tijdens runtime manipuleren).
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
Begrijpen dat "alles een object is" is fundamenteel voor het begrijpen van Ruby's ontwerp en consistentie, en het is een van de definiërende karakteristieken van de taal.
In tegenstelling tot talen met primitieve types (Java/C# waar nummers en booleans value-type primitieven zijn, geen objecten), behandelt Ruby alles — nummers, strings, nil, booleans, en zelfs klassen zelf — als objecten met methodes die je kunt aanroepen.
Deze pure object-georiënteerde consistentie heeft praktische implicaties: je kunt rechtstreeks methodes op elke waarde aanroepen (42.even?, nil.to_s, 42.times), dezelfde object-georiënteerde patronen werken uniform over alle waarden (geen speciale behandeling voor "primitieven"), en elk object deelt gemeenschappelijke methodes die van Object zijn overgeërfd.
Kritisch is het feit dat klassen zelf objecten zijn (instanties van Class) wat Ruby's krachtige metaprogrammering mogelijk maakt — je kunt klassen tijdens runtime inspecteren en manipuleren, wat veel van Ruby's flexibiliteit en frameworks zoals Rails ondersteunt.
Het begrijpen van dit principe verklaart waarom Ruby-code methodes op alles kan aanroepen, waarom de taal zo consistent en uniform voelt, en hoe metaprogrammering mogelijk is.
Het is een kernconceptuele basis die Ruby onderscheidt van talen met primitieve/object dualiteiten, en het beheersen ervan is essentieel voor het begrijpen van Ruby's elegante consistentie, zijn methode-aanroepen-op-alles stijl, en zijn metaprogrammering mogelijkheden — wat het belangrijke, fundamentele kennis voor het werken met de taal maakt en een veelvoorkomend punt dat Ruby's karakteristieke object-georiënteerde aard benadrukt.