Katika Ruby, kila kitu ni object — ikiwa ni pamoja na nambari, strings, nil, true/false, na hata classes zenyewe. Kila thamani ina methods unazoweza kuziita juu yake, na hakuna primitive types (tofauti na Java/C# zenye value-type primitives zao). Uthabiti huu ni sehemu ya msingi ya muundo wa 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
Tofauti na lugha zenye primitive types, katika Ruby 42 ni object kamili (instance ya Integer) — unaita methods moja kwa moja juu yake (42.even?, 42.times). Hata nil, true, na false ni objects zenye classes na methods zao wenyewe.
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
Hata classes ni objects (instances za Class) — ambayo ndiyo huwezesha metaprogramming yenye nguvu ya Ruby (unaweza kudhibiti classes wakati wa 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
Kuelewa kwamba "everything is an object" ni jambo la msingi kwa kufahamu muundo na uthabiti wa Ruby, na ni mojawapo ya sifa zinazofafanua lugha.
Tofauti na lugha zenye primitive types (Java/C# ambapo nambari na booleans ni value-type primitives, si objects), Ruby inashughulikia kila kitu — nambari, strings, nil, booleans, na hata classes zenyewe — kama objects zenye methods unazoweza kuziita.
Uthabiti huu safi wa object-oriented una athari za kivitendo: unaweza kuita methods moja kwa moja juu ya thamani yoyote (42.even?, nil.to_s, 42.times), patterns zilezile za object-oriented hufanya kazi kwa sare kwa thamani zote (hakuna ushughulikiaji maalum kwa "primitives"), na kila object inashiriki methods za kawaida zinazorithiwa kutoka Object.
Kwa muhimu, ukweli kwamba classes zenyewe ni objects (instances za Class) ndiyo huwezesha metaprogramming yenye nguvu ya Ruby — unaweza kukagua na kudhibiti classes wakati wa runtime, ambayo inashikilia sehemu kubwa ya kubadilika kwa Ruby na frameworks kama Rails.
Kuelewa kanuni hii inaeleza kwa nini msimbo wa Ruby unaweza kuita methods juu ya chochote, kwa nini lugha inahisiwa thabiti na sare kiasi hicho, na jinsi metaprogramming inavyowezekana.
Ni msingi wa dhana ambao unatofautisha Ruby na lugha zenye dualities za primitive/object, na kuufahamu ni muhimu kwa kuelewa uthabiti wa kuvutia wa Ruby, mtindo wake wa kuita-methods-juu-ya-kila-kitu, na uwezo wake wa metaprogramming — ukifanya kuwa maarifa muhimu, ya msingi kwa kufanya kazi na lugha na hoja inayotokea mara kwa mara inayonasa asili ya kipekee ya object-oriented ya Ruby.