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
```

**Ruby માં માત્ર `false` અને `nil` જ ખોટા છે** — `0`, `""`, અને `[]` બધા સત્ય છે (અન્ય ઘણી ભાષાઓથી અલગ જ્યાં 0/ખાલી ખોટા છે). સામાન્ય મુશ્કેલી.

## તે શા માટે મહત્ત્વપૂર્ણ છે

Ruby ના ચલો અને મૂળભૂત પ્રકારોને સમજવું તે મૌલિક દૈનિક જ્ઞાન છે.

Ruby ગતિશીલ રીતે ટાઇપ કરાયેલ છે (ચલો કોઈપણ મૂલ્ય ધરાવે છે, કોઈ પ્રકાર ઘોષણા નથી), અને એક વિશિષ્ટ લક્ષણ તેનો **નામકરણ સંમેલનો (સિગિલ્સ) ચલ સ્કોપ સૂચવવા માટે** છે — `@` ઉદાહરણ ચલો માટે, `@@` વર્ગ ચલો માટે, `$` વૈશ્વિક માટે, મૂડી અક્ષર સ્થિરાંક માટે — તેથી ચલનો ઉપસર્ગ તમને તેનો સ્કોપ એક નજરમાં કહે છે, જે Ruby સાચું વાંચવા અને લખવા માટે મહત્ત્વપૂર્ણ છે (ખાસ કરીને `@instance` ચલો, વર્ગમાં સતત ઉપયોગમાં આવે છે).

mૂળભૂત પ્રકારોને જાણવું (જે તમામ Ruby ના શુદ્ધ ઑબ્જેક્ટ-ઓરિએન્ટેડ મોડેલમાં વસ્તુઓ છે) — વિશિષ્ટ **Symbol** પ્રકાર સહિત — ડેટા સાથે કામ કરવા માટે જરૂરી છે.

Ruby ની **સત્યતા** સમજવું ખાસ મહત્ત્વપૂર્ણ વિચિત્રતા છે: **માત્ર `false` અને `nil` જ ખોટા છે**, બાકી બધું (`0`, `""`, અને `[]` સહિત) સત્ય છે — આ અન્ય ઘણી ભાષાઓથી અલગ છે (જ્યાં 0 અથવા ખાલી મૂલ્યો ખોટા છે) અને અન્ય ભાષાઓથી આવતા ડેવલપર્સ માટે બગ્સનો સામાન્ય સ્ત્રોત છે.

ગતિશીલ ટાઇપિંગ, સ્કોપ-સૂચક નામકરણ સંમેલનો, મૂળભૂત પ્રકારો, અને ખાસ કરીને false-અને-nil-માત્ર સત્યતા નિયમ સમજવું તે સાચો Ruby લખવા અને સામાન્ય મુશ્કેલીઓ ટાળવા માટે ভিત્તિ છે, તેને ભાષા માટે આવશ્યક, અનિવાર્ય જ્ઞાન બનાવે છે.