DEV Community: Pallat Anchaleechamaikorn

คุยกันเรื่อง Writing Better Go: Lessons from 10 Code Reviews

Pallat Anchaleechamaikorn — Fri, 09 Jan 2026 08:37:20 +0000

ใน reddit ของ r/golang มีการนำเอา Writing Better Go: Lessons from 10 Code Reviews ของ Konrad Reiche มาสรุปโดย Asleep-Actuary-4428 ที่นี่ ซึ่งสรุปได้เข้าใจง่าย เลยอยากเอามาเล่าต่อ
สามารถเปิดดู slide ต้นทางไปพร้อมๆกับการอธิบายแต่ละข้อได้เลย

Handle Errors
- อย่าทำเป็นเมิน error ไปแบบเงียบๆ (เช่นเอา _ ไปรับค่า error)
- อย่าคิดว่า error นี้รับได้เช่น if err != nil { return nil }
- ถ้าเจอ error ต้องตรวจสอบก่อนอย่างอื่นและจัดการมันเลย เช่น log ตอนนั้นเลย แล้ว error นั้นก็ถือซะว่าถูกจัดการไปแล้ว ก็ไม่ต้องส่งต่อให้คนอื่น
- อย่าโวยซ้ำ ถ้า log ไปรอบนึงแล้วยัง return ต่อให้คนอื่นไปโวยต่อ เขาก็เอาไป log อีก

bad	good
`if err != nil { slog.Error(err) return err }`	`if err != nil { slog.Error(err) return nil }`

ลดภาระให้ฝั่งที่เรียกใช้
- return result, nil แบบนี้ดีเพราะคืนผลลัพธ์และไม่มี error ให้สับสน
- return nil, err แบบนี้ก็ดีเพราะมี error ให้จัดการในขณะที่ไม่มีผลลัพธ์
- return nil, nil แบบนี้แย่ ถึงแม่ว่าจะไม่มี error แต่การไม่มีผลลัพธ์ส่งออกไป มันทำให้คนเรียกต้องไปตีความต่อ
- _return result, err _อันนี้ก็แย่ ไม่รู้ว่ามันจะต้อง error หรือว่าใช้ได้กันแน่ มันต้องไปตีความต่ออีกว่าจะเชื่อค่าไหน

ใส่ interface เร็วไป
- การใช้ interface แบบผิดๆเป็นภาพที่เห็นบ่อย เพราะมักจะเห็นการสร้าง interface ก่อนเลย (ซึ่งเป็นท่าที่อาจจะเอามาจากบางภาษาเช่น จาวา) หรือทำเพื่อให้ test เช่นทำเพื่อให้ mock ใน test เนื่องจากพอมันมาเร็วไป มันจะทำให้โค้ดอ่านยากขึ้นทันที
- อย่าเริ่มด้วย interface
- ให้ใช่ท่า accept interfaces, return concrete types หรือก็คือ สื่อสารกันผ่าน interface แต่ตอนคืนให้คืนด้วย type จริง
- ทุกอย่างให้เริ่มจากการใช้ type จริงไปก่อน จนกว่าโค้ดมันจะพาเราไปถึงจุดที่จะต้องใช้ interface จริงๆแล้วค่อยใช้
- Litmus Test: ถ้าเราไม่ใช้ interface แล้ว test ได้ ก็ไม่เห็นต้องใช้เลยนี่นา
- อย่าสร้าง interface เพียงเพื่อให้เทสได้เพียงอย่างเดียว อยากให้ลองเทสโดยไม่ต้องมีดูก่อน
Mutexes Before Channels
- เมื่อเริ่มใช้ channel โค้ดจะเริ่มซับซ้อนมาก ซึ่งมันสร้างโอกาสเสี่ยงที่จะเกิด panic ง่ายขึ้น เช่นเมื่อไปเผลอ close channel หรือส่งของเข้า channel ที่ closed ไปแล้ว หรืออาจเกิด deadlocks
- เริ่มด้วยวิธีง่ายๆ ไปทีละขั้น
- เริ่มจาก sync ก่อน อย่าเพิ่งรีบไป async
- ใส่ goroutine เมื่อ profiling แสดงให้เห็นคอขวดจริงๆก่อน
- ใช้ sync.Mutex และ sync.WaitGroup จัดการกับ shared state ดูก่อน
- Channel จะฉายแสงเมื่อต้องเล่นกับการจัดการที่มีความซับซ้อนจริงๆ ไม่ใช่เอามาใช้กับเรื่องเบบี๋ธรรมดา ไม่คุ้ม
Declare ทุกอย่างให้ใกล้กับจุดที่จะใช้ให้มากที่สุด
- นี่เป็นท่ามาตรฐานสำหรับการประกาศ constants, variables, functions and types
- ประกาศของเหล่านี้ไว้ในไฟล์ที่มีการใช้งานมันจริงๆ และ Export (ชื่อขึ้นด้วย CApital Letter) เมื่อมีความต้องการใช้งานจากนอก package จริงๆก่อน
- ในฟังก์ชั่นก็เช่นกัน ประกาศตัวแปรให้ใกล้จุดที่จะถูกใช้ให้มากที่สุด
- จำกันขอบเขตมันให้เล็กที่สุดเช่นทำ 1 statement ใน if
อย่าให้เกิด runtime panics
- ท่าง่ายสุดก็คือให้ตรวจสอบ input ที่เข้ามาจากภายนอกก่อนเอาไปใช้
- อย่าใช้ if x == nil ก็ในเมื่อคุณเป็นคนควบคุมการไหลของข้อมูลมาแล้ว ก็ให้เชื่อในการจัดการ error ในแต่ละจุดไปเลย
- ถ้าจะ dreference ค่า pointer เช่น *p = 10 จะต้อง check nil ก่อนเสมอ
- และการใช้ pointer ให้ปลอดภัยที่สุดก็คือ อย่าใช้มัน หมายถึงพยายามออกแบบให้ไม่ต้องใช้ pointer ให้ได้ก่อน
ใช้เว้นวรรคให้น้อย
- ก็คืออย่าห่อลอจิกหลายๆชั้นเช่น if ซ้อน if ซ้อน for
- อยากชวนให้ใช้ท่า Return Early, Flatter Structure ด้วยการจัดการ error ก่อน แล้วค่อยไปทำอย่างอื่น หรือกำจัดเงื่อนไขที่จะไม่ทำต่อก่อนเลย
หลีกเลี่ยงการตั้งชื่อไฟล์และแพ็กเก็จด้วยชื่อคลุมเครือ
- เช่น util.go, misc.go, constants.go หรือ interfaces/interfaces.go
- อยากให้สื่อความว่ามันมีไว้ทำไม มากกว่าจะบอกว่ามันอยู่ลำดับชั้นไหน
- โค้ดจะอ่านง่ายเมื่อมันอยู่ใกล้ๆกันกับอะไรที่มันเกี่ยวข้องกัน ไม่ใช่แยกกันไปคนละทิศ
- ตั้งชื่อ package ตามโดเมน หรืองานของมัน
- จัดกลุ่มตามความหมาย ไม่ใช่ตาม type เช่น ไปจัดกลุ่มของ controller แบบนี้ไม่เอา
เรียงลำดับ declarations ตามลำดับความสำคัญ
- ใน Go มันช่วยให้อ่านง่ายขึ้น
- โค้ดไหนสำคัญ เอาขึ้นด้านบนเลย
- เช่นพวกที่ต้อง exported หรือ ฟังก์ชั่นที่เป็น API-facing เอาขึ้นข้างบนก่อน
- ตามด้วยพวก helper function พวกนี้มันจะช่วยอธิบายของข้างบน
- เรียงตามความสำคัญ ไม่ใช่ตามความสัมพันธ์ เพื่อให้คนที่มาอ่าน ลำดับความสำคัญจากมากลงมา
ตั้งชื่อให้ดี
หลีกเลี่ยงการเอา type มาเติมท้ายชื่อ (เช่น userMap, idStr, injectFn) ชื่อตัวแปรควรบอกว่ามันเก็บอะไร ไม่ใช่บอกว่ามัน type อะไร
ความยาวของชื่อควรสอดคล้องกับ scope เช่นถ้าตั้งชื่อด้วยอักษรเดียว scope มันควรจะสั้น ไม่ใช่ประกาศ global ด้วยชื่อตัวเดียว อายเค้านะ
ทำ Document เพื่อตอบคำถามว่ามีไว้ทำไม ไม่ใช่แค่ว่ามันทำอะไรได้
- ให้เหตุผลว่ามันมีไว้ทำไม ทำไมต้องใช้มัน
- เวลาเขียน comment ควรสื่อถึงจุดประสงค์หรือประโยชน์ ไม่งั้นก็เหมือนเขียนโค้ดซ้ำธรรมดา
- Document คือเจตนา ไม่ใช่วิธีการ
- คนที่มาอ่านภายหลัง ควรที่จะเข้าใจแรงจูงใจที่คุณทำสิ่งนี้ออกมา เพราะเขาอ่านโค้ดก็รู้ว่ามันทำอะไร แต่ไม่รู้ว่าทำไมต้องทำแบบนี้

gopls MCP in vscode

Pallat Anchaleechamaikorn — Mon, 08 Sep 2025 03:15:21 +0000

พอดีไปเจอ blog นี้ How to use gopls MCP with VS Code เห็นว่าน่าสนใจเลยเอามาทดลองทำดู เลยอยากมาอธิบายซ้ำอีกรอบ

ก่อนอื่นเลย gopls อ่านว่า "Go please" เป็น Language Server ที่พัฒนาโดย Go team มีหน้าที่เป็นตัวช่วย IDE ให้ช่วยตรวจสอบโค้ดที่เขียนด้วย Go ซึ่งถ้าเราใช้ vscode เวลาที่เราติดตั้ง Go extension มันก็จะขอให้เราติดตั้ง gopls ด้วย โดยในเวอร์ชั่นที่ v0.20.0 ก็ได้รวมเอา MCP server เข้ามา ซึ่งสามารถไปอ่าน doc ได้ที่ Gopls: Model Context Protocol support

ทีนี้เราก็จะมาทำให้ feature นี้สามารถทำงานบน vscode ได้ด้วย โดยขั้นตอนแรก จะต้องทำให้เครื่องเรามี gopls ตัวล่าสุดเสียก่อน โดยที่ถ้าเราจะติดตั้งเองก็สามารถทำได้ด้วยคำสั่ง

go install golang.org/x/tools/gopls@latest

หรือไปสั่งใน vscode ก็ได้ ด้วยการเปิด command palette (command + shift + p) เลือก Go: Install/Update Tools เลือก gopls@latest

จากนั้นเราจะไปเพิ่ม flag ให้กับ gopls ใน vscode settings กัน โดยให้เราไปเปิด Settings แล้วเลือกเป็นแบบแก้ json file ตรงๆ

    "go.useLanguageServer": true,
    "go.languageServerFlags": [
        "-mcp.listen=localhost:8092"
    ],

เราเพิ่ม flag นี้ "-mcp.listen=localhost:8092" เข้าไป

ขั้นตอนต่อมาเราก็ต้องไปเพิ่ม MCP Server ด้วยการไปที่ command palette (command + shift + p) อีกครั้ง แล้วเลือก MCP: Add Server... เลือก HTTP (HTTP or Server-Sent Events) แล้วใส่ URL ของ mcp เข้าไปแบบนี้ http://localhost:8092

จากนั้นไปทดลองใช้งานกันได้เลย ด้วยการทดลองเขียนโค้ด

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}

แล้วไปเปิด Chat แล้วเราก็บอกให้มันวิเคราะห์ไฟล์นี้ให้หน่อย เช่น

"Run diagnostics on this file"
"diagnose this file"
หรือ "ตรวจไฟล์นี้"

โดยผมทดลองด้วย model หลายตัว ตัวที่แนะนำได้เหมือนตัวอย่างมากสุดผมใช้ Gemini 2.5 Pro (ลองเมื่อวันที่ 8 Sep 2025 นะครับ)
มันจะวิเคราะห์ให้และแนะนำให้แก้ไขตามนี้

ที่ต้นทางของบทความนี้เขาทำ instruction ให้ github ไว้ด้วย ถ้าใครสนใจลองไปตามดูที่ต้นทางได้นะครับ หวังว่าจะเป็นประโยชน์

omitzero

Pallat Anchaleechamaikorn — Tue, 11 Feb 2025 23:44:48 +0000

จากที่เคยสัญญาไว้ว่าจะมาเขียนเรื่อง feature ใหม่ใน Go1.24.0 อันนึงที่ชื่อ omitzero ที่จะมาให้ใช้กับ package encoding/json โดยถ้าใครเคยใช้ omitempty มาก่อน ก็จะมีวิธีใช้งานเหมือนกัน และเพื่อให้เข้าใจง่าย เรามาเขียนโค้ดทดสอบง่ายๆกันก่อน
ตัวอย่างแรก จะเป็นการสร้าง struct ขึ้นมาตัวหนึ่งหน้าตาแบบนี้

type User struct {
    Name        string
    Title       *string
    DateOfBirth time.Time
    Children    int
}

แล้วก็มาเขียนโค้ดง่ายๆเพื่อสร้าง json message จาก struct นี้ โดยเราจะกำหนดค่าให้แค่ field เดียว

func main() {
    u := User{Name: "Pallat"}
    b, err := json.MarshalIndent(u, " ", " ")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(b))
}

แล้วทดลองรันด้วยคำสั่ง go run main.go จะเห็นผลลัพธ์แบบนี้

{
  "Name": "Pallat",
  "Title": null,
  "DateOfBirth": "0001-01-01T00:00:00Z",
  "Children": 0
 }

เราจะเห็นว่า บางค่าที่เราไม่ได้กำหนดค่าให้ แต่เมื่อเราสร้าง json message ออกมา เรากลับได้เห็น message ของ field นั้นพร้อมค่าบางอย่างเช่น Title เป็นค่า null เนื่องจาก type ของมันเป็น *string ซึ่งพอเป็น pointer มันก็จะแสดงคำว่า null ออกมา และพฤติกรรมนี้แหล่ะ ที่แต่เดิม ถ้าเราไม่ต้องการจะเห็นมัน เราก็จะติด tag คำว่า omitempty เข้าไป โดยเราจะมาทดลองติด tag นี้ให้กับทุกๆ field ดูกัน

type User struct {
    Name        string    `json:"name,omitempty"`
    Title       *string   `json:"title,omitempty"`
    DateOfBirth time.Time `json:"dob,omitempty"`
    Children    int       `json:"children,omitempty"`
}

ส่วนโค้ดเราก็จะเปลี่ยนเอาค่า Name ออกไปด้วยเลย จะได้เห็นพฤติกรรมของ string และ *string ด้วย

func main() {
    u := User{}
    b, err := json.MarshalIndent(u, " ", " ")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(b))
}

ผลลัพธ์ที่ได้จะเป็นแบบนี้

{
  "dob": "0001-01-01T00:00:00Z"
}

หมายความว่าโดยปกติ แม้แต่ basic type ถ้ามันมีค่าเป็น zero value เพียงแค่เราติด tag omitempty เข้าไป เวลาที่ Marshal ออกมามันจะ omitted ค่าใน field นั้นให้เลย ซึ่งเดิม เราก็จะมาติดปัญหาตรง type ที่มันมีโครงสร้างเช่น time.Time นี่แหล่ะที่ต่อให้เราติด omitempty เข้าไปแล้ว เราก็จะยังเห็นค่าแบบนี้อยู่ดี ทีนี้เราจะลองมาติด tag omitzero เข้าไปเพิ่มดูแบบนี้

type User struct {
    Name        string    `json:"name,omitempty"`
    Title       *string   `json:"title,omitempty"`
    DateOfBirth time.Time `json:"dob,omitempty,omitzero"`
    Children    int       `json:"children,omitempty"`
}

แล้วเรารันโค้ดชุดเดิม ผลลัพธ์จะกลายเป็น

{}

ส่วนตัวผมคิดว่าบางอย่างอาจจะไม่ได้เป็นไปตาม document ยกตัวอย่างเช่นค่า int ที่ถ้าเราไม่กำหนดค่าให้ แล้วโดยปกติมันจะมี zero value เป็น 0 การติด omitempty มันไม่ควรทำให้ค่านี้หายไป แต่ตอนนี้ถ้าเราทดลองดูก็จะเห็นว่ามันหายไปด้วยแล้ว
แต่ก็ไม่เป็นปัญหา ถ้าเราอยากเห็นเลย 0 เราก็เอา tag ออกก็ใช้ได้

ส่วนที่ doc พยายามอธิบายคือ ถ้าเราติด omitempty มันจะดูที่ตัว message ของ json ว่าถ้าค่าที่ได้มาได้ค่่าเช่น null หรือ string, object หรือ array ที่ว่างเปล่า มันจะ omitted ให้

ส่วน omitzero จะมีผลกับค่า zero value ของ Go เอง เช่น time.Time ที่เราไม่ได้กำหนดค่าให้มัน มันจะ omitted ให้ และจะมีผลกับค่าที่มเมธอด IsZero() bool ด้วยเช่นกัน

ทีนี้เราลองทดลองค่าที่เป็น int กันดูว่า ถ้าเรามีเงื่อนไขให้มันเช่น ถ้าค่าที่ได้มีค่าตั้งแต่ 0 ขึ้นไป เราจะแสดงค่าเหล่านั้นออกมาใน json message และในทางกลับกันถ้าได้ค่าติดลบใดใดเราจะ omitted มัน

type User struct {
    Name        string    `json:"name,omitempty"`
    Title       *string   `json:"title,omitempty"`
    DateOfBirth time.Time `json:"dob,omitempty,omitzero"`
    Children    Int       `json:"children,omitzero"`
}

type Int int

func (i Int) IsZero() bool {
    return i < 0
}

โดยเราสร้าง type ใหม่ที่ชื่อ Int และเอาไปใช้กับ field ชื่อ Children โดยเราใส่เงื่อนไขใน IsZero ว่าถ้าค่าน้อยกว่า 0 จะคืนค่า false ออกมา
แล้วเปลี่ยน tag เป็น omitzero ดู จากนั้นเราก็รันโค้ดชุดเดิม ก็จะได้ผลลัพธ์แบบนี้

{
  "children": 0
}

เอาละครับ หลักๆแล้ว เราก็ได้ของที่อำนวยความสะดวกมาให้เราเพิ่มอย่างหนึ่ง อย่างน้อยเวลาเราจะต้องสร้าง json message ที่มี type ซับซ้อน เราก็ยังมีตัวช่วยให้ชีวิตง่ายขึ้นมาอีกหน่อย แต่เพื่อความชัวร์ เวลาเขียนก็ลองทดสอบพฤติกรรมมันให้มั่นใจดูก่อนนะครับ หวังว่าจะเป็นประโยชน์

htmx handle array response

Pallat Anchaleechamaikorn — Tue, 15 Oct 2024 08:21:19 +0000

จากคราวก่อนที่เราสามารถรับ json response มาแสดงผลใน html ได้แล้ว แต่ถ้าเกิดว่า response นั้นส่งกลับมาเป็น array ล่ะ เราจะจัดการมันแบบไหนดี เรามาดูตัวอย่างกัน

index.html

<script src="https://unpkg.com/htmx.org@2.0.3"></script>
<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/json-enc.js"></script>
<script src="https://unpkg.com/htmx-ext-client-side-templates@2.0.0/client-side-templates.js"></script>
<script src="https://unpkg.com/mustache@latest"></script>

<div hx-ext="client-side-templates">
    <form hx-post="/api" hx-swap="innerHTML" hx-target="#content" hx-ext="json-enc" mustache-array-template="mytemplate">
        <div><textarea placeholder="Leave a comment here" name="message" id="message"></textarea></div>
        <div><input type="text" name="name" id="name" placeholder="name" required></div>
        <button type="submit">Submit</button>
    </form>

    <div id="content">replace here</div>

    <template id="mytemplate">
        {{#data}}
        <div>
            <p> {{message}} {{name}}</p>
        </div>
        {{/data}}
    </template>
</div>

main.go

package main

import (
    "encoding/json"
    "io"
    "log"
    "net/http"
)

func main() {
    fs := http.FileServer(http.Dir("./"))
    http.Handle("/", fs)

    http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
        _, err := io.ReadAll(r.Body)
        if err != nil {
            log.Fatal(err)
        }
        r.Body.Close()

        json.NewEncoder(w).Encode([]map[string]string{
            {
                "message": "test message #1",
                "name":    "test name #1",
            },
            {
                "message": "test message #2",
                "name":    "test name #2",
            },
        })
    })

    http.ListenAndServe(":8910", nil)
}

จากตัวอย่างนี้ เราแก้ให้ API คืน response ออกมาเป็น array 2 records
ส่วนที่ html เราใช้ htmx เหมือนตอนที่เรารับ json object ปกติเลย
สิ่งที่ต่างไปจากเดิมก็คือ mustache-template="mytemplate" เป็น mustache-array-template="mytemplate"

แล้วที่ template ให้ใส่ {{#data}} ครอบแล้วปิดด้วย {{/data}}

{{#data}}
  <!-- fields -->
{{/data}}

นอกนั้นก็จัดรูปแบบไว้ มันจะ repeat ของใน array ไปจนกว่าจะหมด

ถึงตอนนี้ เราก็น่าจะใช้ htmx จัดการ request/response ในรูปแบบ json เบื้องต้นได้ค่อนข้างครอบคลุมแล้วนะครับ หวังว่าจะเป็นประโยชน์

htmx handle json response

Pallat Anchaleechamaikorn — Tue, 15 Oct 2024 08:09:27 +0000

คราวนี้เราจะลองมาดูวิธีการรับ json response ที่เราได้รับมาจาก API เพื่อมาแสดงผลที่หน้าจอเราแบบง่ายๆกันดู โดยเราจะนำโค้ดจากครั้งที่แล้วมาเติมของให้ดูแบบนี้

index.html

<script src="https://unpkg.com/htmx.org@2.0.3"></script>
<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/json-enc.js"></script>
<script src="https://unpkg.com/htmx-ext-client-side-templates@2.0.0/client-side-templates.js"></script>
<script src="https://unpkg.com/mustache@latest"></script>

<div hx-ext="client-side-templates">
    <form hx-post="/api" hx-swap="innerHTML" hx-target="#content" hx-ext="json-enc" mustache-template="mytemplate">
        <div><textarea placeholder="Leave a comment here" name="message" id="message"></textarea></div>
        <div><input type="text" name="name" id="name" placeholder="name" required></div>
        <button type="submit">Submit</button>
    </form>

    <div id="content">replace here</div>

    <template id="mytemplate">
        <p> {{message}} {{name}}</p>
    </template>
</div>

จากนั้นไปดู API แบบง่ายๆเพื่อทำการทดสอบกัน

main.go

package main

import (
    "encoding/json"
    "io"
    "log"
    "net/http"
)

func main() {
    fs := http.FileServer(http.Dir("./"))
    http.Handle("/", fs)

    http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
        _, err := io.ReadAll(r.Body)
        if err != nil {
            log.Fatal(err)
        }
        r.Body.Close()

        json.NewEncoder(w).Encode(map[string]string{
            "message": "test message",
            "name":    "test name",
        })
    })

    http.ListenAndServe(":8910", nil)
}

หน้าที่ของ API มีเพียงการรับ request เข้ามาแล้วตอบ json message ออกไปง่ายๆ โดยหน้าตาของ response จะเป็นแบบนี้

{
  "message": "test message",
  "name": "test name"
}

ทีนี้เรามาดูตอนรับไปแสดงผล ก่อนอื่นเราต้อง include ตัว extension เข้ามาก่อน 2 ตัวนี้

<script src="https://unpkg.com/htmx-ext-client-side-templates@2.0.0/client-side-templates.js"></script>
<script src="https://unpkg.com/mustache@latest"></script>

จากนั้นให้ครอบตั้งแต่ form ไปจนถึง target id และ template ด้วย

<div hx-ext="client-side-templates">...</div>

เพื่อเป็นการบอกว่าเราต้องการจะ render ด้วย client-side-templates

ที่ form เราระบุ mustache-template="mytemplate" เพื่อบอกว่า response ที่ได้ เราจะใช้ mustache-template เป็น template ในการแสดงผล

จากนั้นใน template เราสามารถระบุชื่อ field ที่ได้จาก response แบบนี้

{{message}} หมายถึง field ที่ชื่อ message จาก response เลยเป็นต้น

เพียงเท่านี้เราก็สามารถนำ response date มาแสดงผลตามที่เราต้องการได้แล้วครับ

htmx post json

Pallat Anchaleechamaikorn — Tue, 15 Oct 2024 07:43:09 +0000

ต่อจากคราวที่แล้วที่เราพาไปทำความรู้จัก htmx แบบเร็วๆ มาคราวนี้จะพามาดูวิธีส่ง json request ไปให้ API ซึ่ง htmx อย่างเดียวจะไม่เพียงพอต่อการทำงานนี้ละ เราเลยจะต้องใช้ตัวช่วย โดย htmx จะเตรียมบรรดาเหล่า extensions ไว้ให้เราใช้อยู่ด้วย ไปดูได้จาก link นี้

โดยตัวที่เราจะหยิบมาใช้ตอนนี้ก็คือ json-enc โดยหน้าที่ของมันก็คือ เวลาเราต้องการจะยิง request ไปหา API สักตัว โดยจะส่งข้อมูลไปให้อยู่ในรูปแบบของ json เราก็จะใช้วิธีสร้าง form ขึ้นมาชุดหนึ่ง เวลาที่เราใช้ json-enc มันจะทำการ serialize ของใน form ไปอยู่ในรูปแบบของ json ให้เอง เรามาดูวิธีทำกันเลย

index.html

<script src="https://unpkg.com/htmx.org@2.0.3"></script>
<script src="https://unpkg.com/htmx.org@1.9.12/dist/ext/json-enc.js"></script>

<form hx-post="/api" hx-swap="innerHTML" hx-target="#content" hx-ext="json-enc">
    <div><textarea placeholder="Leave a comment here" name="message" id="message"></textarea></div>
    <div><input type="text" name="name" id="name" placeholder="name" required></div>
    <button type="submit">Submit</button>
</form>

<div id="content">replace here</div>

นี่คือในส่วนของ html ซึ่งจะสามารถส่ง request ไปให้ api ได้แล้ว ต่อมาเราจะมาเขียน API แบบง่ายสุดๆด้วย Go ตามนี่ครับ

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
)

func main() {
    fs := http.FileServer(http.Dir("./"))
    http.Handle("/", fs)

    http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
        b, err := io.ReadAll(r.Body)
        if err != nil {
            log.Fatal(err)
        }
        r.Body.Close()

        fmt.Println(string(b))
    })

    http.ListenAndServe(":8910", nil)
}

เมื่อเขียนเสร็จ เราจะรันมันด้วยกันผ่าน go ด้วยคำสั่งนี้ครับ

go run main.go

ทีนี้เราจะไปเปิดหน้า web ผ่าน url ใหม่ http://localhost:8910/

พอเราทดลองกด submit แล้วไปดูที่ console ที่เรารัน go run main.go เอาไว้ เราก็จะเห็น log ที่มีหน้าตาแบบนี้

{"message":"sss","name":"ddd"}

สิ่งที่ต้องไม่ลืมคือการนำ extension เข้ามาใช้ ตามตัวอย่างเราใช้ CDN ใน script
ถ้าเราลืม extension สิ่งที่เราจะได้ก็จะกลายเป็น request ลักษณะแบบ form แทนแบบนี้

message=sss&name=ddd

จากตัวอย่างข้างต้นนี้ เราก็จะสามารถใช้ htmx ทำการส่ง request ในรูปแบบ json ได้แล้ว

htmx in 5 minutes

Pallat Anchaleechamaikorn — Tue, 15 Oct 2024 03:42:00 +0000

</> htmx เป็น library ที่ช่วยให้เราสามารถใช้ AJAX, CSS Transitions, WebSockets และ SSE ได้โดยตรงผ่าน HTML

ถ้าให้เล่าแบบง่ายๆก็คือ แทนที่เราจะไปเขียน Framework อย่าง ReactJS, Vue หรือ Angular เราสามารถทำงานง่ายๆผ่านการใช้ htmx ซึ่งส่วนใหญ่จะเขียนในรูป html, js และ css อย่างละนิดอย่างละหน่อย ยกตัวอย่างเช่น ถ้าเราต้องการจะให้หน้า web ไปยิง API สักเส้น แล้วรับค่า json กลับมาแสดง ก็สามารถทำได้

ผมจะลองยกตัวอย่างการใช้งานง่ายๆที่ทุกคนน่าจะทำตามได้
เริ่มจากการสร้างไฟล์มา 2 files

index.html
hello.html

index.html

<script src="https://unpkg.com/htmx.org@2.0.3"></script>
<button hx-get="/hello.html" hx-swap="outerHTML" hx-target="#content">
    Click Me
</button>

<div id="content">replace here</div>

hello.html

<div id="content">
Hello
</div

ที่เหลือก็ลองทดสอบ โดยผมจะใช้ Live Server นะครับ ใครติดตั้งแล้วก็เปิด Command Palette แล้วเลือก Live Server: Open with Live Server

โดยปกติมันก็จะเปิด browser ขึ้นมาให้เราเลยที่ 127.0.0.1:5500/index.html

เราก็จะเห็นปุ่มแบบนี้

ทดลองกดปุ่ม Click Me ก็จะเห็นข้อความ Hello มาแทน replace here

โดยเมื่อดูจากโค้ดที่เราเขียนมันเริ่มจากการ include ตัว htmx script เข้ามาก่อน ทีนี้ใน tag button เราเพิ่ม hx-get เข้าไปเพื่อบอกมันว่า เมื่อกดปุ่มให้ไปเรียก http request หาอะไร โดยในที่นี้เราเอาง่ายสุด แทนที่จะไปยิง API เราก็แค่เรียกไปที่ html ตัวหนึ่ง

hx-swap ตัวนี้เราบอกมันว่า เมื่อได้ผลลัพธ์มาแล้ว จะให้ไปสลับตำแหน่งกับจุดหมายปลายทางแบบไหน โดยเราใส่ไปว่า outerHTML หมายความว่า id ปลายทางทั้งก้อนจะถูกแทนที่ด้วย response เลย และสุดท้าย
hx-target ก็คือ id ปลายทางที่่เราจะเอา response ไปแสดงนั่นเอง

ทีนี้ ถ้าเรามาลองแก้ hx-swap เป็น innerHTML ดู มันจะเปลี่ยนเป็นการนำเอา response มาแทนที่ของที่อยู่ใน id ปลายทาง โดยที่ tag ของ id ปลายทางจะยังคงอยู่
เราก็ลองไปเปลี่ยนไฟล์ hello.html อีกนิด โดยไปลบ html tag ออก ให้เหลือแค่ข้อความอย่างเดียว แล้วทดลองใหม่ ก็จะเห็นว่ามันก็แสดงผลเหมือนเดิม

การใช้งานนี้เป็นแบบเริ่มต้น เดี๋ยวคราวหน้าเราจะมาลองยิง API แล้วรับส่งข้อมูลแบบ json กันดูครับ

Makefile ep.1

Pallat Anchaleechamaikorn — Sun, 08 Sep 2024 03:54:21 +0000

เนื่องจากที่ผ่านมาเวลาทำ code repo ส่วนใหญ่ก็มักจะเขียน Makefile ใส่เข้าไปด้วย เพื่ออำนวยความสะดวก และอีกเหตุผลหนึ่งคือ คำสั่งบางอย่างมันยาว ก็เลยเขียนใส่ Makefile เอาไว้ เพราะขี้เกียจไปตาม googling มาใหม่นั่นเองครับ ที่มาที่ไปของการใช้ Makefile ของผมก็เป็นเช่นนี้ และไหนๆก็ใช้บ่อยแล้ว น้องๆหลายคนอาจจะเคยเข้ามาเห็นอยู่บ้าง ใช้เป็นบ้างก็ตามๆพี่ๆไป ก็เลยคิดว่า เอามาอธิบายจริงจังให้เข้าใจกันสักยกก็น่าจะดี

โดยเนื้อหาหลักตอนนี้จะเริ่มด้วยการพาไปรู้จักวิธีใช้ตามคู่มือของ GNU make manual

รูปแบบการเขียน Makefile

target … : prerequisites …
        recipe
        …
        …

จากที่เห็นนี้อธิบายว่า target คือชื่อของคำสั่ง เวลาที่เราใช้คำสั่ง make ผมจะยกตัวอย่างจริงให้ดูเพื่อเทียบกันตามนี้นะ

start:
    echo "Hello"
show: start
    echo "Welcome to the Makefile tutorial"

ในที่นี้ target ของเราคือคำว่า start และ show ซึ่งเวลาที่เราอยากจะสั่งให้มันไปทำงานที่ target ชื่อ start เราก็จะสั่งว่า make start แบบนี้นะครับ

prerequisites จากตัวอย่าง target show ผมเขียนให้มันมี prerequisites เป็น start หมายความว่า ถ้าเราสั่งคำสั่ง make show สิ่งที่เกิดขึ้นคือ มันจะไปทำคำสั่ง make start ให้เราก่อน เสร็จแล้วมันถึงจะมาทำตาม recipe ที่อยู่ใน show ต่อ
ซึ่งในที่นี้ recipe ของทั้ง 2 target เราทำเพียงแค่สั่ง echo ให้มันแสดงข้อความออกมาง่ายๆเท่านั้น

การตั้งชื่อไฟล์ของ Makefile เราสามารถตั้งว่า Makefile ก็ได้หรือ makefile ก็ได้เช่นกัน แต่ส่วนตัวผมชอบตั้งว่า Makefile มากกว่า ซึ่งถ้าอ่าน doc ก็จะแนะนำแบบเดียวกันครับ

recipe เราได้เห็นจากตัวอย่างนะครับว่า recipe ในตัวอย่างจะเป็นแบบโคตรง่ายเลย ก็คือสั่ง echo หรือก็คือสั่งพิมพ์ข้อความออกมาให้เราเห็นง่ายๆ สิ่งสำคัญของการวาง recipe ก็มีเพียง เราจะต้องมี indent และต้องเป็น tab เท่านั้น จะมา space ไม่ได้นะ

ทีนี้เราก็จะสามารถเริ่มต้นเขียน Makefile เบื้องต้นง่ายๆเราได้แล้ว โดยเราจะเอาไปสั่งทำอะไรก็ได้ยกตัวอย่างเช่น

go:
    echo "run Go program"
    go run main.go
install:
    echo "install nodejs dependencies"
    npm install

หวังว่าจะเป็นประโยชน์นะครับ

จัดการ Go dependencies tools ด้วย Go mod

Pallat Anchaleechamaikorn — Sat, 07 Sep 2024 02:33:59 +0000

พอดีว่าไปเจอ repo หนึ่ง https://github.com/golang-templates/seed เขามีวิธีจัดการ tools ที่เขาใช้ในการ dev Go ผ่าน Go Module ซึ่งดูแล้วน่าสนใจเลยเอามาเล่าให้ฟัง

จาก repo นี้เขาใช้วิธีสร้าง go module ซ้อนไว้ใน project อีกชั้นหนึ่งแบบนี้

./
├── go.mod
├── go.sum
├── main.go
├── tools
│   ├── go.mod
│   ├── go.sum
│   └── tools.go

แล้วเขียน Makefile กำกับไว้แบนี้

.PHONY: inst
inst: ## go install tools
    cd tools && go install $(shell cd tools && go list -e -f '{{ join .Imports " " }}' -tags=tools)

เขาเขียนไว้ว่า ถ้ารันคำสั่ง make inst มันจะ cd เข้าไปใน tools แล้วสั่ง go install ของที่อยู่ใน import ลงมา
ซึ่งมันเวิร์คโดยเฉพาะกับ tools ต่างๆที่เขียนด้วย Go เหมือนกัน เช่น govulncheck หรือ golangci-lint เป็นต้น แต่ถ้าเป็นพวก tools ที่เขียนด้วยภาษาอื่น อันนี้ทำไม่ได้แน่นอน

จากที่ทดลอง มันติดอยู่อย่างหนึ่ง ถ้าเราเขียน repo แบบนี้ แล้วตั้งใจอยากจะทำเป็น template ให้คนอื่นมาสั่ง gonew ไปใช้ต่อ มันจะไม่สามารถเอา /tools ติดไปด้วยได้ แต่ก็เป็นแนวทางที่น่าสนใจดี สำหรับการนำไปใช้กับโปรเจคทั่วไปครับ

เขียน Go ให้เรียบง่าย บางทีก็ยาก

Pallat Anchaleechamaikorn — Tue, 03 Sep 2024 09:58:07 +0000

ช่วงนี้ผมกำลังพยายามทำ example repo ให้น้องๆในที่ทำงานดูเป็นตัวอย่าง โดยแนวคิดแรกเลยก็คือ simplify

แต่การจะ simplify สำหรับคนบางกลุ่ม มันจะยากมาก ก.ไก่หลายตัว เพราะมันจะขัดความรู้สึกเขา และเขารู้สึกว่า การทำแบบนั้นมันบาป ผิดศีลทุกข้อที่เคยปฏิบัติมาอย่างเคร่งครัด
ผมรู้ได้ไง ก็เพราะคำถามที่เขาตั้ง หลายๆคน หลายๆครั้ง จะตั้งคำถามคล้ายๆกันเช่น

พี่ครับ แล้ว repository ผมจะเขียนยังไง
พี่ครับ repository ผมจะวางไว้ตรงไหน
พี่ครับ ถ้ามี service 2 ตัวผมจะสร้าง interface ยังไง
พี่ครับ ถ้าผมเขียนแบบนี้แล้ว ชั้นของ adapter ผมจะเอาไปวางไว้ที่ไหน

คำถามพวกนี้มันทำให้ผมรู้สึกถึงความเจ็บปวดของเขาได้จริงๆ ผมไม่รู้จะตอบเขายังไงดีว่า ลูกเอ้ย เราไม่ได้อยู่กับพระเจ้าแล้วนะลูก ตอนนี้เราขายวิญญาณให้ซาตานเป็นที่เรียบร้อยแล้ว และตอนนี้เจ้ากำลังอยู่ในนรกนะงี้

ผมยกตัวอย่าง handler มาให้ดูสักตัวหนึ่ง

func (handler *B2CHandler) Order(c *gin.Context) {
    var req B2C
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, app.Response{
            Message: err.Error(),
        })
        return
    }

    if err := handler.payment.MakeOrder(); err != nil {
        c.JSON(http.StatusInternalServerError, app.Response{
            Code:    5001,
            Message: err.Error(),
        })
        return
    }

    c.JSON(http.StatusOK, app.Response{
        Data: Response{},
    })
}

ตัวอย่างนี้เป็นตัวอย่างสมมุตินะครับ มันไม่สมบูรณ์ โดยในนี้มีเรียก payment interface อยู่ตัวหนึ่ง ซึ่งผมเขียนทุกอย่างอยู่ใน pacakge เดียวกัน

ครับ มาถึงตรงนี้ คนที่รู้สึกว่าบาป ก็จะเห็นแล้ว ส่วนคนที่ไม่รู้สึกอะไร เรามากอดคอกัน 555

ความรู้สึกบาปนี้ ผมบอกได้แค่ว่า เราจะต้องวางสิ่งที่ทำให้เรารู้สึกบาปไว้ข้างๆตัวก่อน ไว้เขียน Go จบแล้ว เวลาจะไปเขียนภาษาอื่นค่อยเอามาสวมไว้เหมือนเดิม มันจะพอช่วยเราได้บ้าง อย่าไปเครียด เดี๋ยวมันจะดีเอง

มันจะไม่มีคำที่เราคุ้นๆเช่น service, repository, model และผองเพื่อนอยู่ในนี้เลย ซึ่งผมจะบอกให้ว่า มันทำงานได้นะ ไม่ต้องมีคำพวกนั้นมันก็ทำงานได้ ขอให้มั่นใจในสิ่งที่เขียน ไม่ต้องมีสิ่งศักสิทธิ์เหล่านั้นมันก็อยู่ได้ครับจริงๆ

range-over-func in Go

Pallat Anchaleechamaikorn — Sun, 18 Aug 2024 11:07:09 +0000

Go1.23 ได้นำฟีเจอร์ range-over-func ที่เป็น experiment ใน go1.22 มาให้ใช้จริง ซึ่งถ้าใครได้อ่านโค้ดตัวอย่างเข้าไปแล้วอาจจะต้องนั่งสมาธิกันนานหน่อย อย่ากระนั้นเลย พี่ยอดจะมาอธิบายแบบง่ายสุดๆให้อ่านกัน

เริ่มจาก spec ของ For statements with range clause ได้เพิ่มเติม Expression เข้ามา 3 แบบคือ

func(func() bool)
func(func(V) bool)
func(func(K, V) bool)

โดยพี่จะขอเพิ่มตัวแปรให้ตัวนึงเพิ่อจะได้อธิบายดังนี้

f func(yield func() bool)
f func(yield func(V) bool)
f func(yield func(K, V) bool)

ใน spec บอกว่า เมื่อเราใช้ฟังก์ชั่น f ไปเป็น expression ใน range ทุกครั้งที่เราเรียกฟังก์ชั่น yield ในนั้นก่อนจะจบฟังก์ชั่น f เราจะได้ผลลัพธ์ในแต่ละลูป เท่ากับค่าที่เราใส่เข้าไปใน yield อธิบายแล้วก็ยังงง เขียนโค้ดเลยดีกว่า

func main() {
    for range loop {
        fmt.Println("-")
    }
}

func loop(yield func() bool) {
    yield()
    yield()
}

output:

-
-

ถ้าเราเขียนโค้ดแบบนี้ เราจะได้ loop 2 รอบถ้วน เพราะเราเรียก yield 2 ครั้งใน f ตาม spec ซึ่งในที่นี่เราตั้งชื่อว่า loop และมันจะไม่คืนค่าอะไรออกมาให้เรา เพราะเราเลือกใช้ pattern ที่ yield ไม่รับ arguments ใดๆเลย

อีกตัวอย่าง

func main() {
    for i := range loop {
        fmt.Println(i)
    }
}

func loop(yield func(int) bool) {
    yield(3)
    yield(7)
}

output:

3
7

แบบนี้เราจะได้ 2 รอบเหมือนกัน เพราะเราเรียก yield ครั้ง และทีนี้ range จะคืนค่ามาให้ 2 ค่า ซึ่งก็คือ 3 และ 7 ที่เราใช้เรียก yield ในแต่ละครั้ง

อีกตัวอย่าง

func main() {
    for k, v := range loop {
        fmt.Println(k, v)
    }
}

func loop(yield func(int, string) bool) {
    yield(3, "three")
    yield(5, "five")
    yield(7, "seven")
}

output:

3 three
5 five
7 seven

เราก็จะได้ loop 3 รอบ และได้ค่าออกมารอบละ 2 ค่าตามที่เราใส่ให้ yield ในแต่ละครั้ง
และเรายังสามารถเรียก yield ด้วยการใส่ arguments แบบไหนก็ได้เช่น

func loop(yield func(string, bool) bool) {
    yield("three", true)
    yield("five", false)
    yield("seven", false)
}

ทีนี้พอเราเข้าใจกลไกลของมันแล้ว เวลาเราไปอ่านตัวอย่างยากๆเราจะเข้าใจมากขึ้นเช่นตัวอย่างใน Go Wiki: Rangefunc Experiment

package slices

func Backward[E any](s []E) func(func(int, E) bool) {
    return func(yield func(int, E) bool) {
        for i := len(s)-1; i >= 0; i-- {
            if !yield(i, s[i]) {
                return
            }
        }
    }
}

main

s := []string{"hello", "world"}
for i, x := range slices.Backward(s) {
    fmt.Println(i, x)
}

อ่านง่ายขึ้นเลยใช่ไหม สุดท้ายจะเอาไปประยุกต์ยังไงก็แล้วแต่ เราดูแค่ตอนที่เรียก yield ว่าเรียกกี่รอบ ก็จะได้เท่านั้นรอบตอนเอาไปใส่ใน range
ส่วนค่าที่จะได้ออกมาก็คือค่าที่หย่อนลงไปใน yield นั่นแหล่ะ จบ

time format ใน Go

Pallat Anchaleechamaikorn — Mon, 29 Jul 2024 04:38:49 +0000

บังเอิญผมได้ไปเห็นการใช้ date time format ใน Go แบบผิดๆอยู่บ่อยๆ ก็เลยอยากมาอธิบายเรื่องนี้สักเล็กน้อย

หลายคนอาจจะรู้อยู่แล้วว่าวิธีการจัดการ date time format ใน Go มันจะไม่เหมือนภาษาอื่นที่เขามักจะใช้อักษรแทนเช่น dd คือวันที่ MM คือเลขเดือน yyyy คือปี คศ 4 หลัก และในส่วนของเวลาก็ใช้ hh:mm อะไรแบบนี้ ใน Go จะใช้เลขเรียง 1 2 3 4 5 6 7 มาแทนเพื่อให้จำง่าย(ง่ายตรงไหน)
ซึ่งก็มีหลายคนชื่นชมวิธีคิดแบบนี้ และในขณะเดียวกัน ก็มีคนสรรเสริญไปในทางลบค่อนข้างมากเช่นกัน ซึ่งเหตุผลในส่วนคนที่ชื่นชมก็มองว่า ถ้าคุณจำ magic order ได้ คุณก็ไม่ต้องจำมันอีกต่อไป ซึ่ง Rob Pike เคยมาเฉลยว่า เขาคิดเรื่องนี้ได้ตอนกลับบ้าน แล้วนึกถึงวิธีที่ภาษาโคบอลใช้ ซึ่งเรียกว่า Cobol picture clauses ทั้งๆที่เขาเองก็ไม่เคยเขียน Cobol นะ ส่วนคนที่ไม่ชอบก็ติว่า ทีใน fmt ใช้ %s %d กันสนุกเลย แต่พอมา time format กลับเลี่ยงที่จะทำเหมือนชาวบ้านเขาที่ใช้ %d %Y หรือ ddyy ทำไม มันทำให้ต้องมาจำอะไรแปลกๆเพิ่มขึ้นอีก ก็นะ ส่วนตัวผม ก็ดันชอบการคิดอะไรใหม่ๆอยู่แล้ว แต่ก็ไม่เถียงว่ามันก็ต้องมานั่งจำกันใหม่จริงๆนั่นแหล่ะ เอาล่ะมาเล่าเรื่อง time format กันต่อ โดยตัวแทนแต่ละเลขเป็นดังนี้

1 = เดือน
2 = วัน
3 = ชั่วโมง
4 = นาที
5 = วินาที
6 = ปี
7 = time zone

เห็นไหมว่ามันจำง่่าย (ย้ำว่าง่ายตรงไหน) เช่น "01/02 03:04:05PM '06 -0700" นี่คือหน้าตาของ format นะครับ ไม่ใช่เวลาจริง ส่วนเวลาจริง ถ้าตัวเลขตามนี้เป๊ะมันหมายถึง

วันที่ 2 เดือน มกราคม ปี 2006 เวลา 15 นาฬิกา 4 นาที 5 วินาที ณ time zone ที่ -7 ซึ่งคือเวลาแถวๆประเทศเม็กซิโก ซึ่งตรงกับเวลา 22 นาฬิกา หรือ 4 ทุ่ม 4 นาที 5 วินาที ที่ตำแหน่ง UTC ที่ลอนดอน

ทีนี้ เนื่องจาก format ที่ใส่ -0700 เข้าไปนี่ อาจจะทำให้คนที่ไม่ได้อ่าน doc ตีความกันไปเองว่า ไอ้แถวๆนี้มันน่าจะสามารถใส่อย่างอื่นเข้าไปแทนได้เช่น +0700 หรือ +0000 แต่ความจริง นี่มันเป็น format ซึ่งท่าบังคับมันคือจะต้องเป็น -0700 ไปใส่เครื่องหมาย + ให้มันไม่ได้จ้า และเลขก็ต้องเป็นเลข 7 ซึ่งเป็นเลขเรียงอย่างที่กล่าวไปแล้วข้างต้น

Month = 1

สามารถใช้ได้ 4 รูปแบบ

Jan กรณีต้องการเป็นอักษรย่อ 3 ตัว เช่นถ้า data เป็น Mar เราอยากจะ parse เข้ามาใส่ time.Time เราก็ต้องใช้ Jan แทนค่านั้นใน format
January กรณีต้องการคำเต็มของเดือนเช่น ถ้า data เป็น March เราก็ต้องใช้ January เป็น format สำหรับ parse
01 กรณีที่ data เป็นเลข 2 หลักแทนเดือน
1 กรณีที่ data เป็นเลขที่ไม่ต้องการให้มี 0 นำหน้าสำหรับเดือนที่มี 1 digit เช่น เดือน มีนา ก็จะเป็นเลข 3 เลย

Day = 2

day จะพิเศษหน่อย เนื่องจากวันมีหลายความหมาย

วันในสัปดาห์เช่น จันทร์ อังคาร พุธ

วิธีใช้ สามารถใช้ได้ทั้ง

"Mon"
"Monday"

จะมาใช้ "mon" แบบนี้ไม่ได้นะ

วันในเดือนก็คือวันที่

สามารถใช้ได้ 3 รูปแบบคือ

"2"
"02"
"_2" ตัวนี้ถ้าเราจัด format ออกมาจะได้รูปแบบ 2 digits แต่ถ้าเป็นเดือนหลักเดียว มันจะเว้นวรรคให้เช่นถ้าเดือน 3 จะได้ " 3" แต่ถ้าเดือน 10 จะได้ "10" แบบนี้

วันที่ของปี ซึ่งมีได้ 365 หรือ 366 วัน

มี 2 รูปแบบคือ

"002"
"__2" ก็เหมือนวันของเดือน โดยจะเว้นวรรคและแสดงให้ครบ 3 digits

Hour = 3

15" "3" "03" (PM or AM)
มี 3 รูปแบบคือ

"15"
"3" หรือ "3 PM"
"03" หรือ "03 PM"

การใส่ PM จะช่วยเพิ่มรายละเอียดให้การบอกเวลาแบบ 12 hour clock ให้รู้ว่าเป็นเวลาก่อนเที่ยง(ante merīdiem หรือ “before midday”) หรือหลังเที่ยง(post merīdiem หรือ "before midday") ซึ่งจะไม่สามารถใช้ AM แทนได้นะ อย่าสับสน นี่คือการจัด format เด้อ มันบังคับให้ใช้ได้แค่ "PM"

Minute = 4

มี 2 รูปแบบ

"4"
"04"

Second = 5

มี 2 รูปแบบ

"5"
"05"

Year = 6

มี 2 รูปแบบ

"2006"
"06"

Time zone = 7

ก่อนอื่นต้องทำความเข้าใจเรื่อง Time zone ก่อนว่าเราจะใช้มาตรฐาน UTC (Universal Time Coordinated) ซึ่งเป็นเวลาสากลเชิงพิกัด โดยจะใช้พิกัดเส้นลองจิจูด ที่ 0° เป็นจุดอ้างอิงว่าเป็น UTC-0 ซึ่งที่ตำแหน่งนั้น มันเป็นเส้นที่ตัดผ่านหอดูดาวหลวงกรีนิช ที่ลอนดอน ซึ่งแต่เดิมจะใช้เวลาจากหอดูดาวนี้ เป็นมาตรฐานเทียบเวลา เรียกว่า GTM (Greenwich Mean Time) แต่นั่นจะถือเป็นมาตรฐานเก่ากว่านะครับ เนื่องจากเป็นเวลาที่อ้างอิงตามหลักดาราศาสตร์ ปัจจุบันให้เปลี่ยนไปใช้ UTC ซึ่งอ้างอิงตามตำแหน่งพิกัดเส้นลองจิจูดแทน
และยังมี MST (Mountain Standard Time) ซึ่งเป็นเวลาอ้างอิงเวลามาตรฐานกับเวลาที่เทือกเขาร็อกกี้ ซึ่งจะเท่ากับ UTC-7 พอดี ทำให้เราก็จะสามารถใช้ MST มาเป็นหนึ่งใน Format ของเราได้ด้วย

มาดู format ของ time zone แบบเบื้องต้นที่ต้องการ parse time zone ในรูปแบบใช้เครื่องหมาย +/- ตามปกติกัน จะใช้รูปแบบนี้ คือต้องเป็น เครื่องหมายลบ "-" เท่านั้น และเลขต้องป็นเลข 7 เท่านั้น ซึ่งพอเอาไป parse เวลาจริง ถ้ามันจะมาเป็น +0800 ก็จะไปตรงกับ format "-0700" แต่ถ้าข้อมูลมาเป็น "+08" ก็ใช้ format "-07" เป็นต้น

"-0700" ±hhmm
"-07:00" ±hh:mm
"-07" ±hh
"-070000" ±hhmmss
"-07:00:00" ±hh:mm:ss

ต่อมาเป็นแบบ ISO 8601

"Z0700" Z or ±hhmm
"Z07:00" Z or ±hh:mm
"Z07" Z or ±hh
"Z070000" Z or ±hhmmss
"Z07:00:00" Z or ±hh:mm:ss

ตัว Z หรือจะเรียกว่า Zulu ก็ได้ไม่ผิด เป็นสัญลักษณ์ที่ใช้วางไว้หลังเวลาวิธีใช้ก็แค่ใช้แทนเครื่องหมายลบ เท่านั้น เวลาแสดง format ก็จะมาในรูปแบบ +/- เหมือนเดิม

MST ก็คือ time zone format เวลาที่เราต้องการ parse ตัว time zone ที่เป็นแบบระบุ time zone เช่น EST หรือ PST และแม้แต่จะ custom เองก็ได้เช่นกันผ่าน time.FixedZone

เล่าไว้เท่านี้นะครับ สามารถอ่านให้ละเอียดมากกว่านี้ที่ https://pkg.go.dev/time และเพิ่มความเข้าใจผ่านการทดลองด้วยตัวเองดูจะดีกว่านะครับ