I Ruby er alt et objekt — inkludert tall, strenger, nil, true/false, og til og med klassene selv. Hver verdi har metoder du kan kalle på den, og det finnes ingen primitive typer (ulikt Java/C# som har verdi-type primitiver). Denne konsistensen er en kjernedel av Rubys 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
Ulikt språk med primitive typer, i Ruby er 42 et fullt objekt (en Integer-instans) — du kaller metoder direkte på det (42.even?, 42.times). Selv nil, true og false er objekter med sine egne klasser og metoder.
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
Enkelt klasser er objekter (instanser av Class) — noe som gjør det mulig for Rubys kraftfulle metaprogrammering (du kan manipulere klasser under kjøring).
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
Å forstå at "alt er et objekt" er grunnleggende for å forstå Rubys design og konsistens, og det er en av språkets definerende karakteristikker.
Ulikt språk med primitive typer (Java/C# der tall og boolske verdier er verdi-type primitiver, ikke objekter), behandler Ruby alt — tall, strenger, nil, boolske verdier, og til og med klassene selv — som objekter med metoder du kan kalle.
Denne rene objektorienterte konsistensen har praktiske implikasjoner: du kan kalle metoder direkte på en hvilken som helst verdi (42.even?, nil.to_s, 42.times), de samme objektorienterte mønstrene fungerer jevnt over alle verdier (ingen spesialbehandling for "primitiver"), og hvert objekt deler felles metoder som arves fra Object.
Kritisk sett er det faktum at klasser selv er objekter (instanser av Class) som gjør det mulig for Rubys kraftfulle metaprogrammering — du kan inspeksere og manipulere klasser under kjøring, noe som ligger til grunn for mye av Rubys fleksibilitet og rammeverk som Rails.
Å forstå dette prinsippet forklarer hvorfor Ruby-kode kan kalle metoder på hva som helst, hvorfor språket føles så konsistent og ensartet, og hvordan metaprogrammering er mulig.
Det er et kjernekonseptuelt fundament som skiller Ruby fra språk med primitiv/objekt-dualiteter, og å forstå det er essensielt for å forstå Rubys elegante konsistens, dens stil med å kalle metoder på alt, og dens metaprogrammeringsevner — noe som gjør det viktig, grunnleggende kunnskap for å arbeide med språket og et hyppig poeng som fanger Rubys distinktive objektorienterte natur.