Hogyan működnek a változók és az alapvető típusok a Rubyban?

Question

Accepted Answer

A Ruby **dinamikusan típusos** — a változók nem deklarálnak típust és bármilyen értéket tárolhatnak. A Ruby számos alapvető típussal rendelkezik (mindegyik objektum), és **elnevezési konvenciókat** (sigileket) használ a változó hatóköre jelzésére.

## Változók és dinamikus típusozás

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

## Az alapvető típusok (mindegyik objektum)

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

## A változóelnevezési konvenciók a hatókört jelzik

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

A Ruby **sigileket** (előtagokat) használ a változó hatóköre jelzésére: az egyszerű nevek lokálisak, `@` a példányváltozók számára, `@@` az osztályváltozók számára, `$` a globálisok számára (nem ajánlott), és nagybetűs nevek az konstansok számára. Ez jellegzetes — az előtag egy pillantásra megmutatja a hatókört.

## Igazságértékesség (egy Ruby sajátosság)

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

**Csak a `false` és `nil` hamis értékek** a Rubyban — a `0`, `""` és `[]` mindegyike igaz (ellentétben számos más nyelvvel, ahol a 0/üres hamis). Ez egy gyakori buktatópont.

## Miért fontos

A Ruby változóinak és alapvető típusainak megértése alapvető napi tudás.

A Ruby dinamikusan típusos (a változók bármilyen értéket tárolnak, nincs típusdeklaráció), és sajátosságként használ **elnevezési konvenciókat (sigileket) a változó hatóköre jelzésére** — `@` a példányváltozók számára, `@@` az osztályváltozók számára, `$` a globálisok számára, nagybetűs nevek az konstansok számára — így a változó előtagja egy pillantásra megmutatja a hatókört, ami fontos a Ruby helyes olvasásához és írásához (különösen az osztályokban állandóan használt `@instance` változók).

Az alapvető típusok ismerete (amelyek a Ruby tiszta objektumorientált modelljében mind objektumok) — beleértve a sajátságos **Symbol** típust is — szükséges az adatokkal való munkavégzéshez.

Különösen fontos sajátosság a Ruby **igazságértékességét** megérteni: **csak a `false` és `nil` hamis**, míg minden más (beleértve a `0`, `""` és `[]`) igaz — ez eltér számos más nyelvtől (ahol a 0 vagy üres értékek hamisak) és gyakori hibaforrás azoknak a fejlesztőknek, akik más nyelvekből érkeznek.

A dinamikus típusozás, a hatókört jelző elnevezési konvenciók, az alapvető típusok, és különösen a csak-false-és-nil-hamis igazságértékességi szabály megértése alapozó a helyes Ruby írásához és az általános buktatópontok elkerüléséhez, ezért nélkülözhetetlen, alapvető fontosságú tudás a nyelvhez.