เก็บของหลายชิ้น — Array, Hash, Symbol และ map/select

1 · Array — รายการของที่เรียงเป็นแถว

Array คือตัวแปรหนึ่งตัวที่เก็บของได้หลายชิ้น เรียงตามลำดับ ใช้เมื่อมีของชนิดเดียวกันหลายชิ้น เช่น คะแนนทุกคน หรือบทความทุกชิ้น
ถ้าไม่มี Array คุณต้องตั้งตัวแปร score1 score2 score3 ไปเรื่อย ๆ ซึ่งไม่มีใครทำ

ดูของจริง — สร้าง Array ของคะแนนสามตัว แล้วลองหยิบ ลองเพิ่ม:

# array.rb — รายการตัวเลข
scores = [10, 20, 30]
p scores[0]
p scores[2]
p scores[-1]
scores << 40
p scores
p scores.length
p scores[10]

ผลรันจริง (ruby array.rb):

10
30
30
[10, 20, 30, 40]
4
nil

อ่านทีละบรรทัด:

เทียบกับ Go ที่เคยเขียน — Array ของ Ruby คือ slice ของ Go นั่นเอง:

scores := []int{10, 20, 30}
scores = append(scores, 40)
fmt.Println(len(scores))

scores = [10, 20, 30]
scores << 40
p scores.length

2 · Hash — แฟ้มที่มีป้ายชื่อทุกช่อง

Array หยิบของด้วยเลขช่อง · แต่บางทีของเรามีหลายช่องที่แต่ละช่องมีความหมายต่างกัน เช่น บทความหนึ่งชิ้นมี "ชื่อเรื่อง" กับ "เผยแพร่หรือยัง" — เรียกว่าช่อง 0 ช่อง 1 คงไม่มีใครจำได้
Hash คือที่เก็บของแบบคู่ชื่อ–ค่า หยิบของด้วยชื่อช่อง ไม่ใช่เลขช่อง

ก่อนไปต่อ ขอเล่าเรื่องแอปตัวอย่างนิดหนึ่ง: สไลด์จะพาสร้างแอปบล็อกชื่อ wongnok_blog · ของหลักในแอปคือบทความ ภาษาอังกฤษเรียกว่า post · ตอนนี้เรายังไม่มี Rails เลยจะจำลองบทความหนึ่งชิ้นด้วย Hash ไปก่อน

เรื่องชื่อที่จะเห็นตลอดบท: ตัวแปร post (ตัวเล็ก ไม่มี s) = บทความหนึ่งชิ้น · posts (มี s) = บทความหลายชิ้น · เป็นแค่ชื่อตัวแปรที่เราตั้งเอง ไม่ใช่คำสั่งพิเศษ
ส่วน Post ตัวใหญ่ที่เห็นในสไลด์คือ "แม่พิมพ์ของบทความ" ในแอป Rails จริง — บทนี้ยังไม่ใช้ (สร้างแม่พิมพ์เองในบท 95 · กฎตั้งชื่อในบท 99)

ดูของจริง — แฟ้มบทความหนึ่งแผ่น (จำลองด้วย Hash):

# hash.rb — จำลองบทความ 1 ชิ้นด้วย Hash (ยังไม่มี Rails)
post = { title: "ต้มยำกุ้ง", published: true }
p post
p post[:title]
p post[:published]
post[:views] = 120
p post
p post[:author]
p post.fetch(:author, "ไม่ระบุ")
p post.fetch(:author)

ผลรันจริง (ruby hash.rb):

{title: "ต้มยำกุ้ง", published: true}
"ต้มยำกุ้ง"
true
{title: "ต้มยำกุ้ง", published: true, views: 120}
nil
"ไม่ระบุ"
hash.rb:10:in 'Hash#fetch': key not found: :author (KeyError)
	from hash.rb:10:in '<main>'

อ่านทีละบรรทัด:

อ่านข้อความ error สองบรรทัดสุดท้ายเป็นภาษาคน:

• hash.rb:10 — พังที่ไฟล์ hash.rb บรรทัดที่ 10 (บรรทัด fetch ตัวสุดท้าย)
• key not found: :author — "หาช่อง :author ไม่เจอ" · (KeyError) ในวงเล็บคือชื่อชนิดของ error
• บรรทัด from … บอกเส้นทางที่โค้ดเดินมาถึงจุดนั้น · '<main>' แปลว่า "ตัวไฟล์หลัก" · ตอนนี้ข้ามได้ (error ละเอียดในบท 96)

เทียบกับ Go — Hash ของ Ruby คือ map ของ Go:

m := map[string]int{"a": 1}
v, ok := m["b"]
fmt.Println(v, ok)
// ผลรันจริง: 0 false

m = { a: 1 }
p m[:b]           # nil
p m.fetch(:b, 0)  # 0

ระวังตาลาย: Go เขียน "a": 1 (key เป็นข้อความในเครื่องหมายคำพูด) · Ruby เขียน a: 1 ไม่มีเครื่องหมายคำพูด — หน้าตาคล้ายกันแต่ key ของ Ruby ตรงนี้ไม่ใช่ข้อความ หัวข้อถัดไปจะบอกว่ามันคืออะไร

แล้วทำไมไม่ใช้ struct แบบ Go? ใน Go คุณคงทำบทความเป็น type Post struct { Title string; Published bool } · Ruby ก็มีแม่พิมพ์แบบนั้น (class ในบท 95) แต่ Hash ไม่ต้องประกาศอะไรก่อน เลยเหมาะกับการลองเล่นตอนนี้ · ข้อเสียคือ struct ของ Go ถ้าพิมพ์ชื่อช่องผิด compile ไม่ผ่าน แต่ Hash พิมพ์ชื่อช่องผิดได้ nil เงียบ ๆ

3 · Symbol — :title คือป้ายชื่อ ไม่ใช่ข้อความ

ตัวที่ขึ้นต้นด้วยโคลอนอย่าง :title เรียกว่า Symbol · มันคือชื่อเรียกของสิ่งหนึ่งในโปรแกรม ไม่ใช่ข้อความที่จะเอาไปโชว์ผู้ใช้
Ruby มีของสองชนิดที่หน้าตาคล้ายกัน: "title" (string = ข้อความ) กับ :title (symbol = ป้ายชื่อ) และ Ruby ถือว่าเป็นคนละอย่างกัน

ใน Go ไม่มีของแบบนี้ · ที่ใกล้ที่สุดคือการตั้งค่าคงที่เป็น string ไว้ใช้เป็นชื่อ เช่น const StatusActive = "active" · Ruby มีชนิดข้อมูลแยกไว้ให้เลย ไม่ต้องประกาศที่ไหนก่อน เขียน :active ได้ทันที

ทีนี้ไขปริศนาจากหัวข้อที่แล้ว — ทำไมตอนสร้างโคลอนอยู่ท้าย แต่ตอนหยิบโคลอนอยู่หน้า?

# rocket.rb — เขียน Hash สามแบบ
a = { title: "ต้มยำกุ้ง" }        # แบบสั้น (เจอบ่อยที่สุด)
b = { :title => "ต้มยำกุ้ง" }    # แบบเต็ม
c = { "title" => "ต้มยำกุ้ง" }   # key เป็น string
p a
p b
p c
p a == b
p a == c

ผลรันจริง (ruby rocket.rb):

{title: "ต้มยำกุ้ง"}
{title: "ต้มยำกุ้ง"}
{"title" => "ต้มยำกุ้ง"}
true
false

• => คือลูกศรจับคู่ "key นี้ → ค่านี้" (คนเรียกว่า hash rocket เพราะหน้าตาเหมือนจรวด)
• title: เป็นทางลัดของ :title => — สองแบบนี้ได้ Hash เดียวกันเป๊ะ (a == b ได้ true)
• แต่ c ใช้ key เป็น string "title" — คนละ Hash กับ a (a == c ได้ false)

