Ruby में, हर चीज़ एक object है — numbers, strings, nil, true/false, और यहाँ तक कि classes भी। हर value में methods होते हैं जिन्हें आप उस पर call कर सकते हैं, और कोई primitive types नहीं हैं (Java/C# के विपरीत जिनमें value-type primitives होते हैं)। यह consistency Ruby के 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
primitive types वाली languages के विपरीत, Ruby में 42 एक पूर्ण object है (एक Integer instance) — आप इस पर सीधे methods call करते हैं (42.even?, 42.times)। यहाँ तक कि nil, true, और false भी अपनी classes और methods वाले objects हैं।
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
यहाँ तक कि classes भी objects हैं (Class के instances) — और यही Ruby के शक्तिशाली metaprogramming को सक्षम बनाता है (आप runtime पर classes में हेरफेर कर सकते हैं)।
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
यह समझना कि "हर चीज़ एक object है" Ruby के design और consistency को समझने के लिए मूलभूत है, और यह language की परिभाषित विशेषताओं में से एक है।
primitive types वाली languages के विपरीत (Java/C# जहाँ numbers और booleans value-type primitives हैं, objects नहीं), Ruby हर चीज़ को — numbers, strings, nil, booleans, और यहाँ तक कि classes को भी — methods वाले objects के रूप में मानता है जिन्हें आप call कर सकते हैं।
इस शुद्ध object-oriented consistency के व्यावहारिक निहितार्थ हैं: आप किसी भी value पर सीधे methods call कर सकते हैं (42.even?, nil.to_s, 42.times), वही object-oriented patterns सभी values पर समान रूप से काम करते हैं ("primitives" के लिए कोई विशेष हैंडलिंग नहीं), और हर object Object से विरासत में मिले common methods साझा करता है।
निर्णायक रूप से, यह तथ्य कि classes स्वयं objects हैं (Class के instances) ही Ruby के शक्तिशाली metaprogramming को सक्षम बनाता है — आप runtime पर classes का निरीक्षण और हेरफेर कर सकते हैं, जो Ruby के अधिकांश लचीलेपन और Rails जैसे frameworks का आधार है।
इस सिद्धांत को समझना यह स्पष्ट करता है कि Ruby code किसी भी चीज़ पर methods क्यों call कर सकता है, language इतनी consistent और uniform क्यों महसूस होती है, और metaprogramming कैसे संभव है।
यह एक मूल वैचारिक आधार है जो Ruby को primitive/object द्वैत वाली languages से अलग करता है, और इसे समझना Ruby की elegant consistency, इसकी हर चीज़-पर-method-calling शैली, और इसकी metaprogramming क्षमताओं को समझने के लिए आवश्यक है — जो इसे language के साथ काम करने के लिए महत्वपूर्ण, मूलभूत ज्ञान बनाता है और एक बार-बार आने वाला बिंदु है जो Ruby की विशिष्ट object-oriented प्रकृति को दर्शाता है।