อ่านโค้ด Rails ไม่งง — 5 ไวยากรณ์ที่ Rails ใช้บ่อย

สามบรรทัดที่ดูเหมือนภาษาอังกฤษ

นี่คือโค้ด Rails จริงที่คุณจะเจอในคอร์สนี้ · ยังไม่ต้องเข้าใจ แค่ดูหน้าตาไว้ก่อน:

validates :title, presence: true

redirect_to @post, notice: "saved"

form_with model: @post do |f|
  f.text_field :title
end

แต่ละบรรทัดอยู่คนละที่ในแอป · เทียบกับร้านอาหาร (ภาพที่ใช้ทั้งคอร์ส) ได้แบบนี้:

ถ้าคุณมาจาก Go จะรู้สึกแปลก เพราะใน Go ทุกการเรียกฟังก์ชันมีวงเล็บเสมอ เช่น c.Redirect(http.StatusSeeOther, "/posts/1") ใน Gin
ส่วน Ruby ยอมให้ละของหลายอย่าง จนโค้ดอ่านเหมือนประโยค · บทนี้จะถอดทีละชิ้น ทั้งหมด 5 ชิ้น

ชิ้นที่ 1 — วงเล็บละได้

ใน Ruby การเรียก method จะใส่วงเล็บหรือไม่ใส่ก็ได้ ผลเหมือนกันทุกอย่าง
ลองดูด้วย method เล็ก ๆ ที่เราเขียนเอง:

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

greet("ต้น")    # แบบมีวงเล็บ
greet "ต้น"     # แบบละวงเล็บ

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

• def greet(name) … end — ประกาศ method ชื่อ greet ที่รับค่าหนึ่งตัว (บท 93)
• "สวัสดี #{name}" — #{} คือการเสียบค่าตัวแปรลงใน string (บท 91)
• greet("ต้น") กับ greet "ต้น" — คือการเรียก method ตัวเดียวกัน ต่างกันแค่วงเล็บ

เพราะฉะนั้น validates :title ก็คือ validates(:title) — การเรียก method ชื่อ validates ไม่ใช่คำสั่งพิเศษของภาษา
Go ทำแบบนี้ไม่ได้เลย: เขียน fmt.Println "hi" แล้ว go build ไม่ผ่านแน่นอน

ชิ้นที่ 2 — hash ตัวสุดท้ายละปีกกาได้

ถ้าของชิ้นสุดท้ายที่ส่งเข้า method เป็น hash Ruby ยอมให้ไม่ต้องเขียนปีกกา { }
เวลาเห็น ชื่อ: ค่า ต่อท้ายบรรทัด ให้อ่านว่า "นี่คือ hash ก้อนเดียว ที่ถูกถอดปีกกาออก"

วิธีพิสูจน์ที่ง่ายที่สุด: เขียน validates ปลอมขึ้นมาเอง ให้มันรับของแล้ว p ออกมาดูเฉย ๆ จะได้เห็นว่า Ruby ส่งอะไรเข้าไปจริง (p คือคำสั่งพิมพ์ค่าแบบเห็นชนิดของมัน · บท 93)

# hash1.rb — validates ปลอม: รับของแล้ว p ออกมาดูเฉย ๆ
def validates(name, options)
  p name
  p options
end

validates :title, presence: true, length: { minimum: 5 }        # แบบที่เขียนใน Rails
validates(:title, { presence: true, length: { minimum: 5 } })   # แบบเขียนเต็ม

$ ruby hash1.rb
:title
{presence: true, length: {minimum: 5}}
:title
{presence: true, length: {minimum: 5}}

อ่านโค้ดทีละส่วน:

• def validates(name, options) — method ปลอมของเรา รับของสองชิ้น ตั้งชื่อว่า name กับ options
• presence: true — คู่ "ชื่อ: ค่า" หนึ่งคู่ใน hash (ชื่อ presence ค่า true)
• length: { minimum: 5 } — อีกคู่หนึ่ง ที่ค่าของมันเป็น hash อีกก้อน (hash ซ้อน hash) · ปีกกาด้านในห้ามละ เพราะมันไม่ใช่ตัวสุดท้าย
• บรรทัดแบบเขียนเต็ม — ใส่วงเล็บ (ชิ้นที่ 1) และปีกกาครอบ hash ตัวสุดท้ายให้ครบ

