Ruby-ல், எல்லாமும் ஒரு object — எண்கள், strings, nil, true/false, மற்றும் வகுப்புகளுக்கே சாதாரணம். ஒவ்வொரு மதிப்பிலும் நீங்கள் call செய்யக்கூடிய methods உள்ளன, மேலும் primitive types இல்லை (Java/C# போன்று value-type primitives உள்ள மொழிகளுக்கு மாறாக). இந்த consistency 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 directly call செய்யலாம் (42.even?, 42.times). nil, true, மற்றும் false கூட அவற்றின் சொந்த வகுப்புகள் மற்றும் 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
வகுப்புகளும் objects (Class இன் instances) — இது Ruby-ல் powerful metaprogramming செய்ய முடியும் (நீங்கள் 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
"எல்லாமும் ஒரு object" என்பதை புரிந்துகொள்வது Ruby-ல் வடிவமைப்பு மற்றும் consistency ஐ புரிந்துகொள்ள அடிப்படையாகும், மேலும் இது மொழியின் வரையறுக்கும் குணாதிசயங்களில் ஒன்றாகும்.
Primitive types உள்ள மொழிகளுக்கு மாறாக (Java/C# என்றவற்றில் எண்கள் மற்றும் booleans value-type primitives தான், objects அல்ல), Ruby எல்லாத்தையும் — எண்கள், strings, nil, booleans, மற்றும் வகுப்புகளுக்கே — methods call செய்யக்கூடிய objects ஆக பார்க்கிறது.
இந்த pure object-oriented consistency க்கு practical implications உள்ளன: நீங்கள் எந்த மதிப்பிலும் direct ஆக methods call செய்யலாம் (42.even?, nil.to_s, 42.times), ஒரே object-oriented patterns எல்லா மதிப்புக்களுக்கும் uniformly வேலை செய்கிறது ("primitives"-க்கு special handling தேவை இல்லை), மற்றும் ஒவ்வொரு object Object-ல் இருந்து inherit செய்யப்பட்ட common methods பகிர்ந்துகொள்கிறது.
আরo முக்கியமாக, வகுப்புகளும் objects தாய் (Class இன் instances) என்ற உண்மை Ruby-ல் powerful metaprogramming செய்ய முடியும் — நீங்கள் runtime-ல் வகுப்புகளை inspect மற்றும் manipulate செய்யலாம், இது Rails போன்ற frameworks-ல் உபயோகப்படுத்தப்படுகிறது.
இந்த principle ஐ புரிந்துகொள்வது Ruby code எப்படி எந்த மதிப்பிலும் methods call செய்ய முடியும், மொழி எப்படி consistent மற்றும் uniform உணர்ந்து, metaprogramming எப்படி possible ஆகும் என்பதை விளக்குகிறது.
இது ஒரு core conceptual foundation இது primitive/object dualities உள்ள மொழிகளிலிருந்து Ruby ஐ வேறுபட்டு செய்கிறது, மேலும் இதை புரிந்துகொள்வது Ruby-ல் elegant consistency, method-calling-on-everything style, மற்றும் metaprogramming capabilities புரிந்துகொள்ள அவசியமானது — இது மொழியுடன் வேலை செய்ய முக்கியமான, foundation ஆன அறிவு ஆகும் மற்றும் Ruby-ல் distinctive object-oriented nature ஐ capture செய்யும் அடிக்கடி குறிப்பிடப்படும் புள்ளி.