เปิดร้าน — จาก bin/rails server ถึงหน้าเว็บ และ MVC ของจริง

ภาพรวม — ใบสั่งหนึ่งใบเดินผ่านใครบ้าง

เวลาคุณพิมพ์ localhost:3000/posts แล้วกด Enter browser จะส่งใบสั่ง (request) ไปที่ร้าน ใบสั่งใบนี้ไม่ได้ไปถึงคนทำอาหารทันที มันต้องส่งต่อกันหลายมือ แต่ละมือทำงานแค่อย่างเดียว

บทนี้ทั้งบทคือการเดินตามเส้นข้างล่างนี้ทีละช่วง จำภาพนี้ไว้ก่อน เดี๋ยวเราจะเห็นของจริงทุกช่อง

ถ้าเทียบกับ Go: ใน Gin คุณเขียนเกือบทุกช่องเอง — สร้าง router เอง (gin.Default()) · ใส่ middleware เอง (r.Use(...)) · ลง route เอง · เขียน handler ที่ทำทั้งเตรียมข้อมูลและตอบกลับ · แล้วสั่ง r.Run() เปิดประตูเอง · Rails คือร้านแฟรนไชส์ที่ได้ครัวครบชุด คุณแค่วางของลงช่องที่แฟรนไชส์กำหนด

ก่อนเปิดร้าน — เกิดอะไรขึ้นตอนพิมพ์ bin/rails server

ร้านอาหารไม่ได้เปิดประตูปุ๊บแล้วขายได้เลย ต้องเตรียมครัวก่อน — เปิดไฟ ตั้งเตา เช็ควัตถุดิบ Rails ก็เหมือนกัน ช่วงเตรียมตัวก่อนรับใบสั่งแรกนี้เรียกว่า boot

คุณเคยเปิดร้านมาแล้วหนึ่งครั้งใน บท 98 · รอบนี้เราจะอ่านช้าลงว่าแต่ละบรรทัดบอกอะไร · เข้าไปในโฟลเดอร์โปรเจกต์ wongnok_blog แล้วพิมพ์คำสั่งนี้ในเทอร์มินัล (bin/rails คือโปรแกรมประจำโปรเจกต์ที่รู้จักแล้วในบท 98):

$ bin/rails server
=> Booting Puma
=> Rails 8.1.4 application starting in development
=> Run `bin/rails server --help` for more startup options
Puma starting in single mode...
* Puma version: 8.0.2 ("Into the Arena")
* Ruby version: ruby 4.0.9 (2026-10-23 revision 3e93b23afc) +PRISM [arm64-darwin25]
*  Min threads: 3
*  Max threads: 3
*  Environment: development
*          PID: 2674
* Listening on http://127.0.0.1:3000
* Listening on http://[::1]:3000
Use Ctrl-C to stop

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

• => Booting Puma — กำลังเตรียมเปิดร้าน · Puma คือโปรแกรม “ประตูร้าน” ที่ Rails ใช้รับ request (เหมือน r.Run() ของ Gin ที่เปิดพอร์ตรอ)
• Puma version · Ruby version — แค่บอกรุ่นของโปรแกรมที่ใช้ · ตัวอักษรยาว ๆ ท้ายบรรทัดไม่ต้องอ่าน
• starting in development — เปิดในโหมดสาขาทดลอง สำหรับนั่งเขียนโค้ดบนเครื่องตัวเอง (อีกโหมดคือ production = ร้านจริงที่ลูกค้าใช้)
• Min threads: 3 / Max threads: 3 — ประตูนี้มีพนักงานรับใบสั่ง 3 คน รับพร้อมกันได้ 3 ใบ · ตอนนี้ไม่ต้องสนใจ
• PID: 2674 — เลขประจำตัวของโปรแกรมนี้ในเครื่อง · ของคุณจะเป็นเลขอื่น
• Listening on http://127.0.0.1:3000 — ประตูเปิดแล้ว ที่พอร์ต 3000 · 127.0.0.1 กับ [::1] แปลว่า “เครื่องตัวเอง” ทั้งคู่ (แบบเก่ากับแบบใหม่ของที่อยู่ในเครือข่าย)
• Use Ctrl-C to stop — กด Ctrl กับ C พร้อมกัน = ปิดร้าน

