Mastering Golang for E-commerce Back End Development : Part 2
บทความโดย ผศ.ดร.ณัฐโชติ พรหมฤทธิ์ และ อ.ดร.สัจจาภรณ์ ไวจรรยา
ภาควิชาคอมพิวเตอร์
คณะวิทยาศาสตร์
มหาวิทยาลัยศิลปากร
ใน Part 2 นี้ เราจะก้าวไปอีกขั้นในการเรียนรู้เครื่องมือและแนวคิดที่ทรงพลังของ Go ซึ่งจะช่วยให้คุณสามารถสร้าง Back End ที่มีประสิทธิภาพครับ
Array, Slice และ Map : กล่องเก็บของเล่นที่มีช่องหลายช่อง
Array, Slice และ Map เป็นโครงสร้างข้อมูลพื้นฐานที่สำคัญใน Go ช่วยให้สามารถจัดการข้อมูลได้อย่างมีประสิทธิภาพและมีความปลอดภัย เนื่องจากมีการตรวจสอบ Type อย่างเข้มงวดในขณะ Compile
Go พยายามรวมข้อดีของทั้งภาษา Low-level และ High-level เข้าด้วยกัน โครงสร้างข้อมูลใน Go ถูกออกแบบมาให้เรียบง่าย สะดวกในการใช้งาน แต่มีประสิทธิภาพสูง
Array : กล่องที่มีช่องเท่า ๆ กัน จำนวนแน่นอน
Array เป็นชุดข้อมูลที่มีขนาดคงที่ ประกอบด้วยข้อมูลชนิดเดียวกัน โดยขนาดของ Array ต้องระบุตอนประกาศ และไม่สามารถเปลี่ยนแปลงได้
var fruits [3]string // ระบุขนาดตอนประกาศ
fruits[0] = "แอปเปิ้ล"
fruits[1] = "กล้วย"
fruits[2] = "ส้ม"
fmt.Println(fruits)
numbers := [5]int{1, 2, 3, 4, 5}
fmt.Println(numbers)เราสามารถเข้าถึง Array ได้หลายรูปแบบ เช่น
1. การเข้าถึงโดยตรงด้วย index
2. การวนลูปด้วย for แบบมาตรฐาน
3. การใช้ range เพื่อวนลูป
4. การหาความยาวของ Array ด้วย len()
5. การเปลี่ยนค่าใน Array
// ตัวอย่างการเข้าถึง Array
// 1. การเข้าถึงโดยใช้ index
fmt.Println("ผลไม้ชิ้นแรก:", fruits[0])
fmt.Println("ตัวเลขตัวที่สาม:", numbers[2])
// 2. การวนลูปผ่าน Array ด้วย for แบบมาตรฐาน
fmt.Println("รายการผลไม้:")
for i := 0; i < len(fruits); i++ {
fmt.Printf("%d. %s\n", i+1, fruits[i])
}
// 3. การใช้ range
fmt.Println("ตัวเลขทั้งหมด:")
for index, value := range numbers {
fmt.Printf("ตำแหน่ง %d: %d\n", index, value)
}
// 4. การหาความยาวของ Array
fmt.Println("จำนวนผลไม้:", len(fruits))
fmt.Println("จำนวนตัวเลข:", len(numbers))
// 5. การเปลี่ยนค่าใน Array
fruits[1] = "มะม่วง"
fmt.Println("ผลไม้หลังจากเปลี่ยน:", fruits)Array ใน Go สามารถเก็บข้อมูลได้หลากหลายประเภท รวมทั้ง Function
// ประกาศ array ของ function ที่รับ int และคืนค่า int
var mathFuncs [3]func(int) int
// กำหนด function ให้แต่ละตำแหน่งใน array
mathFuncs[0] = func(x int) int { return x + 1 } // เพิ่ม 1
mathFuncs[1] = func(x int) int { return x * 2 } // คูณ 2
mathFuncs[2] = func(x int) int { return x * x } // ยกกำลัง 2
// ทดลองเรียกใช้ function จาก array
for i, f := range mathFuncs {
result := f(3)
fmt.Printf("Function %d: result = %d\n", i, result)Array ใน Go จะถูกส่งผ่าน Function โดยค่า (By value) ทำให้ต้องคัดลอกข้อมูลทั้งหมด ขณะที่ Array ใน C/C++ และ Java จะถูกส่งผ่านโดยการอ้างอิง (By reference)
func processArray(data [5]int) {
// ทำงานกับ data
}
func main() {
a := [5]int{1, 2, 3, 4, 5}
processArray(a) // ใช้ได้
// processArray(a[:3]) // ไม่สามารถทำได้
}เราส่ง Array ผ่าน Function เมื่อต้องการความแน่นอนของขนาดข้อมูล แต่ไม่ยืดหยุ่นมากนักเมื่อต้องการส่ง Array แค่บางส่วน ดังตัวอย่างด้านบน
Arrays
- กำหนดขนาดตายตัว
var ชื่อ [ขนาด]ชนิดข้อมูล
ชื่อ := [ขนาด]ชนิดข้อมูล{ค่า1, ค่า2, ...}
การใช้งาน
len(array) // ความยาวปัจจุบันSlice : กล่องที่ยืดหดได้
Slice คือ Array ที่สามารถปรับขนาดได้แบบไดนามิก ประกอบด้วยข้อมูลชนิดเดียวกัน และไม่ต้องระบุขนาดตอนประกาศ
Slice ของ Go คล้ายกับ List ใน Python และ Array ของ JavaScrip ในแง่ของการปรับขนาดได้
colors := []string{"แดง", "เขียว", "น้ำเงิน"}
fmt.Println(colors)
colors = append(colors, "เหลือง")
fmt.Println(colors)
subColors := colors[1:3]
fmt.Println(subColors)ชื่อ "Slice" สะท้อนถึงความสามารถในการ "ตัดแบ่ง" หรือ "หยิบส่วน" ของข้อมูลมาใช้งานอย่างยืดหยุ่น
arr := [5]int{1, 2, 3, 4, 5}
slice1 := arr[1:4] // "ตัดแบ่ง" ส่วนของ array: [2, 3, 4]
slice2 := slice1[1:] // "ตัดแบ่ง" ต่อจาก slice: [3, 4]เราสามารถสร้าง Slice ที่มีความยาว (Length) และความจุ (Capacity) ตามที่กำหนด โดยใช้คำสั่ง make()
// ใช้ make() สร้าง slice
s1 := make([]int, 5, 10)
fmt.Println("s1:", s1)
fmt.Println("len(s1):", len(s1))
fmt.Println("cap(s1):", cap(s1))
จากตัวอย่าง Slice s1 ถูกสร้างโดยมีค่าเริ่มต้นเป็น 0 ที่บรรจุอยู่ในกล่อง 5 กล่อง แต่มีการเตรียมพื้นที่เผื่อไว้สำหรับการบรรจุกล่องทั้งหมด 10 กล่อง ดังนั้น s1 จึงพร้อมสำหรับใส่ข้อมูลเพิ่มอีก 5 กล่อง
// เปลี่ยนค่าใน slice
s1[0] = 1
s1[1] = 2
s1[2] = 3
fmt.Println("\ns1 หลังเปลี่ยนค่า:", s1)
// ใช้ append() เพิ่มข้อมูล
s1 = append(s1, 4, 5, 6)
fmt.Println("\ns1 หลัง append:", s1)
fmt.Println("len(s1) ใหม่:", len(s1))
fmt.Println("cap(s1) ใหม่:", cap(s1))
ในการสร้าง Slice s2 ให้เป็น Sub-slice ของ Slice s1 ดังตัวอย่างด้านล่าง s2 จะมีความยาว 3 โดยนับจาก 2 ถึง 4 (ไม่รวม 5)
แต่ Capacity ของ Slice s2 จะเริ่มนับจากจุดเริ่มต้นของ Sub-slice ไปจนถึงสิ้นสุดของ Capacity ของ Slice s1
การเปลี่ยนแปลงข้อมูลใน Sub-slice s2 (ทั้งการกำหนดค่าด้วยการเข้าถึงโดยตรงด้วย Index และการใช้คำสั่ง append) อาจส่งผลต่อ Slice ต้นฉบับได้ เนื่องจาก s2 มีการใช้พื้นที่เก็บข้อมูลบางส่วนร่วมกับ s1
// สร้าง slice จาก slice เดิม
s2 := s1[2:5] // s2 จะมีความยาว 3 นับจาก 2 ถึง 4
fmt.Println("\ns2:", s2)
fmt.Println("len(s2):", len(s2))
fmt.Println("cap(s2):", cap(s2))
เราจะทดลองเพิ่มข้อมูลให้เกิน Capacity ของ s2 (Capacity เดิมเท่ากับ 8) ซึ่งมีข้อมูลบรรจุอยู่ 3 กล่อง
เมื่อพื้นที่เดิมเต็ม ไม่มีที่ว่างเหลือ Go จะเตรียมพื้นที่ใหม่ที่ใหญ่กว่าโดยอัตโนมัติ
// เพิ่มข้อมูลจนล้น capacity
s2 = append(s2, 7, 8, 9, 10, 11, 12)
fmt.Println("\ns2 หลังเพิ่มข้อมูลเกิน capacity:", s2)
fmt.Println("len(s2) ใหม่:", len(s2))
fmt.Println("cap(s2) ใหม่:", cap(s2))
สำหรับ Slice ขนาดเล็ก (Capacity < 1024) เช่น s2 นั้น Go จะเตรียมพื้นที่ใหม่ที่ใหญ่กว่าเดิม 2 เท่า แต่สำหรับ Slice ขนาดใหญ่มาก ๆ (Capacity >= 1024) Go จะเตรียมพื้นที่ใหม่ที่ใหญ่ว่าเดิม 25%
หลังจากนั้น Go จะย้ายกล่องจากพื้นที่เดิม (9 กล่อง) มายังพื้นที่ใหม่ที่จุได้ 16 กล่อง!
หมายเหตุ จำนวน % ของพื้นที่ใหม่ที่ Go เตรียมให้ ไม่ได้เป็นข้อบังคับ แต่เกิดจากการสังเกตจากพฤติกรรมของมัน
อย่างไรก็ตามการย้ายของจะใช้เวลาและทรัพยากร ดังนั้นถ้าทราบขนาดที่ต้องการล่วงหน้า เราควรใช้คำสั่ง make() เพื่อกำหนด Capacity ไว้ตั้งแต่แรกครับ
เรามักจะส่ง Slice ผ่าน Function เพราะมีความยืดหยุ่นกว่า Array โดย Slice จะถูกส่งผ่าน Function โดยการอ้างอิง (By reference) ทำให้ประหยัดหน่วยความจำ ไม่ต้องคัดลอกข้อมูลทั้งหมดเหมือน Array
// ใช้ Slice
func processSlice(data []int) {
// ทำงานกับ data
}
func main() {
s := []int{1, 2, 3, 4, 5}
processSlice(s) // ใช้ได้
processSlice(s[:3]) // ส่งบางส่วนได้
}Slice
- ยืดหยุ่น เปลี่ยนแปลงขนาดได้
ชื่อ := []ชนิดข้อมูล{ค่า1, ค่า2, ...}
ชื่อ := make([]ชนิดข้อมูล, ความยาว, ความจุ)
การใช้งาน
append(slice, ค่า) // เพิ่มค่า
len(slice) // ความยาวปัจจุบัน
cap(slice) // ความจุ
slice[start:end] // สร้าง slice ย่อยMap
Map ใช้เก็บข้อมูลแบบ Key-value ทำให้ค้นหาข้อมูลได้เร็ว เหมาะสำหรับการจัดเก็บข้อมูลที่ต้องการการเข้าถึงแบบไม่เรียงลำดับ ซึ่งคล้ายกับ Dictionary ของ Python และ Object หรือ Map ของ Java
Value ของ Map สามารถเป็นข้อมูลประเภทใดก็ได้ ยกเว้น Function โดยขนาดของ Map สามารถเปลี่ยนแปลงได้แบบไดนามิก
ages := map[string]int{
"Alice": 30,
"Bob": 25,
}
fmt.Println(ages["Alice"])
ages["Charlie"] = 35
delete(ages, "Bob")
age, exists := ages["David"]
if !exists {
fmt.Println("ไม่พบข้อมูลของ David")
} else {
fmt.Println("David อายุ", age)
}
make() จะจัดสรรหน่วยความจำและคืนค่า Map ที่พร้อมใช้งาน โดย make() สามารถระบุขนาดเริ่มต้นได้ เช่น make(map[string]int, 5)
เราสามารถสร้าง Empty Map ได้ทั้งการใช้ make() และไม่ใช้ make() ดังตัวอย่างด้านล่าง เมื่อไม่ใช้ mak(), Go จะสร้าง Map เปล่าโดยไม่มีการจัดสรรหน่วยความจำให้
ทั้งสองวิธีให้ผลลัพธ์เหมือนกันในการใช้งาน แต่อาจมีความแตกต่างในด้านประสิทธิภาพ โดยการใช้ make() อาจมีประสิทธิภาพดีกว่าสำหรับ Map ขนาดใหญ่ เพราะมีการจัดสรรหน่วยความจำให้ล่วงหน้า
// สร้าง Empty Map ด้วย make() โดยไม่ระบุขนาดเริ่มต้น
// Go จะจองพื้นที่หน่วยความจำเริ่มต้นในขนาดเล็กให้
userAges := make(map[string]int)
// เพิ่มข้อมูล
userAges["Alice"] = 30
userAges["Bob"] = 25
fmt.Println("userAges:", userAges)
// สร้าง Empty Map ด้วย make() พร้อมระบุขนาดเริ่มต้น
scores := make(map[string]int, 5)
// เพิ่มข้อมูล
scores["Math"] = 95
scores["English"] = 88
scores["Science"] = 92
fmt.Println("scores:", scores)
// สร้าง Empty Map โดยไม่ใช้ make()
m := map[string]int{}
// เพิ่มข้อมูล
m["x"] = 10
m["y"] = 20
fmt.Println("m:", m)เราสามารถสร้าง Map ที่มี Value เป็น Slice ได้ดังตัวอย่างด้านล่าง
// สร้าง Map ที่มี Value เป็น Slice
userHobbies := make(map[string][]string)
// เพิ่มข้อมูล
userHobbies["Alice"] = []string{"reading", "swimming"}
userHobbies["Bob"] = []string{"gaming", "cooking"}
fmt.Println("userHobbies: ", userHobbies)
การใช้ range เพื่อวนลูปผ่าน Map
// วนลูปผ่าน map ด้วย for
for name, hobbies := range userHobbies {
fmt.Printf("%s's hobbies: ", name)
for i, hobby := range hobbies {
if i > 0 {
fmt.Print(", ")
}
fmt.Print(hobby)
}
fmt.Println()
}
จากตัวอย่างด้านล่าง เราจะใช้ value, exists := map[key] เพื่อตรวจสอบการมีอยู่ของ key โดย exists จะเป็น true ถ้ามี Key อยู่ใน Map
// การตรวจสอบว่ามี Key อยู่ใน Map หรือไม่
name := "Charlie"
age, exists := userAges[name]
if exists {
fmt.Printf("%s is %d years old\n", name, age)
} else {
fmt.Printf("%s is not in the map\n", name)
}Map มี Function เฉพาะสำหรับการลบข้อมูล คือ delete()
// การลบข้อมูลจาก map
delete(userAges, "Bob")
fmt.Println("userAges after deleting Bob:", userAges)Map จึงเหมาะกับการจัดเก็บข้อมูลแบบ Key-value และต้องการค้นหาอย่างรวดเร็ว
Maps
- เก็บข้อมูลแบบ key-value
ชื่อ := map[ชนิดของkey]ชนิดของvalue{
key1: value1,
key2: value2,
}
ชื่อ := make(map[ชนิดของkey]ชนิดของvalue)
การใช้งาน
map[key] = value // เพิ่มหรือแก้ไขค่า
delete(map, key) // ลบค่า
value, exists := map[key] // ตรวจสอบการมีอยู่Exercise
ยกตัวอย่าง Use Case ที่เหมาะสมสำหรับการใช้งาน Array ในภาษา Go
ตัวอย่างโค้ด
package main
import "fmt"
const totalSeats = 100
func main() {
var seats [totalSeats]bool // false = ว่าง, true = จอง
// จองที่นั่ง
seats[10] = true
seats[11] = true
// ตรวจสอบที่นั่งว่าง
for i, isReserved := range seats {
if !isReserved {
fmt.Printf("ที่นั่งหมายเลข %d ว่าง\n", i+1)
}
}
}Go Quiz 4 (19 ข้อ) ขอให้สนุกกับการทำ Quiz นะครับ
Q&A?
รวม Cheat Sheet Array, Slice และ Map : กล่องเก็บของเล่นที่มีช่องหลายช่อง
Array, Slice และ Map
--------------------
Arrays
- กำหนดขนาดตายตัว
var ชื่อ [ขนาด]ชนิดข้อมูล
ชื่อ := [ขนาด]ชนิดข้อมูล{ค่า1, ค่า2, ...}
การใช้งาน
len(array) // ความยาวปัจจุบัน
Slice
- ยืดหยุ่น เปลี่ยนแปลงขนาดได้
ชื่อ := []ชนิดข้อมูล{ค่า1, ค่า2, ...}
ชื่อ := make([]ชนิดข้อมูล, ความยาว, ความจุ)
การใช้งาน
append(slice, ค่า) // เพิ่มค่า
len(slice) // ความยาวปัจจุบัน
cap(slice) // ความจุ
slice[start:end] // สร้าง slice ย่อย
Maps
- เก็บข้อมูลแบบ key-value
ชื่อ := map[ชนิดของkey]ชนิดของvalue{
key1: value1,
key2: value2,
}
ชื่อ := make(map[ชนิดของkey]ชนิดของvalue)
การใช้งาน
map[key] = value // เพิ่มหรือแก้ไขค่า
delete(map, key) // ลบค่า
value, exists := map[key] // ตรวจสอบการมีอยู่Pointer : ส่งรีโมทให้คนอื่นใช้ ง่ายกว่าการยกทีวีทั้งเครื่องไปให้
Pointers เป็นเหมือนป้ายบอกทางไปยังที่เก็บข้อมูลในคอมพิวเตอร์ โดย Pointer จะเก็บ Address ในหน่วยความจำ ไม่ใช่ค่าโดยตรง
x := 5
var p *int = &x // p เก็บที่อยู่ของ x
fmt.Println("ค่าของ x:", x)
fmt.Println("ที่อยู่ของ x:", p)
fmt.Println("ค่าที่ p ชี้ไป:", *p)
จากตัวอย่างด้านบน เราจะใช้ & หรือ Address-of ที่หมายถึง Address ของ x และ * หรือ Dereference สำหรับการประกาศตัวแปร p เป็น Pointer รวมทั้งเพื่อเข้าถึงข้อมูลในตำแหน่งที่ p อ้าง
การประกาศตัวแปร Pointer แบบอัตโนมัติ ด้วย new()
ptr := new(int) // ประกาศแบบอัตโนมัติ
fmt.Println(*ptr)
new(int) จะจองพื้นที่หน่วยความจำสำหรับเก็บค่า int และกำหนดค่าเริ่มต้นให้กับพื้นที่นั้น (สำหรับ int คือ 0) แล้วจึงคืนค่า Pointer ที่ชี้ไปยังพื้นที่หน่วยความจำนั้นให้ ptr
Go ใช้ * สำหรับการประกาศ Pointer และการ Dereferenc รวมทั้งใช้ & สำหรับการรับ Address ของตัวแปรเช่นเดียวกับ C/C++
แต่ Go ไม่มีการคำนวณทางคณิตศาสตร์กับ Pointer ซึ่งทำให้ปลอดภัยกว่า C/C++ โดยต้องแลกกับการทำให้มันไม่มีความยืดหยุ่นเท่า C/C++ ในแง่ของการจัดการหน่วยความจำระดับต่ำ
int arr[] = {1, 2, 3, 4, 5};
int *ptr = arr;
ptr++; // เลื่อน pointer ไปยังตำแหน่งถัดไป
ptr += 2; // เลื่อน pointer ไป 2 ตำแหน่งจึงกล่าวได้ว่า Go พยายามสร้างสมดุลระหว่างความปลอดภัยและประสิทธิภาพในการใช้ Pointer โดยให้ความสามารถในการควบคุมที่มากกว่าภาษาระดับสูงอื่น ๆ แต่ยังคงรักษาความปลอดภัยไว้มากกว่าภาษาระดับต่ำอย่าง C/C++ ครับ
Pointers ช่วยให้ Function doublePointer เปลี่ยนแปลงค่าจริง ที่ไม่ใช่แค่การสำเนาค่าเหมือนใน Function doubleValue ดังตัวอย่างด้านล่าง
func doubleValue(x int) {
x *= 2
}
func doublePointer(x *int) {
*x *= 2
}
func main() {
num := 5
doubleValue(num)
fmt.Println("หลัง doubleValue:", num) // ยังคงเป็น 5
doublePointer(&num)
fmt.Println("หลัง doublePointer:", num) // กลายเป็น 10
}การส่งผ่าน Pointer จะมีประสิทธิภาพมากกว่าการคัดลอกข้อมูล โดยเฉพาะกับโครงสร้างข้อมูลที่มีขนาดใหญ่ครับ
nil Pointer คือ Pointer ที่ไม่ได้ชี้ไปยัง Address ใด ๆ ในหน่วยความจำ มันเป็นค่าเริ่มต้นสำหรับ Pointer ที่ยังไม่ได้ถูกกำหนดค่า การไม่ตรวจสอบ nil Pointer ก่อนใช้งาน อาจทำให้โปรแกรม Panic ซึ่งเป็นสถานการณ์ที่โปรแกรมเจอข้อผิดพลาดร้ายแรงและไม่สามารถดำเนินการต่อไปได้อย่างปลอดภัย จนทำให้โปรแกรมหยุดทำงานทันที
nil เป็นแนวคิดสำคัญใน Go ที่ใช้ในการจัดการกับสถานะว่างเปล่าหรือไม่มีค่า
var ptr *int // ptr เป็น nil pointer
fmt.Println(ptr) // <nil>
fmt.Println(*ptr) // จะเกิด panic: runtime error: invalid memory address or nil pointer dereference
ดังนั้นเราควรตรวจสอบ nil ก่อนเข้าถึงค่า Pointer เสมอ
if ptr != nil {
fmt.Println(*ptr)
} else {
fmt.Println("Pointer is nil")
}Exercise
เขียนฟังก์ชันที่รับ Pointer และเปลี่ยนค่าภายใน
Go Quiz 5 (10 ข้อ) ขอให้สนุกกับการทำ Quiz นะครับ
Q&A?
รวม Cheat Sheet Pointer
Pointer
-------
1. สร้าง Pointer
var p *int // Pointer to int
p = &x // p เก็บที่อยู่ของ x
ptr := new(int) // ประกาศ Pointer แบบอัตโนมัติ
2. เข้าถึงค่าที่ Pointer ชี้ไป
*p // ค่าที่ p ชี้ไป
3. สัญลักษณ์
& // address-of operator
* // dereference operator
4. Pointer กับฟังก์ชัน
func changeSomething(x *int) {
*x = newValue // เปลี่ยนค่าจริงๆ
}
5. ข้อควรระวัง
- Pointer ที่เป็น nil อาจทำให้โปรแกรม panicStruct และ Method : สร้างสิ่งของของเราเอง
เราจะใช้ Struct และ Method สร้างสิ่งของของเรา โดยการสร้างพิมพ์เขียวและกำหนดความสามารถให้กับสิ่งของนั้น
Struct เป็นเหมือนพิมพ์เขียวที่กำหนดว่าสิ่งของของเราจะมีคุณสมบัติอะไรบ้าง
type Cat struct {
Name string
Breed string
Age int
}
func main() {
myCat := Cat{Name: "ตุนตัง", Breed: "มันช์กิ้น", Age: 2}
fmt.Println(myCat)
// การเข้าถึงฟิลด์
fmt.Println("ชื่อแมว:", myCat.Name)
}เรามักใช้ Pointer กับ Struct เมื่อต้องการเปลี่ยนแปลงข้อมูล ดังตัวอย่างด้านล่าง
func birthday(p *Cat) {
p.Age++ // ไม่จำเป็นต้องใช้ (*p).Age
}
func main() {
myCat := Cat{Name: "ตุนตัง", Breed: "มันช์กิ้น", Age: 2}
birthday(&myCat)
fmt.Println(myCat) // {ตุนตัง มันช์กิ้น 3}
}
ส่วน Method เป็น Function ที่เชื่อมโยงกับ Struct ทำให้สิ่งของของเรามีความสามารถ เช่น myCat.Meow() และ myCat.HaveBirthday()
// Value Receiver
func (c Cat) Meow() {
fmt.Printf("%s กำลังร้อง: เมี้ยว! เมี้ยว!\n", c.Name)
}
// Pointer Receiver
func (c *Cat) HaveBirthday() {
c.Age++
fmt.Printf("%s มีอายุ %d ปีแล้ว!\n", c.Name, c.Age)
}
func main() {
myCat := Cat{Name: "ตุนตัง", Breed: "มันช์กิ้น", Age: 2}
myCat.Meow()
myCat.HaveBirthday()
}จากตัวอย่างเรานำ (c Cat) ไว้หน้า Meow() และ HaveBirthday() เพื่อสร้าง Method ให้แก่ Type "Cat" ที่เรานิยามเป็น Struct ไว้ก่อนหน้า
ใน Go เรียกพารามิเตอร์พิเศษ (c Cat) นี้ว่า Receiver ซึ่ง Receiver ทำให้เราสามารถเพิ่ม Method ให้กับ Type ต่าง ๆ ได้โดยไม่ต้องแก้ไข Type นั้น ๆ โดยตรง
Receiver นี้ทำให้ Meow() กลายเป็น Method ของ struct "Cat" ที่สามารถเรียกใช้ผ่าน Instance ของ Cat ได้
func (variable Type) MethodName(parameters) {
// Method body
}Receiver เป็นกลไกสำคัญใน Go ที่ช่วยให้การเขียนโปรแกรมเชิงวัตถุ (OOP) เป็นไปได้โดยไม่ต้องใช้แนวคิดของ Class แบบดั้งเดิม ทำให้ Code มีความยืดหยุ่นและอ่านง่ายขึ้น
Receiver ใน Go มี 2 ประเภท คือ Value Receiver และ Pointer Receiver
Value Receiver จะทำงานกับสำเนาของ Type เช่น Struct โดยไม่สามารถแก้ไขข้อมูลใน Struct ต้นฉบับได้ ซึ่งเหมาะสำหรับ Method ที่เพียงแค่อ่านข้อมูลหรือมีการคำนวณโดยไม่เปลี่ยนแปลงข้อมูล เช่น Method Meow()
Pointer Receiver จะทำงานกับ Pointer ที่ชี้ไปยัง Type เช่น Struct จริง ทำให้สามารถแก้ไขข้อมูลใน Struct ต้นฉบับได้ ซึ่งเหมาะสำหรับ Method ที่ต้องการแก้ไขข้อมูลต้นฉบับ เช่น Method HaveBirthday() เพราะต้องมีการแก้ไขอายุของแมว
Go อนุญาตให้กำหนด Method แก่ Type ที่เราสร้างขึ้นเอง แม้ไม่ใช่ Struct
type MyInt int
// Pointer receiver
func (m *MyInt) Increment() {
*m++
}
func main() {
var num MyInt = 5
num.Increment()
fmt.Println(num)
}หมายเหตุ ถ้าต้องการซ่อนการเข้าถึง field ของ Struct จากภายนอก Package ให้ตั้งชื่อแปรด้วยตัวอักษรตัวเล็ก
จากตัวอย่างด้านบน MyInt เป็น Type ที่สร้างจาก int และมี Method คือ Increment() ที่ประกาศเป็น Pointer Receiver
Composition ใน Go คือการสร้างโครงสร้างข้อมูลที่ซับซ้อนขึ้นโดยการรวมโครงสร้างที่เรียบง่ายเข้าด้วยกัน แทนการใช้การสืบทอด (Inheritance) แบบที่พบในภาษา OOP อื่น ๆ ซึ่งทำให้ Code ของ Go มีความยืดหยุ่นและนำกลับมาใช้ใหม่ได้ดีกว่า
Struct Embedding เป็นวิธีที่ Go ใช้ในการทำ Composition โดยการนำ Struct หนึ่งไปฝังไว้ในอีก Struct หนึ่ง
type Animal struct {
Name string
Age int
}
func (a Animal) Breathe() {
fmt.Printf("%s กำลังหายใจ\n", a.Name)
}
type Cat struct {
Animal // Embedding Struct Animal, Cat "is-a" Animal
Breed string
}
func (c Cat) Meow() {
fmt.Printf("%s กำลังร้อง: เมี้ยว! เมี้ยว!\n", c.Name)
}
func main() {
myCat := Cat{
Animal: Animal{Name: "ตุนตัง", Age: 2},
Breed: "มันช์กิ้น",
}
myCat.Breathe() // เรียกใช้ method จาก Animal
myCat.Meow() // เรียกใช้ method ของ Cat
fmt.Printf("%s เป็นแมวพันธุ์ %s\n", myCat.Name, myCat.Breed)
}จากตัวอย่างด้านบน การ Embedding Struct Animal ลงใน Struct Cat ทำให้ myCat สามารถเรียกใช้ Method Breathe() จาก Animal ได้
เราสามารถนำ Struct ที่มีอยู่แล้วมาใช้กับ Struct ใหม่ได้หลาย Struct และสามารถ Embed หลาย Struct ลงใน Struct เดียวได้เช่นกัน
การใช้ Composition ผ่านการทำ Struct Embedding ใน Go จึงช่วยให้เราสร้างโครงสร้างข้อมูลที่ซับซ้อนและยืดหยุ่น รวมทั้งสามารถนำ Code กลับมาใช้ใหม่ได้ดียิ่งขึ้น โดยไม่ต้องพึ่งพาการสืบทอดแบบดั้งเดิม
Exercise
สร้าง Struct "Book" พร้อม Method สำหรับแสดงข้อมูลหนังสือ
Go Quiz 6 (19 ข้อ) ขอให้สนุกกับการทำ Quiz นะครับ
Q&A?
รวม Cheat Sheet Struct และ Method : สร้างสิ่งของของเราเอง
Struct และ Method
-----------------
1. สร้าง Struct
type ชื่อStruct struct {
Field1 Type1
Field2 Type2
}
2. สร้างตัวแปร Struct
var1 := ชื่อStruct{Field1: value1, Field2: value2}
var2 := &ชื่อStruct{Field1: value1, Field2: value2} // pointer
3. เข้าถึงฟิลด์
var1.Field1 = newValue
4. สร้าง Method (Value Receiver)
func (v ชื่อStruct) ชื่อMethod() ReturnType {
// โค้ดของ method
}
5. สร้าง Method (Pointer Receiver)
func (v *ชื่อStruct) ชื่อMethod() ReturnType {
// โค้ดของ method (สามารถเปลี่ยนแปลงค่าใน struct ได้)
}
6. เรียกใช้ Method
var1.ชื่อMethod()
7. Embedding Structs
type ชื่อStructใหม่ struct {
ชื่อStructเดิม
Fieldใหม่ Type
}Bonus Pair Programming with GO : 1
Interface : ทำความรู้จักกับเพื่อนใหม่
Interfaces ใน Go เป็นเหมือน "สัญญา" ที่บอกว่าสิ่งของต่าง ๆ สามารถทำอะไรได้บ้าง โดยไม่ต้องสนใจว่าเป็นสิ่งของชนิดไหนจริง ๆ
Interface กำหนด ชุดของ Method ที่ต้องมี โดยไม่ระบุวิธีการทำงานภายใน ทำให้สิ่งของต่าง ๆ สามารถ "ปฏิบัติตาม" Interface ได้ตราบใดที่มี Method ตรงตามที่กำหนด มันจึงช่วยแยกการออกแบบ (What) ออกจากการนำไปใช้ (How หรือ Implementation) ออกจากกัน
ในตัวอย่างนี้ Soundmaker เป็น Interface ที่ "กำหนดว่า" หรือ "สัญญาว่า" อะไรก็ตามที่ทำเสียงได้ ต้องมี Method "MakeSound()" โดยไม่สนใจว่าจะเป็นสุนัขหรือแมว ทำให้เราสามารถใช้ Function "AnimalSound()" รับ Parameter ที่มี Type เป็นสัตว์ชนิดใดก็ได้ที่ "ทำเสียง" ได้
// ประกาศ Interface ระบุว่า Soundmaker ต้องสามารถทำอะไรได้บ้าง
// ไม่ได้บอกวิธีการทำงาน เพียงแค่กำหนดว่าต้องมีความสามารถอะไร (What)
type Soundmaker interface {
MakeSound() string
}
// การนำไปใช้ (How หรือ Implementation) แสดงวิธีการที่ Dog และ Cat จะทำเสียง
type Dog struct{}
type Cat struct{}
func (d Dog) MakeSound() string {
return "Woof!"
}
func (c Cat) MakeSound() string {
return "Meow!"
}
// (Usage) การใช้งาน Interface Soundmaker เป็น Parameter
func AnimalSound(s Soundmaker) {
fmt.Println(s.MakeSound())
}
func main() {
dog := Dog{}
cat := Cat{}
AnimalSound(dog) // พิมพ์ "Woof!"
AnimalSound(cat) // พิมพ์ "Meow!"
}เราส่ง dog และ cat เข้าไปใน AnimalSound() ได้โดยไม่ต้องเปลี่ยนแปลง Function รวมทั้งสามารถเพิ่มสัตว์ชนิดใหม่ที่ทำเสียงได้โดยไม่ต้องแก้ไข AnimalSound() เพราะ AnimalSound() ไม่จำเป็นต้องรู้รายละเอียดการทำงานภายในของสัตว์แต่ละประเภท
Empty Interface ทำให้ Function สามารถรับค่าได้ทุกชนิด
Empty Interface ใน Go เขียนแทนด้วย interface{} หรือในเวอร์ชันใหม่ ๆ ของ Go สามารถใช้ any ได้
Empty Interface เป็น Interface ที่ไม่มี Method ใด ๆ กำหนดไว้ ทำให้ทุก ๆ Type ใน Go Implement Interface นี้โดยอัตโนมัติ
func printAnything(v interface{}) {
fmt.Printf("Type: %T, Value: %v\n", v, v)
}
func main() {
printAnything(42)
printAnything("Hello")
printAnything(true)
printAnything([]int{1, 2, 3})
}
อย่างไรก็ตามการใช้ Empty Interface จะทำให้ Go ไม่มีการตรวจสอบ Type ขณะ Compile เราจึงต้องระมัดระวังเรื่องการเกิด Panic ครับ
// Function รับ Empty Interface เป็น Parameter
func doubleValue(v interface{}) {
// พยายามคูณค่าด้วย 2 โดยไม่ตรวจสอบ Type
result := v.(int) * 2
fmt.Println("Double value:", result)
}
// ทดลองเรียก Function กับข้อมูลต่าง ๆ
func main() {
doubleValue(5) // ทำงานได้
doubleValue("Hello") // เกิด Panic
}
การใช้ Empty Interface ทำให้เราต้องตรวจสอบ Type ของข้อมูลเอง เพื่อไม่ให้เกิด Panic และสามารถนำข้อมูลนั้นออกมาใช้ได้อย่างถูกต้อง
เหมือนกับการที่เรามีกล่องใส่ของหลาย ๆ ชนิด แต่เราอยากหยิบแค่ยาลดกรดออกมา เราจึงต้องตรวจสอบมันก่อนว่าสิ่งที่หยิบออกมาเป็นยาลดกรดหรือเปล่า แทนที่จะพยายามนำมากินแล้วกลายเป็นยาลดน้ำตาลในเลือด การกินผิดอาจทำให้น้ำตาลในเลือดต่ำหรือกรดไหลย้อนไม่ดีขึ้น
ใน Go เราสามารถใช้ Type Assertion หรือ Type Switch เพื่อตรวจสอบ Type ก่อนเข้าถึงค่าจริง ๆ
การใช้งาน Type Assertion
func doubleValue(v interface{}) {
if intValue, ok := v.(int); ok {
result := intValue * 2
fmt.Println("Double value:", result)
} else {
fmt.Printf("Cannot double value of type %T\n", v)
}
}
func main() {
doubleValue(5) // ทำงานได้
doubleValue("Hello") // ไม่เกิด Panic
}intValue, ok := v.(int) คือการพยายามแปลงค่า v ให้เป็น int ถ้าแปลงได้สำเร็จ ค่า int จะถูกเก็บใน intValue และ ok จะเป็น true แต่ถ้า v ไม่ใช่ int ตัวแปร intValue จะมีค่าเป็น 0 และ ok จะเป็น false
คำสั่ง if intValue, ok := v.(int); ok คือการเช็คค่า ok ที่เกิดจากการพยายามแปลงค่า v ถ้า ok เป็น true เราจะสามารถใช้ intValue ได้ แต่ถ้า ok เป็น false เราจะแสดงข้อความ "Cannot double value of type..." แทนที่จะปล่อยให้ Program เกิด Panic
การใช้งาน Type Switch
func doubleValue(v interface{}) {
switch val := v.(type) {
case int:
result := val * 2
fmt.Println("Double value:", result)
case float64:
result := val * 2
fmt.Println("Double value:", result)
default:
fmt.Printf("Cannot double value of type %T\n", v)
}
}
doubleValue(5) // ทำงานได้
doubleValue(3.14) // ทำงานได้กับ float64
doubleValue("Hello") // ไม่เกิด panicType Switch ทำให้เราสามารถจัดการกับ Type หลาย Type ได้สะดวก โดย Type อื่น ๆ ที่ไม่ได้ระบุใน case มันจะเข้า Default Case
ทั้ง Type Assertion และ Type Switch ทำให้ Code ของเราปลอดภัยขึ้นและสามารถจัดการกับข้อมูลที่ไม่ตรงตาม Type ที่คาดหวังได้อย่างเหมาะสมครับ
อย่างไรก็ตามเราควรใช้ Empty Interface เมื่อจำเป็นจริง ๆ เท่านั้น เช่น เมื่อต้องการความยืดหยุ่นสูงมาก หรือเมื่อทำงานกับข้อมูลที่ไม่รู้ Type ล่วงหน้า เช่น การ Parse JSON
เราสามารถทำ Embedding กับ Interface ได้เช่นเดียวกับการทำ Struct Embedding
Interface Embedding คือการรวม Interface หลาย ๆ Interface เข้าด้วยกันเพื่อสร้าง Interface ใหม่ที่มีความสามารถรวมกัน
// Interface สำหรับสิ่งมีชีวิตที่เคลื่อนไหวได้
type Mover interface {
Move() string
}
// Interface สำหรับสิ่งมีชีวิตที่ส่งเสียงได้
type Sounder interface {
MakeSound() string
}
// Interface สำหรับสัตว์เลี้ยง
type Pet interface {
GetName() string
}
// รวม Interfaces เข้าด้วยกันเป็น Animal
type Animal interface {
Mover
Sounder
Pet
}
// สร้าง Struct สำหรับแมว
type Cat struct {
Name string
}
// Implement Move สำหรับ Cat
func (c Cat) Move() string {
return c.Name + " is sneaking around"
}
// Implement MakeSound สำหรับ Cat
func (c Cat) MakeSound() string {
return c.Name + " says: Meow!"
}
// Implement GetName สำหรับ Cat
func (c Cat) GetName() string {
return c.Name
}
// Function ที่รับ Animal Interface
func DescribeAnimal(a Animal) {
fmt.Println("Name:", a.GetName())
fmt.Println("Movement:", a.Move())
fmt.Println("Sound:", a.MakeSound())
}
func main() {
myCat := Cat{Name: "ตุนตัง"}
DescribeAnimal(myCat)
}Interface Embedding หรือการใช้ Composition ของ Interface ทำให้สามารถออกแบบ Interface ได้อย่างยืดหยุ่น โดยการแยกความสามารถออกเป็นส่วน ๆ เช่น ถ้าเราต้องการเพิ่มความสามารถของ Animal เราอาจจะสร้าง Interface ใหม่ แล้วเพิ่มเข้าไปใน Interface "Animal" ครับ
Function ใน Go สามารถส่งค่ากลับเป็น Interface ได้ เช่น Function "getRandomAnimal()" ในตัวอย่างถัดไป ที่จะส่งค่ากลับเป็น Interface Soundmaker ซึ่งจะทำให้มันสามารถส่งค่ากลับจริง ๆ เป็น Type Dog, Cat หรือ Cow ซึ่งมีการ Implement Soundmaker Interface (Implement Method MakeSound)
ทำให้ในอนาคตเราสามารถเพิ่มสัตว์ชนิดใหม่ (ซึ่งมีการ Implement Soundmaker Interface) ที่มีความสามารถแตกต่างกันได้ตามต้องการ โดยไม่ต้องเปลี่ยนแปลง Signature ของ Function "getRandomAnimal()"
package main
import (
"fmt"
"math/rand"
)
// ประกาศ Interface
type Soundmaker interface {
MakeSound() string
}
// การนำไปใช้ (Implementation)
type Dog struct{}
type Cat struct{}
type Cow struct{}
func (d Dog) MakeSound() string {
return "Woof!"
}
func (c Cat) MakeSound() string {
return "Meow!"
}
func (c Cow) MakeSound() string {
return "Moo!"
}
// Function ที่ส่งค่ากลับเป็น Interface Soundmaker
func getRandomAnimal() Soundmaker {
randomNumber := rand.Intn(3)
switch randomNumber {
case 0:
return Dog{}
case 1:
return Cat{}
default:
return Cow{}
}
}
// การใช้งาน Interface Soundmaker เป็น Parameter
func AnimalSound(s Soundmaker) {
fmt.Println(s.MakeSound())
}
func main() {
// ใช้ Function ที่ส่งค่ากลับเป็น Interface
for i := 0; i < 5; i++ {
animal := getRandomAnimal()
fmt.Printf("สัตว์ตัวที่ %d ส่งเสียง: ", i+1)
AnimalSound(animal)
}
// ตัวอย่างการใช้ type assertion
randomAnimal := getRandomAnimal()
switch v := randomAnimal.(type) {
case Dog:
fmt.Println("นี่คือหมา!")
case Cat:
fmt.Println("นี่คือแมว!")
case Cow:
fmt.Println("นี่คือวัว!")
default:
fmt.Printf("ไม่รู้จักสัตว์ชนิดนี้: %T\n", v)
}
}Exercise
สร้าง Interface "Mover" ที่มี method Move() และ Implement ด้วย Struct ต่าง ๆ
Go Quiz 7 (23 ข้อ) ขอให้สนุกกับการทำ Quiz นะครับ
Q&A?
รวม Cheat Sheet Interface : ทำความรู้จักกับเพื่อนใหม่
Interface
---------
1. ประกาศ Interface
type ชื่อInterface interface {
ชื่อMethod1() ReturnType1
ชื่อMethod2(ParamType) ReturnType2
}
2. การ Implement Interface
- Struct ที่มี Method ตรงกับที่ Interface กำหนดจะ Implement Interface โดยอัตโนมัติ
- ไม่ต้องประกาศว่า Implement เหมือนภาษาอื่น
3. การใช้ Interface เป็น Parameter:
func ชื่อฟังก์ชัน(param ชื่อInterface) {
// ใช้งาน methods ของ interface
}
4. Empty Interface
interface{} // รับได้ทุกชนิดข้อมูล
5. Type Assertion
value, ok := interfaceVar.(ConcreteType)
6. Type Switch
switch v := interfaceVar.(type) {
case Type1:
// v เป็น Type1
case Type2:
// v เป็น Type2
default:
// ไม่ตรงกับ Type ที่ระบุ
}
7. Best Practices:
- ออกแบบ Interface ให้เล็กและมีจุดประสงค์ชัดเจน
- ใช้ Composition ของ Interfaces เพื่อสร้าง Interface ที่ซับซ้อนขึ้นPackage และ Module : แต่ละแผนกมีหน้าที่เฉพาะ และ Project ใหญ่ที่ประกอบด้วยหลายแผนก
Package และ Module เป็นวิธีจัดระเบียบและแบ่งปัน Code
โดย Package คือ "กลุ่มของไฟล์ Go ที่อยู่ใน Folder เดียวกัน" และ "ทำงานเกี่ยวข้องกัน"
// ไฟล์ math/calculator.go
package math
func Add(a, b int) int {
return a + b
}
// ไฟล์ main.go
package main
import (
"fmt"
"myproject/math"
)
func main() {
result := math.Add(5, 3)
fmt.Println("5 + 3 =", result)
}จากตัวอย่างนี้จะเป็นการสร้าง Package "math" ที่เก็บใน Folder "myproject" โดยโครงสร้างของ Folder และ File จะเป็นดังนี้
myproject/
├── math/
│ └── calculator.go
└── main.goจากตัวอย่างด้านบน เราจะสร้าง myproject เป็น Folder หลักของ Project และสร้าง Folder ย่อย math สำหรับ Package "math"
Go จะใช้ชื่อ Folder ในการอ้างอิงเวลา Import เราจึงไม่จำเป็นต้องตั้งชื่อ Folder เป็นชื่อเดียวกันกับชื่อ Package แต่โดยทั่วไปแล้วการตั้งชื่อ Folder ให้ตรงกับชื่อ Package นั้นเป็นแนวปฏิบัติที่ดี ซึ่งจะช่วยให้ Code อ่านง่ายขึ้นครับ
ใน Folder ย่อย math เราจะสร้าง File "calculator.go" ที่มี Function "Add" โดยใน File "calculator.go" จะมีเนื้อหาดังนี้
// ไฟล์ math/calculator.go
package math
func Add(a, b int) int {
return a + b
}เราประกาศว่า Code นี้อยู่ใน Package ชื่อ "math" ด้วยคำสั่ง package math ซึ่งใน Folder "math" สามารถมีไฟล์ได้หลายไฟล์ แต่ ทุกไฟล์จะต้องประกาศชื่อ Package เดียวกัน
Function "Add" ต้อง ขึ้นต้นด้วยตัวพิมพ์ใหญ่ เพื่อให้สามารถ Export ได้ ส่วนชื่อ Function ที่ขึ้นต้นด้วยตัวพิมพ์เล็กจะใช้ได้เฉพาะภายใน Package เท่านั้น
ใน Folder "myproject" เราจะสร้าง File "main.go" เป็นไฟล์หลักที่มีเนื้อหาดังนี้
// ไฟล์ main.go
package main
import (
"fmt"
"myproject/math"
)
func main() {
result := math.Add(5, 3)
fmt.Println("5 + 3 =", result)
}ใน Go เราต้องระบุว่า Code ส่วนนี้เป็น Package หลักของ Program ซึ่งจำเป็นสำหรับการสร้างไฟล์ Executable ด้วยคำสั่ง package main
package main ในไฟล์ main.go จะไม่สามารถเปลี่ยนเป็นชื่ออื่นได้ ถ้าต้องการให้ Program ของเราเป็น Program ที่สามารถรันได้เมื่อเรา Build Program
เมื่อเรา Build Program ด้วยคำสั่ง go build แล้ว Go Compiler จะมองหา package main รวมทั้ง func main() เพื่อกำหนดจุดเป็นเริ่มต้นของ Program ดังนั้น func main() ต้องอยู่ใน package main เท่านั้น เมื่อต้องการ Build Program
import คือ ส่วนนำเข้า Package ที่จะใช้ ซึ่ง main.go จะใช้งาน Package "fmt" ที่เป็น Package มาตรฐานสำหรับการ Input/Output และ Package "math" ที่เราสร้างขึ้น
import (
"fmt"
"myproject/math"
)ใน func main() มีการเรียกใช้ Function "Add" จาก Package "math" และ Function Println จาก Package "fmt" เพื่อแสดงผลลัพธ์
func main() {
result := math.Add(5, 3)
fmt.Println("5 + 3 =", result)
}Module คือ กลุ่มของ Package ที่เกี่ยวข้องกัน ซึ่งจะถูกพัฒนาและถูกจัดการ Version ร่วมกัน
เราจะเพิ่ม Package ใหม่ชื่อ "utils" ที่มี Function สำหรับการแปลงตัวเลขเป็นคำอ่านภาษาไทย ดังนี้
1. สร้าง Folder ใหม่ชื่อ "utils" เป็น Folder ย่อยใน myproject
myproject/
├── math/
│ └── calculator.go
├── utils/
│ └── converter.go
└── main.go2. สร้างไฟล์ "converter.go" ใน Folder "utils"
// ไฟล์ utils/converter.go
package utils
func NumberToThai(num int) string {
thaiNumbers := []string{"ศูนย์", "หนึ่ง", "สอง", "สาม", "สี่", "ห้า", "หก", "เจ็ด", "แปด", "เก้า"}
if num >= 0 && num <= 9 {
return thaiNumbers[num]
}
return "ไม่สามารถแปลงได้"
}3. แก้ไขไฟล์ main.go เพื่อเรียกใช้งาน Package ใหม่
// ไฟล์ main.go
package main
import (
"fmt"
"myproject/math"
"myproject/utils"
)
func main() {
result := math.Add(5, 3)
fmt.Println("5 + 3 =", result)
thaiNumber := utils.NumberToThai(result)
fmt.Println("ผลลัพธ์เป็นภาษาไทย:", thaiNumber)
}ดังนั้นในตัวอย่างนี้ ชื่อ Module ของเรา คือ myproject
เพื่อกำหนด Module อย่างเป็นทางการ เราจะสร้างไฟล์ go.mod ใน Folder "myproject" โดยใช้คำสั่ง go mod init
go mod init myproject
หลังจากรันคำสั่ง go mod init แล้ว Go จะสร้างไฟล์ go.mod ใน Folder "myproject"
.
├── go.mod
├── main.go
├── math
│ └── calculator.go
├── myproject
└── utils
└── converter.goไฟล์ go.mod ใน Folder "myproject" มีเนื้อหาดังตัวอย่างต่อไปนี้
module myproject
go 1.21.0การมี Module อย่างเป็นทางการ จะช่วยในการจัดการ Dependency และทำให้การ Import Package ภายใน Project เป็นไปอย่างถูกต้อง ซึ่งเป็นไปตามหลักการออกแบบและพัฒนา Software แบบ 12-Factor App ที่เราได้เรียนมาในอาทิตย์ก่อนหน้าครับ
หลังจากสร้างไฟล์ go.mod แล้ว เราสามารถ Build Program โดยใช้คำสั่ง go build อย่างสั้น ๆ ได้ ซึ่ง go build จะ Compile Code แล้วสร้างไฟล์ Executable ชื่อ "myproject" ที่สามารถรันบน macOS ด้วยคำสั่ง ./myproject ตามตัวอย่างต่อไปนี้
Go มี Standard Library ที่ครอบคลุมและมีประสิทธิภาพมากมาย เช่น
- fmt สำหรับการ Input/Output
- time จัดการเวลาและวันที่
- encoding/json เข้าและถอดรหัส JSON
- database/sql ทำงานกับฐานข้อมูล SQL
- errors สำหรับการ Error
- testing สำหรับ Unit Testing
การใช้งาน Standard Library เหล่านี้ เราเพียง Import มันมายัง Go Code ตามต้องการ โดยไม่ต้องติดตั้ง Library เพิ่ม
import (
"database/sql"
"fmt"
)
แต่เมื่อต้องการใช้งาน Module ภายนอกที่ไม่ได้อยู่ใน Standard Library ของ Go เช่น Web Framework "gin" เราต้องใช้คำสั่ง go get
go get github.com/gin-gonic/gin
ซึ่ง Go จะมีการเพิ่ม Dependency ในไฟล์ go.mod ดังตัวอย่างต่อไปนี้
module myproject
go 1.21.0
require (
github.com/bytedance/sonic v1.11.6 // indirect
github.com/bytedance/sonic/loader v0.1.1 // indirect
github.com/cloudwego/base64x v0.1.4 // indirect
github.com/cloudwego/iasm v0.2.0 // indirect
github.com/gabriel-vasile/mimetype v1.4.3 // indirect
github.com/gin-contrib/sse v0.1.0 // indirect
github.com/gin-gonic/gin v1.10.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.20.0 // indirect
github.com/goccy/go-json v0.10.2 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.2.7 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.2.2 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.2.12 // indirect
golang.org/x/arch v0.8.0 // indirect
golang.org/x/crypto v0.23.0 // indirect
golang.org/x/net v0.25.0 // indirect
golang.org/x/sys v0.20.0 // indirect
golang.org/x/text v0.15.0 // indirect
google.golang.org/protobuf v1.34.1 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)อย่างไรก็ตาม Dependency เหล่านี้จะถูก Comment เป็น // indirect เพราะมีการติดตั้ง Moddule "gin" ก่อนการใช้งานใน Go Code
นอกจากการเพิ่ม Dependency ในไฟล์ go.mod แล้ว Go ยังสร้างไฟล์ go.sum ที่เก็บ Hash (จาก Hash Algorithm เช่น SHA-256) ของแต่ละ Module ที่ Project ของเราใช้ เพื่อตรวจสอบความถูกต้องของ Module ที่ Download มา
โครงสร้างของ Hash ในแต่ละ Module ของไฟล์ go.sum
<module> <version> <hash>
<module> <version>/go.mod <hash>ตัวอย่าง go.sum เมื่อติดตั้ง Module "gin"
github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
ทุกครั้งที่ Download หรือใช้ Module ใน Version นั้น ๆ Go จะตรวจสอบ Hash ใน go.sum กับ Hash ที่คำนวณได้จาก Module ที่ Download หรือใช้งานในปัจจุบัน (จาก Cache) ถ้า Hash ไม่ตรงกัน Go จะแจ้งเตือนและหยุดการทำงาน
วิธีนี้ช่วยให้มั่นใจได้ว่า Module ที่ใช้ ยังคงเหมือนเดิมกับตอนที่ Download หรือ Update ครั้งแรก ไม่มีการเปลี่ยนแปลงโดยไม่ได้ตั้งใจหรือจะเป็นอันตรายจากการพยายามแก้ไข Module โดยไม่เปลี่ยน Version อย่างถูกต้อง
สมมติว่าเราเพิ่ม Code API ด้วย Web Framework "gin" ใน func main()แล้วกด Save, VS Code จะแทรกการ Import "github.com/gin-gonic/gin" และ "net/http" ลงใน Code ให้โดยอัตโนมัติ
// ไฟล์ main.go
package main
import (
"fmt"
"myproject/math"
"myproject/utils"
"net/http"
"github.com/gin-gonic/gin"
)
func main() {
result := math.Add(5, 3)
fmt.Println("5 + 3 =", result)
thaiNumber := utils.NumberToThai(result)
fmt.Println("ผลลัพธ์เป็นภาษาไทย:", thaiNumber)
// สร้าง Gin engine
r := gin.Default()
// กำหนด route
r.GET("/ping", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"message": "pong",
})
})
// กำหนด route ที่รับพารามิเตอร์
r.GET("/hello/:name", func(c *gin.Context) {
name := c.Param("name")
c.String(http.StatusOK, "Hello %s", name)
})
// รัน server ที่ port 8080
r.Run(":8080")
}
เราสามารถใช้คำสั่ง go mod tidy เพื่อทำให้ไฟล์ go.mod และ go.sum สะท้อนสถานะจริงของ Project โดยรักษาความสอดคล้องและความถูกต้องของ Dependency
go mod tidygo mod tidy จะช่วยจัดการและ Update สถานะของ Dependency ในไฟล์ go.mod โดยแยก github.com/gin-gonic/gin ออกมาไว้ต่างหาก
module myproject
go 1.21.0
require github.com/gin-gonic/gin v1.10.0
require (
github.com/bytedance/sonic v1.11.6 // indirect
github.com/bytedance/sonic/loader v0.1.1 // indirect
github.com/cloudwego/base64x v0.1.4 // indirect
github.com/cloudwego/iasm v0.2.0 // indirect
github.com/gabriel-vasile/mimetype v1.4.3 // indirect
github.com/gin-contrib/sse v0.1.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.20.0 // indirect
github.com/goccy/go-json v0.10.2 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.2.7 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.2.2 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.2.12 // indirect
golang.org/x/arch v0.8.0 // indirect
golang.org/x/crypto v0.23.0 // indirect
golang.org/x/net v0.25.0 // indirect
golang.org/x/sys v0.20.0 // indirect
golang.org/x/text v0.15.0 // indirect
google.golang.org/protobuf v1.34.1 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
เมื่อใช้คำสั่ง go mod why เพื่อดูว่าทำไม Dependency นี้ถึงจำเป็น จะพบว่ามันไม่ถูกใช้ จาก Dependency อื่น จึงไม่มีการ Comment เป็น // indirect อีกต่อไป
go mod why github.com/gin-gonic/gin
แต่ถ้าใช้คำสั่ง go mod why กับ Indirect Dependency เช่น github.com/bytedance/sonic เราจะเห็นว่า Indirect Dependency นี้ถูกใช้โดย Dependency ใดบ้าง
go mod why github.com/bytedance/sonic
เรามักจะใช้คำสั่ง go get -u เพื่อ Update Dependency ให้เป็น Version ล่าสุด ร่วมกับคำสั่ง go mod tidy เพื่อทำความสะอาด และจัดการความสอดคล้องของ Dependency เช่น
go get -u github.com/gin-gonic/gin
go mod tidyแต่การอัพเดท Dependency อาจทำให้เกิดการเปลี่ยนแปลงที่ไม่คาดคิดใน Code เราจึงควรทดสอบ Program หลังจากรัน go mod tidy เสมอ
Exercise
สร้าง Package ง่าย ๆ และ Import มาใช้ในโปรแกรมหลัก
Go Quiz 8 (20 ข้อ) ขอให้สนุกกับการทำ Quiz นะครับ
Q&A?
รวม Cheat Sheet Package และ Module
Package และ Module
------------------
1. สร้าง Package
- สร้าง Folder ใหม่
- สร้างไฟล์ .go ใน Folder นั้น
- เริ่มไฟล์ด้วย package ชื่อแพ็คเกจ
2. Import Package
import "path/to/package"
import (
"package1"
"package2"
)
3. Export/Unexport
- Function หรือตัวแปรที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่จะ Export ได้
- ที่ขึ้นต้นด้วยตัวพิมพ์เล็กจะใช้ได้เฉพาะภายใน Package
4. สร้าง Module
go mod init github.com/username/module
5. เพิ่ม Dependency
go get package_url
6. ทำไม Dependency นี้จึงจำเป็น
go mod why
7. Update Dependency
go get -u
go mod tidy
8. ไฟล์สำคัญ
- go.mod รายการ Dependency
- go.sum ตรวจสอบความถูกต้องของ Dependency
9. Build
go buildError, Defer, Panic และ Recover : จัดการกับปัญหา
การจัดการกับปัญหาหรือข้อผิดพลาด เป็นส่วนสำคัญในการสร้าง Program ที่มีความทนทานและน่าเชื่อถือ
Go มีแนวทางที่เรียบง่ายและชัดเจนในการจัดการข้อผิดพลาด โดยไม่มี Exception แบบที่พบในภาษาอื่น
Go มี Built-in Interface "error" (error ไม่มี s) ที่มี Method เดียว คือ Method "Error()" ซึ่งไม่รับพารามิเตอร์ และคืนค่าเป็น string ที่อธิบายข้อผิดพลาดโดยไม่จำเป็นต้อง Import อะไรเพิ่มเติมเพื่อใช้งาน
// การประกาศ Interface error เป็น Built-in Interface ใน Go
type error interface {
Error() string
}และ Go มี Standard Library "errors" สำหรับการจัดการข้อผิดพลาด
import "errors"Interface "error" จะถูกส่งกลับจาก Function "New()" ใน Library "errors"
// Function "New" และการ Implement Method Error() แก่ errorString ใน Library "errors"
package errors
func New(text string) error {
return &errorString {
text
}
}
type errorString struct {
s string
}
func(e * errorString) Error() string {
return e.s
}เราจึงสามารถเขียน Function ที่สามารถจัดการกับข้อผิดพลาดที่อาจเกิดขึ้นได้โดยการส่งค่ากลับเป็น Interface "error" เช่น
// ประกาศ Function "divide" ให้ส่งค่ากลับเป็น Interface "error"
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("หารด้วยศูนย์ไม่ได้")
}
return a / b, nil
}การตรวจสอบและจัดการ Error
Function "divide" จะคืนค่า 2 ค่า ค่าแรกเป็น float64 ซึ่งเป็นค่าผลลัพธ์ที่ต้องการ และค่าที่สองเป็น error จาก Built-in Interface
ถ้า Function ทำงานสำเร็จ มันจะคืนค่าผลลัพธ์และ nil แต่ถ้าเกิดข้อผิดพลาด มันจะคืนค่า 0 และ error ที่ไม่ใช่ nil ด้วยคำสั่ง errors.New("หารด้วยศูนย์ไม่ได้")
หมายเหตุ errors คือชื่อ Library และ New() คือ Function ใน Library "errors"
result, err := divide(10, 0)
if err != nil {
fmt.Println("เกิดข้อผิดพลาด:", err)
} else {
fmt.Println("ผลลัพธ์:", result)
}การมี Built-in Interface "error" จะทำให้เราสามารถสร้าง Error แบบกำหนดเองได้ เช่น ด้วยการ Implement Method Error() แก่ DivisionError ที่มี 2 Field คือ dividend และ divisor
package main
import (
"fmt"
)
// Implement Error Interface (Implement Method Error())
type DivisionError struct {
dividend float64
divisor float64
}
func (e *DivisionError) Error() string {
return fmt.Sprintf("ไม่สามารถหาร %.2f ด้วย %.2f ได้", e.dividend, e.divisor)
}
// การใช้งาน
func safeDivide(a, b float64) (float64, error) {
if b == 0 {
return 0, &DivisionError{a, b}
}
return a / b, nil
}
func main() {
result, err := safeDivide(5, 0)
if err != nil {
fmt.Println("เกิดข้อผิดพลาด", err)
} else {
fmt.Printf("5 / 0 = %.2f\n", result)
}
}ในตัวอย่างนี้เราไม่ได้เรียกใช้ Function "errors.New()" ใน Code จึงไม่ต้องมีการ Import Package "errors"
Go มีกลไกพิเศษสำหรับจัดการกับข้อผิดพลาดร้ายแรง
เราจะใช้คำสั่ง defer ที่คล้ายกับ Try-Finally ในภาษาอื่น แต่มีความยืดหยุ่นมากกว่า เพื่อทำให้แน่ใจว่าข้อผิดพลาดร้ายแรงจะถูกจัดการก่อน Program จะหยุดทำงาน
defer ช่วยให้เราสามารถจัดการกับสิ่งที่ต้องทำหลังจากงานหลักเสร็จ โดยไม่ต้องกังวลว่าจะลืม และช่วยให้ Code ของเราเป็นระเบียบมากขึ้น เหมือนกับการวางแผนให้ดีก่อนไปเที่ยว โดยการจดสิ่งที่ต้องทำหลังกลับบ้าน ลงในสมุดโน้ต เราจะได้สนุกเต็มที่โดยไม่ต้องกังวลว่าจะลืมทำอะไรเมื่อกลับถึงบ้าน
func readFile(filename string) error {
file, err := os.Open(filename)
if err != nil {
return err
}
defer file.Close()
// ทำงานกับไฟล์...
return nil
}จากตัวอย่างนี้ เมื่อเจอคำสั่ง defer, Go จะบันทึก Function และ Argument (ถ้ามี) ไว้ โดย Function "file.Close()" ที่ถูก defer จะถูกเรียกหลังจาก Function "readFile()" ที่ครอบอยู่ทำงานเสร็จ ก่อนการคืนค่า nil (return nil)
defer ทำให้ Code อ่านง่ายขึ้น โดยวาง Cleanup Code เช่น การปิดไฟล์เพื่อคืนทรัพยากร ไว้ใกล้กับจุดที่ใช้ทรัพยากร
ถ้ามีหลาย defer มันจะทำงานแบบ Last In First Out (LIFO)
func processFile() {
defer fmt.Println("3. ปิดไฟล์")
defer fmt.Println("2. เขียนข้อมูลลงไฟล์")
defer fmt.Println("1. เปิดไฟล์")
fmt.Println("กำลังประมวลผล...")
}
// Output:
// กำลังประมวลผล...
// 1. เปิดไฟล์
// 2. เขียนข้อมูลลงไฟล์
// 3. ปิดไฟล์defer ทำงานแม้ในกรณีที่เกิด Panic
กลไกพิเศษสำหรับจัดการกับ Error ร้ายแรงในที่นี้คือ recover() ซึ่งจะส่งค่ากลับที่ไม่ใช่ nil เมื่อเกิด Panic ดังนั้นเมื่อใช้ร่วมกับ defer ก็จะทำให้มั่นใจได้ว่า มันจะจัดการ Error เมื่อเกิด Panic โดยที่ Program ยังคงสามารถทำงานต่อไปได้
package main
import (
"fmt"
)
// Function ที่อาจเกิดข้อผิดพลาดร้ายแรง
func riskyFunction() {
// defer Function ที่จะจับ Panic
defer func() {
// ใช้ recover() เพื่อจับ Panic
if r := recover(); r != nil {
fmt.Println("Recovered:", r)
}
}()
// จำลองการเกิดข้อผิดพลาดร้ายแรงด้วย Panic
panic("เกิดข้อผิดพลาดร้ายแรง!")
// บรรทัดนี้จะไม่ถูกทำงานเนื่องจากเกิด Panic ก่อนหน้านี้
fmt.Println("บรรทัดนี้จะไม่ถูกพิมพ์")
}
func main() {
// เรียกใช้ Function ที่อาจเกิดข้อผิดพลาด
riskyFunction()
// แสดงข้อความว่าโปรแกรมยังทำงานต่อได้
fmt.Println("โปรแกรมยังทำงานต่อไปได้")
}
Exercise
เขียน Function ที่อาจเกิดข้อผิดพลาด และจัดการกับข้อผิดพลาดที่อาจเกิดขึ้น
Go Quiz 9 (15 ข้อ) ขอให้สนุกกับการทำ Quiz นะครับ
Q&A?
รวม Cheat Sheet Error, Defer, Panic และ Recover
Error, Defer, Panic และ Recover
-------------------------------
1. การสร้างและคืนค่า Error
errors.New("ข้อความอธิบายข้อผิดพลาด")
2. การตรวจสอบ Error
if err != nil {
// จัดการกับข้อผิดพลาด
}
3. Custom Error
type MyError struct {
// ฟิลด์ที่เกี่ยวข้อง
}
func (e *MyError) Error() string {
return "คำอธิบายข้อผิดพลาด"
}
4. Defer
defer function() // ทำงานหลังจาก Function หลักเสร็จสิ้น
5. Panic
panic("ข้อความอธิบายสถานการณ์ร้ายแรง")
6. Recover
defer func() {
if r := recover(); r != nil {
// จัดการกับ Panic
}
}()
7. Best Practice
- ตรวจสอบ error ทุกครั้งที่เรียก Function ที่อาจเกิดข้อผิดพลาด
- ใช้ Custom Error เพื่อให้ข้อมูลเพิ่มเติมเกี่ยวกับข้อผิดพลาด
- ใช้ Panic เฉพาะกรณีที่โปรแกรมไม่สามารถดำเนินการต่อได้จริงๆการทดสอบเบื้องต้น : ลองชิมอาหารก่อนเสิร์ฟ
การทดสอบเป็นส่วนสำคัญในการพัฒนา Software ที่มีคุณภาพ การทดสอบช่วยให้มั่นใจว่า Code ของเราทำงานถูกต้องตามความต้องการ
Unit Test เป็นการทดสอบส่วนย่อยที่สุดของ Code ซึ่งโดยปกติคือการทดสอบระดับ Function หรือ Method เพื่อตรวจสอบว่ามันทำงานถูกต้องตามที่คาดหวังหรือไม่
การเขียน Unit Test เป็นความรับผิดชอบร่วมกันของทีม โดยมี Software Developer เป็นผู้รับผิดชอบหลัก ซึ่ง Software Developer ควรเขียน Unit Test สำหรับ Code ที่ตนเองพัฒนา
การทำ Unit Test จะช่วยให้การ Refactor Code ง่ายขึ้น ซึ่ง Refactor Code เป็นการปรับปรุง Code เพื่อให้อ่านง่าย บำรุงรักษาง่าย และมีประสิทธิภาพมากขึ้น โดยไม่เปลี่ยนแปลงพฤติกรรมภายนอกที่มองเห็นได้ เพราะเราสามารถ Refactor มันทีละส่วน และรัน Test เพื่อยืนยันความถูกต้องในแต่ละขั้นตอน
Go มี Standard Library "testing" สำหรับทำ Unit Test โดยไม่ต้องติดตั้ง Library เพิ่มเติม
// ไฟล์ internal/math/calculator.go
package math
func Add(a, b int) int {
return a + b
}
// ไฟล์ internal/math/calculator_test.go
package math
import "testing"
func TestAdd(t *testing.T) {
result := Add(2, 3)
if result != 5 {
t.Errorf("Add(2, 3) = %d; want 5", result)
}
}สมมติว่าเรากำลังสร้าง Package "math" ที่มี Function "Add" อยู่ในไฟล์ calculator.go
เพื่อตรวจสอบว่ามันทำงานถูกต้องตามที่คาดหวังหรือไม่ เราจึงเขียน Unit Test เพื่อทดสอบ Code โดยตั้งชื่อไฟล์ที่ลงท้ายด้วย _test.go และเก็บไว้ใน Folder เดียวกันกับ Code ของ Package "math" แม้ว่าไฟล์ Test จะไม่จำเป็นต้องมีชื่อข้างหน้าเหมือนกับไฟล์ที่เก็บ Fucntion ที่จะ Test ใน Package "math" แต่เพื่อให้สามารถแยกการทดสอบตามกลุ่ม Function ในไฟล์ได้อย่างชัดเจน โดยไม่เกิดความสับสนในภายหลัง เราจึงตั้งชื่อไฟล์ Test เป็น calculator_test.go แล้วจึงเขียน Test Case
เมื่อรัน Test และปรับปรุง Package จนผ่านทุก Test Case ตามที่คาดหวังแล้ว เราจะทดลองใช้งาน Package "math" ใน main.go ต่อไป
Project ที่มีการทำ Unit Test สามารถใช้โครงสร้าง ดังตัวอย่างด้านล่าง
myproject/
├── cmd/
│ └── main.go
├── internal/
│ └── math/
│ ├── calculator.go
│ └── calculator_test.go
├── go.mod
└── go.sum- Folder cmd สำหรับเก็บไฟล์หลักของ Application
- Folder internal สำหรับเก็บ Package ที่ใช้ภายใน Project นี้
- ไฟล์ go.mod และ go.sum ไฟล์สำหรับการจัดการ Dependency
แต่ก่อนอื่นให้เราสร้าง Folder cmd, internal และ math รวมทั้งไฟล์ calculator.go และ calculator_test.go ดังต่อไปนี้
calculator.go คือ ไฟล์ที่เก็บ Code ใน Package "math" ซึ่งมี Function "Add" ที่จะ Test
// ไฟล์ internal/math/calculator.go
package math
func Add(a, b int) int {
return a + b
}
calculator_test.go คือไฟล์ Test ซึ่งต้องอยู่ใน Package เดียวกันกับ Code ที่จะทดสอบ
Function Test ของ Go ต้องขึ้นต้นด้วยคำว่า "Test" และอาจตามด้วยชื่อ Function หรือ Feature ที่ต้องการจะ Test โดยต้องมีการรับพารามิเตอร์เป็น Pointer ไปยัง Struct T (*testing.T)
หมายเหตุ testing คือ ชื่อ Package และ T คือ Struct ใน Package "testing" ที่มี Method สำหรับการ Test เช่น Method Errorf() สำหรับรายงานความล้มเหลวและรัน Test Case ที่เหลือต่อ
// ไฟล์ internal/math/calculator_test.go
package math
import "testing"
func TestAdd(t *testing.T) {
result := Add(2, 3)
//การ Assert
if result != 5 {
t.Errorf("Add(2, 3) = %d; want 5", result)
}
}
โครงสร้าง Project สำหรับการ Test ในตอนนี้
myproject/
├── cmd
└── internal
└── math
├── calculator.go
└── calculator_test.goก่อนรัน Test เราควรจะต้องมีไฟล์ go.mod โดยการใช้คำสั่ง go mod init
go mod init myprojectตัวอย่างไฟล์ go.mod
module myproject
go 1.21.0
โครงสร้าง Project สำหรับการ Test ในตอนนี้
.
├── cmd
├── go.mod
└── internal
└── math
├── calculator.go
└── calculator_test.goเพื่อจะ Test เราจะใช้คำสั่ง go test ./... เพื่อ Test ทั้ง Project หรือใช้คำสั่ง go test ./internal/math เพื่อระบุ Package ที่จะ Test โดยตรง
go test ./...
หรือ
go test ./internal/math 
เพื่อให้ง่ายต่อการเพิ่มหรือแก้ไข Test Case และสามารถทดสอบได้หลายกรณีพร้อมกันใน Function เดียว เราจะใช้เทคนิค Table-Driven Test ในการเขียน Test Case
Table-Driven Test คือ การเขียนชุดทดสอบโดยใช้โครงสร้างข้อมูลแบบตาราง (เช่น slice ของ struct) เพื่อกำหนดชุดของ Input และ Expected Output
เราจะสร้าง slice ของ struct ที่มี name ซึ่งอธิบายว่ากำลังทดสอบอะไร, input (a และ b) และ expected (ค่าที่คาดหวัง) แล้วใช้ t.Run() เพื่อรัน Subtest สำหรับแต่ละ Test Case
โดยการใช้ t.Run() จะทำให้ Go สามารถแสดงผลการทดสอบแยกตาม Subtest และเห็นว่า Test Case ไหนผ่านหรือไม่ผ่าน
ในแต่ละ Subtest เราเรียก Function "Add" ด้วย Input ที่กำหนด และเปรียบเทียบผลลัพธ์กับค่าที่คาดหวัง ถ้าผลลัพธ์ไม่ตรงกับค่าที่คาดหวัง เราจะใช้ t.Errorf() เพื่อรายงานความล้มเหลวพร้อมกับข้อมูลที่เกี่ยวข้อง
// ไฟล์ internal/math/calculator.go
package math
import "testing"
func TestAdd(t *testing.T) {
// กำหนดชุดของ test cases
tests := []struct {
name string
a int
b int
expected int
}{
{"positive numbers", 2, 3, 5},
{"negative numbers", -2, -3, -5},
{"mixed numbers", -2, 3, 1},
{"zero and positive", 0, 5, 5},
{"zero and negative", 0, -5, -5},
{"both zero", 0, 0, 0},
{"large numbers", 1000000, 2000000, 3000000},
}
// วนลูปทดสอบแต่ละ test case
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := Add(tt.a, tt.b)
if result != tt.expected {
t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
}
})
}
} ในการ Test เราสามารถใช้คำสั่ง go test -v เพื่อให้ Go แสดงรายละเอียดที่มากขึ้น
go test -v ./...
หรือ
go test -v ./internal/math 
Test Coverage คือการวัดว่า Code ของเราถูกทดสอบมากน้อยเพียงใด โดย Go จะวัด % ของ Coverage จากสัดส่วนของจำนวน Statement ใน Code ที่ถูกรันระหว่างการทดสอบกับจำนวน Statement ทั้งหมด
ในการดู % ของ Coverage เราสามารถใช้คำสั่ง go test -cover
go test -cover ./...
อย่างไรก็ตาม Coverage 100% ไม่ได้หมายความว่าทุก Logic ใน Code จะถูกทดสอบ เราจึงควรพิจารณาคุณภาพของ Test Cast ควบคู่ไปกับ % ของ Coverage ด้วย
หลังจากรัน Unit Test แล้วเราจะทดลองใช้งาน Package "math" ใน main.go ดังตัวอย่างต่อไปนี้
// ไฟล์ cmd/main.go
package main
import (
"fmt"
"myproject/internal/math"
)
func main() {
result := math.Add(5, 3)
fmt.Printf("ผลลัพธ์ของ 5 + 3 = %d\n", result)
// ทดลองใช้งานเพิ่มเติม
a := 10
b := 7
sum := math.Add(a, b)
fmt.Printf("ผลลัพธ์ของ %d + %d = %d\n", a, b, sum)
}
โครงสร้าง Project สำหรับการ Test จะมีดังนี้
myproject/
├── cmd
│ └── main.go
├── go.mod
└── internal
└── math
├── calculator.go
└── calculator_test.goเราสามารถรัน Code จาก main.go ที่ myproject ด้วยคำสั่ง go run cmd/main.go ครับ
go run cmd/main.go
Unit Test กับ Grader
นักศึกษาหลายคนมักจะเคยชินกับการฝึกทำโจทย์ด้วย Grader โดยการส่ง Code ไปตรวจที่ Server ซึ่งมีการกำหนด Test Case ไว้ล่วงหน้า โดยมากมักจะเป็น Test Case แบบ Positive Test (Happy Path) ที่จะมีการตรวจสอบว่าผลลัพธ์ตรงตามที่คาดหวังในกรณีปกติหรือไม่
Grader ทำให้ผู้เรียนสามารถทำโจทย์ได้มากขึ้นในเวลาที่จำกัด ซึ่งง่ายกว่าการต้องมานั่งเขียน Unit Test สำหรับผู้ที่เพิ่งเริ่มเรียน Programming
รวมทั้งการใช้ Test Case เดียวกันจะทำให้การประเมินผลมีมาตรฐานเดียวกัน
นอกจากนี้ Grader ยังเหมาะสำหรับการฝึกไปแข่ง ที่เน้นการแก้ปัญหา Algorithm ที่ซับซ้อนในเวลาที่จำกัด โดยการฝึกโจทย์แข่งขันมาก ๆ และศึกษา Advance Data Structure และ Advance Algorithm ไปด้วย
อย่างไรก็ตามสำหรับผู้ที่ต้องการจะเป็น Software Developer ที่ดี การฝึกด้วย Grader อาจจะไม่เพียงพอ เพราะ Grader ให้ผลลัพธ์แบบผ่าน/ไม่ผ่าน โดยไม่ให้รายละเอียดอื่นมากนัก การไม่เปิดเผย Test Case ทำให้ไม่เห็นภาพรวมของการทดสอบ อาจทำให้ผู้เรียนไม่เข้าใจสาเหตุที่แท้จริงของข้อผิดพลาด และเกิดการแก้ปัญหาแบบลองผิดลองถูก
ดังนั้นเพื่อจะพัฒนาทักษะของ Software Developer เราจึงควรฝึกทำ Project จริงให้มากขึ้น เน้นการทำงานเป็นทีม และฝึกการเขียน Code ที่มีคุณภาพ
การฝึกเขียน Unit Test จะทำให้เราเห็นความสัมพันธ์ระหว่าง Input และ Output ที่คาดหวัง และเห็นว่า Program ผิดพลาดตรงไหน ซึ่งครอบคลุมทั้ง Positive Test (Happy Path) และ Negative Test (Error Case) ที่จะตรวจสอบว่า Function สามารถจัดการกับข้อมูลที่ไม่ถูกต้องได้อย่างเหมาะสมหรือไม่
เราสามารถออกแบบ Test Case เพื่อทดสอบเฉพาะส่วนได้เอง ซึ่งเป็นการฝึกการมองปัญหาจากหลายมุมมองด้วยตนเอง ไม่ใช่ตามมุมมองของคนเขียน Test Case เช่นอาจารย์เท่านั้น รวมทั้งจะทำให้เราเข้าใจ Edge Case หรือสถานการณ์ที่ไม่ปกติหรือเกิดขึ้นไม่บ่อย และข้อจำกัดของ Program เช่น การป้อนค่าว่างหรือค่า nil การทดสอบกับค่าสูงสุดหรือต่ำสุดที่เป็นไปได้ และการจัดการกับรูปแบบข้อมูลที่ไม่ถูกต้องหรือไม่คาดคิด จึงทำให้เราเข้าใจโจทย์จริงได้ลึกซึ้ง ซึ่งเป็นรากฐานสำคัญในการพัฒนาทักษะการคิดวิเคราะห์สำหรับ Software Developer ครับ
Exercise
เขียน Test Function สำหรับฟังก์ชัน Multiply
Go Quiz 10 (15 ข้อ) ขอให้สนุกกับการทำ Quiz นะครับ
Q&A?
รวม Cheat Sheet การทดสอบเบื้องต้น : ลองชิมอาหารก่อนเสิร์ฟ
การทดสอบเบื้องต้น
--------------
1. สร้างไฟล์ทดสอบ
- ชื่อไฟล์ต้องลงท้ายด้วย _test.go
- อยู่ใน Package เดียวกับ Code ที่ต้องการทดสอบ
2. เขียน Function ทดสอบ
func TestXxx(t *testing.T) {
// Code ทดสอบ
}
3. การ Assert
if got != want {
t.Errorf("ได้ %v, ต้องการ %v", got, want)
}
4. รัน Tests
go test
go test -v // แสดงรายละเอียดมากขึ้น
5. Table-Driven Tests
tests := []struct {
input type
expected type
}{
{input1, expected1},
{input2, expected2},
}
for _, tt := range tests {
// ทดสอบแต่ละกรณี
}
6. Subtests
t.Run("ชื่อ subtest", func(t *testing.T) {
// โค้ดทดสอบ
})
7. Test Coverage
go test -coverพบกับ Mastering Golang for E-commerce Back End Development : Part 3 เร็ว ๆ นี้ครับ