Mengapa symbol lebih disukai sebagai kunci hash?

Question

Accepted Answer

**Symbol** ialah pilihan lazim dan disukai untuk **kunci hash** dalam Ruby kerana ia cekap memori (diintern — satu objek dikongsi) dan pantas dibandingkan (mengikut identiti). Menggunakan kunci symbol adalah Ruby yang idiomatik dan standard dalam rangka kerja seperti Rails.

## Kunci symbol vs kunci string

```ruby
# ✅ symbol keys — the idiomatic, preferred choice
user = { name: "Ann", age: 30, role: :admin }   # modern syntax: key: value
user[:name]                                       # "Ann"

# string keys — works, but less idiomatic and less efficient for fixed keys
user = { "name" => "Ann", "age" => 30 }
user["name"]
```

Sintaks moden `{ name: "Ann" }` menggunakan kunci symbol — standard untuk kunci tetap dan diketahui.

## Mengapa symbol lebih baik sebagai kunci

```ruby
# 1. MEMORY: each string key is a NEW object; a symbol is ONE shared (interned) object
{ "name" => 1 }   # "name" — a new string object each time it appears
{ name: 1 }        # :name — always the SAME single object (interned)
# → in a program with thousands of hashes using the same keys, symbols save lots of memory

# 2. SPEED: comparing symbols is by IDENTITY (fast); strings compare character-by-character
:name == :name     # fast — same object
"name" == "name"   # slower — compares each character
```

```text
✓ Memory-efficient — :name is interned (one shared object), reused everywhere
✓ Fast comparison — by object identity, not character-by-character
✓ Immutable — keys won't accidentally change
✓ Idiomatic — symbol keys are the Ruby/Rails convention; signal "this is an identifier"
```

Memandangkan kunci hash lazimnya ialah pengecam tetap yang digunakan berulang kali (bukan data teks yang berubah-ubah), penginternan symbol (satu objek dikongsi yang digunakan semula di mana-mana) dan perbandingan identiti yang pantas menjadikannya lebih cekap dan sesuai berbanding string.

## Bila string masih sesuai sebagai kunci

```ruby
# use STRING keys when keys are dynamic/data (e.g. from user input, JSON, varying values)
params = JSON.parse(input)    # → string keys (data, not fixed identifiers)
counts = Hash.new(0)
counts[user_input] += 1        # dynamic keys from data → strings
```

Kunci string sesuai apabila kunci datang daripada **data dinamik** (input pengguna, JSON yang diurai, nilai yang berubah-ubah) berbanding pengecam tetap.

## Mengapa ia penting

Memahami mengapa symbol lebih disukai sebagai kunci hash ialah pengetahuan Ruby idiomatik yang penting, kerana hash berkunci symbol (`{ name: "Ann" }`) berleluasa dalam Ruby dan Rails, dan mengetahui *mengapa* (dan bila tidak) mencerminkan pemahaman yang betul.

Sebab-sebab symbol lebih baik untuk kunci tetap adalah konkrit: **kecekapan memori** (symbol diintern — `:name` sentiasa satu objek dikongsi yang digunakan semula di mana-mana, manakala setiap kunci string `"name"` ialah objek berasingan, jadi dalam program dengan banyak hash menggunakan kunci yang sama, symbol menjimatkan memori yang ketara) dan **kelajuan** (symbol dibandingkan mengikut identiti objek, yang pantas, manakala string dibandingkan aksara demi aksara).

Memandangkan kunci hash lazimnya ialah **pengecam tetap yang digunakan berulang kali** (nama pilihan, nama medan, label tetap) berbanding data teks yang berubah-ubah, penginternan symbol dan perbandingan pantas menjadikannya pilihan yang cekap, sesuai, dan idiomatik — itulah sebabnya sintaks moden `key: value` dan konvensyen Rails menggunakan kunci symbol.

Sama pentingnya ialah mengetahui **bila string masih sesuai** sebagai kunci: apabila kunci ialah **data dinamik** (daripada input pengguna, JSON yang diurai, atau nilai yang berubah) berbanding pengecam tetap.

Memahami sebab-sebab kecekapan (penginternan, perbandingan pantas), kesesuaian symbol untuk pengecam tetap, dan kes-kes di mana kunci string sesuai (data dinamik) adalah penting untuk menulis Ruby yang idiomatik dan cekap serta untuk memahami hash berkunci symbol yang berleluasa dalam kod Ruby/Rails.

Ini berkait dengan perbezaan symbol-lawan-string yang lebih luas dan merupakan topik yang kerap mencerminkan pemahaman tentang amalan Ruby idiomatik utama yang mempengaruhi kedua-dua prestasi dan konvensyen.