Ruby માં, બધું એક object છે — તેમાં સંખ્યાઓ, strings, nil, true/false, અને પણ classes પોતે સમાવિષ્ટ છે. દરેક value પર તમે methods કોલ કરી શકો છો, અને કોઈ primitive types નથી (Java/C# જેવી ભાષાઓમાં તેમના value-type primitives છે તેથી અલગ). આ સુસંગતતા 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
Primitive types ધરાવતી ભાષાઓથી અલગ, Ruby માં 42 એક સંપૂર્ણ object છે (એક Integer instance) — તમે તેના પર સીધા methods કોલ કરો છો (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 ના ડિજાઇન અને સુસંગતતા સમજવા માટે મૌલિક છે, અને તે ભાષાની વ્યાખ્યાત્મક લક્ષણો માંનું એક છે.
Primitive types ધરાવતી ભાષાઓથી અલગ (Java/C# જ્યાં સંખ્યાઓ અને booleans value-type primitives છે, objects નહીં), Ruby બધું — સંખ્યાઓ, strings, nil, booleans, અને પણ classes પોતે — objects તરીકે માને છે જેના પર તમે methods કોલ કરી શકો છો.
આ શુદ્ધ object-oriented સુસંગતતા વ્યવહારિક અર્થઘટન ધરાવે છે: તમે કોઈ પણ value પર સીધા methods કોલ કરી શકો છો (42.even?, nil.to_s, 42.times), સમાન object-oriented patterns સમોચ્ચલ વ્યવહાર કરે છે તમામ values માટે ("primitives" માટે કોઈ વિશેષ હેન્ડલિંગ નથી), અને દરેક object સામાન્ય methods શેર કરે છે જે Object માંથી inherit થાય છે.
ર્ણત રીતે, તે હકીકત કે classes પોતે objects છે (Class ના instances) તે Ruby ની શક્તિશાળી metaprogramming સક્ષમ કરે છે — તમે runtime પર classes ને inspect અને হેરફેર કરી શકો છો, જે Rails જેવા frameworks ના મોટા ભાગનો આધાર છે.
આ સિદ્ધાંત સમજવું બતાવે છે કે શા માટે Ruby code બધું પર methods કોલ કરી શકે છે, શા માટે ભાષા એટલી સુસંગત અને uniform લાગે છે, અને metaprogramming કેવી રીતે શક્ય છે.
તે એક મૂલ ખ્યાલીય પાયો છે જે Ruby ને primitive/object દ્વૈતવાળી ભાષાઓથી અલગ કરે છે, અને તેને સમજવું Ruby ની elegant સુસંગતતા, તેની method-calling-on-everything શૈલી, અને તેની metaprogramming ક્ષમતાઓ સમજવા માટે જરૂરી છે — તેને મહત્વપૂર્ણ, મૌલિક જ્ઞાન બનાવે છે ભાષા સાથે કામ કરવા માટે અને આ Ruby ની વિશિષ્ટ object-oriented પ્રકૃતિ પકડનાર હોય તેવો વારંવાર બિંદુ છે.