สรุปเป็นภาษาคน: ตอนสร้าง title: กับตอนหยิบ [:title] คือ Symbol ตัวเดียวกัน แค่วิธีเขียนต่างกัน

post = { title: "ต้มยำกุ้ง" }
p post[:title]
p post["title"]

"ต้มยำกุ้ง"
nil

ใน Rails คุณจะเห็น Symbol แทบทุกบรรทัด เช่นบรรทัดนี้ที่สไลด์ยกมา (จะได้เขียนจริงใน Day 2):

validates :title, presence: true

ตอนนี้ยังไม่ต้องเข้าใจว่ามันทำอะไร แค่ให้อ่านออกว่า validates คือชื่อ method ตัวหนึ่งของ Rails · :title คือ "ป้ายชื่อของช่อง title" และ presence: true คือ Hash แบบสั้นที่มีช่องเดียว (ทำไมไม่มีวงเล็บและไม่มีปีกกา อธิบายในบท 97)

4 · map · select · find · sum · sort — สายพานแทน for loop

ใน Go ถ้าอยากทำอะไรกับของทุกชิ้นใน slice คุณต้องเขียน for เดินหยิบทีละชิ้นเอง · Ruby ให้คุณบอกแค่ว่าอยากได้อะไร แล้ว Array เดินให้เอง ผ่าน method อย่าง map และ select
คนเขียน Ruby แทบไม่เขียน for เลย

ก่อนดูโค้ด ต้องรู้จักของใหม่หนึ่งอย่าง: block คือก้อนโค้ดในปีกกาที่ส่งให้ method เอาไปใช้กับของทีละชิ้น

nums.map { |n| n * 2 }

• { … } — ก้อนโค้ดที่จะทำกับทุกชิ้นบนสายพาน (ปีกกาตรงนี้คือ block ไม่ใช่ Hash · Ruby ดูจากตำแหน่งว่ามันตามหลัง method)
• |n| — ขีดตั้งสองขีดล้อมชื่อ = "ชิ้นที่ไหลมาถึงตอนนี้ ขอเรียกว่า n" · ตั้งชื่ออะไรก็ได้ · เทียบ Go คือตัว n ใน for _, n := range nums นั่นเอง
• n * 2 — สิ่งที่ทำกับชิ้นนั้น · ค่าที่ได้จากบรรทัดนี้คือผลของชิ้นนั้น (ไม่ต้องเขียน return)

ตอนนี้รู้เท่านี้พอ · block ละเอียดกว่านี้ (เขียนหลายบรรทัด · do … end) อยู่ในบท 93

ดูของจริงกับตัวเลขห้าตัว (ชุดเดียวกับสไลด์หน้า 21):

# belt.rb — สายพานของตัวเลข
nums = [3, 1, 4, 1, 5]
p nums.map { |n| n * 2 }
p nums.select { |n| n > 2 }
p nums.reject { |n| n > 2 }
p nums.find { |n| n > 2 }
p nums.find { |n| n > 100 }
p nums.select { |n| n > 100 }
p nums.sum
p nums.sort
p nums.min
p nums.max
p nums

ผลรันจริง (ruby belt.rb):

[6, 2, 8, 2, 10]
[3, 4, 5]
[1, 1]
3
nil
[]
14
[1, 1, 3, 4, 5]
1
5
[3, 1, 4, 1, 5]

เทียบกับ Go — "คูณ 2 ทุกตัว" แบบเดินเองกับแบบสายพาน:

out := []int{}
for _, n := range nums {
    out = append(out, n*2)
}

out = nums.map { |n| n * 2 }

5 · รวมร่าง — เอาเฉพาะบทความที่เผยแพร่แล้ว แล้วขอแค่ชื่อเรื่อง

