Phần này sẽ tìm hiểu trong Selected tutorials -> Documentation trong trang chủ của Go.

Link tham khảo: https://go.dev/doc/

Nếu các bạn lười đọc tiếng anh thì có thể xem series này viết nhé. Mình sẽ dịch và có thể thêm những thứ hay ho để tìm hiểu được. Bối cảnh là công ty làm BE cũng chuyển dần từ Java -> Go vì nhẹ và nhanh của nó.

Getting Started

Ngôn ngữ lập trình Go là một dự án mã nguồn mở nhằm giúp lập trình viên làm việc hiệu quả hơn.

Go có tính biểu đạt (expressive), ngắn gọn (concise), sạch sẽ (clean) và hiệu quả (efficient). Các cơ chế đồng thời của nó giúp dễ dàng viết các chương trình tận dụng tối đa sức mạnh của các máy đa lõi và hệ thống mạng, trong khi hệ thống kiểu dữ liệu mới cho phép xây dựng chương trình linh hoạt và theo mô-đun. Go được biên dịch nhanh thành mã máy nhưng vẫn có sự tiện lợi của thu gom rác và sức mạnh của phản chiếu tại thời gian chạy (Run-time reflection). Đây là một ngôn ngữ được biên dịch, kiểu tĩnh, tốc độ cao nhưng mang lại cảm giác như một ngôn ngữ kiểu động, thông dịch.

Run-time reflection là khả năng của một chương trình để kiểm tra và thao tác với cấu trúc của chính nó trong khi đang chạy.

Download and install

https://go.dev/dl/

Hãy download phiên bản tương thích. Mình dùng windown nên sẽ download mục Microsoft Windows.

1. Mở tệp MSI mà bạn đã tải xuống và làm theo hướng dẫn để cài đặt Go.

Theo mặc định, trình cài đặt sẽ cài Go vào thư mục Program Files hoặc Program Files (x86). Bạn có thể thay đổi vị trí này nếu cần. Sau khi cài đặt, bạn cần đóng và mở lại bất kỳ cửa sổ dòng lệnh (command prompt) nào đang mở để các thay đổi môi trường do trình cài đặt thiết lập được phản ánh trong dòng lệnh.

2. Xác minh rằng bạn đã cài đặt Go.

Trên Windows, nhấp vào menu Start. Trong ô tìm kiếm của menu, nhập cmd, sau đó nhấn phím Enter. Trong cửa sổ Command Prompt hiện ra, nhập lệnh sau:

Xác nhận rằng lệnh đã in ra phiên bản Go đã được cài đặt.

Tutorial: Getting started

Một hướng dẫn nhanh “Hello, World” để bắt đầu. Tìm hiểu một chút về mã Go, công cụ, gói (packages) và mô-đun (modules).

IDE sử dụng là: Goland

Hãy tạo 1 project mới nhé.

package main import ( "fmt"
) //TIP <p>To run your code, right-click the code and select <b>Run</b>.</p> <p>Alternatively, click
// the <icon src="AllIcons.Actions.Execute"/> icon in the gutter and select the <b>Run</b> menu item from here.</p> func main() { //TIP <p>Press <shortcut actionId="ShowIntentionActions"/> when your caret is at the underlined text // to see how GoLand suggests fixing the warning.</p><p>Alternatively, if available, click the lightbulb to view possible fixes.</p> s := "gopher" fmt.Printf("Hello and welcome, %s!\n", s) for i := 1; i <= 5; i++ { //TIP <p>To start your debugging session, right-click your code in the editor and select the Debug option.</p> <p>We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.</p> fmt.Println("i =", 100/i) }
}

Khi sử dụng Goland để tạo project thì phần mềm đã tự tạo sẵn cho 2 file go.mod và main.go để demo.

Bật theo dõi phụ thuộc cho mã nguồn của bạn.

Enable dependency tracking for your code

Khi mã Go sử dụng các gói từ mô-đun khác, bạn cần quản lý phụ thuộc bằng tệp go.mod. Tệp này được tạo bằng lệnh:

$ go mod init learnGo
go: creating new go.mod: module learnGo