redirect_to ในสามบรรทัดแรกก็เป็นแบบเดียวกัน · ลองด้วย method ปลอมอีกตัว (@post ตรงนี้เป็นแค่ string จำลอง · ใน Rails มันคือบทความจริงที่ controller หยิบมา):

# hash2.rb — redirect_to ปลอม
def redirect_to(target, options)
  p target
  p options
end

@post = "บทความที่ 1 (จำลอง)"   # ใน Rails ตัวนี้คือบทความจริงที่ controller หยิบมา

redirect_to @post, notice: "saved"
redirect_to(@post, { notice: "saved" })

$ ruby hash2.rb
"บทความที่ 1 (จำลอง)"
{notice: "saved"}
"บทความที่ 1 (จำลอง)"
{notice: "saved"}

ใน Go ไม่มีท่านี้ · ถ้าอยากส่ง "ก้อนตัวเลือก" เข้าฟังก์ชัน ต้องประกาศ struct แล้วเขียนปีกกาเองทุกครั้ง (โค้ด Go ข้างล่างเป็นการเลียนแบบรูปร่างเพื่อเทียบเท่านั้น ไม่ใช่ library จริง):

Validates("title", Rules{Presence: true})

validates :title, presence: true

ชิ้นที่ 3 — block ที่ได้รับของ |f| และ yield

บรรทัด form_with model: @post do |f| ทำให้คนงงมากที่สุด เพราะ f โผล่มาจากไหนไม่รู้
คำตอบคือ: method form_with เป็นคนสร้างของชิ้นหนึ่ง แล้วยื่นให้ block · ช่อง |f| คือมือที่รับของชิ้นนั้น
คำสั่งที่ใช้ "ยื่นของให้ block" ชื่อว่า yield (แปลตรงตัวว่า "ส่งมอบ")

มาเขียน form_with จิ๋วที่รันได้จริงกัน (จำลองหลักการ ไม่ใช่โค้ดของ Rails จริง · บทความจำลองด้วย hash เพราะยังไม่มี Rails):

# form.rb — form_with จิ๋ว (จำลองหลักการ ไม่ใช่โค้ดของ Rails จริง)
class FormBuilder
  def initialize(model)
    @model  = model
    @fields = []
  end

  def text_field(name)
    value = @model[name]
    @fields << "  <input name=\"post[#{name}]\" value=\"#{value}\">"
  end

  def to_html
    "<form>\n" + @fields.join("\n") + "\n</form>"
  end
end

def form_with(model:)
  builder = FormBuilder.new(model)   # ① เตรียมกล่องเครื่องมือ
  yield(builder)                     # ② ยื่นกล่องให้ block → กลายเป็น f
  builder.to_html                    # ③ เก็บงาน แล้วส่ง HTML คืน
end

post = { title: "สวัสดี Ruby", body: "บทความแรก" }   # บทความจำลองด้วย hash

html = form_with model: post do |f|
  f.text_field :title
  f.text_field :body
end

puts html

$ ruby form.rb
<form>
  <input name="post[title]" value="สวัสดี Ruby">
  <input name="post[body]" value="บทความแรก">
</form>

อ่านทีละส่วน — ส่วนกล่องเครื่องมือ (FormBuilder):

• class FormBuilder — แม่พิมพ์ของ "กล่องเครื่องมือทำฟอร์ม" (class · บท 95)
• initialize(model) — ทำงานตอนสร้างกล่อง · จำบทความไว้ใน @model และเตรียม array ว่าง @fields ไว้เก็บช่องกรอก
• @model[name] — หยิบค่าจาก hash ด้วยชื่อ เช่น @model[:title] ได้ "สวัสดี Ruby"
• @fields << "…" — << แปลว่า "ใส่เพิ่มต่อท้าย array" · \" คือเครื่องหมายคำพูดที่อยู่ข้างใน string
• to_html — join("\n") ต่อทุกช่องเข้าด้วยกันโดยคั่นด้วยการขึ้นบรรทัดใหม่ (\n)

ส่วน form_with — หัวใจของเรื่อง:

