Method และ Block — เขียนคำสั่งของตัวเอง และส่งโค้ดเป็นก้อน

1 · Method คืออะไร — ตั้งชื่อให้คำสั่งชุดหนึ่ง

method คือคำสั่งหลายบรรทัดที่เราจับมัดรวมแล้วตั้งชื่อให้ จะได้เรียกใช้ซ้ำได้ด้วยชื่อเดียว
มันคือของเดียวกับ func ใน Go ทุกประการ แค่ Ruby เรียกว่า method

ลองดู method แรก — ทักทายคนตามชื่อที่ส่งเข้ามา:

# greet.rb
def greet(name)
  "สวัสดี #{name}"
end

puts greet("ต้น")
puts greet("มด")

$ ruby greet.rb
สวัสดี ต้น
สวัสดี มด

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

• def = "ต่อไปนี้คือ method ใหม่" (ย่อมาจาก define) — ตรงกับคำว่า func ใน Go
• greet คือชื่อ method · (name) คือของที่ต้องส่งเข้ามา (เรียกว่า argument) — ไม่ต้องบอกชนิด ว่าเป็น string
• "สวัสดี #{name}" คือข้อความที่จะส่งกลับไป — ไม่มีคำว่า return (หัวข้อ 2 จะอธิบาย)
• end = ปิด method · Ruby ไม่ใช้ปีกกา { } ครอบเนื้อ method แบบ Go
• puts greet("ต้น") = เรียก method แล้วเอาผลไปพิมพ์ออกจอ

วางคู่กับ Go ที่คุณเคยเขียน จะเห็นว่าความหมายเหมือนกันทุกส่วน ต่างแค่หน้าตา:

func Greet(name string) string {
    return "สวัสดี " + name
}

def greet(name)
  "สวัสดี #{name}"
end

2 · บรรทัดสุดท้ายคือของที่ส่งกลับ

ใน Go ฟังก์ชันที่ประกาศว่าจะคืนค่า ต้องเขียน return เสมอ — ลืมแล้ว go build ฟ้อง missing return
Ruby กลับกัน: ค่าของบรรทัดสุดท้ายที่ถูกรัน คือค่าที่ method ส่งกลับเสมอ โดยไม่ต้องบอก

# add.rb
def add(a, b)
  a + b          # บรรทัดสุดท้าย → ค่านี้คือของที่ส่งกลับ
end

p add(2, 3)

$ ruby add.rb
5

(p คือคำสั่งพิมพ์อีกตัวหนึ่ง คล้าย puts — หัวข้อ 7 จะบอกว่าต่างกันยังไง ตอนนี้อ่านว่า "พิมพ์" ไปก่อน)

คำว่า "บรรทัดสุดท้าย" หมายถึงบรรทัดสุดท้ายที่ได้รันจริง ไม่ใช่บรรทัดล่างสุดในไฟล์
เช่นใน if / else — ถ้าเข้ากิ่งไหน บรรทัดสุดท้ายของกิ่งนั้นคือค่าที่ส่งกลับ:

# grade.rb
def grade(score)
  if score >= 50
    "pass"       # เข้ากิ่งนี้ → ส่ง "pass" กลับ
  else
    "fail"       # เข้ากิ่งนี้ → ส่ง "fail" กลับ
  end
end

p grade(70)
p grade(10)

$ ruby grade.rb
"pass"
"fail"

คำว่า return ยังมีอยู่ และใช้ได้เหมือน Go — คนเขียน Ruby ใช้มันตอนอยากออกจาก method กลางทางเท่านั้น
ที่ไม่มีใครทำคือเขียน return ไว้บรรทัดสุดท้าย เพราะมันซ้ำ

สไลด์หน้า 23 ยังโชว์อีกแบบหนึ่งที่สั้นสุด ๆ คือ method บรรทัดเดียว def add(a, b) = a + b (มีเครื่องหมาย = และไม่มี end) — รันแล้วได้ 5 เหมือนกัน · ใช้ได้เมื่อเนื้อ method เป็นการคำนวณสั้น ๆ อย่างเดียว

