Package và module tổ chức code Go như thế nào?

Question

Accepted Answer

Go tổ chức code với **package** (tập hợp các file nguồn trong một thư mục) và **module** (tập hợp các package với các phụ thuộc được đánh phiên bản). Cùng nhau, chúng cấu trúc các dự án và quản lý phụ thuộc.

## Package — một thư mục code liên quan

```go
// mọi file .go bắt đầu bằng việc khai báo package của nó
package main         // "main" là đặc biệt — tạo ra một executable

// hoặc một package thư viện (đặt tên theo thư mục của nó, theo quy ước)
package mathutil

func Add(a, b int) int { return a + b }   // Exported (viết hoa) — dùng được bên ngoài
func helper() {}                           // unexported (viết thường) — riêng tư trong package
```

Tất cả các file trong một thư mục thuộc về một package. **Việc viết hoa kiểm soát khả năng hiển thị**: tên viết hoa là exported (công khai giữa các package), viết thường là riêng tư trong package.

## Import và sử dụng package

```go
import (
    "fmt"                          // thư viện chuẩn
    "strings"
    "github.com/user/repo/mathutil" // một package module bên thứ ba hoặc local
)

fmt.Println(strings.ToUpper("hi"))
mathutil.Add(2, 3)                  // dùng tên Exported qua package.Name
```

## Module — quản lý phụ thuộc theo phiên bản

```bash
go mod init github.com/user/myapp   # tạo một module → tạo go.mod
go get github.com/gin-gonic/gin     # thêm một phụ thuộc (ghi vào go.mod)
go mod tidy                          # thêm phụ thuộc thiếu & gỡ phụ thuộc không dùng
go build                             # build dùng các phụ thuộc của module
```

```text
go.mod  — khai báo đường dẫn module, phiên bản Go, và các phụ thuộc trực tiếp (+ phiên bản)
go.sum  — checksum mã hóa của các phụ thuộc (toàn vẹn/bảo mật)
```

Một **module** (giới thiệu trong Go 1.11) là đơn vị quản lý phụ thuộc — `go.mod` liệt kê các phiên bản phụ thuộc chính xác, khiến các bản build có thể tái lập. `go.sum` xác minh tính toàn vẹn của phụ thuộc.

## Hàm init và main

```go
package main

func init() {    // chạy tự động khi package được load (trước main)
    // thiết lập
}
func main() {    // điểm vào của một executable (chỉ package main)
}
```

## Quy ước cấu trúc dự án

```text
myapp/
  go.mod
  main.go              package main
  internal/            các package ở đây là RIÊNG TƯ với module này (không import từ bên ngoài được)
  pkg/ hoặc thư mục khác/  các package tái sử dụng
```

Thư mục `internal/` là đặc biệt — các package của nó chỉ có thể import trong cùng module, thực thi việc đóng gói (encapsulation) ở cấp module.

## Tại sao điều này quan trọng

Package và module là cách các dự án Go được cấu trúc và cách quản lý phụ thuộc — thiết yếu cho mọi dự án thực tế.

Hiểu package (một thư mục các file, khả năng hiển thị exported/unexported dựa trên viết hoa, package `main` đặc biệt) là nền tảng để tổ chức code và kiểm soát API công khai của nó.

Module (`go mod`, `go.mod`/`go.sum`) cung cấp quản lý phụ thuộc có thể tái lập, đánh phiên bản, kiểm tra toàn vẹn — chuẩn hiện đại thay thế cách tiếp cận GOPATH cũ.

Biết hệ thống import, quy ước `internal/` cho code riêng-tư-trong-module, và tooling (`go mod init/tidy`, `go get`) là cần thiết để build, chia sẻ và bảo trì các dự án Go, đồng thời phản ánh sự thông thạo thực tế với hệ sinh thái Go.