ทีนี้เอาสามเรื่องมาต่อกัน: Array ที่ข้างในเป็น Hash (บทความหลายชิ้น) แล้วใช้สายพานคัดและแปลง · ในร้านของเรา นี่ก็คือ "ลิ้นชักบทความ" ที่มีแฟ้มหลายแผ่น — ยังเป็นของจำลอง ของจริงจะอยู่ใน database ตอน Day 2

# posts.rb — จำลองบทความหลายชิ้น (ยังไม่มี Rails: ใช้ Array ของ Hash)
posts = [
  { title: "ต้มยำกุ้ง",  published: true,  views: 120 },
  { title: "ส้มตำ",      published: false, views: 40 },
  { title: "เที่ยวน่าน", published: true,  views: 300 },
]

published_posts = posts.select { |post| post[:published] }
titles = published_posts.map { |post| post[:title] }
p titles

p posts.select { |post| post[:published] }.map { |post| post[:title] }
p posts.sum { |post| post[:views] }
p posts.sort_by { |post| post[:views] }.map { |post| post[:title] }
p posts.find { |post| post[:views] > 100 }

ผลรันจริง (ruby posts.rb):

["ต้มยำกุ้ง", "เที่ยวน่าน"]
["ต้มยำกุ้ง", "เที่ยวน่าน"]
460
["ส้มตำ", "ต้มยำกุ้ง", "เที่ยวน่าน"]
{title: "ต้มยำกุ้ง", published: true, views: 120}

• posts = [ {…}, {…}, {…} ] — Array ที่แต่ละช่องเป็น Hash หนึ่งก้อน (บทความหนึ่งชิ้น) · จุลภาคท้ายชิ้นสุดท้ายใส่ได้ Ruby ไม่ว่า
• { |post| post[:published] } — "บทความที่ไหลมา เรียกว่า post · ดูช่อง published" · ถ้าเป็น true ชิ้นนั้นผ่าน
• สองบรรทัดแรกได้ผลเดียวกัน — แบบแรกพักผลไว้ในตัวแปร published_posts ก่อน · แบบที่สองต่อจุดเลย: ผลของ select ไหลเข้า map ต่อทันที เหมือนสายพานสองสถานีต่อกัน
• sum { |post| post[:views] } — รวมยอดอ่าน (120 + 40 + 300 = 460) · ใส่ block บอกว่า "รวมช่องไหน"
• sort_by { |post| post[:views] } — เรียงโดยใช้ยอดอ่านเป็นเกณฑ์ น้อยไปมาก · ต่อด้วย map เพื่อดูแค่ชื่อ
• find — ได้บทความทั้งก้อนชิ้นแรกที่ยอดอ่านเกิน 100 (ไม่ใช่แค่ชื่อ)

เทียบกับ Go ที่ทำงานเดียวกัน (สไลด์หน้า 20 วางไว้ให้เทียบ) · ฝั่ง Go บทความเป็น struct ที่ประกาศไว้ก่อน · ผมรันโค้ด Go นี้จริง (ใส่ package main กับข้อมูลสามชิ้นแบบเดียวกัน) ได้ [ต้มยำกุ้ง เที่ยวน่าน]:

type Post struct {
    Title     string
    Published bool
}
// posts คือ []Post ที่ใส่ข้อมูลไว้แล้ว

titles := []string{}
for _, p := range posts {
    if p.Published {
        titles = append(titles, p.Title)
    }
}

titles = posts
  .select { |post| post[:published] }
  .map    { |post| post[:title] }

ฝั่ง Ruby ขึ้นบรรทัดใหม่แล้วเริ่มด้วยจุดได้ — Ruby รู้ว่าเป็นการต่อจากบรรทัดบน · อ่านจากบนลงล่างได้ตรงกับประโยคภาษาคน: "บทความทั้งหมด → เลือกที่เผยแพร่แล้ว → เอาแต่ชื่อ"

