Go 构建约束完全指南：跨平台条件编译的 12 种实战模式

// +build linux,amd64
// +build !cgo

package main

//go:build (linux || darwin) && amd64 && !cgo

package main

// Package config provides platform-specific configuration
//go:build darwin

package config

//go:build linux

package main

//go:build linux
//go:build amd64

package main
// 等效于 linux && amd64

// config_linux.go
//go:build linux

package main

import (
    "os"
    "path/filepath"
)

func getConfigPath() string {
    if xdgConfig := os.Getenv("XDG_CONFIG_HOME"); xdgConfig != "" {
        return filepath.Join(xdgConfig, "myapp", "config.yaml")
    }
    return filepath.Join(os.Getenv("HOME"), ".config", "myapp", "config.yaml")
}

func getHomeDir() string {
    return os.Getenv("HOME")
}

func getDataDir(appName string) string {
    if xdgData := os.Getenv("XDG_DATA_HOME"); xdgData != "" {
        return filepath.Join(xdgData, appName)
    }
    return filepath.Join(os.Getenv("HOME"), ".local", "share", appName)
}

func getTempDir() string {
    if tmpDir := os.Getenv("TMPDIR"); tmpDir != "" {
        return tmpDir
    }
    return "/tmp"
}

// config_darwin.go
//go:build darwin

package main

import (
    "os"
    "path/filepath"
)

func getConfigPath() string {
    return filepath.Join(
        getHomeDir(),
        "Library",
        "Application Support",
        "MyApp",
        "config.yaml",
    )
}

func getHomeDir() string {
    return os.Getenv("HOME")
}

func getDataDir(appName string) string {
    return filepath.Join(
        getHomeDir(),
        "Library",
        "Application Support",
        appName,
    )
}

func getTempDir() string {
    return os.Getenv("TMPDIR")
}

// config_windows.go
//go:build windows

package main

import (
    "os"
    "path/filepath"
)

func getConfigPath() string {
    if appData := os.Getenv("APPDATA"); appData != "" {
        return filepath.Join(appData, "MyApp", "config.yaml")
    }
    return filepath.Join(os.Getenv("USERPROFILE"), "MyApp", "config.yaml")
}

func getHomeDir() string {
    if home := os.Getenv("USERPROFILE"); home != "" {
        return home
    }
    return os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
}

func getDataDir(appName string) string {
    if localAppData := os.Getenv("LOCALAPPDATA"); localAppData != "" {
        return filepath.Join(localAppData, appName)
    }
    return filepath.Join(os.Getenv("APPDATA"), appName)
}

func getTempDir() string {
    if tmp := os.Getenv("TEMP"); tmp != "" {
        return tmp
    }
    if tmp := os.Getenv("TMP"); tmp != "" {
        return tmp
    }
    return filepath.Join(os.Getenv("WINDIR"), "Temp")
}

# 当前平台编译（Linux 上会自动选择 config_linux.go）
go build

# 交叉编译 Windows 版本
GOOS=windows go build

# 交叉编译 macOS ARM64 版本（Apple Silicon）
GOOS=darwin GOARCH=arm64 go build

# 交叉编译 Linux ARM 版本（树莓派等）
GOOS=linux GOARCH=arm go build

//go:build arm64

package simd

func vectorProduct(a, b []float32, result []float32) {
    // ARM64 NEON 优化实现
    // 利用 NEON 向量指令进行并行浮点运算
    neonVectorProduct(a, b, result)
}

//go:build amd64

package simd

func vectorProduct(a, b []float32, result []float32) {
    // x86 AVX2 优化实现
    // 利用 AVX2 256位向量寄存器
    avx2VectorProduct(a, b, result)
}

// go:build !(arm64 || amd64)

package simd

func vectorProduct(a, b []float32, result []float32) {
    // 通用纯 Go 回退实现
    for i := range a {
        result[i] = a[i] * b[i]
    }
}

// database_integration_test.go
//go:build integration

package main

import (
    "context"
    "database/sql"
    "os"
    "testing"
    "time"

    _ "github.com/lib/pq"
)

func TestDatabaseConnection(t *testing.T) {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    db, err := sql.Open("postgres", os.Getenv("TEST_DATABASE_URL"))
    if err != nil {
        t.Fatalf("打开数据库失败: %v", err)
    }
    defer db.Close()

    if err := db.PingContext(ctx); err != nil {
        t.Fatalf("数据库连接失败: %v", err)
    }
}

