ทำไม symbol จึงเป็นที่นิยมใช้เป็น hash key?

Question

Accepted Answer

**Symbol** เป็นตัวเลือกตามธรรมเนียมและเป็นที่นิยมสำหรับ **hash key** ใน Ruby เพราะประหยัดหน่วยความจำ (interned — เป็นอ็อบเจกต์เดียวที่ใช้ร่วมกัน) และเปรียบเทียบได้รวดเร็ว (โดยใช้เอกลักษณ์ของอ็อบเจกต์) การใช้ symbol key เป็นแบบ Ruby ตามแบบนิยมและเป็นมาตรฐานในเฟรมเวิร์กอย่าง Rails

## symbol key เทียบกับ string key

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

ไวยากรณ์สมัยใหม่ `{ name: "Ann" }` ใช้ symbol key — เป็นมาตรฐานสำหรับ key ที่คงที่และทราบล่วงหน้า

## ทำไม symbol จึงดีกว่าในการเป็น key

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

เนื่องจาก hash key มักเป็นตัวระบุ (identifier) ที่คงที่และใช้ซ้ำ ๆ (ไม่ใช่ข้อมูลข้อความที่เปลี่ยนแปลง) การ intern ของ symbol (อ็อบเจกต์เดียวที่ใช้ร่วมกันทั่วทั้งโปรแกรม) และการเปรียบเทียบด้วยเอกลักษณ์ที่รวดเร็วจึงทำให้มันมีประสิทธิภาพและเหมาะสมกว่า string

## เมื่อใดที่ string ยังเหมาะสมในการเป็น key

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

string key เหมาะสมเมื่อ key มาจาก **ข้อมูลแบบไดนามิก** (อินพุตจากผู้ใช้, JSON ที่ถูก parse, ค่าที่เปลี่ยนแปลง) มากกว่าตัวระบุที่คงที่

## ทำไมจึงสำคัญ

การเข้าใจว่าทำไม symbol จึงเป็นที่นิยมในการเป็น hash key เป็นความรู้ Ruby ตามแบบนิยมที่สำคัญ เนื่องจาก hash ที่ใช้ symbol เป็น key (`{ name: "Ann" }`) แพร่หลายใน Ruby และ Rails และการรู้ *เหตุผล* (และเมื่อไม่ควรใช้) สะท้อนความเข้าใจที่ถูกต้อง

เหตุผลที่ symbol ดีกว่าสำหรับ key ที่คงที่นั้นเป็นรูปธรรม: **ประสิทธิภาพด้านหน่วยความจำ** (symbol ถูก intern — `:name` เป็นอ็อบเจกต์เดียวที่ใช้ร่วมกันทั่วทั้งโปรแกรม ในขณะที่ string key `"name"` แต่ละตัวเป็นอ็อบเจกต์แยกกัน ดังนั้นในโปรแกรมที่มี hash จำนวนมากใช้ key เดียวกัน symbol จะประหยัดหน่วยความจำได้อย่างมาก) และ **ความเร็ว** (symbol เปรียบเทียบด้วยเอกลักษณ์ของอ็อบเจกต์ซึ่งรวดเร็ว ในขณะที่ string เปรียบเทียบทีละตัวอักษร)

เนื่องจาก hash key มักเป็น **ตัวระบุที่คงที่และใช้ซ้ำ ๆ** (ชื่อตัวเลือก, ชื่อฟิลด์, ป้ายชื่อที่คงที่) มากกว่าข้อมูลข้อความที่เปลี่ยนแปลง การ intern และการเปรียบเทียบที่รวดเร็วของ symbol จึงทำให้มันเป็นตัวเลือกที่มีประสิทธิภาพ เหมาะสม และตามแบบนิยม — ซึ่งเป็นเหตุผลที่ไวยากรณ์สมัยใหม่ `key: value` และธรรมเนียมของ Rails ใช้ symbol key

สำคัญพอ ๆ กันคือการรู้ว่า **เมื่อใดที่ string ยังเหมาะสม** ในการเป็น key: เมื่อ key เป็น **ข้อมูลแบบไดนามิก** (จากอินพุตของผู้ใช้, JSON ที่ถูก parse หรือค่าที่เปลี่ยนแปลง) มากกว่าตัวระบุที่คงที่

การเข้าใจเหตุผลด้านประสิทธิภาพ (การ intern, การเปรียบเทียบที่รวดเร็ว), ความเหมาะสมของ symbol สำหรับตัวระบุที่คงที่ และกรณีที่ string key เหมาะสม (ข้อมูลแบบไดนามิก) เป็นสิ่งสำคัญสำหรับการเขียน Ruby ที่ตามแบบนิยมและมีประสิทธิภาพ และสำหรับการเข้าใจ hash ที่ใช้ symbol เป็น key ที่พบเห็นได้ทั่วไปในโค้ด Ruby/Rails

สิ่งนี้เชื่อมโยงกับความแตกต่างที่กว้างขึ้นระหว่าง symbol กับ string และเป็นหัวข้อที่พบบ่อยซึ่งสะท้อนความเข้าใจแนวปฏิบัติ Ruby ตามแบบนิยมที่สำคัญซึ่งส่งผลทั้งต่อประสิทธิภาพและธรรมเนียม