A Ruby-ban minden egy objektum — beleértve a számokat, stringeket, nil-t, true/false-t, és magát az osztályokat is. Minden érték rendelkezik olyan metódusokkal, amelyeket meghívhatsz rajta, és nincsenek primitív típusok (ellentétben a Java-val/C#-mal, amelyeknek vannak value-type primitívjeik). Ez a konzisztencia a Ruby tervezésének lényeges része.
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
Ellentétben a primitív típusokkal rendelkező nyelvekkel, a Ruby-ban a 42 egy teljes objektum (Integer instancia) — közvetlenül meghívhatod rajta a metódusokat (42.even?, 42.times). Még a nil, true és false is objektumok, saját osztályaikkal és metódusaikkal.
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
Még az osztályok is objektumok (Class instanciái) — ami lehetővé teszi a Ruby hatékony metaprogramozását (futásidőben manipulálhatod az osztályokat).
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
Annak megértése, hogy "minden egy objektum", alapvető a Ruby tervezésének és konzisztenciájának felfogásához, és a nyelv egyik jellegzetes tulajdonsága.
Ellentétben a primitív típusokkal rendelkező nyelvekkel (Java/C#, ahol a számok és a logikai értékek value-type primitívek, nem pedig objektumok), a Ruby mindennek — számoknak, stringeknek, nil-nek, logikai értékeknek, és magának az osztályoknak — objektumként kell lennie, amelyeken metódusokat lehet meghívni.
Ennek a tiszta objektumorientált konzisztenciának gyakorlati következményei vannak: közvetlenül meghívhatod a metódusokat bármely értéken (42.even?, nil.to_s, 42.times), ugyanazok az objektumorientált minták egyenletesen működnek az összes értéken (nincs szükség "primitívek" speciális kezelésére), és minden objektum közös metódusokat örököl az Object-ből.
Kritikus, hogy az osztályok maguk is objektumok (Class instanciái), ami lehetővé teszi a Ruby erőteljes metaprogramozását — futásidőben meg tudod vizsgálni és manipulálni az osztályokat, ami a Rails-hoz hasonló keretrendszerek rugalmasságának alapját képezi.
Ennek az elvnek a megértése magyarázza meg, hogy a Ruby-kód miért tud metódusokat hívni bármin, miért érzi magát a nyelv olyan konzisztensnek és egyenletesnek, és hogyan lehetséges a metaprogramozás.
Ez a Ruby jellegzetes objektumorientált természetét felöleli, és megértése elengedhetetlen a nyelvvel való munkához, valamint alapvető tudás, amely megkülönbözteti a Ruby-t a primitív/objektum dualitással rendelkező nyelvektől — így fontos, alapozó ismeret a Ruby elegáns konzisztenciájának, metódus-meghívási stílusának és metaprogramozási képességeinek megértéséhez.