Mi a különbség a stringek és a szimbólumok között?

Question

Accepted Answer

**A stringek** mutable karaktersorozatok; **a szimbólumok** (`:name`) immutable, **interned** azonosítók — ugyanaz a szimbólum a memóriában mindenütt pontosan ugyanaz az objektum. A szimbólumokat könnyű, hatékony azonosítóként (különösen hash kulcsként) használják, míg a stringek a tényleges szöveges adatokat tárolják.

## Az alapvető különbség: identitás és mutabilitás

```ruby
# strings — each is a NEW object (even with the same content)
"hello".object_id == "hello".object_id    # false — two different objects
"hello" << " world"                        # mutable — can be modified in place

# symbols — the SAME symbol is always the SAME object (interned)
:hello.object_id == :hello.object_id       # true — identical object every time
:hello.frozen?                              # true — symbols are immutable
```

Minden string literal egy új objektumot hoz létre, de a szimbólum **interned** — a `:hello` mindig pontosan ugyanaz az objektum a memóriában, függetlenül attól, hogy hányszor jelenik meg. A szimbólumok immutablek is.

## A szimbólumok memória- és teljesítményelőnyei

```text
Strings: each "name" allocates a new object → more memory, slower comparison (char by char)
Symbols: :name is ONE shared object → memory-efficient, fast comparison (by identity)
→ Symbols are ideal as identifiers used repeatedly (hash keys, method names, options).
```

## Mikor melyiket használjuk

```ruby
# SYMBOLS — for identifiers: hash keys, method names, options, fixed labels
user = { name: "Ann", role: :admin }       # symbol keys (the idiom)
send(:upcase)                               # method name as a symbol
status = :active                            # a fixed label/state

# STRINGS — for actual text DATA that you display, manipulate, or that varies
name = "Ann Smith"                          # real text content
message = "Hello, #{name}"                  # building/interpolating text
user_input = gets.chomp                     # data from outside
```

Használj **szimbólumokat azonosítókhoz** (hash kulcsok, opció nevek, állapotok, metódus nevek — rögzített, ismételt címkék) és **stringeket tényleges szöveges adatokhoz** (megjelenítendő tartalom, manipulálható tartalom, vagy felhasználóktól származó adat).

## Konvertálás közöttük

```ruby
"hello".to_sym    # :hello
:hello.to_s        # "hello"
```

## Miért fontos

A string vs. szimbólum megkülönböztetés fontos és egyedi Ruby tudás, mivel a szimbólumok olyan funkció, amely sok más nyelvből hiányzik, és helyes használatuk idiomatikus Ruby.

A kulcskülönbség az, hogy **a szimbólumok interned és immutable** (a `:name` mindig ugyanaz az egyetlen objektum a memóriában, immutable), míg **a stringek mutable és minden literal egy új objektum**.

Ez **memória- és teljesítményelőnyöket** ad a szimbólumoknak azonosítóként: egyszer kerülnek allokálásra és megosztásra (memória-hatékony ismételt használat esetén), és az identitás alapján (gyors) kerülnek összehasonlításra, nem karakter-karakter alapon.

A gyakorlati útmutató — **szimbólumok azonosítókhoz** (hash kulcsok, metódus nevek, opció feliratok, rögzített állapotok — ismételten címkékként használt dolgok) és **stringek tényleges szöveges adatokhoz** (megjelenítendő, manipulálható tartalom, vagy felhasználóktól kapott adat) — fontos idiomatikus Ruby, amely mind a teljesítményre, mind az egyértelműségre hatással van.

A szimbólum hash kulcsok (`{ name: "Ann" }`) Ruby és Rails konvenció, és rögzített azonosítók stringek helyett szimbólumként való használata hatékony és szokványos.

Annak megértése, mikor kell melyiket használni, a szimbólumok interning/immutabilitása és a hatékonyságuk azonosítóként alapvető, gyakran alkalmazott Ruby tudás — ez közös zűrzavar a kezdők körében (miért is vannak mindkettő?), és e megkülönböztetés megértése (szimbólumok mint hatékony interned azonosítók, stringek mint mutable szöveges adatok) lényeges az idiomatikus, hatékony Ruby írásához és gyakori interjúkérdés, amely ennek az egyedi Ruby funkciónak a megértését tükrözi.