• def form_with(model:) — รับค่าแบบ keyword ชื่อ model (บท 93) · ตอนเรียกต้องเขียน model: …
• ① สร้างกล่องเครื่องมือหนึ่งกล่อง เก็บไว้ในตัวแปร builder
• ② yield(builder) — กระโดดไปทำ block ที่แนบมา และยื่น builder ให้ · ใน block ของชิ้นนี้จึงมีชื่อว่า f
• ③ block ทำเสร็จ กลับมาบรรทัดนี้ · บรรทัดสุดท้ายของ method คือค่าที่ส่งคืนอัตโนมัติ (บท 93)
• form_with model: post do |f| … end — ละวงเล็บ (ชิ้นที่ 1) · ส่ง keyword model: · แนบ block ที่มีช่องรับของชื่อ f

ชื่อ f ไม่ใช่คำพิเศษ · ผมลองเปลี่ยนเป็น |form| แล้วเขียน form.text_field :title ก็ได้ผลเหมือนเดิมทุกตัวอักษร · คนเขียน Rails แค่นิยมใช้ f เพราะสั้น

เทียบกับ Go ที่คุณเคยเขียน — ใน Gin คุณเขียนแบบนี้ (บท 38):

r.GET("/posts", func(c *gin.Context) {
    c.String(200, "hi")
})

form_with model: post do |f|
  f.text_field :title
end

ท่าเดียวกันเป๊ะ — c ใน func(c *gin.Context) คือ f ใน do |f| · Ruby แค่เขียนสั้นกว่า (ไม่ต้องเขียน func ไม่ต้องบอกชนิด)

ทีนี้ลองกลับไปเรื่องคำเตือนในชิ้นที่ 2 — ถ้าเราใส่ปีกกาเองตอนเรียก form_with จิ๋ว:

# form_braces.rb — เหมือน form.rb ทุกบรรทัด ยกเว้นบรรทัดนี้
html = form_with({ model: post }) do |f|

$ ruby form_braces.rb
form_braces.rb:18:in 'Object#form_with': wrong number of arguments (given 1, expected 0; required keyword: model) (ArgumentError)

    caller: form_braces.rb:26
    | html = form_with({ model: post }) do |f|
             ^^^^^^^^^
    callee: form_braces.rb:18
    | def form_with(model:)
          ^^^^^^^^^
	from form_braces.rb:26:in '<main>'

ท่า "method ยื่นของให้ block" นี้ Rails ใช้ทั่วไปหมด ไม่ใช่แค่ฟอร์ม · ยังไม่ต้องจำ แค่จำหน้าตาไว้:

ชิ้นที่ 4 — symbol อยู่ทุกที่

ในสามบรรทัดแรกมี symbol ซ่อนอยู่มากกว่าที่ตาเห็น · ทวนจากบท 92: symbol คือ "ป้ายชื่อ" ที่ Rails ใช้เรียกชื่อของต่าง ๆ เช่นชื่อช่อง ชื่อคอลัมน์ ชื่อตัวเลือก

• :title — โคลอนอยู่หน้า = symbol ตัวเดี่ยว ๆ
• presence: true — โคลอนอยู่หลัง = คู่ใน hash ที่ชื่อช่องเป็น symbol :presence
• status: :see_other — มีทั้งสองแบบในคู่เดียว: ชื่อช่องคือ :status ค่าคือ symbol :see_other

พิสูจน์ว่าชื่อช่องใน hash เป็น symbol จริง:

# sym.rb
options = { presence: true }
p options.keys
p options.keys.first.class
p :title.class

$ ruby sym.rb
[:presence]
Symbol
Symbol

• options.keys — ขอรายชื่อช่องทั้งหมดของ hash ได้เป็น array [:presence] · เห็นโคลอนย้ายมาอยู่หน้าแล้ว
• .first.class — หยิบตัวแรกแล้วถามว่า "เป็นชนิดอะไร" ได้ Symbol

ใน Go คุณใช้ string เป็นชื่อช่องแทน เช่น c.JSON(200, gin.H{"title": "สวัสดี"}) · Ruby เลือกใช้ symbol เพราะเป็นป้ายชื่อที่ "ตายตัว" เทียบกันได้เร็ว

ชิ้นที่ 5 — method ที่ Rails สร้างให้ตอนรัน

