第 8 章：包与模块¶

// 文件路径：main.go
// main 包是可执行程序的入口
package main

import "fmt"

func main() {
    fmt.Println("这是一个可执行程序")
}

// 文件路径：mathutil/mathutil.go
// 库包：被其他程序导入使用
package mathutil

// Add 返回两个整数的和
func Add(a, b int) int {
    return a + b
}

// subtract 以小写字母开头，是包外不可见的私有函数
func subtract(a, b int) int {
    return a - b
}

package main

// 单行导入
import "fmt"

// 多行导入（推荐，风格更清晰）
import (
    "math"
    "strings"
)

func main() {
    fmt.Println(math.Sqrt(16))
    fmt.Println(strings.ToUpper("hello"))
}

package main

import (
    "fmt"
    "math/rand"
    cr "crypto/rand" // 别名 cr
)

func main() {
    // 使用 math/rand 包
    fmt.Println(rand.Intn(100))

    // 使用 crypto/rand 包（通过别名）
    b := make([]byte, 4)
    cr.Read(b)
    fmt.Println(b)
}

package main

import (
    "fmt"
    _ "image/png" // 仅注册 PNG 解码器，不直接使用
)

func main() {
    fmt.Println("匿名导入仅执行 init 函数")
}

package example

// === 导出（包外可访问） ===

// PI 是导出的常量
const PI = 3.14159

// Point 是导出的结构体类型
type Point struct {
    X, Y float64 // 字段 X, Y 也是导出的
}

// NewPoint 是导出的构造函数
func NewPoint(x, y float64) Point {
    return Point{X: x, Y: y}
}

// Distance 是导出的函数
func Distance(p1, p2 Point) float64 {
    return p1.distance(p2) // 内部调用私有方法
}

// === 非导出（包内可见） ===

// version 是包私有的常量
const version = "1.0.0"

// coordinate 是非导出类型
type coordinate struct {
    lat, lng float64
}

// distance 是包私有的方法
func (p Point) distance(other Point) float64 {
    return sqrt(pow(p.X-other.X) + pow(p.Y-other.Y))
}

// pow 是包私有的辅助函数
func pow(x float64) float64 {
    return x * x
}

// sqrt 是包私有的辅助函数
func sqrt(x float64) float64 {
    // 简易实现，实际应使用 math.Sqrt
    return x / 2
}

module github.com/user/myproject

go 1.21

require (
    github.com/gin-gonic/gin v1.9.1
    github.com/go-sql-driver/mysql v1.7.1
)

// 可选：替换模块（常用于本地开发或代理）
replace example.com/old => example.com/new v1.2.0

// 可选：排除特定版本
exclude example.com/bad v1.0.0

// project/internal/auth/token.go
package auth

// Token 生成函数（只允许 project 内部的包使用）
func GenerateToken(userID string) string {
    return "token_" + userID
}

// project/api/handler.go — 合法导入
package api

import "project/internal/auth"

func HandleLogin() {
    token := auth.GenerateToken("user123") // OK：处于 project 内部
    _ = token
}

package main

import "fmt"

// init 函数在 main 之前自动执行
func init() {
    fmt.Println("第二个 init")
}

// 同一个包中可以有多个 init 函数
func init() {
    fmt.Println("第一个 init")
}

func main() {
    fmt.Println("main 函数执行")
}

// 执行顺序：
// 第一个 init
// 第二个 init
// main 函数执行

// 文件：a/pack1.go
package a

import _ "b"

func init() {
    fmt.Println("pack1 init")
}

// 文件：b/pack2.go
package b

func init() {
    fmt.Println("pack2 init")
}

package database

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql" // 匿名导入，执行 init 驱动注册
)

var db *sql.DB

func init() {
    var err error
    db, err = sql.Open("mysql", "user:password@tcp(localhost:3306)/db")
    if err != nil {
        panic("数据库连接失败: " + err.Error())
    }
}

func GetDB() *sql.DB {
    return db
}