func TestUserCRUD(t *testing.T) {
    db, err := sql.Open("postgres", os.Getenv("TEST_DATABASE_URL"))
    if err != nil {
        t.Fatalf("打开数据库失败: %v", err)
    }
    defer db.Close()

    _, err = db.Exec("CREATE TEMP TABLE test_users (id SERIAL PRIMARY KEY, name TEXT)")
    if err != nil {
        t.Fatalf("创建临时表失败: %v", err)
    }

    _, err = db.Exec("INSERT INTO test_users (name) VALUES ($1)", "Alice")
    if err != nil {
        t.Fatalf("插入数据失败: %v", err)
    }

    var name string
    err = db.QueryRow("SELECT name FROM test_users WHERE id = 1").Scan(&name)
    if err != nil {
        t.Fatalf("查询数据失败: %v", err)
    }

    if name != "Alice" {
        t.Errorf("期望 name = Alice, 实际得到 %s", name)
    }
}

# 默认不运行集成测试（快速本地验证）
go test ./...

# 运行单元测试 + 集成测试
go test -tags integration ./...

# 启用多个标签（空格或逗号分隔）
go test -tags "integration e2e" ./...

//go:build linux && amd64

package main
// 只在 Linux 的 amd64 架构上编译

//go:build linux || darwin

package main
// 在 Linux 或 macOS 上编译

//go:build !windows

package main
// 除了 Windows 外的所有平台

//go:build (linux || darwin || freebsd) && amd64 && !cgo

package main
/* 编译条件：
   1. 操作系统是 Linux、macOS 或 FreeBSD
   2. 架构是 amd64
   3. 未启用 CGO
*/

// 不好的写法：依赖优先级，容易误解
//go:build linux || darwin && amd64
// 实际等效于：linux || (darwin && amd64)

// 好的写法：明确括号
//go:build (linux || darwin) && amd64

//go:build go1.21

package main

import "slices"

func SortStrings(data []string) {
    slicessort(data)
}

//go:build !go1.21

package main

import "sort"

func SortStrings(data []string) {
    sort.Strings(data)
}

// paths.go
package config

import "os"

type Paths interface {
    ConfigFile() string
    DataDir() string
    LogDir() string
    TempDir() string
    HomeDir() string
}

// paths_linux.go
//go:build linux

package config

import (
    "os"
    "path/filepath"
)

type platformPaths struct {
    appName string
}

func NewPaths(appName string) Paths {
    return &platformPaths{appName: appName}
}

func (p *platformPaths) HomeDir() string {
    if home := os.Getenv("HOME"); home != "" {
        return home
    }
    return "/tmp"
}

func (p *platformPaths) ConfigFile() string {
    if xdg := os.Getenv("XDG_CONFIG_HOME"); xdg != "" {
        return filepath.Join(xdg, p.appName, "config.yaml")
    }
    return filepath.Join(p.HomeDir(), ".config", p.appName, "config.yaml")
}

func (p *platformPaths) DataDir() string {
    if xdg := os.Getenv("XDG_DATA_HOME"); xdg != "" {
        return filepath.Join(xdg, p.appName)
    }
    return filepath.Join(p.HomeDir(), ".local", "share", p.appName)
}

func (p *platformPaths) LogDir() string {
    if xdg := os.Getenv("XDG_STATE_HOME"); xdg != "" {
        return filepath.Join(xdg, p.appName, "logs")
    }
    return filepath.Join(p.DataDir(), "logs")
}

func (p *platformPaths) TempDir() string {
    return os.TempDir()
}

// db_linux.go
//go:build linux

package main

import (
    "database/sql"
    _ "github.com/mattn/go-sqlite3"
)

func openDB(dsn string) (*sql.DB, error) {
    return sql.Open("sqlite3", dsn)
}

// db_windows.go
//go:build windows

package main

import (
    "database/sql"
    _ "modernc.org/sqlite"
)

func openDB(dsn string) (*sql.DB, error) {
    return sql.Open("sqlite", dsn)
}

// main.go
package main

func main() {
    db, err := openDB("app.db")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    // 正常操作数据库...
}

// middleware_dev.go
//go:build dev || debug

package main

import (
    "log"
    "net/http"
    "time"
)

func applyMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("[DEV] %s %s - %v", r.Method, r.URL.Path, time.Since(start))
    })
}

// middleware_prod.go
//go:build !dev && !debug

package main

import "net/http"

func applyMiddleware(next http.Handler) http.Handler {
    return next // 生产环境：不添加额外日志中间件
}

// hash_cgo.go
//go:build cgo

package main

/*
#cgo LDFLAGS: -lcrypto
#include <openssl/evp.h>
#include <string.h>
*/
import "C"
import "unsafe"

