Ruby లో వేరియబల్‌లు మరియు ప్రాథమిక రకాలు ఎలా పనిచేస్తాయి?

Question

Accepted Answer

Ruby **డైనమిక్‌గా టైప్‌ చేయబడింది** — వేరియబల్‌లు రకాన్ని ప్రకటించవు మరియు ఏదైనా విలువను ఉంచుకుంటాయి. Ruby కొన్ని ప్రాథమిక రకాలను కలిగి ఉంది (అన్నీ objects), మరియు వేరియబల్ స్కోప్‌ను సూచించడానికి **నామకరణ సంప్రదాయాలు** (sigils) ను ఉపయోగిస్తుంది.

## వేరియబల్‌లు మరియు డైనమిక్ టైపింగ్

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

## ప్రాథమిక రకాలు (అన్నీ objects)

```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 వేరియబల్ స్కోప్‌ను సూచించడానికి **sigils** (ఉపసర్గలు) ని ఉపయోగిస్తుంది: సాధారణ పేర్లు లోకల్ స్కోప్, `@` ఇన్‌స్టెన్స్ వేరియబల్‌ల కోసం, `@@` క్లాస్ వేరియబల్‌ల కోసం, `$` గ్లోబల్‌ల కోసం (నిరుత్సాహపరచబడినవి), మరియు పెద్ద అక్షరాలు స్థిరాంకాల కోసం. ఇది విశిష్టమైనది — ఉపసర్గ ఒక నిమిషంలో స్కోప్‌ను చెప్పుకుంటుంది.

## సత్యత (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
```

**Ruby లో కేవలం `false` మరియు `nil` మాత్రమే falsy** — `0`, `""`, మరియు `[]` అన్నీ truthy (అనేక భాషలలో భిన్నంగా ఇక్కడ 0/ఖాళీ falsy). సాధారణ సమస్య.

## ఇది ఎందుకు ముఖ్యమైనది

Ruby యొక్క వేరియబల్‌లు మరియు ప్రాథమిక రకాలను అర్థం చేసుకోవడం ప్రాథమిక రోజువారీ జ్ఞానం.

Ruby డైనమిక్‌గా టైప్‌ చేయబడింది (వేరియబల్‌లు ఏదైనా విలువను ఉంచుకుంటాయి, రకం ప్రకటనలు లేవు), మరియు ఒక విశిష్ట లక్షణం వేరియబల్ స్కోప్‌ను సూచించడానికి **నామకరణ సంప్రదాయాలు (sigils) ని ఉపయోగించడం** — ఇన్‌స్టెన్స్ వేరియబల్‌ల కోసం `@`, క్లాస్ వేరియబల్‌ల కోసం `@@`, గ్లోబల్‌ల కోసం `$`, స్థిరాంకాల కోసం పెద్ద అక్షరాలు — కాబట్టి వేరియబల్‌ కు ఉపసర్గ ఒక క్ষణంలో సరిపోతుంది, ఇది Ruby ను సరిగ్గా చదవడానికి మరియు వ్రాయడానికి ముఖ్యమైనది (ముఖ్యంగా `@instance` వేరియబల్‌లు, క్లాస్‌లలో స్థిరంగా ఉపయోగించబడతాయి).

ప్రాథమిక రకాలను తెలుసుకోవడం (Ruby యొక్క స్వచ్ఛమైన ఆబ్జెక్ట్-ఓరియంటెడ్ మోడల్‌లో సమస్త రకాలు objects) — విశిష్ట **Symbol** రకం సహా — డేటాతో పని చేయడానికి అవసరం.

ప్రత్యేకంగా ముఖ్యమైన విలక్షణత Ruby యొక్క **సత్యత**: **కేవలం `false` మరియు `nil` మాత్రమే falsy**, అయితే ఇతర అన్నీ (`0`, `""`, మరియు `[]` సహా) truthy — ఇది అనేక భాషల నుండి భిన్నంగా ఉంది (ఇక్కడ 0 లేదా ఖాళీ విలువలు falsy) మరియు ఇతర భాషల నుండి వచ్చిన డెవలపర్‌ల కోసం సాధారణ బగ్ల మూలం.

డైనమిక్ టైపింగ్, స్కోప్-సూచించే నామకరణ సంప్రదాయాలు, ప్రాథమిక రకాలు, మరియు ముఖ్యంగా false-మరియు-nil-only సత్యత నియమాన్ని అర్థం చేసుకోవడం సరైన Ruby ని వ్రాయడానికి మరియు సాధారణ సమస్యలను నివారించడానికి ప్రాథమికమైనది, ఇది భాష కోసం అవసరమైన, తప్పనిసరిగా తెలుసుకోవలసిన జ్ఞానం.