Ruby ਵਿੱਚ ਵੇਰੀਏਬਲਜ਼ ਅਤੇ ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ?

Question

Accepted Answer

Ruby **dynamically typed** ਹੈ — ਵੇਰੀਏਬਲਜ਼ ਕਿਸਮ ਦੀ ਘੋਸ਼ਣਾ ਨਹੀਂ ਕਰਦੇ ਅਤੇ ਕੋਈ ਵੀ ਮੁੱਲ ਰੱਖ ਸਕਦੇ ਹਨ। Ruby ਕੋਲ ਕਈ ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਹਨ (ਸਭ ਆਬਜੈਕਟ), ਅਤੇ ਵੇਰੀਏਬਲ ਸਕੋਪ ਨੂੰ ਦਰਸਾਉਣ ਲਈ **naming conventions** (sigils) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

## ਵੇਰੀਏਬਲਜ਼ ਅਤੇ dynamic typing

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

## ਵੇਰੀਏਬਲ ਨਾਮਿੰਗ conventions scope ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ

```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 ਵੇਰੀਏਬਲ scope ਨੂੰ ਦਰਸਾਉਣ ਲਈ **sigils** (prefixes) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ: ਸਧਾਰਨ ਨਾਮ local ਹਨ, `@` instance variables ਲਈ, `@@` class variables ਲਈ, `$` globals ਲਈ (discouraged), ਅਤੇ uppercase constants ਲਈ। ਇਹ distinctive ਹੈ — prefix ਤੁਹਾਨੂੰ ਤੁਰੰਤ scope ਵੱਲ ਸੰਕੇਤ ਕਰਦਾ ਹੈ।

## Truthiness (ਇੱਕ Ruby quirk)

```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 ਹਨ)। ਇਹ ਇੱਕ ਆਮ gotcha ਹੈ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Ruby ਦੀਆਂ ਵੇਰੀਏਬਲਜ਼ ਅਤੇ ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਨੂੰ ਸਮਝਣਾ ਰੋਜ਼ਮਰ੍ਹਾ ਦਾ ਬੁਨਿਆਦੀ ਗਿਆਨ ਹੈ।

Ruby dynamically typed ਹੈ (ਵੇਰੀਏਬਲਜ਼ ਕੋਈ ਵੀ ਮੁੱਲ ਰੱਖਦੇ ਹਨ, ਕੋਈ type declarations ਨਹੀਂ), ਅਤੇ ਇੱਕ distinctive ਵਿਸ਼ੇਸ਼ਤਾ ਵੇਰੀਏਬਲ scope ਨੂੰ ਦਰਸਾਉਣ ਲਈ **naming conventions (sigils) ਦੀ ਵਰਤੋਂ ਹੈ** — `@` instance variables ਲਈ, `@@` class variables ਲਈ, `$` globals ਲਈ, uppercase constants ਲਈ — ਇਸ ਲਈ ਵੇਰੀਏਬਲ ਦਾ prefix ਤੁਹਾਨੂੰ ਇਸਦਾ scope ਤੁਰੰਤ ਦਰਸਾ ਦਿੰਦਾ ਹੈ, ਜੋ Ruby ਨੂੰ ਸਹੀ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ (ਖਾਸ ਤੌਰ ਤੇ `@instance` ਵੇਰੀਏਬਲਜ਼, ਜੋ ਕਲਾਸਾਂ ਵਿੱਚ ਲਗਾਤਾਰ ਵਰਤੇ ਜਾਂਦੇ ਹਨ)।

ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ (ਸਭ Ruby ਦੇ pure object-oriented ਮਾਡਲ ਵਿੱਚ objects ਹਨ) ਨੂੰ ਜਾਣਨਾ — ਜਿਸ ਵਿੱਚ distinctive **Symbol** ਕਿਸਮ ਵੀ ਸ਼ਾਮਲ ਹੈ — data ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਖਾਸ ਤੌਰ ਤੇ ਸਮਝਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਇੱਕ quirk Ruby ਦੀ **truthiness** ਹੈ: **ਸਿਰਫ `false` ਅਤੇ `nil` ਹੀ falsy ਹਨ**, ਜਦੋਂ ਕਿ ਬਾਕੀ ਸਭ ਕੁਝ (ਜਿਸ ਵਿੱਚ `0`, `""`, ਅਤੇ `[]` ਵੀ ਸ਼ਾਮਲ ਹਨ) truthy ਹੈ — ਇਹ ਬਹੁਤ ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਵੱਖ ਹੈ (ਜਿੱਥੇ 0 ਜਾਂ empty values falsy ਹਨ) ਅਤੇ ਦੂਜੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਆਉਣ ਵਾਲੇ developers ਲਈ bugs ਦਾ ਇੱਕ ਆਮ ਸਰੋਤ ਹੈ।

Dynamic typing, scope-indicating naming conventions, ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ, ਅਤੇ ਖਾਸ ਤੌਰ ਤੇ false-and-nil-only truthiness rule ਨੂੰ ਸਮਝਣਾ ਸਹੀ Ruby ਲਿਖਣ ਅਤੇ ਆਮ pitfalls ਨੂੰ ਰੋਕਣ ਲਈ ਭਿੱਤੀ ਹੈ, ਇਸ ਨੂੰ ਭਾਸ਼ਾ ਲਈ ਜ਼ਰੂਰੀ, ਮਾਨਤਾ-ਪ੍ਰਾਪਤ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ।