Ruby-లో, everything is an object — సంఖ్యలు, strings, nil, true/false, మరియు classes కూడా ఈ వర్గంలో ఉన్నాయి. ప్రతి value కు methods ఉన్నాయి, మరియు 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 కలిగిన ఇతర భాషల నుండి భిన్నంగా, 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 యొక్క powerful metaprogramming సక్ష్మతను ప్రారంభం చేస్తుంది (మీరు runtime-లో classes ను manipulate చేయవచ్చు).
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
"Everything is an object" అని అర్థం చేసుకోవడం Ruby యొక్క design మరియు consistency ను గ్రహించడానికి fundamental, మరియు ఇది language యొక్క defining characteristics లలో ఒకటి.
Primitive types కలిగిన ఇతర భాషల నుండి (Java/C# ఇక్కడ numbers మరియు booleans value-type primitives, objects కాదు), Ruby everything — numbers, strings, nil, booleans, మరియు classes కూడా — objects గా handle చేస్తుంది, ఇవి methods కలిగి ఉన్నాయి.
ఈ pure object-oriented consistency ఆచరణాత్మక implications లను కలిగి ఉంది: మీరు ఏదైనా value పై నేరుగా methods కాల్ చేయవచ్చు (42.even?, nil.to_s, 42.times), అదే object-oriented patterns అన్ని values లో uniformly పని చేస్తాయి ("primitives" కు special handling లేదు), మరియు ప్రతి object Object నుండి inherit చేయబడిన common methods ను share చేస్తుంది.
ముఖ్యంగా, classes కూడా objects (Class యొక్క instances) అనే fact Ruby యొక్క powerful metaprogramming ను సక్ష్మం చేస్తుంది — మీరు runtime-లో classes ను inspect చేయవచ్చు మరియు manipulate చేయవచ్చు, ఇది Rails వంటి frameworks యొక్క underlying కారణం.
ఈ principle ను అర్థం చేసుకోవడం Ruby code ఎందుకు ఏదైనా పై methods కాల్ చేయగలదని, ఎందుకు language అంత consistent మరియు uniform గా ఫీల్ అవుతుందని, మరియు metaprogramming ఎలా సాధ్యమవుతుందని వివరిస్తుంది.
ఇది ఒక core conceptual foundation, ఇది primitive/object dualities కలిగిన ఇతర భాషల నుండి Ruby ను వేరు చేస్తుంది, మరియు ఇది Ruby యొక్క elegant consistency, దాని method-calling-on-everything style, మరియు దాని metaprogramming capabilities ను అర్థం చేసుకోవడానికి అవసరమైనది — language తో పని చేయడానికి ముఖ్యమైన, foundational knowledge, మరియు Ruby యొక్క distinctive object-oriented nature ను capture చేసే ఒక frequent point.