นี่คือคำถามที่ผู้เรียนถามบ่อยที่สุด: "ใน Go ต้องประกาศ struct ชัดเจน แล้วใน Rails post.title มาจากไหน?"
เพราะไฟล์ model ของบทความใน Rails หน้าตาแบบนี้ — ว่างเปล่าจริง ๆ:

# app/models/post.rb — ทั้งไฟล์ (Rails สร้างให้)
class Post < ApplicationRecord
end

(< ApplicationRecord แปลว่า "สืบทอดความสามารถจาก ApplicationRecord" · บท 95)
คำตอบสั้น ๆ: ตอนโปรแกรมรัน Rails ไปอ่านชื่อคอลัมน์จากตาราง posts ในฐานข้อมูล แล้วสร้าง method ชื่อเดียวกันให้ · ตารางมีคอลัมน์ title → ได้ method post.title
คุณเห็นผลของเรื่องนี้มาแล้วใน บท 90 กับ บท 95 (Post.column_names) · ชิ้นนี้จะพาดูอีกด้าน: Rails ทำได้ยังไง — จำลองด้วย Ruby ล้วนที่รันเองได้

type Post struct {
    ID    uint
    Title string
    Body  string
}

class Post < ApplicationRecord
end

สังเกตว่าทิศทางกลับกัน · Go: struct คือต้นฉบับ · Rails: ตารางในฐานข้อมูลคือต้นฉบับ

ฟังดูเหมือนเวทมนตร์ แต่ Ruby ล้วนก็ทำได้ด้วย method ชื่อ define_method (แปลว่า "สร้าง method ชื่อนี้ให้หน่อย") · มาลองจำลองสิ่งที่ Rails ทำ ด้วย Ruby ล้วน (บทความจำลองด้วย hash เหมือนเดิม): เอารายชื่อคอลัมน์ (สมมติว่าอ่านมาจากตาราง) มาวนสร้าง method ทีละชื่อ

# magic.rb — จำลองหลักการที่ Rails ใช้ (ของจริงซับซ้อนกว่านี้)
class Post
  def initialize(data)
    @data = data
  end
end
# ตอนนี้ class Post ยังไม่มี method title เลย

column_names = [:title, :body]   # สมมติว่าอ่านมาจากตาราง posts

column_names.each do |name|
  Post.define_method(name) do    # สร้าง method ชื่อตามคอลัมน์
    @data[name]
  end
end

post = Post.new({ title: "สวัสดี Ruby", body: "บทความแรก" })
p post.title
p post.body
p Post.instance_methods(false)
post.author

$ ruby magic.rb
"สวัสดี Ruby"
"บทความแรก"
[:title, :body]
magic.rb:21:in '<main>': undefined method 'author' for an instance of Post (NoMethodError)

post.author
    ^^^^^^^

• column_names.each do |name| — วนทีละชื่อใน array (บท 92–93) · รอบแรก name = :title รอบสอง = :body
• Post.define_method(name) do … end — สร้าง method ใหม่ให้ class Post โดยชื่อ method มาจากค่าในตัวแปร · ข้างใน do … end คือเนื้อของ method
• @data[name] — เนื้อของ method: หยิบค่าจาก hash ของบทความชิ้นที่ถูกเรียก (@data ที่จำไว้ตอน initialize) ด้วยชื่อคอลัมน์
• Post.instance_methods(false) — ขอรายชื่อ method ที่ class Post มีเอง (false = ไม่รวมที่สืบทอดมา) ได้ [:title, :body]
• post.author — ไม่มีคอลัมน์ author ในรายชื่อ จึงไม่ถูกสร้าง → พังด้วย NoMethodError (หา method ชื่อนี้ไม่เจอ · บท 91) · แปลว่า class ไม่ได้มี method ทุกชื่อติดมาเอง ต้องมีคนสร้าง

ต่างจาก def ตรงที่ def title ต้องรู้ชื่อตั้งแต่ตอนพิมพ์โค้ด · define_method รับชื่อตอนโปรแกรมรัน — ชื่อจะมาจากไหนก็ได้ รวมถึงจากฐานข้อมูล

แล้วใน Rails จริงล่ะ? ผมลองในแอป wongnok_blog ให้ดูแล้ว (คำสั่งสร้างตารางเป็นเรื่องของ Day 2 · ตอนนี้ยังไม่ต้องทำตาม) — ไฟล์ db/schema.rb สรุปตาราง posts ไว้แบบนี้:

