Hướng dẫn: Tạo một module Go

Đây là phần đầu tiên của một hướng dẫn giới thiệu một số tính năng cơ bản của ngôn ngữ Go. Nếu bạn mới bắt đầu với Go, hãy xem Hướng dẫn: Bắt đầu với Go, nơi giới thiệu lệnh go, Go modules và mã Go đơn giản.

Trong hướng dẫn này, bạn sẽ tạo hai module. Module đầu tiên là một thư viện dùng để được import bởi các thư viện hoặc ứng dụng khác. Module thứ hai là một ứng dụng gọi module đầu tiên.

Hướng dẫn này bao gồm bảy chủ đề ngắn, mỗi chủ đề minh họa một khía cạnh khác nhau của ngôn ngữ.

Tạo một module -- Viết một module nhỏ với các hàm bạn có thể gọi từ một module khác.
Gọi mã của bạn từ một module khác -- Import và sử dụng module mới của bạn.
Trả về và xử lý lỗi -- Thêm xử lý lỗi đơn giản.
Trả về lời chào ngẫu nhiên -- Xử lý dữ liệu trong slice (mảng có kích thước động của Go).
Trả lời lời chào cho nhiều người -- Lưu trữ các cặp key/value trong map.
Thêm một bài kiểm thử -- Sử dụng tính năng kiểm thử đơn vị tích hợp của Go để kiểm thử mã của bạn.
Biên dịch và cài đặt ứng dụng -- Biên dịch và cài đặt mã của bạn cục bộ.

Điều kiện tiên quyết

Một số kinh nghiệm lập trình. Mã ở đây khá đơn giản, nhưng sẽ hữu ích nếu bạn biết về hàm, vòng lặp và mảng.
Công cụ soạn thảo mã. Bất kỳ trình soạn thảo văn bản nào bạn có đều dùng được. Hầu hết các trình soạn thảo đều hỗ trợ tốt Go. Phổ biến nhất là VSCode (miễn phí), GoLand (trả phí) và Vim (miễn phí).
Thiết bị đầu cuối lệnh. Go hoạt động tốt trên bất kỳ terminal nào của Linux và Mac, cũng như trên PowerShell hoặc cmd trong Windows.

Bắt đầu một module mà người khác có thể sử dụng

Bắt đầu bằng cách tạo một module Go. Trong một module, bạn tập hợp một hoặc nhiều gói liên quan cho một tập hợp hàm rời rạc và hữu ích. Ví dụ, bạn có thể tạo một module với các gói chứa hàm để phân tích tài chính, để những người viết ứng dụng tài chính có thể sử dụng công việc của bạn. Để biết thêm về phát triển module, xem Phát triển và publish module.

Mã Go được nhóm thành các gói, và các gói được nhóm thành các module. Module của bạn chỉ định các dependency cần thiết để chạy mã, bao gồm phiên bản Go và tập hợp các module khác mà nó yêu cầu.

Khi bạn thêm hoặc cải thiện chức năng trong module, bạn publish các phiên bản mới của module. Các nhà phát triển viết mã gọi các hàm trong module của bạn có thể import các gói đã cập nhật của module và kiểm thử với phiên bản mới trước khi đưa vào môi trường production.

Mở dấu nhắc lệnh và cd vào thư mục home của bạn.
Trên Linux hoặc Mac:
```
cd
```
Trên Windows:
```
cd %HOMEPATH%
```
Tạo thư mục greetings cho mã nguồn module Go của bạn.
Ví dụ, từ thư mục home của bạn, dùng các lệnh sau:
```
mkdir greetings
cd greetings
```
Khởi tạo module của bạn bằng lệnh go mod init.
Chạy lệnh go mod init, truyền vào đường dẫn module -- ở đây, dùng example.com/greetings. Nếu bạn publish một module, đây phải là đường dẫn mà từ đó module của bạn có thể được tải xuống bởi các công cụ Go. Đó sẽ là kho lưu trữ mã của bạn.

Để biết thêm về đặt tên module với đường dẫn module, xem Quản lý dependency.
```
$ go mod init example.com/greetings
go: creating new go.mod: module example.com/greetings
```
Lệnh go mod init tạo một tệp go.mod để theo dõi các dependency của mã. Hiện tại, tệp chỉ bao gồm tên module của bạn và phiên bản Go mà mã của bạn hỗ trợ. Nhưng khi bạn thêm các dependency, tệp go.mod sẽ liệt kê các phiên bản mà mã của bạn phụ thuộc. Điều này giúp các bản dựng có thể tái tạo được và cho bạn quyền kiểm soát trực tiếp về các phiên bản module nào được sử dụng.
Trong trình soạn thảo văn bản, tạo một tệp để viết mã và đặt tên là greetings.go.
Dán đoạn mã sau vào tệp greetings.go của bạn và lưu tệp.
```
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
}
```
Đây là mã đầu tiên của module bạn. Nó trả về lời chào cho bất kỳ người gọi nào yêu cầu. Bạn sẽ viết mã gọi hàm này trong bước tiếp theo.

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 tham số name có kiểu là string. Hàm cũng trả về một string. Trong Go, một hàm có tên bắt đầu bằng chữ hoa có thể được gọi bởi một hàm không cùng gói. Điều này được gọi trong Go là tên được xuất. Để biết thêm về tên được xuất, xem Tên được xuất trong Tour Go.
- Khai báo biến message để lưu lời chào của bạn.
  Trong Go, toán tử := là cách viết tắt để khai báo và khởi tạo một biến trong một dòng (Go dùng giá trị bên phải để xác định kiểu của biến). Nếu viết đầy đủ, bạn có thể viết như sau:
```
var message string
message = fmt.Sprintf("Hi, %v. Welcome!", name)
```
- Dùng hàm Sprintf của gói fmt để tạo thông điệp lời chào. Đối số đầu tiên là chuỗi định dạng, và Sprintf thay thế giá trị của tham số name vào ký hiệu định dạng %v. Việc chèn giá trị của tham số name hoàn thiện văn bản lời chào.
- Trả về văn bản lời chào đã định dạng cho người gọi.

Trong bước tiếp theo, bạn sẽ gọi hàm này từ một module khác.