6 · &:upcase — ทางลัดเมื่อ block แค่ "เรียก method ตัวเดียว"

ในโค้ด Rails คุณจะเห็นท่านี้บ่อยมาก: .map(&:title) · มันคือทางลัดของ block ที่ทำแค่อย่างเดียว คือ "เรียก method ชื่อนี้กับทุกชิ้น"

# amp.rb — &:ชื่อmethod เป็นทางลัด
names = ["som", "nok", "ploy"]
p names.map { |name| name.upcase }
p names.map(&:upcase)
p names.map(&:length)

ผลรันจริง (ruby amp.rb):

["SOM", "NOK", "PLOY"]
["SOM", "NOK", "PLOY"]
[3, 3, 4]

• สองบรรทัดแรกได้ผลเหมือนกันทุกตัว — &:upcase แปลว่า "ทุกชิ้น ให้เรียก .upcase"
• :upcase คือ Symbol ที่ใช้เป็นชื่อของ method (เห็นไหม Symbol คือ "ชื่อเรียก" จริง ๆ)
• & ข้างหน้าบอก Ruby ว่า "เอาชื่อนี้ไปทำเป็น block ให้ที" · เขียนไว้ในวงเล็บ (&:…) แทนปีกกา (เอาไปใส่ในปีกกาจะพัง)

ฝั่ง Go ไม่มีทางลัดแบบนี้ · ทุกครั้งต้องเขียน for _, n := range … เต็ม ๆ เหมือนตัวอย่างในหัวข้อ 4

posts = [
  { title: "ต้มยำกุ้ง", published: true },
  { title: "ส้มตำ",     published: false },
]
p posts.map { |post| post[:title] }
p posts.map(&:title)

["ต้มยำกุ้ง", "ส้มตำ"]
amp_hash.rb:6:in 'Array#map': undefined method 'title' for an instance of Hash (NoMethodError)

p posts.map(&:title)
       ^^^^
	from amp_hash.rb:6:in '<main>'

7 · ภารกิจ — ลิ้นชักบทความ 4 แผ่น

# 1) ชื่อบทความที่เผยแพร่แล้ว
p posts.select { |post| post[:published] }.map { |post| post[:title] }

# 2) ยอดอ่านรวมทุกบทความ
p posts.sum { |post| post[:views] }

# 3) ชื่อบทความแรกที่ยอดอ่านเกิน 100
p posts.find { |post| post[:views] > 100 }[:title]

["ต้มยำกุ้ง", "เที่ยวน่าน", "ข้าวซอย"]
540
"ต้มยำกุ้ง"

แบบทดสอบ

ถ้าเปิดสไลด์ดูประกอบ

อ้างอิง

• Ruby From Other Languages (ruby-lang.org) — อ่านหัวข้อย่อย Iteration และ Symbols are not lightweight Strings สั้นมาก อธิบายตรงกับหัวข้อ 3–4 ของบทนี้ว่าทำไมคน Ruby ไม่เขียน for และ Symbol ต่างจาก String ยังไง
• Ruby 4.0 — class Hash — อ่านแค่ส่วน Hash Data Syntax และ Key Not Found? ส่วนแรกคือเรื่อง title: กับ => · ส่วนหลังคือเรื่อง nil กับ fetch
• Ruby 4.0 — module Enumerable — ดูรายการใต้ Methods for Searching and Filtering จะเห็น find select reject อยู่ด้วยกัน พร้อมคำอธิบายหนึ่งบรรทัดของแต่ละตัว
• Ruby 4.0 — class Array — ใช้เปิดดูเมื่ออยากรู้ว่า Array ทำอะไรได้อีก · ลองหา << กับ sum ในหน้านี้
• A Tour of Go — Slices และ Go maps in action — ทวนฝั่ง Go ถ้าลืม slice กับ map · ในบทความ maps อ่านส่วนที่พูดถึง zero value กับ ok แล้วเทียบกับ nil ของ Ruby