# oops.rb — เพิ่ม puts ไว้ท้าย method เพื่อดูว่ามันทำงาน
def add(a, b)
  a + b
  puts "บวกเสร็จแล้ว"
end

result = add(2, 3)
p result

$ ruby oops.rb
บวกเสร็จแล้ว
nil

3 · Keyword argument — ส่งของโดยบอกชื่อช่อง

argument แบบธรรมดาจับคู่กันตามลำดับ: ตัวแรกไปช่องแรก ตัวที่สองไปช่องที่สอง
ถ้าส่งสลับกัน Ruby ไม่รู้หรอกว่าเราสลับ — ลองสร้างบทความ (จำลองด้วย Hash) แบบนี้ดู:

# post_order.rb
def make_post(title, body)
  { title: title, body: body }
end

p make_post("Hello", "My first post")
p make_post("My first post", "Hello")   # เผลอสลับ

$ ruby post_order.rb
{title: "Hello", body: "My first post"}
{title: "My first post", body: "Hello"}

{ title: title, body: body } ในเนื้อ method คือ Hash จากบท 92 — title: ตัวหน้าคือชื่อช่อง · title ตัวหลังคือตัวแปรที่ส่งเข้ามา (ชื่อซ้ำกันเฉย ๆ)

บรรทัดที่สองได้บทความที่ชื่อเรื่องเป็นเนื้อหา และเนื้อหาเป็นชื่อเรื่อง — ไม่มี error เลย
keyword argument แก้ปัญหานี้: ให้คนเรียกบอกชื่อช่องทุกครั้งที่ส่งของ

# post_kw.rb
def make_post(title:, body: "", draft: false)
  { title: title, body: body, draft: draft }
end

p make_post(title: "Hello")
p make_post(title: "Hello", draft: true)
p make_post(draft: true, title: "Hello")   # สลับลำดับ

$ ruby post_kw.rb
{title: "Hello", body: "", draft: false}
{title: "Hello", body: "", draft: true}
{title: "Hello", body: "", draft: true}

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

• title: — มี : ต่อท้ายชื่อ แต่ไม่มีค่าตามหลัง = ช่องบังคับ ต้องส่งทุกครั้ง
• body: "" — มีค่าตามหลัง = ค่าเริ่มต้น ถ้าไม่ส่งมาก็ใช้ "" (ข้อความว่าง)
• draft: false — เหมือนกัน ไม่ส่งก็ได้ false
• ข้างใน method เรียกใช้ด้วยชื่อเปล่า ๆ title · body · draft (ไม่มี :)

บรรทัดที่สามสลับลำดับแล้วยังได้ผลเหมือนบรรทัดที่สองทุกตัว เพราะ Ruby จับคู่ด้วยชื่อ ไม่ใช่ลำดับ

ทีนี้ลองลืมส่งช่องบังคับดู — ไฟล์ forgot.rb (บรรทัด 1–3 คือ method เดิม · บรรทัด 6 คือตัวที่ลืมส่ง title):

def make_post(title:, body: "", draft: false)
  { title: title, body: body, draft: draft }
end

puts "start"
make_post(body: "no title")

$ ruby forgot.rb
start
forgot.rb:1:in 'Object#make_post': missing keyword: :title (ArgumentError)

    caller: forgot.rb:6
    | make_post(body: "no title")
      ^^^^^^^^^
    callee: forgot.rb:1
    | def make_post(title:, body: "", draft: false)
          ^^^^^^^^^
	from forgot.rb:6:in '<main>'

วิธีอ่าน error นี้:

