本章目標

學完本章後，你將能夠：

1. 看懂 go.mod 的三個核心欄位
2. 理解 module path 與 import path 的關係
3. 知道為什麼 Go 指令要在 module 根目錄執行
4. 分辨標準庫與第三方依賴

【觀察】go.mod 定義 module

go.mod 的核心用途是宣告目前 module 的身份、Go 版本與外部依賴。一個 Go 專案通常會在 module 根目錄放 go.mod：

1module example.com/notify-service
2
3go 1.25.1
4
5require (
6    github.com/gorilla/websocket v1.5.3
7)

這份檔案表達三件事：module 名稱、Go 語言版本、外部依賴。

【判讀】module 是 Go 編譯與依賴解析的單位

module 的核心規則是：Go 工具鏈以 go.mod 所在目錄作為依賴解析與 package 掃描的根。Go 工具鏈需要知道「目前這批程式碼」的根在哪裡；go.mod 就是這個根。

當你在 module 根目錄執行：

1go test ./...

./... 的意思是測試目前 module 底下所有 package。實務上要先找到 go.mod 所在目錄，再從那裡執行 Go 指令。

【策略】先分辨三種 import

閱讀 import 的核心規則是：先分辨能力來源，再決定去哪裡查。讀 Go 檔案時，先把 import 分成三類：

這個分類會告訴你：問題應該去查標準庫文件、第三方套件文件，還是目前 module 的其他目錄。

【執行】用 module 模型閱讀 main.go

閱讀入口程式 import 的核心方法是：先把 import 依來源分群，再判斷程式依賴哪些能力。main.go 的 import 可以整理成這樣：

 1import (
 2    "context"
 3    "fmt"
 4    "log/slog"
 5    "net/http"
 6    "os"
 7    "time"
 8
 9    "example.com/notify-service/messages"
10)

前面是標準庫，最後一個是專案內部 package。這表示入口程式主要依賴 Go 標準庫，只有日誌訊息常數被拆到內部 messages package。

變數一定有型別

Go 的變數一定屬於某個明確型別。這個型別可以由程式直接寫出，也可以由編譯器根據右側的初始值推斷出來；但推斷完成後，變數的型別就固定了。

1var name string = "api"
2var port int = 8080
3
4enabled := true
5timeout := 30

name 的型別是 string，port 的型別是 int，enabled 與 timeout 則由右側初始值推斷型別。Go 允許省略重複資訊，但不允許變數在執行期間任意改變型別。

1count := 10
2count = 20      // 可以，仍然是 int
3// count = "20" // 編譯錯誤：string 不能指派給 int

這個規則讓 Go 程式在閱讀時更穩定：看到一個變數後，讀者可以相信它的型別不會在後面突然變成另一種資料。

零值讓變數可立即使用

零值是 Go 對「尚未明確指定初始值」的標準答案。每個型別都有自己的零值：數字是 0，字串是空字串，布林是 false，指標、slice、map、function、interface 與 channel 是 nil。

1var retryCount int
2var title string
3var debug bool
4var tags []string
5
6fmt.Println(retryCount) // 0
7fmt.Println(title)      // ""
8fmt.Println(debug)      // false
9fmt.Println(tags == nil) // true

零值是型別的預設狀態。這是 Go 設計中很重要的精神：讓資料結構在最少初始化下仍然有合理行為。

 1type Counter struct {
 2    value int
 3}
 4
 5func (c *Counter) Add(n int) {
 6    c.value += n
 7}
 8
 9func (c Counter) Value() int {
10    return c.value
11}
12
13var counter Counter
14counter.Add(3)
15fmt.Println(counter.Value()) // 3

Counter 沒有建構函式也能使用，因為 value 的零值是 0。當型別可以靠零值進入可用狀態時，使用者需要記住的初始化規則就會少很多。

var 適合宣告意圖

var 的主要用途是清楚宣告變數的存在、型別或零值意義。當你需要讓讀者知道「這個變數稍後才會被賦值」或「零值本身有意義」時，var 比 := 更清楚。

1var userID string
2
3if fromHeader != "" {
4    userID = fromHeader
5} else {
6    userID = fromCookie
7}

這裡的 userID 需要經過條件判斷才會得到值，因此先用 var 宣告變數，再在不同分支指派。讀者看到 var userID string，可以理解這是一個稍後會被填入的字串。

var 也適合用在 package 層級，因為 package 層級不能使用 :=。

1var defaultPort = 8080
2var serviceName = "worker"

package 層級變數會增加全域狀態，使用前要先確認它是否真的代表整個 package 的共同狀態；如果只是函式內部暫存資料，應該放回函式裡。

:= 適合區域初始化

短變數宣告 := 的主要用途是在函式內同時宣告與初始化變數。當右側初始值已經清楚表達型別時，:= 可以讓程式更精簡。

1func greeting(name string) string {
2    message := "hello, " + name
3    return message
4}

message 的型別可以從字串串接結果推斷，所以不需要寫成 var message string = ...。這種省略是移除讀者已經能從右側看懂的重複資訊。

短變數宣告只能用在函式內。以下寫法不能放在 package 層級：

1// package 層級不允許：
2// port := 8080

:= 也要求左側至少有一個新變數。這個規則會影響常見的錯誤處理寫法。

1data, err := loadFile("config.json")
2if err != nil {
3    return err
4}
5
6config, err := parseConfig(data) // config 是新變數，err 是重新指派
7if err != nil {
8    return err
9}

第二次使用 := 是合法的，因為 config 是新變數；同時 err 會被重新指派。這種寫法在 Go 很常見，但要留意不要在內層區塊意外宣告出新的同名變數。

型別推斷不等於放棄型別

型別推斷的核心作用是減少重複，不是讓變數變成動態型別。Go 只在編譯期根據右側表達式推斷型別，推斷後仍然遵守靜態型別規則。

1limit := 100       // int
2ratio := 0.75      // float64
3label := "active"  // string

當右側型別不夠明確，或你需要指定更精確的型別時，就應該直接寫出型別。

1var timeoutSeconds int64 = 30
2var threshold float32 = 0.8

這裡如果只寫 timeoutSeconds := 30，通常會得到 int；如果 API、資料庫欄位或二進位格式需要 int64，明確宣告型別會比事後轉型更好讀。

指標、slice 與 map 的零值差異

零值的共同規則是「未初始化時有定義好的狀態」，但不同型別的零值可用程度不同。指標的零值是 nil，使用前需要確認是否指向有效資料；slice 的零值可以安全讀長度與 append；map 的零值可以讀取但不能寫入。

1var names []string
2names = append(names, "alice")
3fmt.Println(len(names)) // 1
4
5var scores map[string]int
6fmt.Println(scores["alice"]) // 0
7// scores["alice"] = 10      // panic: assignment to entry in nil map

slice 的零值能直接 append，所以很多函式可以回傳 nil slice 表示沒有資料；呼叫端仍然可以用 len 與 range 處理。map 要寫入前必須先用 make 初始化。

1scores := make(map[string]int)
2scores["alice"] = 10

這個差異是零值判讀的核心陷阱：nil slice 通常容易處理，nil map 則需要先初始化才能寫入。

命名要服務讀者

變數名稱的核心責任是說明資料在當前範圍內的角色。範圍越小，名稱可以越短；範圍越大，名稱就應該越具體。

1for i, item := range items {
2    fmt.Println(i, item)
3}

i 在很短的迴圈內代表 index，讀者可以立即理解。相反地，跨越多個段落使用的變數應該使用更完整的名稱。

1requestTimeout := 5 * time.Second
2maxRetryCount := 3

Go 程式常使用短名稱，但短名稱不是目標本身。好的名稱應該讓讀者不必回頭搜尋變數來源，就能理解這個值現在代表什麼。

下一章

下一章會進入控制流程，說明 Go 如何用少量語法表達條件、迴圈與多分支判斷。

if 表達條件與提前返回

if 的核心責任是根據條件決定程式是否進入某段邏輯。Go 的 if 條件不需要小括號，但區塊大括號是必要語法。

1if age >= 18 {
2    fmt.Println("adult")
3}

Go 不會把數字、字串或指標自動當成布林值。條件必須是明確的 bool 表達式。

1count := 3
2
3if count > 0 {
4    fmt.Println("has items")
5}
6
7// if count {
8//     fmt.Println("invalid")
9// }

這個規則讓條件判斷更直接：讀者不需要猜某個非布林值在條件中會被如何轉換。

if 可以包含短宣告

if 的短宣告用來把只屬於這個判斷的暫存變數限制在區塊內。這讓錯誤處理與查找結果的作用範圍更清楚。

1if value, ok := cache["user:1"]; ok {
2    fmt.Println("cache hit:", value)
3}

value 與 ok 只存在於 if 與對應的 else 區塊內。這種寫法適合處理 map 查找、型別轉換、函式呼叫錯誤等短生命週期資料。

1if err := saveProfile(profile); err != nil {
2    return err
3}

這裡的 err 只用來判斷 saveProfile 是否失敗，離開 if 後就不再需要。短宣告可以降低變數留在外層範圍造成的干擾。

提前返回讓主流程靠左

Go 常用提前返回處理失敗或特殊情況。核心原則是先處理不能繼續的狀態，讓正常流程留在較少縮排的位置。

 1func normalizeEmail(input string) (string, error) {
 2    input = strings.TrimSpace(input)
 3    if input == "" {
 4        return "", fmt.Errorf("email is required")
 5    }
 6
 7    if !strings.Contains(input, "@") {
 8        return "", fmt.Errorf("invalid email")
 9    }
10
11    return strings.ToLower(input), nil
12}

這段程式先排除空字串與格式錯誤，最後才回傳正常結果。讀者可以依序看到「不能接受什麼」以及「通過檢查後會得到什麼」。

提前返回不是要求每個條件都拆開。當兩個條件代表同一個規則時，可以合併成一個判斷；當條件代表不同失敗原因時，拆開通常比較清楚。

for 是唯一迴圈語法

Go 的迴圈只有 for。它可以表達傳統計數迴圈、條件迴圈、無限迴圈與 range 迴圈。

1for i := 0; i < 3; i++ {
2    fmt.Println(i)
3}

這是傳統的三段式迴圈：初始化、條件、迭代後處理。它適合需要 index、固定次數或精準控制遞增方式的場景。

1remaining := 3
2for remaining > 0 {
3    fmt.Println(remaining)
4    remaining--
5}

省略初始化與後處理後，for 就是其他語言常見的 while 迴圈。Go 不另外提供 while，因為 for 條件 已經能表達同一件事。

1for {
2    fmt.Println("polling")
3    break
4}

沒有條件的 for 是無限迴圈，通常會搭配 break、return、context 或 channel 退出。無限迴圈要讓退出條件清楚可見，否則很容易讓讀者無法判斷生命週期。

range 用來走訪集合

range 的核心用途是逐一走訪陣列、slice、map、字串與 channel。它會依資料型別產生不同的索引或值。

1names := []string{"alice", "bob"}
2
3for i, name := range names {
4    fmt.Println(i, name)
5}

走訪 slice 時，第一個值是 index，第二個值是元素副本。若不需要 index，可以用 _ 忽略。

1for _, name := range names {
2    fmt.Println(name)
3}

走訪 map 時，順序沒有保證。這是語言刻意設計的結果，避免程式誤以為 map 有穩定順序。

1scores := map[string]int{
2    "alice": 90,
3    "bob":   80,
4}
5
6for name, score := range scores {
7    fmt.Println(name, score)
8}

如果輸出順序重要，應該先取出 key、排序，再依序讀取 map。

break 與 continue 控制迴圈節奏

break 的核心作用是結束目前迴圈，continue 的核心作用是跳過本次迭代並進入下一輪。它們應該用來表達清楚的流程轉折，而不是補救過度複雜的迴圈。

 1for _, line := range lines {
 2    if line == "" {
 3        continue
 4    }
 5
 6    if line == "STOP" {
 7        break
 8    }
 9
10    fmt.Println(line)
11}

這段程式忽略空行，遇到 STOP 停止，其他行則輸出。條件都放在處理邏輯前方，讀者可以先理解哪些資料不進入主流程。

當迴圈內的 break、continue、巢狀條件太多時，通常代表應該把部分邏輯抽成函式，讓每個函式只負責一層判斷。

switch 表達多分支判斷

switch 的核心責任是把同一個概念的多種可能集中呈現。Go 的 switch 預設不會自動落入下一個 case，所以大多數情況不需要寫 break。

 1switch method {
 2case "GET":
 3    fmt.Println("read")
 4case "POST":
 5    fmt.Println("create")
 6case "DELETE":
 7    fmt.Println("delete")
 8default:
 9    fmt.Println("unsupported")
10}

每個 case 預設只執行自己的區塊。若真的需要落入下一個 case，Go 提供 fallthrough，但日常程式很少需要它。

switch 也可以不帶目標值，用來取代一長串 if else。

 1switch {
 2case score >= 90:
 3    fmt.Println("A")
 4case score >= 80:
 5    fmt.Println("B")
 6case score >= 70:
 7    fmt.Println("C")
 8default:
 9    fmt.Println("D")
10}

這種寫法適合條件都在描述同一個分類規則時使用。若每個條件都在處理不同概念，拆成多個 if 或不同函式通常更清楚。

下一章

下一章會回到 package 與檔案組織，說明 Go 如何用 package 建立程式邊界。

本章目標

學完本章後，你將能夠：

1. 理解 package main 和一般 package 的差異
2. 看懂同一個 package 如何拆成多個檔案
3. 用大小寫判斷 exported 與 unexported 名稱
4. 設計不暴露過多細節的 package API

【觀察】每個 Go 檔案都從 package 開始

package 宣告的核心規則是：每個 Go 檔案都必須先宣告自己屬於哪個 package。可執行程式使用 package main，例如：

1package main
2
3import "fmt"
4
5func main() {
6    fmt.Println("hello")
7}

第一行 package main 表示這個檔案屬於 main package。Go 編譯器會尋找 main package 裡的 main() 函式，將它編譯成可執行程式。

一般 package 的核心規則是：它不負責啟動程式，而是提供型別、函式或方法給其他 package 使用。可被其他程式引用的工具 package 通常會使用自己的 package 名稱：

1package config
2
3type Config struct {
4    Port int
5}

這個 package 不會自己啟動程式，而是提供型別、函式或方法給其他 package 使用。

【判讀】package 是一組共同編譯的檔案

package 的編譯單位是一組同 package 檔案。同一個資料夾中的 Go 檔案通常必須宣告同一個 package；這些檔案會被一起編譯，也可以直接互相使用彼此的 unexported 名稱。

例如：

1config/
2├── config.go
3├── defaults.go
4└── validate.go

三個檔案都可以是：

1package config

這表示 config.go 裡的函式可以直接呼叫 validate.go 裡的小工具函式，即使那個工具函式沒有 exported。

【策略】用大小寫控制 API 邊界

Go 可見性的核心規則是：大寫開頭 exported，小寫開頭 unexported。Go 沒有 public、private 關鍵字，而是用命名大小寫決定可見性：

範例：

 1package config
 2
 3type Config struct {
 4    Port int
 5}
 6
 7const defaultPort = 8080
 8
 9func Load(path string) (Config, error) {
10    if path == "" {
11        return Config{Port: defaultPort}, nil
12    }
13    return readConfig(path)
14}
15
16func readConfig(path string) (Config, error) {
17    // 內部解析邏輯
18    return Config{Port: defaultPort}, nil
19}

其他 package 可以使用 config.Config 和 config.Load，但不能直接使用 config.defaultPort 或 config.readConfig。

【執行】把檔案切分成認知單位

檔案切分的核心規則是：依照讀者理解程式的方式分組，而不是機械地一個型別一個檔案。Go 不要求「一個型別一個檔案」。

例如設定讀取 package 可以這樣切：

1config/
2├── config.go       # Config 型別與 Load 入口
3├── defaults.go     # 預設值
4├── validate.go     # 驗證規則
5└── config_test.go  # 測試

這樣切分的好處是：

• config.go 作為 package 入口，讀者先看這裡
• defaults.go 集中預設值，不和解析流程混在一起
• validate.go 集中驗證規則，方便測試
• unexported helper 留在 package 內，不污染外部 API

設計檢查

檢查一：控制 exported API

如果你把所有型別、函式、常數都用大寫開頭，其他 package 就會開始依賴你的內部細節。未來你想重構時，會發現很多名稱都不能改。

檢查二：package 名稱表達責任

utils、common、helpers 這類名稱常讓 package 變成雜物間。Go 更偏好用資料或能力命名，例如 config、auth、metrics、parser。

檢查三：檔案切分服務閱讀

過度切分會讓讀者一直跳檔案。Go 的檔案可以稍微長一點，只要同一個檔案仍然圍繞同一組概念。

本章目標

學完本章後，你將能夠：

1. 判斷何時保留單一 main.go
2. 理解同 package 多檔案如何互相呼叫
3. 分辨「拆檔案」和「拆 package」的差異
4. 看懂跨 package 呼叫、exported 名稱與 import path 的關係
5. 避免過早把小程式拆成複雜架構

【觀察】單檔是合理起點

單一 main.go 的核心價值是降低初期理解成本。程式還小的時候，把入口、設定、簡單函式放在同一個檔案，通常比一開始拆成多個資料夾更容易閱讀。

1notify/
2├── go.mod
3└── main.go

一個最小 HTTP 服務可以先長這樣：

 1package main
 2
 3import (
 4    "fmt"
 5    "net/http"
 6)
 7
 8func main() {
 9    http.HandleFunc("/health", healthHandler)
10
11    if err := http.ListenAndServe(":8080", nil); err != nil {
12        panic(err)
13    }
14}
15
16func healthHandler(w http.ResponseWriter, r *http.Request) {
17    fmt.Fprintln(w, "ok")
18}

這個階段不需要急著建立 handler、service 或 domain 資料夾。讀者一眼能看懂程式如何啟動，比形式上的分層更重要。

【判讀】main.go 膨脹時，先拆同 package 多檔案

同 package 多檔案的核心規則是：同一個資料夾、同一個 package 名稱的 Go 檔案會被一起編譯，彼此可以直接呼叫，不需要 import。

當 main.go 開始同時包含設定、handler、資料型別與啟動流程，可以先拆成這樣：

1notify/
2├── go.mod
3├── main.go
4├── config.go
5├── server.go
6└── message.go

每個檔案仍然使用：

1package main

因此 main.go 可以直接呼叫 loadConfig()：

1func main() {
2    cfg := loadConfig()
3    server := newServer(cfg)
4
5    if err := server.ListenAndServe(); err != nil {
6        panic(err)
7    }
8}

config.go 可以提供這個函式：

1package main
2
3type config struct {
4    Port string
5}
6
7func loadConfig() config {
8    return config{Port: ":8080"}
9}

這是同 package 內的檔案切分。loadConfig 即使用小寫開頭，main.go 也可以呼叫，因為它們都屬於 package main。

【策略】先拆檔案，再拆 package

拆分的核心判斷是：檔案用來降低閱讀負擔，package 用來建立 API 邊界。這兩者成本不同，不應混在一起。

例如 message.go 只是放一些內部型別時，可以留在 package main：

1package main
2
3type message struct {
4    Title string
5    Body  string
6}

如果 notification 概念開始有自己的建構規則、驗證規則與測試需求，就可以搬成獨立 package：

1notify/
2├── go.mod
3├── main.go
4└── notification/
5    ├── notification.go
6    └── validate.go

此時 notification package 要明確決定哪些名稱是對外 API。

【執行】跨 package 呼叫需要 import 與 exported 名稱

跨 package 呼叫的核心規則是：其他 package 只能使用大寫開頭的 exported 名稱，並且必須透過 import path 引入。

假設 module path 是：

1module example.com/notify

notification/notification.go 可以這樣寫：

 1package notification
 2
 3import "strings"
 4
 5type Notification struct {
 6    Title string
 7    Body  string
 8}
 9
10func New(title, body string) Notification {
11    return Notification{
12        Title: strings.TrimSpace(title),
13        Body:  strings.TrimSpace(body),
14    }
15}
16
17func isEmpty(n Notification) bool {
18    return n.Title == "" && n.Body == ""
19}

main.go 要使用這個 package，必須 import：

 1package main
 2
 3import (
 4    "fmt"
 5
 6    "example.com/notify/notification"
 7)
 8
 9func main() {
10    n := notification.New("Deploy finished", "Version 1.2.0 is live")
11    fmt.Println(n.Title)
12}

notification.New 和 notification.Notification 可以被外部使用，因為它們是大寫開頭。isEmpty 不能被 main.go 呼叫，因為它是 package 內部實作細節。

【判讀】import cycle 是依賴方向錯了

import cycle 的核心意義是兩個 package 互相依賴，Go 會直接拒絕編譯。Go 工具鏈透過這個限制強迫你把依賴方向想清楚。

例如這種結構容易出問題：

1notify/
2├── main.go
3├── handler/
4│   └── handler.go
5└── notification/
6    └── notification.go

如果 handler import notification，同時 notification 又 import handler，就會形成循環依賴。

1handler -> notification -> handler

修正的核心做法是讓低層概念不要依賴高層協定。notification 應該描述通知資料與規則，不應知道 HTTP handler；handler 可以把 HTTP request 轉成 notification command 或 value。

1handler -> notification

這個方向比「互相知道」更容易測試，也更容易重構。

常見拆分路線

Go 服務常見的成長路線是漸進式的。每一步都應該解決當下的閱讀、測試或依賴問題，而不是為了看起來正式。

階段一：單一檔案

1notify/
2├── go.mod
3└── main.go

適合小工具、實驗程式、剛開始的服務雛形。

階段二：同 package 多檔案

1notify/
2├── go.mod
3├── main.go
4├── config.go
5├── server.go
6└── notification.go

適合 main.go 開始太長，但概念還沒有明確 API 邊界的階段。

階段三：多 package

 1notify/
 2├── go.mod
 3├── main.go
 4├── config/
 5│   └── config.go
 6├── notification/
 7│   ├── notification.go
 8│   └── validate.go
 9└── transport/
10    └── http.go

適合設定、通知規則、HTTP transport 已經能清楚分成不同責任的階段。

階段四：服務邊界更清楚

1notify/
2├── go.mod
3├── cmd/
4│   └── notify-server/
5│       └── main.go
6└── internal/
7    ├── notification/
8    ├── transport/
9    └── storage/

適合服務已經有明確部署入口、內部 package 不想被外部 module 引用的階段。這是程式長大後的選擇。

設計檢查

檢查一：檔案切分跟著 Go package 模型

Go 的檔案不是 class。把每個 struct 都拆成一個檔案，通常只會增加跳轉成本，不會讓設計更清楚。

檢查二：資料夾跟著邊界成長

程式還小時就建立 domain、application、infrastructure，會讓讀者先學資料夾，再學行為本身。Go 更適合先讓程式跑起來，再根據壓力拆邊界。

檢查三：exported 名稱代表公開承諾

exported 名稱就是 package 對外承諾。還不確定會被外部使用的型別與函式，先保持 unexported，等 API 真的穩定再開放。

本章目標

學完本章後，你將能夠：

1. 區分普通函式與方法
2. 理解 receiver 的語法與語義
3. 判斷何時使用 pointer receiver
4. 用建構函式集中初始化規則

【觀察】普通函式不屬於特定值

普通函式的核心規則是：它不綁定特定型別，只接收參數並回傳結果。以下函式只負責把名稱正規化：

1func NormalizeName(name string) string {
2    return strings.TrimSpace(strings.ToLower(name))
3}

呼叫方式：

1name := NormalizeName(" Alice ")

這種函式適合描述純粹轉換：輸入什麼，輸出什麼，不需要修改某個物件的內部狀態。

【判讀】方法是帶 receiver 的函式

方法的核心規則是：函式若需要以某個型別作為操作對象，就用 receiver 綁到該型別。行為和某個型別密切相關時，可以寫成方法：

 1type Counter struct {
 2    value int
 3}
 4
 5func (c *Counter) Inc() {
 6    c.value++
 7}
 8
 9func (c Counter) Value() int {
10    return c.value
11}

(c *Counter) 和 (c Counter) 就是 receiver。它放在 func 和方法名稱之間，表示這個函式是 Counter 的方法。receiver 只表示「這個函式以這個型別作為操作對象」，不代表繼承關係 — Go 沒有類別繼承，方法只是綁定到型別的函式。

呼叫方式：

1var c Counter
2c.Inc()
3fmt.Println(c.Value())

Go 會讓方法呼叫看起來像物件操作，但本質仍然是函式呼叫。

【策略】用是否修改狀態選擇 receiver

receiver 選擇的核心規則是：要修改原值用 pointer receiver，不修改且型別小可以用 value receiver。receiver 有兩種常見形式：

例如 Value() 不修改 Counter，可以用 value receiver：

1func (c Counter) Value() int {
2    return c.value
3}

Inc() 需要修改原本的 counter，所以使用 pointer receiver：

1func (c *Counter) Inc() {
2    c.value++
3}

如果你不確定，先問一個問題：這個方法是否要改變 receiver 的狀態？答案是 yes，通常就用 pointer receiver。

【執行】用建構函式集中初始化

建構函式的核心用途是集中初始化規則。Go 沒有 constructor 關鍵字，但慣例會用 NewTypeName 建立需要初始化的型別：

 1type Cache struct {
 2    items map[string]string
 3}
 4
 5func NewCache() *Cache {
 6    return &Cache{
 7        items: make(map[string]string),
 8    }
 9}
10
11func (c *Cache) Set(key, value string) {
12    c.items[key] = value
13}
14
15func (c *Cache) Get(key string) (string, bool) {
16    value, ok := c.items[key]
17    return value, ok
18}

使用方式：

1cache := NewCache()
2cache.Set("theme", "dark")
3value, ok := cache.Get("theme")

這裡 NewCache() 的價值是保證 items 一定被初始化。呼叫者不需要知道 Cache 內部有 map，也不需要記得手動 make。

函式還是方法？

函式與方法的選擇規則是：純轉換用函式，依賴型別狀態用方法，需要初始化保證用 NewTypeName。可以用這張表判斷：

範例：

1func ParsePort(raw string) (int, error) {
2    // 純資料轉換，適合普通函式
3}
4
5func (s *Server) Start() error {
6    // 啟動 Server，適合方法
7}

本章目標

學完本章後，你將能夠：

1. 用啟動流程理解 Go 應用結構
2. 看懂 channel 與元件之間的資料流
3. 理解 context.WithCancel 在關閉流程中的角色
4. 判斷新增功能應該接在哪個生命週期位置

【觀察】入口流程分成五段

入口程式的核心責任是揭露應用如何啟動，而不是承載所有實作細節。一個稍具規模的 main() 可以切成五個區塊：

這種切法讓入口同時保留完整脈絡，又不把所有實作細節塞進 main()。

【判讀】main() 的價值是揭露依賴關係

main() 的核心價值是讓依賴關係可見。Go 專案常把依賴直接組裝在 main()，好處是維護者能直接看到應用骨架：

1events := make(chan Event, 128)
2notifications := make(chan Notification, 128)
3
4repo := NewNotificationRepository()
5worker := NewWorker(repo, events, notifications)
6server := NewHTTPServer(repo, notifications)

這段程式揭露一個重要事實：repo 負責保存共享狀態，worker 負責處理背景事件，server 負責提供 HTTP 入口。資料如何流動，不需要先查框架設定就能看懂。

【策略】用生命週期判斷功能應該放哪裡

新增功能的核心判斷是：先確認它屬於哪一種生命週期，再決定接入位置。新增功能時，先判斷它屬於哪一種生命週期：

這個判斷可以避免把功能塞進錯誤元件，造成後續難測與難改。

【執行】完整啟動路徑

啟動路徑的核心用途是提供除錯地圖。一個有背景工作與 HTTP 介面的 Go 應用，啟動後的主要路徑可能如下：

 1main()
 2  ├─ setup logger / runtime
 3  ├─ create channels
 4  ├─ create repository / worker / server
 5  ├─ context.WithCancel()
 6  ├─ go worker.Run(ctx)
 7  ├─ go startPeriodicSync(ctx)
 8  ├─ go server.Run(ctx)
 9  ├─ register /health
10  ├─ register /ws
11  ├─ register /events
12  ├─ go waitForShutdown(cancel, ...)
13  └─ http.Server.ListenAndServe()

這份路徑也是除錯清單。當應用沒有產生預期輸出時，可以依序確認：輸入來源是否產生資料、worker 是否處理資料、對外介面是否有 client 或呼叫者、狀態資料是否被正確更新。

預計補充內容

這些工具使用邊界會在下列章節展開：

• Go 入門：從入口程式看應用啟動流程：先看 go run 與 go build 如何對應入口 package，才能理解 Go 專案真正的執行起點。
• Go 入門：testing 基礎：先建立最小回歸檢查的習慣，再談 go test ./... 在流程中的角色。
• Backend：可靠性驗證流程：CI 與自動化驗證的責任在這裡展開，不應塞進語言章節。
• Backend：部署平台與網路入口：容器建置、發布門檻與平台合約屬於部署層，不是 toolchain 本身。

與 Backend 教材的分工

本章只處理 Go toolchain。CI pipeline、container build、部署前 gate 與 release artifact 會放在 Backend：可靠性驗證流程 與 Backend：部署平台與網路入口。

和 Go 教材的關係

這一章承接的是入口流程、測試與設定讀取；如果你要先回看語言教材，可以讀：

• Go：從入口程式看應用啟動流程
• Go：testing 基礎
• Go：flag、os/env 與設定邊界
• Go：composition root 與依賴組裝