Tên module thường là đường dẫn kho chứa mã, ví dụ: github.com/mymodule. Nếu bạn muốn chia sẻ module, tên này phải là đường dẫn mà Go có thể tải về.

• Khai báo gói main (một gói là cách để nhóm các hàm, và bao gồm tất cả các tệp trong cùng một thư mục).
• Nhập gói phổ biến fmt, chứa các hàm để định dạng văn bản, bao gồm in ra màn hình. Đây là một trong các gói chuẩn được cài sẵn cùng với Go.
• Triển khai hàm main để in một thông báo ra màn hình. Hàm main sẽ được thực thi mặc định khi bạn chạy gói main.

Lệnh go run là một trong nhiều lệnh go mà bạn sẽ sử dụng để làm việc với Go. Sử dụng lệnh sau để xem danh sách các lệnh khác:

go help

Gọi mã từ một gói bên ngoài

Call code in an external package

Khi cần dùng chức năng đã có sẵn, bạn có thể tìm các gói phù hợp trên trang pkg.go.dev.

Tìm gói rsc.io/quote, chọn phiên bản v1, và dùng hàm Go() trong mã của bạn để in ra một câu trích dẫn.

Hoặc làm một cách thủ công:

Thêm yêu cầu mô-đun và tệp kiểm tra (sums). Go sẽ thêm mô-đun quote vào tệp go.mod và tạo tệp go.sum để xác thực mô-đun. (Xem thêm trong Go Modules Reference – Mục xác thực mô-đun.)

Module Go là cách Go quản lý các thư viện phụ thuộc (dependencies).

$ go mod tidy
go: finding module for package rsc.io/quote
go: found rsc.io/quote in rsc.io/quote v1.5.2

Lệnh go mod tidy đã tự động tìm và tải mô-đun rsc.io/quote, mặc định dùng phiên bản mới nhất – v1.5.2.

Chạy chương trình để xem thông điệp được in ra từ hàm bạn đã gọi:

Tutorial: Create a Go module

Trong hướng dẫn này, bạn sẽ tạo hai mô-đun:

1. Một thư viện, được thiết kế để các ứng dụng hoặc thư viện khác nhập vào.
2. Một ứng dụng gọi, sử dụng thư viện đó.

Start a module that others can use

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

Lệnh go mod init sẽ tạo tệp go.mod để theo dõi các phụ thuộc của mã nguồn. Hiện tại, tệp chỉ chứa tên mô-đun và phiên bản Go được hỗ trợ. Khi bạn thêm phụ thuộc, go.mod sẽ liệt kê phiên bản mô-đun mà mã của bạn sử dụng, giúp việc build ổn định và bạn kiểm soát được phiên bản mô-đun.

Tạo 1 file greetings.go

package greetings import "fmt" // Hello returns a greeting for the named person.
func Hello(name string) string { // Return a greeting that embeds the name in a message. message := fmt.Sprintf("Hi, %v. Welcome!", name) return message
}

Trong đoạn mã này, bạn:

• Khai báo gói greetings để tập hợp các hàm liên quan.
• Triển khai hàm Hello để trả về lời chào.

Hàm này nhận một tham số name kiểu string và trả về một chuỗi (string). Trong Go, các hàm bắt đầu bằng chữ cái viết hoa có thể được gọi từ các gói khác — gọi là tên được xuất (exported name).

Bạn khai báo biến message để chứa lời chào.

Toán tử := là cách viết ngắn để khai báo và khởi tạo biến trong một dòng (Go tự xác định kiểu dựa trên giá trị). Cách viết đầy đủ sẽ là:

var message string message = fmt.Sprintf("Hi, %v. Welcome!", name)

Bạn dùng hàm Sprintf của gói fmt để tạo thông điệp, trong đó %v sẽ được thay thế bằng giá trị của name. Cuối cùng, trả về chuỗi đã định dạng cho nơi gọi hàm.

Call your code from another module

Tiếp tục tạo ra 1 folder thứ 2

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

Rồi sau đó tạo file hello.go trong folder đó

package main import ( "fmt" "example.com/greetings"
) func main() { // Get a greeting message and print it. message := greetings.Hello("Gladys") fmt.Println(message)
}

Trong đoạn mã này, bạn:

• Khai báo gói main. Trong Go, mã được thực thi dưới dạng ứng dụng phải nằm trong gói main.

• Nhập hai gói: example.com/greetings và fmt. Điều này cho phép bạn sử dụng các hàm trong những gói đó.

  • Việc nhập example.com/greetings (gói nằm trong mô-đun bạn đã tạo trước đó) giúp bạn có thể gọi hàm Hello.
  • Nhập fmt để dùng các hàm xử lý văn bản nhập/xuất (ví dụ: in ra màn hình).

• Gọi hàm Hello trong gói greetings để nhận một lời chào.

Để gọi được thì trước tiên tìm hiểu cách chỉnh sửa mô-đun example.com/hello để sử dụng mô-đun example.com/greetings trong máy cục bộ.

Trong môi trường thực tế, bạn sẽ công bố (public) mô-đun greetings lên kho mã, để Go có thể tải về theo đường dẫn mô-đun. Nhưng hiện tại, vì chưa công bố, bạn cần chỉnh để Go tìm thấy mã từ thư mục cục bộ.

Thực hiện như sau:

1. Từ thư mục hello, chạy lệnh sau để thay thế đường dẫn mô-đun:

go mod edit -replace example.com/greetings=../greetings

Lệnh này yêu cầu Go thay example.com/greetings bằng thư mục cục bộ ../greetings.

2. Chạy tiếp tục lệnh để đồng bộ phụ thuộc:

$ go mod tidy go: found example.com/greetings in example.com/greetings v0.0.0-00010101000000-000000000000

Số phiên bản ở cuối là phiên bản giả lập (pseudo-version), được Go tạo ra tạm thời vì mô-đun chưa được gắn tag chính thức.

Nếu dùng mô-đun đã công bố, bạn sẽ không cần dòng replace, và chỉ cần dòng require với phiên bản thật, ví dụ:

require example.com/greetings v1.1.0

Tại dấu nhắc lệnh (command prompt) trong thư mục hello, chạy mã của bạn để xác nhận rằng nó hoạt động:

$ go run .
Hi, Gladys. Welcome!

GoLand dùng go build để biên dịch mã nguồn Go của bạn thành file .exe, lưu tạm vào thư mục tmp. → Chạy chương trình .exe đã biên dịch.

Return and handle an error

Việc xử lý lỗi là rất quan trọng để viết ra mã Go vững chắc. Trong phần này, bạn sẽ:

Cập nhật tệp greetings.go