# db/schema.rb — ส่วนของตาราง posts
create_table "posts", force: :cascade do |t|
  t.string "title"
  t.text "body"
  t.datetime "created_at", null: false
  t.datetime "updated_at", null: false
end

(สังเกตว่าไฟล์นี้ใช้ชิ้นที่ 1–4 ครบ: ละวงเล็บ · hash ไม่มีปีกกา force: :cascade · symbol · block |t| · ความหมายของ force: :cascade กับ null: false ยังไม่ต้องสนใจ รอ Day 2)
แล้วรันโค้ดสั้น ๆ ผ่าน bin/rails runner (คำสั่งที่รันไฟล์ Ruby โดยโหลดแอป Rails ให้ด้วย):

# runner.rb
p Post.column_names
post = Post.new
post.title = "สวัสดี Rails"
p post.title
p post.body

$ bin/rails runner runner.rb
["id", "title", "body", "created_at", "updated_at"]
"สวัสดี Rails"
nil

• Post.column_names — ถาม model ว่า "ตารางของคุณมีคอลัมน์อะไร" · Rails ไปอ่านจากฐานข้อมูลมาให้
• post.title = "สวัสดี Rails" — Rails สร้าง method สำหรับตั้งค่าให้ด้วย (ชื่อ title=)
• p post.body ได้ nil (แปลว่า "ไม่มีค่า" · บท 94) เพราะยังไม่ได้ใส่อะไร — แต่ method มีอยู่ ไม่พัง

# runner2.rb
p Post.column_names
post = Post.new
p post.author

$ bin/rails runner runner2.rb
["id", "title", "body", "created_at", "updated_at", "author"]
nil

กลับไปอ่านสามบรรทัดแรกอีกรอบ

ตอนนี้เขียนเต็มได้แล้ว — และบอกได้ว่าแต่ละบรรทัดใช้ชิ้นไหนบ้าง:

ภารกิจ — ร้านอาหารจำลองในไฟล์เดียว

:kaprao
{spicy: "มาก", egg: true}
:kaprao
{spicy: "มาก", egg: true}
หยิบจาน
ตักกะเพราลงจานขาว
ยกไปเสิร์ฟ

# order.rb — ร้านอาหารจำลอง
def order(menu, options)
  p menu
  p options
end

def serve
  puts "หยิบจาน"
  yield("จานขาว")
  puts "ยกไปเสิร์ฟ"
end

order :kaprao, spicy: "มาก", egg: true
order(:kaprao, { spicy: "มาก", egg: true })

serve do |plate|
  puts "ตักกะเพราลง#{plate}"
end

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

บทนี้เรียงเรื่องใหม่ให้มือใหม่อ่านง่าย · ถ้าเปิดสไลด์หน้า 33–38 คู่กัน มีจุดที่ควรรู้แค่นี้:

อ้างอิง

• Ruby docs — Calling Methods — อ่านย่อหน้าแรกสุด (ประโยค "the parenthesis are optional") แล้วข้ามไปหัวข้อ Keyword Arguments และ Block Argument · ครอบคลุมชิ้นที่ 1–3 ของบทนี้
• ruby-lang.org — Separation of positional and keyword arguments in Ruby 3.0 — อ่านแค่ส่วน tl;dr ด้านบน · เป็นเหตุผลว่าทำไม form_with({ … }) ถึงพัง
• Ruby docs — Module#define_method — ดูตัวอย่างสั้น ๆ ใต้หัวข้อ · คือเครื่องมือที่ใช้ใน magic.rb
• Rails Guides — Active Record Basics — อ่านหัวข้อ 3. Creating Active Record Models ที่บอกว่าคอลัมน์ในตารางกลายเป็น attribute ของ model ให้เอง (ละเอียดรอ Day 2)
• Rails Guides — Action View Form Helpers — ดูหัวข้อ 2. Creating Forms with Model Objects เพื่อเห็น form_with model: … do |form| ตัวจริง (คู่มือใช้ชื่อ form แทน f)
• rubygems.org — annotate · annotaterb — ดูช่อง Runtime Dependencies ของแต่ละตัว เพื่อยืนยันเรื่องรุ่นของ Rails ที่รองรับ