Ruby ਵਿੱਚ, ਸਭ ਕੁਝ ਇੱਕ ਆਬਜੈਕਟ ਹੈ — ਸੰਖਿਆਵਾਂ, ਸਤਰਾਂ, nil, true/false, ਅਤੇ ਇਹ ਵੀ ਕਿ ਕਲਾਸਾਂ ਖੁਦ ਵੀ। ਹਰ ਮੁੱਲ ਦੇ ਢੰਗ ਹਨ ਜੋ ਤੁਸੀਂ ਇਸ ਤੇ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਕੋਈ 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 ਇੱਕ ਪੂਰਾ ਆਬਜੈਕਟ ਹੈ (ਇੱਕ Integer ਇਨਸਟੈਂਸ) — ਤੁਸੀਂ ਇਸ ਤੇ ਸਿੱਧੇ ਢੰਗ ਕਾਲ ਕਰਦੇ ਹੋ (42.even?, 42.times)। ਇਹ ਵੀ nil, true, ਅਤੇ false ਆਬਜੈਕਟ ਹਨ ਆਪਣੀਆਂ ਖੁਦ ਦੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਢੰਗਾਂ ਦੇ ਨਾਲ।
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
ਕਲਾਸਾਂ ਵੀ ਆਬਜੈਕਟ ਹਨ (Class ਦੇ ਇਨਸਟੈਂਸਸ) — ਜੋ Ruby ਦੀ ਸ਼ਕਤੀਸ਼ਾਲੀ metaprogramming ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ (ਤੁਸੀਂ ਰਨਟਾਈਮ ਤੇ ਕਲਾਸਾਂ ਨੂੰ ਜੋਰ ਦੇ ਸਕਦੇ ਹੋ)।
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
ਇਹ ਸਮਝਣਾ ਕਿ "ਸਭ ਕੁਝ ਇੱਕ ਆਬਜੈਕਟ ਹੈ" Ruby ਦੇ ਡਿਜ਼ਾਈਨ ਅਤੇ ਇਕਸਾਰਤਾ ਨੂੰ ਸਮਝਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ, ਅਤੇ ਇਹ ਭਾਸ਼ਾ ਦੀ ਪਰਿਭਾਸ਼ਾ ਵਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ।
Primitive types ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ (Java/C# ਜਿਥੇ ਸੰਖਿਆਵਾਂ ਅਤੇ booleans value-type primitives ਹਨ, ਆਬਜੈਕਟ ਨਹੀਂ) ਦੀ ਤਰ੍ਹਾਂ ਨਹੀਂ, Ruby ਸਭ ਕੁਝ — ਸੰਖਿਆਵਾਂ, ਸਤਰਾਂ, nil, booleans, ਅਤੇ ਇਹ ਵੀ ਕਿ ਕਲਾਸਾਂ ਖੁਦ — ਨੂੰ ਆਬਜੈਕਟਸ ਦੇ ਰੂਪ ਵਿੱਚ ਸਮਝਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦੇ ਢੰਗ ਤੁਸੀਂ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ।
ਇਹ ਸ਼ੁੱਧ object-oriented ਇਕਸਾਰਤਾ ਦੇ ਅਮਲੀ ਪ੍ਰਭਾਵ ਹਨ: ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਮੁੱਲ ਤੇ ਸਿੱਧੇ ਢੰਗ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ (42.even?, nil.to_s, 42.times), ਇੱਕ ਜੈਸੇ object-oriented ਪੈਟਰਨ ਸਾਰੀਆਂ ਕੀਮਤਾਂ ਵਿੱਚ ਇਕਸਾਰ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ (