Go Academy · บทเรียน

ฮุกและขอบเขต

ปรับแต่งคำสั่งสอบถาม

ฮุกและขอบเขต เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

ฮุกและขอบเขต

GORM มีเครื่องมือปรับแต่งสองอย่าง ได้แก่ ฮุก ซึ่งเรียกใช้โค้ดโดยอัตโนมัติก่อนหรือหลังเหตุการณ์ในวงจรการทำงาน และ ขอบเขต ซึ่งจัดกลุ่มตรรกะการค้นข้อมูลที่นำกลับมาใช้ใหม่ได้ ทั้งสองอย่างช่วยให้การเข้าถึงข้อมูลสะอาดและสอดคล้องกัน

ฮุกคืออะไร

ฮุกคือเมธอดบนแบบจำลองที่ GORM เรียกใช้ก่อนหรือหลังการดำเนินการ เช่น BeforeCreate, AfterCreate, BeforeUpdate, BeforeDelete และอื่น ๆ

ฮุก BeforeCreate

กำหนดเมธอดที่มีรูปแบบพารามิเตอร์และค่าที่ส่งกลับถูกต้องบนแบบจำลอง ในที่นี้เรากำหนด UUID ก่อนแทรกระเบียน

func (u *User) BeforeCreate(tx *gorm.DB) error {
    u.UUID = uuid.NewString()
    return nil
}

การตรวจสอบความถูกต้องในฮุก

ส่งคืนข้อผิดพลาดจากฮุกเพื่อยกเลิกการดำเนินการ GORM จะย้อนกลับธุรกรรมที่ครอบอยู่ ดังนั้นข้อมูลที่ไม่ถูกต้องจะไม่ไปถึงฐานข้อมูล

func (u *User) BeforeSave(tx *gorm.DB) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    return nil
}

ฮุกทำงานภายในธุรกรรม

อาร์กิวเมนต์ tx *gorm.DB คือธุรกรรมที่ GORM กำลังใช้งาน หากเขียนข้อมูลที่เกี่ยวข้องภายในฮุก ให้ใช้ tx นี้ เพื่อให้ข้อมูลถูกยืนยันหรือย้อนกลับแบบอะตอมพร้อมกับการดำเนินการหลัก

ขอบเขตคืออะไร

ขอบเขตคือฟังก์ชันที่รับและคืนค่า *gorm.DB โดยห่อหุ้มส่วนหนึ่งของคำค้นหาไว้ คุณใช้ขอบเขตนั้นด้วย db.Scopes(...) และนำกลับมาใช้ซ้ำกับคำค้นหาหลายรายการได้

func ActiveUsers(db *gorm.DB) *gorm.DB {
    return db.Where("active = ?", true)
}

การใช้ Scopes

ส่งขอบเขตอย่างน้อยหนึ่งรายการไปยัง Scopes ขอบเขตเหล่านี้ทำงานประกอบกันได้ คุณจึงรวมตัวกรองต่าง ๆ เป็นคำค้นหาสุดท้ายได้แบบประกาศ

db.Scopes(ActiveUsers, Recent).Find(&users)

ฮุกที่รันได้และการจำลองขอบเขต

GORM ต้องใช้ฐานข้อมูล ดังนั้นตัวอย่างที่รันได้นี้จึงจำลองฮุก BeforeCreate และตัวกรองลักษณะเดียวกับขอบเขตที่นำกลับมาใช้ซ้ำได้ด้วยฟังก์ชันธรรมดา

package main

import (
    "errors"
    "fmt"
)

type User struct {
    Name   string
    Age    int
    Active bool
}

func beforeCreate(u *User) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    if u.Name == "" {
        u.Name = "anonymous"
    }
    return nil
}

func activeOnly(users []User) []User {
    var out []User
    for _, u := range users {
        if u.Active {
            out = append(out, u)
        }
    }
    return out
}

func main() {
    u := User{Age: 30, Active: true}
    if err := beforeCreate(&u); err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println("created:", u.Name)
    all := []User{u, {Name: "Lin", Active: false}}
    fmt.Println("active count:", len(activeOnly(all)))
}

Scopes สำหรับการแบ่งหน้า

ขอบเขตที่ใช้กันทั่วไปสามารถสร้างการแบ่งหน้าจากหมายเลขหน้า โดยห่อหุ้ม Offset และ Limit ไว้ เพื่อให้จุดเชื่อมต่อรายการทุกแห่งแบ่งหน้าในลักษณะเดียวกัน

func Paginate(page, size int) func(*gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        return db.Offset((page - 1) * size).Limit(size)
    }
}

ฮุกกับตรรกะของแอปพลิเคชัน

ฮุกช่วยรวมข้อกังวลที่ใช้ร่วมกันหลายส่วนไว้ในที่เดียว เช่น การประทับเวลา สลักชื่อ และฟิลด์ตรวจสอบประวัติ ควรเก็บตรรกะทางธุรกิจที่ซับซ้อนไว้ในบริการ ไม่ใช่ในฮุก เพื่อให้พฤติกรรมคาดเดาได้และทดสอบได้

การข้ามฮุก

สำหรับการดำเนินการจำนวนมาก คุณสามารถปิดใช้ฮุกด้วย db.Session(&gorm.Session{SkipHooks: true}) วิธีนี้ช่วยเร่งการนำเข้าข้อมูลจำนวนมาก แต่จะข้ามการตรวจสอบความถูกต้องของคุณด้วย จึงควรใช้อย่างระมัดระวัง

ตรวจสอบความเข้าใจ

ทดสอบความรู้เกี่ยวกับฮุกและขอบเขตของคุณ

สรุปทบทวน

คุณได้เรียนรู้เกี่ยวกับฮุกและขอบเขตดังนี้:

ฮุกทำงานโดยรอบเหตุการณ์ในวงจรการทำงาน หากคืนค่าข้อผิดพลาด การดำเนินการจะถูกยกเลิกและย้อนกลับ
ฮุกทำงานภายในธุรกรรมผ่านอาร์กิวเมนต์ tx
ขอบเขตคือฟังก์ชัน *gorm.DB ที่นำกลับมาใช้ซ้ำและเรียกใช้ด้วย Scopes
ใช้ขอบเขตสำหรับตัวกรองและการแบ่งหน้า
SkipHooks จะข้ามฮุกสำหรับงานที่ดำเนินการเป็นจำนวนมาก

คำถามที่พบบ่อย

บทเรียน “ฮุกและขอบเขต” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ฮุกและขอบเขต” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ฮุกและขอบเขต”

ปรับแต่งคำสั่งสอบถาม คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “ฮุกและขอบเขต” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Go Academy