ก่อนบรรทัด Listening on จะโผล่ Rails แอบทำงานเตรียมครัวไปหลายอย่าง โดยอ่านไฟล์ตั้งค่าในโฟลเดอร์ config/ เช่น config/application.rb (ตั้งค่าของทั้งร้าน) · config/environments/development.rb (กฎเฉพาะสาขาทดลอง) · และไฟล์ใน config/initializers/ (งานเตรียมเล็ก ๆ ทีละข้อ)
คุณไม่ต้องจำลำดับไฟล์ · จำแค่ว่า “ตั้งค่าอยู่ใน config/ และถูกอ่านตอนเปิดร้าน” ก็พอ

ลงมือ — ทำหน้า “บทความทั้งหมด” ด้วย 3 ไฟล์

ร้านเปิดแล้ว แต่ยังไม่มีเมนูอะไรเลย · เราจะเพิ่มหน้า /posts ที่โชว์รายชื่อบทความ โดยแตะแค่ 3 ช่องที่ Rails ให้เราเขียน: พนักงานต้อนรับ → หัวหน้าเชฟ → จัดจาน

ไฟล์ที่ 1 · พนักงานต้อนรับ — config/routes.rb

เปิดไฟล์นี้ (มีอยู่แล้วตั้งแต่ rails new) แล้วเพิ่มบรรทัด get "/posts", … เข้าไป · ไฟล์จริงมีบรรทัด comment (ขึ้นต้นด้วย #) อีกหลายบรรทัด ข้างล่างตัดออกให้สั้น — จะลบหรือเก็บไว้ก็ได้ ไม่มีผล:

# config/routes.rb
Rails.application.routes.draw do
  get "up" => "rails/health#show", as: :rails_health_check   # มีมาให้แล้ว ไม่ต้องแตะ

  get "/posts", to: "posts#index"      # ← เพิ่มบรรทัดนี้
end

• Rails.application.routes.draw do … end — “เริ่มเขียนรายการเส้นทางของร้าน” · ของที่อยู่ระหว่าง do กับ end คือ block (ก้อนโค้ดที่ส่งให้ method — บท 93)
• get "up" => … — ของที่ rails new ใส่มาให้: หน้า /up ไว้เช็คว่าร้านยังเปิดอยู่ · => ตรงนี้อ่านว่า “ไปที่” · ไม่ต้องแตะ และไม่ต้องเข้าใจตอนนี้ (บท 101)
• get "/posts" — “ถ้ามีใบสั่งแบบ GET (ขอดู) มาที่ /posts…” · get คือ method ตัวหนึ่ง ที่เรียกโดยละวงเล็บ (บท 97) — เขียนเต็มได้ว่า get("/posts", to: "posts#index")
• to: "posts#index" — “…ส่งไปแผนก posts เมนู index” · to: คือ hash ท้าย argument ที่ไม่ต้องใส่ปีกกา (บท 97) · ละเอียดของ routes อยู่ใน บท 101

ไฟล์ที่ 2 · หัวหน้าเชฟ — app/controllers/posts_controller.rb

สร้างไฟล์ใหม่ ชื่อต้องเป๊ะตามกฎตั้งชื่อ (บท 99):

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  def index
    # ข้อมูลจำลอง — ยังไม่มี database (รอ Day 2)
    @posts = [
      { title: "ข้าวซอยเจ้าเด็ด", author: "สมชาย" },
      { title: "ส้มตำปูปลาร้า", author: "สมหญิง" }
    ]
  end
end

• class PostsController < ApplicationController — แผนกบทความ · < แปลว่า “สืบทอดความสามารถมาจาก” (บท 95) · ApplicationController คือ controller แม่ที่ rails new สร้างให้
• def index … end — เมนู index ของแผนกนี้ คือ method ธรรมดาตัวหนึ่ง (บท 93) · ชื่อต้องตรงกับคำหลัง # ใน routes
• @posts = [ … ] — Array (รายการ ใส่ใน [ ]) ของ Hash สองก้อน (บท 92) · แต่ละก้อนจำลองบทความหนึ่งชิ้น · { title: "…", author: "…" } คือ Hash ที่มีช่อง :title กับ :author (เขียน title: = ช่องชื่อ :title) · ต้องมี @ เพราะ @ตัวแปร คือถาดที่ส่งต่อให้คนจัดจาน — view อ่านได้ · ตัวแปรธรรมดาที่ไม่มี @ view มองไม่เห็น (ละเอียดใน บท 102)
• สังเกตว่าไม่มีบรรทัดไหนสั่งให้ส่งหน้าเว็บกลับ · ถ้า action จบเฉย ๆ Rails จะไปหา view ที่ชื่อตรงกันเอง (ไฟล์ที่ 3)

ไฟล์ที่ 3 · จัดจาน — app/views/posts/index.html.erb

สร้างโฟลเดอร์ app/views/posts/ แล้วสร้างไฟล์ index.html.erb ข้างใน:

<h1>บทความทั้งหมด</h1>

<% @posts.each do |post| %>
  <h2><%= post[:title] %></h2>
  <p>โดย <%= post[:author] %></p>
<% end %>

• ไฟล์ .html.erb คือ HTML ที่แทรกโค้ด Ruby ได้ (ERB — ละเอียดใน บท 103)
• <% … %> — รันโค้ด Ruby แต่ไม่พิมพ์อะไรลงหน้า · ใช้กับคำสั่งวนลูป
• <%= … %> (มี =) — รันแล้วพิมพ์ผลลงหน้า
• @posts.each do |post| … end — วนทีละบทความ แต่ละรอบเรียกบทความนั้นว่า post (บท 93)
• post[:title] — หยิบค่าจาก Hash ด้วย symbol :title (บท 92)

ทำไม Rails รู้ว่าต้องใช้ไฟล์นี้? กฎตั้งชื่อจาก บท 99: PostsController + action index → app/views/posts/index.html.erb ไม่ต้องเขียนบอกเลย

เปิดดูผล

เปิด browser ไปที่ http://localhost:3000/posts จะเห็นหัวข้อ “บทความทั้งหมด” กับบทความสองชิ้น · ถ้าดู HTML ที่ได้กลับมา (กด View Source) ช่วงท้ายของหน้า ตั้งแต่ <main> จะเป็นแบบนี้:

    <main class="container mx-auto mt-28 px-5 flex">
      <!-- BEGIN app/views/posts/index.html.erb
--><h1>บทความทั้งหมด</h1>

  <h2>ข้าวซอยเจ้าเด็ด</h2>
  <p>โดย สมชาย</p>
  <h2>ส้มตำปูปลาร้า</h2>
  <p>โดย สมหญิง</p>
<!-- END app/views/posts/index.html.erb -->
    </main>
  </body>
</html>
<!-- END app/views/layouts/application.html.erb -->

• view ของเรามี 6 บรรทัด แต่หน้าที่ได้มี <html> <head> <main> ครบ — เพราะ Rails เอาไปวางบนจานรองที่ใช้ทุกหน้า คือไฟล์ app/views/layouts/application.html.erb (เรียกว่า layout · บท 103)
• class="container mx-auto …" — คลาสแต่งหน้าตาของ Tailwind ที่มากับ layout ตอน rails new … --css=tailwind · ไม่ใช่ของเรา ไม่ต้องสนใจ
• <!-- BEGIN … --> กับ <!-- END … --> คือป้ายที่ Rails แปะให้ในโหมด development บอกว่าส่วนนี้มาจากไฟล์ไหน · ช่วยมากเวลาหาว่าข้อความบนหน้ามาจากไฟล์อะไร

อ่าน log — สมุดบันทึกของร้าน

กลับไปดูเทอร์มินัลที่เปิด server ไว้ ทุกครั้งที่มีใบสั่งเข้ามา Rails จะจดลงสมุด (log) ให้เอง · นี่คือ log จริงตอนเปิดหน้า /posts:

Started GET "/posts" for ::1 at 2026-11-03 20:47:30 +0700
Processing by PostsController#index as HTML
  Rendering layout layouts/application.html.erb
  Rendering posts/index.html.erb within layouts/application
  Rendered posts/index.html.erb within layouts/application (Duration: 0.3ms | GC: 0.0ms)
  Rendered layout layouts/application.html.erb (Duration: 6.5ms | GC: 0.0ms)
Completed 200 OK in 18ms (Views: 7.7ms | ActiveRecord: 0.0ms (0 queries, 0 cached) | GC: 0.0ms)

อ่านคู่กับภาพร้านอาหาร (ตัวเลขเวลาของคุณจะต่าง):

ส่วน ActiveRecord: 0.0ms (0 queries …) ท้ายบรรทัดสุดท้าย บอกว่ารอบนี้ไม่ได้แตะ database เลย (Active Record คือส่วนของ Rails ที่คุยกับ database — เจอจริง Day 2) — ตรงกับที่เราจำลองข้อมูลไว้ใน controller · Day 2 ตัวเลขนี้จะเริ่มขยับ

request แรกหลังเปิด server คุณอาจเห็นบรรทัด ActiveRecord::SchemaMigration Load … แทรกมาอีกหนึ่งบรรทัด — Rails แค่แง้มดูว่าตู้เก็บแฟ้ม (database) พร้อมไหม ไม่ต้องตกใจ (:: อ่านว่า “ที่อยู่ข้างใน” แบบที่เจอในบท 99)

ถ้าเทียบกับ Gin: log ของ Gin ต่อหนึ่ง request มีบรรทัดเดียว (ผลจริงจากโปรแกรม Go ในหัวข้อ MVC ข้างล่าง):

[GIN] 2026/11/03 - 21:12:17 | 200 | 86.291µs |             ::1 | GET      "/posts"

Rails จดละเอียดกว่า เพราะมันแบ่งงานเป็นหลายช่อง แล้วบอกว่า request ผ่านช่องไหนบ้าง · เวลาหน้าเว็บพัง ให้ดู log ก่อนเสมอ — มันบอกว่าใบสั่งไปติดอยู่ที่มือใคร

# routes.rb มีแค่ get "/posts" (ไม่มี /menu)
# เปิด browser ไปที่
http://localhost:3000/menu

Started GET "/menu" for ::1 at 2026-11-03 20:47:31 +0700

ActionController::RoutingError (No route matches [GET] "/menu"):

ด่านหน้าครัว — middleware

ก่อนใบสั่งจะถึงพนักงานต้อนรับ มันต้องผ่านด่านหลายด่านเรียงกัน แต่ละด่านทำงานหนึ่งอย่างกับทุกใบสั่ง เช่น จดลงสมุด · อ่านบัตรสมาชิกของลูกค้า (cookie) · กันคนแปลกหน้า · ด่านพวกนี้เรียกว่า middleware

บรรทัด Started GET "/posts" … ที่เห็นใน log ก็มาจาก middleware ตัวหนึ่ง — มันคือคนจดสมุดที่ประตูครัว · อยากดูว่ามีด่านอะไรบ้าง สั่งได้ด้วยคำสั่งข้างล่าง (ชื่อแต่ละด่านมี :: คั่น เช่น ActionDispatch::Static = ด่าน Static ที่อยู่ในกล่อง ActionDispatch):

$ bin/rails middleware
use ActionDispatch::HostAuthorization
use Rack::Sendfile
use ActionDispatch::Static
…(ตัดออก)…
run WongnokBlog::Application.routes

ในโปรเจกต์ที่เพิ่ง rails new โหมด development มี 28 ด่าน (บรรทัด use) · อ่านจากบนลงล่าง = ลำดับที่ใบสั่งเดินผ่าน · บรรทัดสุดท้าย run … routes บอกว่าผ่านด่านสุดท้ายแล้วส่งให้ routes · คุณไม่ต้องจำชื่อสักตัว — รู้แค่ว่ามีด่านพวกนี้ และ Rails ใส่มาให้ครบแล้ว

ใน Go คุณรู้จักของนี้แล้ว — gin.Default() ใส่ middleware ให้ 2 ตัว (Logger กับ Recovery) และคุณเพิ่มเองด้วย r.Use(...) (บท 39) · แนวคิดเดียวกันเป๊ะ ต่างแค่ Rails ใส่มาให้ 28 ตัวตั้งแต่วันแรก

เลข status ที่เจอใน log — ภาษาคน

บรรทัด Completed … ทุกครั้งมีเลขสามหลัก เรียกว่า status code — เป็นป้ายสั้น ๆ ที่ติดไปกับจาน บอกลูกค้าว่าใบสั่งนี้จบแบบไหน (เคยเรียนฝั่ง Go แล้วใน บท 34) · ใน Rails มีชื่อเป็น symbol (คำที่ขึ้นต้นด้วย : — บท 92) ให้ใช้แทนตัวเลขได้ · วันนี้แค่อ่านเลขใน log ให้ออก ยังไม่ต้องเขียนเอง · คู่ชื่อกับเลขในตารางนี้ผมเช็คกับ Rails 8.1.4 จริงแล้ว:

ลองดู 302 ของจริง · สมมติร้านเคยใช้ URL /articles แล้วย้ายมาเป็น /posts เราอยากให้คนที่ยังเข้า URL เก่าถูกส่งต่อไป URL ใหม่ · เพิ่ม route กับ action อีกอย่างละหนึ่ง:

# config/routes.rb — เพิ่มใต้ get "/posts"
  get "/articles", to: "posts#articles"

# app/controllers/posts_controller.rb — เพิ่มต่อจาก def index … end (ก่อน end ตัวสุดท้าย)
  def articles
    redirect_to "/posts"
  end

redirect_to "/posts" แปลว่า “ไม่ต้องจัดจาน บอกลูกค้าให้ไปสั่งที่ /posts แทน” (ละเอียดใน บท 102) · เปิด localhost:3000/articles แล้วดู log:

Started GET "/articles" for ::1 at 2026-11-03 20:47:30 +0700
Processing by PostsController#articles as HTML
Redirected to http://localhost:3000/posts
↳ app/controllers/posts_controller.rb:11:in 'PostsController#articles'
Completed 302 Found in 1ms (ActiveRecord: 0.0ms (0 queries, 0 cached) | GC: 0.0ms)

• Redirected to http://localhost:3000/posts — หัวหน้าเชฟบอกลูกค้าว่าให้ไปที่ไหน
• ↳ app/controllers/posts_controller.rb:11 — บรรทัดที่ 11 ของไฟล์ controller คือคนสั่ง redirect (Rails ชี้ให้เองในโหมด development · เลขบรรทัดของคุณอาจต่างถ้าเว้นบรรทัดไม่เท่ากัน)
• Completed 302 Found — จบด้วยเลข 302 · ไม่มีบรรทัด Rendering เพราะไม่ได้จัดจาน
• ถ้าเปิดด้วย browser จะเห็น log ต่อท้ายอีกก้อนเป็น Started GET "/posts" ทันที — นั่นคือ browser ยื่นใบสั่งใบใหม่ตามที่ถูกบอก รวมเป็น 2 request · ช่องที่อยู่ของ browser ก็จะเปลี่ยนจาก /articles เป็น /posts เอง

MVC ของจริง — Gin ทำในฟังก์ชันเดียว · Rails แบ่งแผนก

ถึงตรงนี้เราเห็นสองช่องจากสามช่องของ MVC แล้ว: Controller (หัวหน้าเชฟ) กับ View (จัดจาน) · ช่องที่สามคือ Model = ห้องเก็บวัตถุดิบ + คนดูแลสต็อก ที่รู้ว่าข้อมูลอยู่ตู้ไหนใน database · MVC คือการแบ่งโค้ดเป็นสามกองตามหน้าที่ แทนที่จะกองรวมกัน

ลองเขียนหน้าเดียวกันด้วย Gin ดูก่อน (โค้ดนี้ go build ผ่าน · รันแล้วได้บทความสองชิ้นเหมือนกัน แค่ไม่มี layout ห่อ):

// main.go
package main

import (
	"fmt"
	"net/http"

	"github.com/gin-gonic/gin"
)

type Post struct {
	Title  string
	Author string
}

func main() {
	r := gin.Default() // พนักงานต้อนรับ + ด่านหน้าครัว (Logger, Recovery)

	r.GET("/posts", func(c *gin.Context) {
		// 1) หาข้อมูล (งานของ Model)
		posts := []Post{
			{"ข้าวซอยเจ้าเด็ด", "สมชาย"},
			{"ส้มตำปูปลาร้า", "สมหญิง"},
		}
		// 2) จัดจานเป็น HTML (งานของ View)
		html := "<h1>บทความทั้งหมด</h1>"
		for _, p := range posts {
			html += fmt.Sprintf("<h2>%s</h2><p>โดย %s</p>", p.Title, p.Author)
		}
		// 3) ยกจานออกไป (งานของ Controller)
		c.Data(http.StatusOK, "text/html; charset=utf-8", []byte(html))
	})

	r.Run(":8080")
}

• type Post struct — ประกาศหน้าตาของบทความเอง (Go ต้องบอกทุกช่องชัด ๆ)
• r.GET("/posts", func(c *gin.Context) { … }) — ลง route กับเขียน handler ในบรรทัดเดียวกัน
• fmt.Sprintf(…) — ต่อ string HTML เองทีละบทความ
• c.Data(http.StatusOK, …) — ส่ง HTML กลับพร้อมเลข 200 เอง

สังเกตว่า handler ตัวเดียวทำทั้งสามงาน: หาข้อมูล · ประกอบ HTML · ตอบกลับ · ตอนหน้ามีหน้าเดียวก็สบายดี แต่พอมี 30 หน้า ทุกหน้าต้องมี HTML ปนอยู่ใน Go · ทุกหน้าต้องรู้ว่าข้อมูลอยู่ตาราง SQL ไหน

Rails เตรียมห้องแยกไว้ให้ตั้งแต่ rails new แล้วใช้กฎตั้งชื่อจับคู่ให้: หาข้อมูลไป app/models/ · ประกอบ HTML ไป app/views/ · ประสานงานอยู่ app/controllers/ · สไลด์หน้า 52 สรุปไว้แบบนี้:

กฎตัดสินใจง่าย ๆ จากสไลด์: เป็นข้อมูลหรือกฎของธุรกิจ → Model · เกี่ยวกับ HTTP เช่น URL, params, redirect → Controller · หน้าตาล้วน ๆ → View

แล้ว Model ของเราอยู่ไหน? วันนี้ยังไม่มี · ข้อมูลจำลองที่วางใน controller คือ หัวหน้าเชฟเก็บวัตถุดิบไว้ในกระเป๋าตัวเองชั่วคราว ซึ่งผิดแผนก · Day 2 เราจะสร้าง model Post กับตาราง posts ใน database จริง แล้ว controller จะเหลือบรรทัดเดียวแบบภาพในสไลด์หน้า 53:

# Day 2 — ยังรันไม่ได้วันนี้ เพราะยังไม่มี model Post และตาราง posts
def index
  @posts = Post.all   # "ห้องเก็บของ ขอบทความทั้งหมด"
end

Post (ตัวใหญ่ เอกพจน์) คือคนดูแลสต็อกของบทความ · .all คือขอ “ทุกชิ้น” · Post ไม่ได้โผล่มาเฉย ๆ — Day 2 จะมีไฟล์ app/models/post.rb ที่ประกาศ class Post ไว้ แล้ว Rails หาเจอเองจากชื่อ ไม่ต้อง import (autoload — บท 99) · เส้นทางทั้งเส้นในสไลด์หน้า 53 จึงเป็น: browser → routes → PostsController → Post → database → กลับมาที่ controller → ส่ง @posts ให้ view → HTML กลับไปที่ browser — เส้นเดียวกับที่เราทำวันนี้ แค่เพิ่มห้องเก็บของเข้ามา

ภารกิจ — เพิ่มหน้า “บทความแรก” ด้วยมือตัวเอง

# config/routes.rb
Rails.application.routes.draw do
  get "up" => "rails/health#show", as: :rails_health_check

  get "/posts", to: "posts#index"
  get "/articles", to: "posts#articles"
  get "/posts/first", to: "posts#first"
end

# app/controllers/posts_controller.rb — เพิ่ม action นี้ (ตรงไหนก็ได้ระหว่าง class … end)
  def first
    @post = { title: "ข้าวซอยเจ้าเด็ด", author: "สมชาย" }
  end

<h1><%= @post[:title] %></h1>
<p>โดย <%= @post[:author] %></p>

Started GET "/posts/first" for ::1 at 2026-11-03 20:46:21 +0700
Processing by PostsController#first as HTML
  Rendering layout layouts/application.html.erb
  Rendering posts/first.html.erb within layouts/application
  Rendered posts/first.html.erb within layouts/application (Duration: 0.1ms | GC: 0.0ms)
  Rendered layout layouts/application.html.erb (Duration: 1.2ms | GC: 0.0ms)
Completed 200 OK in 3ms (Views: 2.0ms | ActiveRecord: 0.0ms (0 queries, 0 cached) | GC: 0.0ms)

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

ติดตรงไหน ถามกลับได้เลย · ถ้าหน้าเว็บพัง ก็อป log ตั้งแต่ Started ถึง Completed มาทั้งก้อน พร้อมบอกว่าเปิด URL อะไร · แค่นั้นก็เดาได้แล้วเกือบทุกครั้งว่าติดที่มือใครในร้าน

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

สไลด์หน้า 49–53 สรุปไว้สั้น บางจุดไม่ตรงกับที่เห็นในเครื่องจริง · ทั้งหมดนี้ไม่ทำให้โค้ดในบทนี้พัง อ่านผ่าน ๆ ได้

อ้างอิง

• Rails Guides — Getting Started — อ่านหัวข้อ Model-View-Controller Basics (สั้น) แล้วต่อด้วย A Request's Journey Through Rails ที่เล่าเส้นทางเดียวกับบทนี้ (route → controller → view) ด้วยตัวอย่างแอปขายสินค้า
• Rails Guides — Layouts and Rendering — อ่านหัวข้อ Rendering by Default ที่อธิบายว่าทำไม action ว่าง ๆ ถึงหา view ชื่อเดียวกันเจอเอง
• Rails Guides — Rails on Rack — อ่านแค่หัวข้อ Inspecting the Middleware Stack (คำสั่ง bin/rails middleware) · ส่วนที่เหลือลึกเกินสำหรับตอนนี้
• Rails Guides — Debugging Rails Applications — อ่านหัวข้อ The Logger ว่า log เก็บไว้ไฟล์ไหน และ Verbose Redirect Logs ที่เป็นที่มาของบรรทัด ↳ app/controllers/… ใน log ของ redirect
• Rails Guides — The Rails Initialization Process — สำหรับคนอยากรู้ว่าตอน boot อ่านไฟล์ไหนก่อนหลัง · ลึกมาก ไม่ต้องอ่านตอนนี้ กลับมาอ่านหลังจบ Day 1 ได้