Jak działają zmienne i typy podstawowe w Ruby?

Question

Accepted Answer

Ruby jest **dynamicznie typowany** — zmienne nie deklarują typu i mogą przechowywać dowolną wartość. Ruby posiada kilka typów podstawowych (wszystkie obiekty) i używa **konwencji nazewnictwa** (sigli) aby wskazać zakres zmiennej.

## Zmienne i dynamiczne typowanie

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

## Typy podstawowe (wszystkie są obiektami)

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

## Konwencje nazewnictwa zmiennych wskazują zakres

```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 używa **sigli** (prefiksów) aby oznaczyć zakres zmiennej: proste nazwy są lokalne, `@` dla zmiennych instancji, `@@` dla zmiennych klasy, `$` dla zmiennych globalnych (odradzane), a wielkie litery dla stałych. To jest charakterystyczne — prefiks mówi ci o zakresie na pierwszy rzut oka.

## Truthiness (osobliwość 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
```

**Tylko `false` i `nil` są fałszywe** w Ruby — `0`, `""` i `[]` są wszystkie prawdziwe (w przeciwieństwie do wielu języków, gdzie 0/puste wartości są fałszywe). Częsty pułapka.

## Dlaczego to ważne

Zrozumienie zmiennych i typów podstawowych Ruby jest fundamentalną codzienną wiedzą.

Ruby jest dynamicznie typowany (zmienne przechowują dowolną wartość, bez deklaracji typu), a charakterystyczną cechą jest używanie **konwencji nazewnictwa (sigli) aby wskazać zakres zmiennej** — `@` dla zmiennych instancji, `@@` dla zmiennych klasy, `$` dla zmiennych globalnych, wielkie litery dla stałych — więc prefiks zmiennej mówi ci o jej zakresie na pierwszy rzut oka, co jest ważne dla czytania i pisania Ruby poprawnie (zwłaszcza zmienne `@instance`, używane stale w klasach).

Znajomość typów podstawowych (wszystkie są obiektami w czystym modelu object-oriented Ruby) — w tym charakterystyczny typ **Symbol** — jest konieczna do pracy z danymi.

Szczególnie ważna osobliwość do zrozumienia to **truthiness** w Ruby: **tylko `false` i `nil` są fałszywe**, podczas gdy wszystko inne (w tym `0`, `""` i `[]`) jest prawdziwe — różni się to od wielu języków (gdzie 0 lub puste wartości są fałszywe) i jest częstym źródłem błędów dla deweloperów przychodzących z innych języków.

Zrozumienie dynamicznego typowania, konwencji nazewnictwa wskazujących zakres, typów podstawowych, a szczególnie reguły false-and-nil-only truthiness jest fundamentalne dla pisania poprawnego Ruby i unikania typowych pułapek, co czyni to niezbędną, podstawową wiedzą o języku.