• forgot.rb:1:in 'Object#make_post' = พังในไฟล์ forgot.rb บรรทัด 1 ข้างใน method make_post (คำว่า Object# ข้ามไปก่อน — บท 96 อธิบายว่า # ในข้อความ error คั่นชื่อ class กับชื่อ method)
• missing keyword: :title = "ขาดช่องชื่อ title" · ArgumentError = ชนิดของ error คือ "ส่ง argument ผิด"
• caller = บรรทัดที่เรียก (ตัวที่ลืมส่ง) · callee = บรรทัดที่ประกาศ method · ^^^ ชี้ตำแหน่งให้
• from forgot.rb:6:in '<main>' = "ถูกเรียกมาจากบรรทัด 6" · <main> คือตัวไฟล์ชั้นนอกสุด ที่ไม่ได้อยู่ใน method ไหน
• สังเกตว่า start ถูกพิมพ์ออกมาก่อน — Ruby เจอปัญหาตอนรันมาถึงบรรทัดนั้น ไม่ได้ตรวจล่วงหน้า

เทียบกับ Go: Go ไม่มี keyword argument · ท่าที่ใกล้สุดคือส่ง struct แล้วระบุชื่อ field ซึ่งถ้าลืม field ไหน Go ก็ใส่ค่าศูนย์ (zero value) ให้เงียบ ๆ:

type Post struct {
    Title string
    Body  string
    Draft bool
}

p := Post{Body: "no title"}   // ลืม Title
fmt.Printf("%+v\n", p)
// ผลรันจริง: {Title: Body:no title Draft:false}   ← Title เป็น "" ไม่มีใครบอก

(%+v = ให้ Go พิมพ์ struct พร้อมชื่อ field · Title: ที่ไม่มีอะไรตามคือข้อความว่าง)

Ruby กลับเข้มกว่าตรงนี้ — ลืมช่องบังคับแล้วพังให้เห็นทันทีที่รันถึง ไม่ปล่อยค่าว่างหลุดไป

ในโค้ด Rails คุณจะเห็นบรรทัดหน้าตาคล้ายกันเยอะมาก เช่น render json: post, status: :created (render คือคำสั่งของ Rails ที่ส่งผลกลับไปให้ browser — เหมือนยกจานไปเสิร์ฟลูกค้า · บท 102)
ตัวนั้นเป็นอีกท่าหนึ่งที่ดูคล้ายกัน (Hash ที่ละปีกกาได้) เดี๋ยวเจอละเอียดใน บทเรียน 97

4 · ? กับ ! ท้ายชื่อ — ป้ายเตือนที่ทุกคนตกลงกัน

Ruby ยอมให้ชื่อ method ลงท้ายด้วย ? หรือ ! ได้ — มันเป็นแค่ตัวอักษรในชื่อ ภาษาไม่ได้บังคับความหมาย
แต่คนเขียน Ruby ทั้งโลกตกลงกันว่า: ? = "method นี้ตอบคำถาม ใช่/ไม่ใช่" · ! = "ระวัง ตัวนี้อันตรายกว่าตัวที่ไม่มี !"

ฝั่ง ? — ลองถามคำถามดู:

# ask.rb
p [].empty?                  # Array ว่างไหม
p [1, 2].empty?
p "hello".include?("ell")    # มีคำว่า ell อยู่ข้างในไหม
p 5.even?                   # เป็นเลขคู่ไหม

def draft?(post)                # เขียนเองก็ได้
  post[:draft]
end

post = { title: "Hello", draft: true }
p draft?(post)

$ ruby ask.rb
true
false
true
false
true

พอเห็นชื่อลงท้าย ? ก็เดาได้ทันทีว่ามันตอบคำถาม ใช่/ไม่ใช่ (ส่วนใหญ่คืน true / false) โดยไม่ต้องเปิดดูข้างใน
เทียบกับ Go: Go ใส่ ? ในชื่อไม่ได้ เลยใช้คำว่า Is นำหน้าแทน เช่น func IsDraft(p Post) bool — หน้าที่เดียวกันเป๊ะ
ในแอป Rails จะเจอแบบนี้บ่อย เช่น post.published? (บทความนี้เผยแพร่แล้วหรือยัง) — ที่เขียนเป็น post. นำหน้า เพราะใน Rails บทความเป็น object ที่มี method ของตัวเอง (บท 95 กับบท 97)

ฝั่ง ! — ดูคู่ที่สไลด์หน้า 24 ยกมา upcase กับ upcase!:

# bang.rb
name = "abc"
loud = name.upcase     # ไม่มี ! → สร้างข้อความใหม่
p loud
p name                  # ตัวเดิมเปลี่ยนไหม?

name2 = "abc"
name2.upcase!           # มี ! → แก้ตัวเดิมเลย
p name2

$ ruby bang.rb
"ABC"
"abc"
"ABC"

• name.upcase สร้างข้อความตัวใหญ่อันใหม่ แล้วส่งกลับ · name ยังเป็น "abc" เหมือนเดิม
• name2.upcase! แก้ข้อความเดิมให้เป็นตัวใหญ่ · ไม่ต้องเอาไปใส่ตัวแปรใหม่ name2 ก็เปลี่ยนแล้ว

# already.rb — ข้อความเป็นตัวใหญ่อยู่แล้ว
s = "ABC"
r = s.upcase!
p r
p s

$ ruby already.rb
nil
"ABC"

name = "ADMIN"
puts name.upcase!.length

$ ruby chain.rb
chain.rb:2:in '<main>': undefined method 'length' for nil (NoMethodError)

puts name.upcase!.length
                 ^^^^^^^

5 · Block — ฝากก้อนโค้ดให้ method ไปทำให้

ในบท 92 คุณเขียน [1, 2, 3].map { |n| n * 2 } มาแล้ว — ก้อน { |n| n * 2 } ตรงนั้นแหละคือ block
block คือก้อนโค้ดที่เราส่งติดไปกับการเรียก method แล้ว method จะเป็นคนเรียกใช้ก้อนนั้นเองตามจังหวะของมัน (เช่นเรียกหนึ่งครั้งต่อของหนึ่งชิ้น)

ตัวที่ง่ายที่สุดคือ each — "ของแต่ละชิ้นใน Array ให้ทำตามก้อนนี้":

# each.rb
[10, 20, 30].each { |n| puts n }

$ ruby each.rb
10
20
30

• { ... } = ขอบของ block (ปีกกาตรงนี้ไม่ใช่ Hash — มันอยู่ติดท้ายการเรียก method)
• |n| = ชื่อที่เราตั้งเอง ไว้รับของที่ each ส่งเข้ามาทีละชิ้น · จะตั้งชื่อ x หรือ price ก็ได้
• puts n = สิ่งที่ให้ทำกับของแต่ละชิ้น · each เรียก block นี้ 3 ครั้ง ครั้งละหนึ่งตัวเลข

อีกตัวที่เจอบ่อยคือ times — "ทำซ้ำ N ครั้ง":

# times.rb
3.times { |i| puts "จานที่ #{i}" }

$ ruby times.rb
จานที่ 0
จานที่ 1
จานที่ 2

(นับจาก 0 เหมือน index ใน Go) · สังเกตว่าตัวเลข 3 ก็เป็น object ที่มี method ชื่อ times ของตัวเอง

block ยาวหลายบรรทัด ใช้ do ... end แทนปีกกา — ความหมายเดียวกัน:

# each_posts.rb — บทความ 2 ชิ้น (จำลองด้วย Hash)
posts = [
  { title: "Hello", draft: false },
  { title: "Ruby 101", draft: true }
]

posts.each do |post|
  puts "บทความ: #{post[:title]}"
  puts "เป็นฉบับร่างไหม: #{post[:draft]}"
end

$ ruby each_posts.rb
บทความ: Hello
เป็นฉบับร่างไหม: false
บทความ: Ruby 101
เป็นฉบับร่างไหม: true

• do = เปิด block · end = ปิด block (แทน { กับ })
• |post| = ชื่อที่รับบทความทีละชิ้น — ชิ้นแรกคือ Hash ของ "Hello" ชิ้นที่สองคือ "Ruby 101"
• ธรรมเนียมที่ทีมส่วนใหญ่ใช้ (สไลด์หน้า 22): บรรทัดเดียวใช้ { } · หลายบรรทัดใช้ do ... end

เทียบกับ Go: ใน Go คุณทำแบบเดียวกันได้ด้วยการส่ง func เข้าไปเป็น argument ตัวหนึ่ง:

func Each(nums []int, f func(n int)) {
    for _, n := range nums {
        f(n)
    }
}

Each([]int{10, 20, 30}, func(n int) {
    fmt.Println(n)
})

[10, 20, 30].each { |n| puts n }

ทั้งสองฝั่งรันแล้วได้ 10 · 20 · 30 เหมือนกัน (Go ตัวนี้ go build ผ่านจริง)

แอบดูข้างใน: method ที่รับ block เรียกใช้ก้อนนั้นด้วยคำว่า yield ("ถึงตาก้อนที่ฝากมาแล้ว") — ตอนนี้ยังไม่ต้องเขียนเอง ดูไว้ให้รู้ว่าข้างในหน้าตาแบบนี้:

# yield.rb
def serve_twice
  puts "เริ่มเสิร์ฟ"
  yield                 # เรียก block ที่ฝากมา ครั้งที่ 1
  yield                 # ครั้งที่ 2
  puts "เสิร์ฟครบแล้ว"
end

serve_twice { puts "  ยกจานออกไป 1 จาน" }

$ ruby yield.rb
เริ่มเสิร์ฟ
  ยกจานออกไป 1 จาน
  ยกจานออกไป 1 จาน
เสิร์ฟครบแล้ว

• def serve_twice ไม่มีวงเล็บ = method นี้ไม่รับ argument ธรรมดาเลย (block ไม่ต้องประกาศไว้ในวงเล็บ)
• yield แต่ละครั้ง = กระโดดไปรันก้อน { puts ... } หนึ่งรอบ แล้วกลับมาทำบรรทัดถัดไป
• serve_twice { ... } = เรียก method แล้วฝาก block ไปด้วย — ไม่มีวงเล็บเพราะไม่มี argument ให้ส่ง

ในโค้ด Rails จะเจอ do |...| ... end แทบทุกไฟล์ เช่นที่สไลด์หน้า 22 ยกมา respond_to do |format| ... end (คำสั่งที่อยู่ใน controller — หัวหน้าเชฟของแผนก — ใช้เลือกว่าจะจัดจานเป็นหน้าเว็บหรือเป็นข้อมูล)
อ่านได้แล้วว่า "เรียก method respond_to แล้วฝาก block หลายบรรทัดไปด้วย · format คือของที่ respond_to ส่งเข้ามาให้ใน block" (บท 97 เล่าสั้น ๆ ว่า format คืออะไร · ได้ใช้จริงใน Day 3)

6 · กับดัก — puts หน้าบรรทัด + do ... end

หัวข้อที่แล้วบอกว่า { } กับ do ... end "ความหมายเดียวกัน" — เกือบจริง มีจุดเดียวที่ต่าง และมันโผล่ตอนที่คุณแปะ puts หรือ p ไว้หน้าบรรทัดเพื่อ debug

# trap.rb — ต่างกันแค่ { } กับ do...end
puts [1, 2].map { |n| n * 2 }
puts "---"
puts [1, 2].map do |n| n * 2 end

$ ruby trap.rb
2
4
---
#<Enumerator:0x000000012457de90>

7 · puts กับ p — เครื่องมือแอบดูค่าที่ใช้ทุกวัน

ทั้งสองตัวพิมพ์ค่าออกจอ แต่พิมพ์ให้คนละคนอ่าน: puts พิมพ์ให้ผู้ใช้อ่าน (สวย ๆ) · p พิมพ์ให้โปรแกรมเมอร์อ่าน (บอกชนิดให้เห็น)

# show.rb
puts 1
puts "1"
p 1
p "1"
puts nil
puts ""
p nil
p ""

$ ruby show.rb
1
1
1
"1"


nil
""

• puts 1 กับ puts "1" ออกมาเหมือนกันเป๊ะ — ดูไม่ออกว่าตัวไหนเป็นตัวเลข ตัวไหนเป็นข้อความ
• p "1" มีฟันหนูให้เห็น → รู้ทันทีว่าเป็น string
• puts nil กับ puts "" ได้บรรทัดว่างเหมือนกัน (สองบรรทัดว่างตรงกลาง) — แยกไม่ออกเลยว่า "ไม่มีค่า" หรือ "ข้อความว่าง"
• p บอกตรง ๆ ว่า nil หรือ ""

อีกความต่างคือค่าที่ส่งกลับ (เชื่อมกับหัวข้อ 2):

# give_back.rb
a = puts "hello"
b = p "hello"
p a
p b

$ ruby give_back.rb
hello
"hello"
nil
"hello"

puts ส่งกลับ nil เสมอ · p ส่งของเดิมกลับมา — เพราะงั้นแทรก p กลางการคำนวณเพื่อแอบดูค่าได้ เช่น x = p(1 + 2) * 10 พิมพ์ 3 แล้ว x ยังได้ 30 (รันจริงแล้ว)

ในแอป Rails ที่รันจริง คนจะใช้ Rails.logger (ตัวจดบันทึกของแอป — เหมือนสมุดบันทึกประจำครัว) แทนทั้งคู่ — Day 1 ยังไม่ได้ใช้ตัวนี้ · เครื่องมือดูค่าที่ Day 1 ใช้แทน puts คือ debugger ใน บทเรียน 104

ภารกิจ — เขียนเครื่องมือจัดการบทความ 4 ตัว

# post_tools.rb — จำลองบทความด้วย Hash (ยังไม่มี Rails)

def make_post(title:, body: "", draft: false)
  { title: title, body: body, draft: draft }
end

def draft?(post)
  post[:draft]
end

def titles(posts)
  posts.map { |post| post[:title] }
end

def shout(text)
  text.upcase
end

# ---- ส่วนตรวจ (เหมือนในโจทย์) ----

$ ruby post_tools.rb
true
true
true
true
true

$ ruby post_tools.rb
true
true
true
true
false

ทดสอบความเข้าใจ

def total(prices)
  sum = prices.sum
  puts "รวม #{sum}"
end

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

สไลด์หน้า 22–25 เขียนสั้นและถูกเป็นส่วนใหญ่ · จุดที่ของจริงต่างจากที่สไลด์เขียน หรือสไลด์ไม่ได้บอก:

อ้างอิง

• Ruby 4.0 — Methods — อ่านหัวข้อ Return Values (method คืนค่าบรรทัดสุดท้าย) · Method Names (ย่อหน้าเรื่องชื่อที่ลงท้าย ? กับ ! ว่าเป็นแค่ข้อตกลง) · และ Keyword Arguments (ฝั่งประกาศ)
• Ruby 4.0 — Calling Methods — อ่านหัวข้อ Block Argument ย่อหน้าที่เริ่มด้วย "do end has lower precedence than { }" — คำอธิบายทางการของกับดักในหัวข้อ 6
• Ruby 4.0 — String#upcase! — ดูแค่บรรทัดแรก upcase!(mapping) → self or nil — คำว่า "or nil" คือที่มาของ predict ในหัวข้อ 4
• Ruby 4.0 — Kernel#p และ Kernel#puts — เทียบกันว่าแต่ละตัวคืนอะไร (ตรงกับตารางในหัวข้อ 7)
• The Go Programming Language Specification — Function literals — ฝั่ง Go ที่ใช้เทียบกับ block: func ที่เขียนสด ๆ ตรงที่ใช้ แล้วส่งเป็น argument ได้ (แบบ Each ในหัวข้อ 5)