func fastHash(data []byte) []byte {
    md := C.EVP_sha256()
    ctx := C.EVP_MD_CTX_new()
    defer C.EVP_MD_CTX_free(ctx)

    C.EVP_DigestInit_ex(ctx, md, nil)
    if len(data) > 0 {
        C.EVP_DigestUpdate(ctx, unsafe.Pointer(&data[0]), C.size_t(len(data)))
    }

    var hash [C.EVP_MAX_MD_SIZE]C.uchar
    var length C.uint
    C.EVP_DigestFinal_ex(ctx, &hash[0], &length)

    result := make([]byte, length)
    copy(result, (*[C.EVP_MAX_MD_SIZE]byte)(unsafe.Pointer(&hash[0]))[:length:length])
    return result
}

// hash_nocgo.go
//go:build !cgo

package main

import "crypto/sha256"

func fastHash(data []byte) []byte {
    sum := sha256.Sum256(data)
    return sum[:]
}

// api_integration_test.go
//go:build integration

package main

import (
    "net/http"
    "net/http/httptest"
    "os"
    "testing"
)

func TestAPIEndpoints(t *testing.T) {
    if os.Getenv("TEST_API_URL") == "" {
        t.Skip("跳过集成测试：未设置 TEST_API_URL")
    }

    resp, err := http.Get(os.Getenv("TEST_API_URL") + "/health")
    if err != nil {
        t.Fatalf("请求失败: %v", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        t.Errorf("期望状态码 200, 实际 %d", resp.StatusCode)
    }
}

// e2e_test.go
//go:build e2e

package main

import (
    "os"
    "testing"
)

func TestEndToEndPurchaseFlow(t *testing.T) {
    if os.Getenv("STAGING_URL") == "" {
        t.Skip("需要 STAGING_URL 环境变量")
    }
    // 完整的端到端购买流程验证
}

# 仅运行单元测试（最快）
go test -short ./...

# 运行包括集成在内的所有测试
go test -tags integration ./...

# 运行全部测试（CI 流程）
go test -tags "integration e2e" ./...

# .github/workflows/release.yaml
name: Multi-Platform Build

on:
  push:
    tags:
      - 'v*'

jobs:
  build:
    strategy:
      matrix:
        include:
          - goos: linux
            goarch: amd64
            runner: ubuntu-latest
          - goos: linux
            goarch: arm64
            runner: ubuntu-latest
          - goos: linux
            goarch: arm
            runner: ubuntu-latest
          - goos: darwin
            goarch: amd64
            runner: macos-latest
          - goos: darwin
            goarch: arm64
            runner: macos-latest
          - goos: windows
            goarch: amd64
            runner: windows-latest
          - goos: freebsd
            goarch: amd64
            runner: ubuntu-latest

    runs-on: ${{ matrix.runner }}

    steps:
      - uses: actions/checkout@v4

      - name: Set up Go
        uses: actions/setup-go@v5
        with:
          go-version: '1.23'

      - name: Build
        env:
          GOOS: ${{ matrix.goos }}
          GOARCH: ${{ matrix.goarch }}
          CGO_ENABLED: 0
        run: |
          go build -ldflags="-s -w -X main.version=${{ github.ref_name }}" \
            -o dist/app-${{ matrix.goos }}-${{ matrix.goarch }}${{ matrix.goos == 'windows' && '.exe' || '' }}

      - name: Upload Artifact
        uses: actions/upload-artifact@v4
        with:
          name: app-${{ matrix.goos }}-${{ matrix.goarch }}
          path: dist/*

//go:build !dev
//go:embed static/*
var staticFiles embed.FS

func getStaticFile(name string) ([]byte, error) {
    return staticFiles.ReadFile("static/" + name)
}

//go:build dev

package main

import (
    "os"
    "path/filepath"
)

// 开发模式：从磁盘读取，方便实时修改
func getStaticFile(name string) ([]byte, error) {
    return os.ReadFile(filepath.Join("static", name))
}

# 查看当前平台会编译哪些源文件
go list -f '{{.GoFiles}}' ./...

# 查看特定平台（交叉编译视角）的文件列表
GOOS=windows GOARCH=amd64 go list -f '{{.GoFiles}}' ./...

# 查看被排除的源文件及其被排除原因
go list -f '{{.IgnoredGoFiles}}' ./...
GOOS=windows go list -f '{{.IgnoredGoFiles}}' ./...

# 查看所有约束标签（含推导后的完整标签列表）
go list -f '{{.BuildConstraints}}' ./...

# 查看完整文件信息
go list -json ./...

go tool dist list