package greetings import ( "errors" "fmt"
) // Hello returns a greeting for the named person.
func Hello(name string) (string, error) { if name == "" { return "", errors.New("empty name") // Trả về lỗi nếu tên bị rỗng } message := fmt.Sprintf("Hi, %v. Welcome!", name) return message, nil
}

• Hàm Hello giờ trả về 2 giá trị: chuỗi lời chào và lỗi.
• Trả lỗi (errors.New(...)) nếu tên bị bỏ trống.
• Trả nil ở vị trí lỗi nếu không có lỗi.

Cập nhật hello.go để xử lý lỗi

package main import ( "fmt" "log" "example.com/greetings"
) func main() { log.SetPrefix("greetings: ") log.SetFlags(0) //var message string // var err error // message, err = greetings.Hello("") message, err := greetings.Hello("") if err != nil { log.Fatal(err) // In lỗi và dừng chương trình } fmt.Println(message)
}

• Cấu hình log để in lỗi ngắn gọn.
• Gọi Hello("") với chuỗi rỗng để kiểm tra xử lý lỗi.
• Nếu có lỗi, dùng log.Fatal(err) để dừng chương trình.

go run . greetings: empty name
exit status 1

nil có thể được hiểu là null, hoặc không được khởi tạo. Dùng để chỉ rằng một biến không trỏ đến bất kỳ giá trị nào.

Return a random greeting

Thay vì trả về một lời chào cố định, giờ đây chương trình sẽ chọn ngẫu nhiên một trong nhiều lời chào được định nghĩa trước để gửi cho người dùng.

Thay đổi chính trong greetings.go:

1. Thêm hàm randomFormat():

• Trả về một trong các mẫu lời chào được định nghĩa sẵn.
• Sử dụng math/rand để chọn ngẫu nhiên lời chào từ một slice.

2. Thay đổi trong Hello(name string):

• Sử dụng fmt.Sprintf() với mẫu lời chào lấy từ randomFormat() và tên được truyền vào.
• Vẫn trả về lỗi nếu name == "".

• Slice là một kiểu dữ liệu rất linh hoạt trong Go – giống mảng nhưng có thể thay đổi kích thước.
• Hàm rand.Intn(len(slice)) chọn ngẫu nhiên chỉ số trong slice.
• Hàm randomFormat() viết thường nên chỉ dùng được trong package greetings.

Return greetings for multiple people

Bạn sẽ cập nhật chương trình để hàm Hello có thể trả lời lời chào cho nhiều người một lúc bằng cách tạo hàm mới tên là Hellos. Việc này giúp giữ nguyên hàm Hello để đảm bảo tương thích với mã cũ (backward compatibility).

1. Trong greetings/greetings.go:

• Thêm hàm mới Hellos(names []string) nhận một danh sách tên và trả về một map[string]string, ánh xạ từ tên đến lời chào tương ứng.
• Dùng vòng lặp để duyệt danh sách tên và gọi hàm Hello cho từng tên.
• Nếu tên rỗng thì trả lỗi.
• Trả lại map các lời chào.

2. Trong hello/hello.go:

• Tạo biến names chứa danh sách tên: Gladys, Samantha, Darrin.
• Gọi greetings.Hellos(names) để lấy các lời chào.
• In ra map kết quả.

map[Darrin:Hail, Darrin! Well met! Gladys:Hi, Gladys! Samantha:Hail, Samantha! Well met!] 

Add a test

Sau khi hoàn thiện phần chính của chương trình, bạn sẽ viết test cho hàm Hello để đảm bảo mọi thứ hoạt động đúng và phát hiện lỗi sớm.

1. Tạo file test

Tạo file mới tên là greetings_test.go trong thư mục greetings. File này sẽ chứa các hàm kiểm thử (test function).

• TestHelloName: Kiểm tra hàm Hello("Gladys") có trả về lời chào chứa tên Gladys hay không.
• TestHelloEmpty: Kiểm tra xem khi truyền chuỗi rỗng, hàm có trả về lỗi không.

Nếu muốn xem chi tiết:

Muốn test 1 case fail hãy sửa hàm Hello trong greetings.go

func Hello(name string) (string, error) { if name == "" { return name, errors.New("empty name") } message := fmt.Sprint(randomFormat()) // bỏ tên ra return message, nil
}

Rồi chạy lại go test. Test TestHelloName sẽ bị fail vì kết quả không chứa tên Gladys

Compile and install the application

Tổng kết phần cuối

1. go build – Tạo file thực thi (.exe)

Di chuyển vào thư mục chứa mã nguồn (hello) và chạy:

go build

Nó sẽ biên dịch mã Go thành một file thực thi:

• Trên Windows: hello.exe
• Trên Linux/macOS: hello

Lưu ý: go build không cài đặt file thực thi, nó chỉ tạo ra file đó tại chỗ (local).

2. Chạy file thực thi Sau khi build xong, bạn chạy:

Trên Windows:

hello.exe

3. go install – Biên dịch và cài đặt

Nếu bạn muốn chạy chương trình từ bất kỳ đâu mà không cần cd vào thư mục hello, bạn cần dùng:

go install

Nó sẽ:

• Biên dịch chương trình
• Cài file thực thi vào thư mục mặc định của Go (thường là $GOPATH/bin hoặc GOBIN nếu đã cấu hình)

4. Xác định thư mục cài đặt (go install)

go list -f '{{.Target}}'

Nghĩa là file thực thi sẽ được đặt tại đó.

5. Thêm thư mục bin vào PATH

Nếu bạn chưa thêm vào hệ thống PATH, bạn cần thêm để có thể gõ hello ở bất kỳ đâu.

Trên Windows, chạy trong terminal:

set PATH=%PATH%;C:\Users\nhtha\go\bin hoặc thiết lập cố định qua: go env -w GOBIN=C:\Users\nhtha\go\bin

Kết luận Kết luận: