Variables na types za msingi hufanya kazi vipi katika Ruby?

Question

Accepted Answer

Ruby ni **dynamically typed** — variables hazitangazi type na zinashikilia thamani yoyote. Ruby ina types kadhaa za msingi (zote ni objects), na inatumia **kanuni za kupatia majina** (sigils) kuonyesha scope ya variable.

## Variables na dynamic typing

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

## Types za msingi (zote ni 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
```

## Kanuni za kupatia majina ya variable zinaonyesha 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 inatumia **sigils** (viambishi awali) kuonyesha scope ya variable: majina ya kawaida ni local, `@` kwa instance variables, `@@` kwa class variables, `$` kwa globals (haishauriwi), na herufi kubwa kwa constants. Hii ni ya kipekee — kiambishi awali kinakuambia scope kwa mtazamo mmoja.

## Truthiness (kipengele cha kipekee cha 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
```

**Ni `false` na `nil` pekee ndizo falsy** katika Ruby — `0`, `""`, na `[]` zote ni truthy (tofauti na lugha nyingi ambapo 0/tupu ni falsy). Tatizo la kawaida.

## Kwa nini ni muhimu

Kuelewa variables na types za msingi za Ruby ni maarifa ya msingi ya kila siku.

Ruby ni dynamically typed (variables hushikilia thamani yoyote, hakuna type declarations), na kipengele cha kipekee ni matumizi yake ya **kanuni za kupatia majina (sigils) kuonyesha scope ya variable** — `@` kwa instance variables, `@@` kwa class variables, `$` kwa globals, herufi kubwa kwa constants — hivyo kiambishi awali cha variable kinakuambia scope yake kwa mtazamo mmoja, ambacho ni muhimu kwa kusoma na kuandika Ruby kwa usahihi (hasa `@instance` variables, zinazotumika mara kwa mara katika classes).

Kujua types za msingi (zote ambazo ni objects katika muundo safi wa object-oriented wa Ruby) — ikiwa ni pamoja na type ya kipekee ya **Symbol** — ni muhimu kwa kufanya kazi na data.

Kipengele muhimu hasa cha kuelewa ni **truthiness** ya Ruby: **ni `false` na `nil` pekee ndizo falsy**, ilhali kila kitu kingine (ikiwa ni pamoja na `0`, `""`, na `[]`) ni truthy — hii inatofautiana na lugha nyingi (ambapo 0 au thamani tupu ni falsy) na ni chanzo cha kawaida cha bugs kwa wendelezaji wanaotoka lugha nyingine.

Kuelewa dynamic typing, kanuni za kupatia majina zinazoonyesha scope, types za msingi, na hasa kanuni ya truthiness ya false-na-nil-pekee ni msingi wa kuandika Ruby sahihi na kuepuka makosa ya kawaida, ikifanya kuwa maarifa muhimu, ya lazima kujua kwa lugha.