Dalam Ruby, semuanya adalah objek — termasuk nombor, string, nil, true/false, dan juga kelas itu sendiri. Setiap nilai mempunyai kaedah yang boleh anda panggil padanya, dan tiada jenis primitif (tidak seperti Java/C# dengan primitif jenis nilai mereka). Ketekalan ini adalah sebahagian teras daripada reka bentuk 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
Tidak seperti bahasa dengan jenis primitif, dalam Ruby 42 adalah objek penuh (instance Integer) — anda memanggil kaedah secara langsung padanya (42.even?, 42.times). Malah nil, true, dan false adalah objek dengan kelas dan kaedah mereka sendiri.
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
Malah kelas adalah objek (instance bagi Class) — yang membolehkan metaprogramming Ruby yang berkuasa (anda boleh memanipulasi kelas semasa 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
Memahami bahawa "semuanya adalah objek" adalah asas untuk menguasai reka bentuk dan ketekalan Ruby, dan ia adalah salah satu ciri yang mentakrifkan bahasa ini.
Tidak seperti bahasa dengan jenis primitif (Java/C# di mana nombor dan boolean adalah primitif jenis nilai, bukan objek), Ruby memperlakukan segala-galanya — nombor, string, nil, boolean, dan juga kelas itu sendiri — sebagai objek dengan kaedah yang boleh anda panggil.
Ketekalan berorientasikan objek tulen ini mempunyai implikasi praktikal: anda boleh memanggil kaedah secara langsung pada sebarang nilai (42.even?, nil.to_s, 42.times), corak berorientasikan objek yang sama berfungsi secara seragam merentasi semua nilai (tiada pengendalian khas untuk "primitif"), dan setiap objek berkongsi kaedah biasa yang diwarisi daripada Object.
Yang penting, hakikat bahawa kelas itu sendiri adalah objek (instance bagi Class) adalah apa yang membolehkan metaprogramming Ruby yang berkuasa — anda boleh memeriksa dan memanipulasi kelas semasa runtime, yang menyokong sebahagian besar fleksibiliti Ruby dan kerangka seperti Rails.
Memahami prinsip ini menjelaskan mengapa kod Ruby boleh memanggil kaedah pada apa sahaja, mengapa bahasa ini terasa begitu tekal dan seragam, dan bagaimana metaprogramming menjadi mungkin.
Ia adalah asas konsep teras yang membezakan Ruby daripada bahasa dengan dualiti primitif/objek, dan menguasainya adalah penting untuk memahami ketekalan elegan Ruby, gaya panggil-kaedah-pada-segala-galanya, dan keupayaan metaprogrammingnya — menjadikannya pengetahuan asas yang penting untuk bekerja dengan bahasa ini dan satu perkara yang kerap menangkap sifat berorientasikan objek tersendiri Ruby.