I Ruby är allt ett objekt — inklusive siffror, strängar, nil, true/false, och även klasserna själva. Varje värde har metoder som du kan anropa på det, och det finns inga primitiva typer (till skillnad från Java/C# med deras värdetypsbaserade primitiver). Denna konsekvens är en central del 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
Till skillnad från språk med primitiva typer är 42 i Ruby ett fullständigt objekt (en Integer-instans) — du kan anropa metoder direkt på det (42.even?, 42.times). Till och med nil, true och false är objekt med sina egna klasser och 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
Till och med klasser är objekt (instanser av Class) — vilket är vad som möjliggör Rubys kraftfulla metaprogrammering (du kan manipulera klasser vid körning).
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
Att förstå att "allt är ett objekt" är grundläggande för att förstå Rubys design och konsekvens, och det är en av språkets definierande egenskaper.
Till skillnad från språk med primitiva typer (Java/C# där siffror och booleska värden är värdetypsbaserade primitiver, inte objekt) behandlar Ruby allt — siffror, strängar, nil, booleska värden och till och med klasserna själva — som objekt med metoder som du kan anropa.
Denna rena objektorienterade konsekvens har praktiska implikationer: du kan anropa metoder direkt på vilket värde som helst (42.even?, nil.to_s, 42.times), samma objektorienterade mönster fungerar enhetligt över alla värden (ingen särskild hantering för "primitiver"), och alla objekt delar gemensamma metoder som ärvs från Object.
Kritiskt är det faktum att klasser själva är objekt (instanser av Class) vilket möjliggör Rubys kraftfulla metaprogrammering — du kan inspektera och manipulera klasser vid körning, vilket ligger till grund för mycket av Rubys flexibilitet och ramverk som Rails.
Att förstå denna princip förklarar varför Ruby-kod kan anropa metoder på vad som helst, varför språket känns så konsekvent och enhetligt, och hur metaprogrammering är möjlig.
Det är en central begreppslig grund som skiljer Ruby från språk med primitiva/objekt-dualiteter, och att förstå det är väsentligt för att förstå Rubys eleganta konsekvens, dess stil med metodanrop på allt, och dess metaprogrammeringsförmågor — vilket gör det till viktig, grundläggande kunskap för att arbeta med språket och en vanlig punkt som fångar Rubys distinktiva objektorienterade natur.