Go Beginner Guide

Go is a compiled language: the go tool turns your code into a single program file that runs on its own, with nothing else to install on the server. Install Go, then check it works: Go เป็นภาษาแบบคอมไพล์ เครื่องมือ go จะแปลงโค้ดเป็นไฟล์โปรแกรมไฟล์เดียวที่รันได้ด้วยตัวเอง โดยไม่ต้องติดตั้งอะไรเพิ่มบนเซิร์ฟเวอร์ ติดตั้ง Go แล้วตรวจว่าใช้งานได้:

Every Go program lives in a module, a folder with a go.mod file. Create one, write main.go, and run it: โปรแกรม Go ทุกตัวอยู่ใน module ซึ่งก็คือโฟลเดอร์ที่มีไฟล์ go.mod สร้าง module เขียน main.go แล้วรัน:

$ go version
go version go1.25.4 darwin/arm64

$ mkdir hello && cd hello

$ go mod init example.com/hello
go: creating new go.mod: module example.com/hello

$ go run .
Hello, Go!

$ go build && ls
go.mod
hello
main.go

$ ./hello
Hello, Go!

• package main and func main() mark the program's starting point.package main และ func main() คือจุดเริ่มต้นของโปรแกรม
• import "fmt" loads the formatting package. Go refuses to compile if you import something and don't use it.import "fmt" โหลด package สำหรับจัดรูปแบบข้อความ Go จะไม่ยอมคอมไพล์ถ้า import แล้วไม่ได้ใช้
• No semicolons, and the opening { must stay on the same line as func, if or for.ไม่ต้องมีเซมิโคลอน และ { ต้องอยู่บรรทัดเดียวกับ func, if หรือ for

Every value in Go has a fixed type, checked before the program runs. Inside a function, := declares a variable and lets Go work out its type. A variable you declare without a value gets its type's zero value, so there's no "undefined" in Go. ทุกค่าใน Go มีชนิดข้อมูล (type) ที่ตายตัวและถูกตรวจก่อนโปรแกรมทำงาน ภายในฟังก์ชัน := ใช้ประกาศตัวแปรโดยให้ Go หาชนิดเอง ตัวแปรที่ประกาศโดยไม่ให้ค่าจะได้ค่าศูนย์ (zero value) ของชนิดนั้น Go จึงไม่มีค่า "undefined"

The strings package has a function for almost every text job. Strings can't be changed in place, so these functions return a new string. package strings มีฟังก์ชันสำหรับงานข้อความแทบทุกอย่าง string แก้ไขในตัวเองไม่ได้ ฟังก์ชันเหล่านี้จึงคืน string ใหม่

Bytes, runes and Thai textไบต์ rune และข้อความภาษาไทย

A Go string is a sequence of bytes in UTF-8. len() counts bytes, and a Thai letter takes three. A rune is one Unicode character. range over a string gives you runes, and []rune(s) lets you cut by character instead of by byte. string ใน Go คือลำดับของไบต์ในรูปแบบ UTF-8 len() นับเป็นไบต์ และตัวอักษรไทยใช้สามไบต์ rune คืออักขระ Unicode หนึ่งตัว การใช้ range กับ string จะได้ rune ออกมา และ []rune(s) ช่วยให้ตัดเป็นตัวอักษรแทนการตัดเป็นไบต์

if needs no parentheses, but always needs braces. It can start with a short statement, which is how Go code checks errors in one line. switch stops after the matching case, so there's no break to forget. if ไม่ต้องมีวงเล็บ แต่ต้องมีวงเล็บปีกกาเสมอ และเริ่มด้วยคำสั่งสั้นๆ ได้ ซึ่งเป็นวิธีที่โค้ด Go ใช้ตรวจ error ในบรรทัดเดียว ส่วน switch จะหยุดหลัง case ที่ตรง จึงไม่มี break ให้ลืม

Go has one loop keyword: for. It counts, it works like while when you give it only a condition, and with range it walks through slices, maps and strings. Go มีคำสั่งวนซ้ำเพียงคำเดียวคือ for ใช้นับรอบได้ ทำงานเหมือน while เมื่อให้แค่เงื่อนไข และเมื่อใช้กับ range จะเดินผ่าน slice, map และ string

A slice ([]int) is a list that can grow. append adds to it and returns the new slice, which you must store. Cutting a slice with s[a:b] doesn't copy: both slices share the same underlying memory. slice ([]int) คือรายการที่ขยายได้ append ใช้เพิ่มข้อมูลและคืน slice ใหม่ ซึ่งต้องเก็บไว้เสมอ การตัด slice ด้วย s[a:b] ไม่ได้คัดลอก ทั้งสอง slice ใช้หน่วยความจำชุดเดียวกัน

A map (map[string]int) looks values up by key. Reading a missing key gives the zero value, so use the "comma ok" form when you need to know whether it was there. Map order is random on purpose: sort the keys when the order matters. map (map[string]int) ใช้ค้นหาค่าด้วยคีย์ การอ่านคีย์ที่ไม่มีอยู่จะได้ค่าศูนย์ จึงต้องใช้รูปแบบ "comma ok" เมื่ออยากรู้ว่ามีคีย์นั้นหรือไม่ ลำดับใน map ถูกสุ่มโดยตั้งใจ ถ้าลำดับสำคัญให้เรียงคีย์ก่อน

Types come after names: func add(a, b int) int. A Go function can return several values, which is how it reports errors: a result plus an error that is nil when everything went fine. Functions are values too, so you can store them and return them. ชนิดข้อมูลเขียนหลังชื่อ เช่น func add(a, b int) int ฟังก์ชัน Go คืนค่าได้หลายค่า ซึ่งเป็นวิธีรายงาน error: คืนผลลัพธ์พร้อม error ที่เป็น nil เมื่อทุกอย่างเรียบร้อย ฟังก์ชันก็เป็นค่าเช่นกัน จึงเก็บไว้ในตัวแปรหรือคืนออกมาได้

Go has no classes. A struct groups fields, and methods are functions attached to a type. A name that starts with a capital letter is visible to other packages; a lower-case name is private to its package. A method with a pointer receiver (*Account) can change the struct; one with a value receiver works on a copy. Go ไม่มีคลาส struct ใช้รวมฟิลด์เข้าด้วยกัน และ method คือฟังก์ชันที่ผูกกับชนิดข้อมูล ชื่อที่ขึ้นต้นด้วยตัวพิมพ์ใหญ่ package อื่นมองเห็นได้ ส่วนชื่อตัวพิมพ์เล็กใช้ได้เฉพาะใน package ของมัน method ที่มี pointer receiver (*Account) แก้ไข struct ได้ ส่วน value receiver ทำงานกับสำเนา

An interface lists methods. Any type that has those methods satisfies it automatically; there's no implements keyword. That lets a function accept "anything with an Area()" without knowing the concrete types. interface คือรายการของ method ชนิดข้อมูลใดที่มี method ครบก็เป็น interface นั้นโดยอัตโนมัติ ไม่ต้องมีคำว่า implements ทำให้ฟังก์ชันรับ "อะไรก็ได้ที่มี Area()" โดยไม่ต้องรู้ชนิดที่แท้จริง

Go has no exceptions for everyday problems. A function that can fail returns an error as its last result, and the caller checks it straight away with if err != nil. You'll write that line a lot; it keeps every failure visible right where it happens. Go ไม่ใช้ exception กับปัญหาทั่วไป ฟังก์ชันที่อาจล้มเหลวจะคืน error เป็นค่าสุดท้าย และผู้เรียกตรวจทันทีด้วย if err != nil จะได้เขียนบรรทัดนี้บ่อยมาก เพราะทำให้เห็นทุกความล้มเหลวตรงจุดที่เกิด

Put go in front of a function call and it runs in a goroutine, alongside the rest of your program. Goroutines are cheap; a server can run thousands. A channel passes values between them and makes the receiver wait until a value arrives. ใส่ go หน้าการเรียกฟังก์ชัน ฟังก์ชันนั้นจะทำงานใน goroutine ไปพร้อมกับส่วนอื่นของโปรแกรม goroutine ใช้ทรัพยากรน้อยมาก เซิร์ฟเวอร์หนึ่งตัวรันได้เป็นพันๆ channel ใช้ส่งค่าระหว่าง goroutine และทำให้ฝั่งรับรอจนกว่าจะมีค่ามาถึง

The three downloads took 600 ms of work but finished in about 300 ms, in the order they completed. When goroutines share a variable, protect it with a sync.Mutex, and use a sync.WaitGroup to wait for all of them: การดาวน์โหลดสามงานรวมกันใช้เวลาทำงาน 600 ms แต่เสร็จในเวลาประมาณ 300 ms และเรียงตามลำดับที่เสร็จ เมื่อหลาย goroutine ใช้ตัวแปรร่วมกัน ให้ป้องกันด้วย sync.Mutex และใช้ sync.WaitGroup เพื่อรอให้ทุกตัวเสร็จ:

The rest of this guide builds one small program in a real terminal: a task list, then a JSON API for it. A module is the project (go.mod); a package is one folder of .go files. The tasks package keeps the data; main uses it. ส่วนที่เหลือของคู่มือนี้สร้างโปรแกรมเล็กๆ หนึ่งตัวในเทอร์มินัลจริง เริ่มจากรายการงาน แล้วต่อด้วย JSON API ของมัน module คือตัวโปรเจกต์ (go.mod) ส่วน package คือโฟลเดอร์หนึ่งที่มีไฟล์ .go package tasks เก็บข้อมูล และ main เป็นผู้ใช้

• Import a package by its module path plus folder: "example.com/taskapi/tasks". Then use it as tasks.NewStore().import package ด้วยพาธของ module ต่อด้วยโฟลเดอร์ เช่น "example.com/taskapi/tasks" แล้วเรียกใช้เป็น tasks.NewStore()
• Store, Add and Task start with a capital letter, so main can use them. The fields mu, tasks and nextID don't, so only the tasks package can touch them.Store, Add และ Task ขึ้นต้นด้วยตัวพิมพ์ใหญ่ main จึงใช้ได้ ส่วนฟิลด์ mu, tasks และ nextID ไม่ใช่ จึงมีแต่ package tasks ที่แตะต้องได้
• A comment right above an exported name is its documentation; go doc and editors show it.คอมเมนต์ที่อยู่เหนือชื่อที่ export คือเอกสารของมัน go doc และตัวแก้โค้ดจะแสดงให้เห็น

$ go mod init example.com/taskapi
go: creating new go.mod: module example.com/taskapi

$ go run .
error: title is required
1. Learn Go (done: true)
2. Build an API (done: false)

$ go vet ./...

The tools catch mistakes for youเครื่องมือช่วยจับข้อผิดพลาดให้

To see that, I added two bad lines to main.go: one prints a string with %d, the other reads the private field store.tasks. เพื่อให้เห็นภาพ ผมเพิ่มบรรทัดที่ผิดสองบรรทัดใน main.go บรรทัดแรกพิมพ์ string ด้วย %d อีกบรรทัดอ่านฟิลด์ส่วนตัว store.tasks

$ go build ./...
# example.com/taskapi
./main.go:18:20: store.tasks undefined (cannot refer to unexported field tasks)

$ go vet ./...   # after removing the store.tasks line
# example.com/taskapi
# [example.com/taskapi]
./main.go:17:14: fmt.Printf format %d has arg "three" of wrong type string

Go also has one official code style, applied by gofmt (or go fmt). Nobody argues about tabs or brace position; most editors run it every time you save. Go มีรูปแบบการจัดโค้ดอย่างเป็นทางการแบบเดียว ซึ่ง gofmt (หรือ go fmt) จัดให้ จึงไม่มีใครต้องเถียงเรื่องแท็บหรือตำแหน่งวงเล็บ ตัวแก้โค้ดส่วนใหญ่รันให้ทุกครั้งที่บันทึก

$ gofmt -l .
main.go

$ gofmt -d main.go
diff main.go.orig main.go
--- main.go.orig
+++ main.go
@@ -1,5 +1,7 @@
 package main
+
 import "fmt"
-func main(){
-fmt.Println("hi")
-    }
+
+func main() {
+	fmt.Println("hi")
+}

Go's standard library includes a production-ready web server, net/http. No framework needed. Replace main.go with a small JSON API around the same tasks package: ไลบรารีมาตรฐานของ Go มีเว็บเซิร์ฟเวอร์ที่พร้อมใช้งานจริงอยู่แล้ว คือ net/http ไม่ต้องใช้เฟรมเวิร์ก แทนที่ main.go ด้วย JSON API เล็กๆ ที่ใช้ package tasks ตัวเดิม:

• "GET /tasks" and "PATCH /tasks/{id}/done" are route patterns with a method, built into Go since 1.22. r.PathValue("id") reads the {id} part."GET /tasks" และ "PATCH /tasks/{id}/done" คือรูปแบบ route ที่ระบุ method ได้ ซึ่งมีในตัว Go ตั้งแต่ 1.22 r.PathValue("id") ใช้อ่านส่วน {id}
• The tags on Task (`json:"title"`) choose the JSON names. json.NewDecoder(r.Body).Decode(&body) reads the request; json.NewEncoder(w).Encode(v) writes the response.tag บน Task (`json:"title"`) กำหนดชื่อใน JSON ส่วน json.NewDecoder(r.Body).Decode(&body) อ่านคำขอ และ json.NewEncoder(w).Encode(v) เขียนคำตอบ
• Each request runs in its own goroutine, so several can hit Store at once. That's why Store uses a sync.Mutex (lesson 11).แต่ละคำขอทำงานใน goroutine ของตัวเอง หลายคำขอจึงอาจเข้าถึง Store พร้อมกัน นี่คือเหตุผลที่ Store ใช้ sync.Mutex (บทที่ 11)

$ go build -o taskapi . && ./taskapi
2026/10/05 23:23:35 listening on http://localhost:8080

$ curl -s localhost:8080/tasks
[]

$ curl -si -X POST localhost:8080/tasks -d '{"title":"Learn Go"}'
HTTP/1.1 201 Created
Content-Type: application/json

{"id":1,"title":"Learn Go","done":false}

$ curl -s -X POST localhost:8080/tasks -d '{"title":"  Build an API  "}'
{"id":2,"title":"Build an API","done":false}

$ curl -s -w "%{http_code}\n" -X POST localhost:8080/tasks -d '{"title":"   "}'
{"error":"title is required"}
422

$ curl -s -w "%{http_code}\n" -X POST localhost:8080/tasks -d '{"title":'
{"error":"invalid JSON"}
400

$ curl -s -X PATCH localhost:8080/tasks/1/done
{"id":1,"title":"Learn Go","done":true}

$ curl -s -w "%{http_code}\n" -X PATCH localhost:8080/tasks/99/done
{"error":"task not found"}
404

$ curl -s -w "%{http_code}\n" -X DELETE localhost:8080/tasks
Method Not Allowed
405

$ curl -s localhost:8080/tasks
[{"id":1,"title":"Learn Go","done":true},{"id":2,"title":"Build an API","done":false}]

Testing is built into Go: no library to install. Tests live next to the code in files ending in _test.go, and go test runs them. Go code usually tests with a table: a list of inputs and expected results, checked in one loop. Here's the idea in a runnable form. Delete the TrimSpace line and press Run. การทดสอบมีมาในตัว Go ไม่ต้องติดตั้งไลบรารีเพิ่ม เทสต์อยู่ข้างๆ โค้ดในไฟล์ที่ลงท้ายด้วย _test.go และ go test เป็นตัวรัน โค้ด Go มักทดสอบด้วยตาราง คือรายการข้อมูลเข้าและผลลัพธ์ที่คาดไว้ แล้วตรวจในลูปเดียว นี่คือแนวคิดในแบบที่รันได้ ลองลบบรรทัด TrimSpace แล้วกด Run

The real tests for the task API: a table-driven test for CleanTitle, and two tests that call the HTTP handler directly with httptest, with no server or network. เทสต์จริงของ task API ได้แก่เทสต์แบบตารางสำหรับ CleanTitle และเทสต์สองตัวที่เรียก HTTP handler โดยตรงด้วย httptest ไม่ต้องมีเซิร์ฟเวอร์หรือเครือข่าย

Red: a planted bugแดง: บั๊กที่ตั้งใจใส่ไว้

To show a failure, I deleted the strings.TrimSpace line from CleanTitle. Three checks catch it, in both packages: เพื่อให้เห็นความล้มเหลว ผมลบบรรทัด strings.TrimSpace ออกจาก CleanTitle มีการตรวจสามจุดที่จับได้ ในทั้งสอง package:

$ go test ./...
--- FAIL: TestBlankTitleIsRejected (0.00s)
    main_test.go:35: status 201, want 422
FAIL
FAIL	example.com/taskapi	1.212s
--- FAIL: TestCleanTitle (0.00s)
    --- FAIL: TestCleanTitle/trims_spaces (0.00s)
        tasks_test.go:28: CleanTitle("  Write tests  ") = "  Write tests  ", want "Write tests"
    --- FAIL: TestCleanTitle/only_spaces (0.00s)
        tasks_test.go:25: CleanTitle("   ") error = <nil>, want title is required
FAIL
FAIL	example.com/taskapi/tasks	0.653s
FAIL

Green: put the line backเขียว: ใส่บรรทัดนั้นกลับคืน

$ go test ./...
ok  	example.com/taskapi	0.519s
ok  	example.com/taskapi/tasks	1.051s

$ go test -v ./tasks
=== RUN   TestCleanTitle
=== RUN   TestCleanTitle/plain_title
=== RUN   TestCleanTitle/trims_spaces
=== RUN   TestCleanTitle/empty
=== RUN   TestCleanTitle/only_spaces
--- PASS: TestCleanTitle (0.00s)
    --- PASS: TestCleanTitle/plain_title (0.00s)
    --- PASS: TestCleanTitle/trims_spaces (0.00s)
    --- PASS: TestCleanTitle/empty (0.00s)
    --- PASS: TestCleanTitle/only_spaces (0.00s)
=== RUN   TestMarkDone
--- PASS: TestMarkDone (0.00s)
PASS
ok  	example.com/taskapi/tasks	0.300s

$ go test -cover ./...
ok  	example.com/taskapi	0.577s	coverage: 53.3% of statements
ok  	example.com/taskapi/tasks	1.112s	coverage: 83.3% of statements

$ go test -run 'TestCleanTitle/only' -v ./tasks
=== RUN   TestCleanTitle
=== RUN   TestCleanTitle/only_spaces
--- PASS: TestCleanTitle (0.00s)
    --- PASS: TestCleanTitle/only_spaces (0.00s)
PASS
ok  	example.com/taskapi/tasks	0.323s

Write the code, press Run, and compare with the solution when you're done. Every solution was run with go run, and its output is shown under it. เขียนโค้ด กด Run แล้วเทียบกับเฉลยเมื่อเสร็จ ทุกเฉลยถูกรันด้วย go run และแสดงผลลัพธ์ไว้ด้านล่าง

The comments show what the real Go compiler and runtime printed (go run, Go 1.25.4). Several of these are compile errors, which the browser runner doesn't always report, so learn the messages here. คอมเมนต์แสดงสิ่งที่คอมไพเลอร์และ runtime ของ Go ตัวจริงพิมพ์ออกมา (go run, Go 1.25.4) หลายข้อเป็น compile error ซึ่งตัวรันในเบราว์เซอร์ไม่ได้แจ้งทุกครั้ง จึงควรจำข้อความจากที่นี่

The English terms are what you'll see in Go's documentation and error messages, so it pays to know both. คำศัพท์ภาษาอังกฤษคือสิ่งที่จะเจอในเอกสารและข้อความแจ้งข้อผิดพลาดของ Go จึงควรรู้ทั้งสองภาษา