Ruby मध्ये व्हेरिएबल्स आणि बेसिक टाइप्स कसे काम करतात?

Question

Accepted Answer

Ruby **डायनॅमिकली टाइपड** आहे — व्हेरिएबल्स टाइप डिक्लेअर करत नाहीत आणि कोणतेही व्हॅल्यू होल्ड करू शकतात. Ruby मध्ये अनेक बेसिक टाइप्स आहेत (सर्व ऑब्जेक्ट्स), आणि **नेमिंग कन्व्हेंशन्स** (सिगील्स) व्हेरिएबल स्कोप दर्शवण्यासाठी वापरतो.

## व्हेरिएबल्स आणि डायनॅमिक टाइपिंग

```ruby
count = 42           # no type declaration — inferred
name = "Ann"
count = "now a string"   # dynamically typed — can change type
```

## बेसिक टाइप्स (सर्व ऑब्जेक्ट्स आहेत)

```ruby
42              # Integer
3.14            # Float
"hello"         # String
:symbol         # Symbol (an immutable, interned identifier)
true / false    # Boolean (TrueClass / FalseClass)
nil             # NilClass — "nothing" (Ruby's null)
[1, 2, 3]       # Array
{ a: 1 }        # Hash (key-value)
1..10           # Range
```

## व्हेरिएबल नेमिंग कन्व्हेंशन्स स्कोप दर्शवतात

```ruby
name        = "local"      # local variable (lowercase)
@instance   = "instance"   # @ → INSTANCE variable (per object)
@@class_var = "class"      # @@ → CLASS variable (shared across instances)
$global     = "global"     # $ → global variable (avoid)
CONSTANT    = "constant"   # Uppercase start → CONSTANT (convention; can change with warning)
```

Ruby **सिगील्स** (प्रीफिक्सेस) स्कोप दर्शवण्यासाठी वापरतो: साधी नावे लोकल आहेत, `@` इन्स्टन्स व्हेरिएबल्ससाठी, `@@` क्लास व्हेरिएबल्ससाठी, `$` ग्लोबल्ससाठी (अनुचित), आणि अपरकेस कॉन्स्टंट्ससाठी. हे विशिष्ट आहे — प्रीफिक्स तुम्हाला स्कोप एक नजरेने सांगते.

## ट्रूदिनेस (Ruby ची एक विचित्रता)

```ruby
# in Ruby, ONLY false and nil are falsy — EVERYTHING else is truthy
puts "truthy" if 0        # prints — 0 is TRUTHY in Ruby! (unlike many languages)
puts "truthy" if ""        # prints — empty string is truthy too
puts "falsy" unless nil    # nil is falsy
```

**फक्त `false` आणि `nil` falsy आहेत** Ruby मध्ये — `0`, `""`, आणि `[]` सर्व truthy आहेत (बर्‍याच भाषांच्या विपरीत जेथे 0/empty falsy आहेत). हा एक सामान्य नुकसान आहे.

## हे महत्वाचे का आहे

Ruby च्या व्हेरिएबल्स आणि बेसिक टाइप्स समजणे हे दैनंदिन मूलभूत ज्ञान आहे.

Ruby डायनॅमिकली टाइपड आहे (व्हेरिएबल्स कोणतेही व्हॅल्यू होल्ड करतात, कोणती टाइप डिक्लेरेशन नाही), आणि एक विशिष्ट फीचर म्हणजे **नेमिंग कन्व्हेंशन्स (सिगील्स) व्हेरिएबल स्कोप दर्शवण्यासाठी** वापरणे — `@` इन्स्टन्स व्हेरिएबल्ससाठी, `@@` क्लास व्हेरिएबल्ससाठी, `$` ग्लोबल्ससाठी, अपरकेस कॉन्स्टंट्ससाठी — त्यामुळे व्हेरिएबलचा प्रीफिक्स तुम्हाला त्याचा स्कोप एक नजरेने सांगते, जो Ruby योग्यरित्या वाचण्यासाठी आणि लिहिण्यासाठी महत्वाचा आहे (विशेषतः `@instance` व्हेरिएबल्स, क्लासेस मध्ये सतत वापरतात).

बेसिक टाइप्स जाणणे (Ruby च्या शुद्ध ऑब्जेक्ट-ओरिएंटेड मॉडेलमध्ये सर्व ऑब्जेक्ट्स आहेत) — विशिष्ट **Symbol** टाइप सह — डेटा सह काम करण्यासाठी आवश्यक आहे.

आणि विशेषतः समजणे महत्वाचे आहे Ruby ची **truthiness**: **फक्त `false` आणि `nil` falsy आहेत**, बाकी सर्व काही truthy आहे (आणि `0`, `""`, आणि `[]` सह) — हे बर्‍याच भाषांपेक्षा वेगळे आहे (जेथे 0 किंवा empty व्हॅल्यूज falsy आहेत) आणि इतर भाषांमधून येणाऱ्या डेव्हलपर्ससाठी बग्सचा सामान्य स्रोत आहे.

डायनॅमिक टाइपिंग, स्कोप-इंडिकेटिंग नेमिंग कन्व्हेंशन्स, बेसिक टाइप्स, आणि विशेषतः false-and-nil-only truthiness नियम समजणे हे सही Ruby लिहिण्यासाठी आणि सामान्य नुकसान टाळण्यासाठी आधारभूत आहे, ज्यामुळे हे भाषासाठी आवश्यक, अवश्य-जाणावे ज्ञान आहे.