Jak fungují proměnné a základní typy v Ruby?

Question

IT Interview Practice · Accepted Answer

Ruby je **dynamicky typovaný** — proměnné nedeklarují typ a mohou obsahovat libovolnou hodnotu. Ruby má několik základních typů (všechny jsou objekty) a používá **konvence pojmenování** (sigily) k označení rozsahu proměnné.

## Proměnné a dynamické typování

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

## Základní typy (všechny jsou objekty)

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

## Konvence pojmenování proměnných označují rozsah

```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 používá **sigily** (předpony) k označení rozsahu proměnné: běžné názvy jsou lokální, `@` pro proměnné instance, `@@` pro proměnné třídy, `$` pro globální proměnné (nedoporučuje se) a velká písmena pro konstanty. To je charakteristické — předpona vám na první pohled řekne rozsah.

## Truthy/Falsy hodnoty (specifická vlastnost 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
```

**Pouze `false` a `nil` jsou falsy** v Ruby — `0`, `""` a `[]` jsou všechny truthy (na rozdíl od mnoha jiných jazyků, kde jsou 0/prázdné hodnoty falsy). Běžná chyba.

## Proč je to důležité

Porozumění proměnným a základním typům Ruby je základní každodenní znalostí.

Ruby je dynamicky typovaný (proměnné obsahují libovolnou hodnotu, bez deklarací typů), a charakteristickou vlastností je používání **konvencí pojmenování (sigily) k označení rozsahu proměnné** — `@` pro proměnné instance, `@@` pro proměnné třídy, `$` pro globální proměnné, velká písmena pro konstanty — takže předpona proměnné vám na první pohled řekne její rozsah, což je důležité pro čtení a psaní Ruby kódu správně (zvláště `@instance` proměnné, které se používají neustále v třídách).

Znalost základních typů (všechny jsou objekty v Ruby's čistě objektově orientovaném modelu) — včetně charakteristického typu **Symbol** — je nezbytná pro práci s daty.

Obzvláště důležitou vlastností, kterou je třeba pochopit, je Ruby's **truthy/falsy chování**: **pouze `false` a `nil` jsou falsy**, zatímco vše ostatní (včetně `0`, `""` a `[]`) je truthy — to se liší od mnoha jiných jazyků (kde jsou 0 nebo prázdné hodnoty falsy) a je to častý zdroj chyb pro vývojáře přicházející z jiných jazyků.

Porozumění dynamickému typování, konvencím pojmenování označujícím rozsah, základním typům a obzvláště pravidlu false-and-nil-only truthy je základem pro psaní správného Ruby kódu a vyhýbání se běžným chybám, což z toho dělá nezbytnou, základní znalost jazyka.

Proměnné a dynamické typování

Základní typy (všechny jsou objekty)

Konvence pojmenování proměnných označují rozsah

Truthy/Falsy hodnoty (specifická vlastnost Ruby)

Proč je to důležité

Související otázky