1
2
3
4
5
6
7
8

//go:build linux

package mypackage

// 这个文件只会在 Linux 平台上编译
func GetLinuxInfo() string {
    return "Running on Linux!"
}

1
2
3
4
5
6
7
8

//go:build windows

package mypackage

// 这个文件只会在 Windows 平台上编译
func GetWindowsInfo() string {
    return "Running on Windows!"
}

1
2
3
4
5
6

# 文件名模式
myscript.go           # 所有平台都编译
myscript_linux.go     # 仅 Linux
myscript_windows.go   # 仅 Windows
myscript_amd64.go     # 仅 AMD64 架构
myscript_linux_amd64.go # 仅 Linux + AMD64

1
2
3
4
5
6
7
8

// 文件名：hello.go
package main

import "fmt"

func main() {
    fmt.Println("Hello from all platforms!") // Hello from all platforms!
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 文件名：hello_windows.go
//go:build windows

package main

import "fmt"

func main() {
    fmt.Println("Hello from Windows!") // Hello from Windows!
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 文件名：hello_linux.go
//go:build linux

package main

import "fmt"

func main() {
    fmt.Println("Hello from Linux!") // Hello from Linux!
}

1
2
3
4
5
6
7
8

// 文件：util.go（无约束，所有平台都编译）
//go:build

package utils

func GetMessage() string {
    return "通用消息"
}

1
2
3
4
5
6
7
8

// 文件：util_windows.go（Windows 专用）
//go:build windows

package utils

func GetMessage() string {
    return "Windows 专属消息"
}

1
2
3
4
5
6
7
8

// 文件：util_linux_amd64.go（Linux AMD64 专用）
//go:build linux && amd64

package utils

func GetMessage() string {
    return "Linux AMD64 专属消息"
}

1

//go:build <约束条件>

1
2
3
4
5
6
7
8

//go:build linux

package mypackage

// 这个文件只在 Linux 上编译
func GetOSInfo() string {
    return "Linux"
}

1
2
3
4
5
6
7
8

//go:build windows

package mypackage

// 这个文件只在 Windows 上编译
func GetOSInfo() string {
    return "Windows"
}

1
2
3
4
5
6
7
8

//go:build linux && amd64

package mypackage

// 只在 Linux AMD64 平台上编译
func PlatformInfo() string {
    return "Linux on AMD64"
}

1
2
3
4
5
6
7
8

//go:build darwin || windows

package mypackage

// 在 macOS 或 Windows 上编译
func DesktopInfo() string {
    return "Desktop OS"
}

1
2
3
4
5
6
7
8

//go:build !linux

package mypackage

// 在非 Linux 平台上编译（也就是说在 Windows、macOS 等平台上）
func NotLinuxInfo() string {
    return "Not running on Linux"
}

1
2
3
4
5
6
7
8

//go:build linux && amd64 && !cgo

package mypackage

// 在 Linux AMD64 平台上，使用非 cgo 编译时生效
func PureGoInfo() string {
    return "Pure Go on Linux AMD64"
}

1
2
3
4
5
6
7
8

//go:build (linux && amd64) || (darwin && arm64)

package mypackage

// Linux AMD64 或 macOS ARM64
func SpecificPlatforms() string {
    return "Specific platforms"
}

1
2
3
4
5
6
7
8

// +build linux

package mypackage

// Linux 专用
func GetOSInfo() string {
    return "Linux"
}

1
2
3
4
5
6
7
8

// +build windows,amd64

package mypackage

// Windows AMD64 专用
func PlatformInfo() string {
    return "Windows on AMD64"
}

1
2
3
4
5

//go:build linux && (amd64 || arm64)
// +build linux amd64
// +build linux arm64

package mypackage

1
2
3
4
5
6

//go:build linux

// Linux 专用代码
func GetOS() string {
    return "Linux"
}

1
2
3
4
5
6

//go:build windows

// Windows 专用代码
func GetOS() string {
    return "Windows"
}

1
2
3
4
5
6

//go:build darwin

// macOS 专用代码
func GetOS() string {
    return "macOS"
}

1
2
3
4
5
6

//go:build freebsd

// FreeBSD 专用代码
func GetOS() string {
    return "FreeBSD"
}

1
2
3
4
5
6

//go:build amd64

// 仅 AMD64 (x86-64)
func GetArch() string {
    return "AMD64"
}

1
2
3
4
5
6

//go:build arm64

// 仅 ARM64
func GetArch() string {
    return "ARM64"
}

1
2
3
4
5
6

//go:build 386

// 仅 32位 x86
func GetArch() string {
    return "x86"
}

1
2
3
4
5
6

//go:build arm

// 仅 ARM
func GetArch() string {
    return "ARM"
}

1
2
3
4
5
6

//go:build gc

// 仅使用 gc 编译器（Go 标准编译器）
func GetCompiler() string {
    return "gc"
}

1
2
3
4
5
6

//go:build gccgo

// 仅使用 gccgo 编译器（GCC 的 Go 前端）
func GetCompiler() string {
    return "gccgo"
}

1
2
3
4
5
6
7

//go:build go1.18

// 仅 Go 1.18 及以上版本
// 可以使用泛型
func GenericFunc[T any](v T) T {
    return v
}

1
2
3
4
5
6

//go:build go1.21

// 仅 Go 1.21 及以上版本
func NewFeature() string {
    return "Go 1.21 新特性"
}

1
2
3
4
5
6

//go:build debug

// 仅在 debug 构建时包含
func DebugInfo() string {
    return "DEBUG 模式"
}

1
2
3
4
5
6

//go:build prod

// 仅在 prod 构建时包含
func ProdInfo() string {
    return "PRODUCTION 模式"
}

1
2
3
4
5
6

//go:build test

// 仅在测试时包含
func TestInfo() string {
    return "TEST 模式"
}

1
2
3
4
5
6

//go:build ignore

// 文件被忽略，不会编译
func Ignored() string {
    return "你看不到我"
}

1
2
3
4

# 使用自定义标签编译
go build -tags "debug"
go build -tags "prod"
go build -tags "test,integration"

1
2
3

name_OS.go
name_ARCH.go
name_OS_ARCH.go

1
2
3
4
5
6
7
8

# 适用于 Linux
util_linux.go

# 适用于 Windows
util_windows.go

# 适用于 macOS
util_darwin.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：platform_linux.go
package platform

import "runtime"

func GetPlatformName() string {
    return "Linux"
}

func GetOSVersion() string {
    return runtime.GOOS
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：platform_windows.go
package platform

import "runtime"

func GetPlatformName() string {
    return "Windows"
}

func GetOSVersion() string {
    return runtime.GOOS
}

1
2
3
4
5
6
7
8

# 适用于 AMD64 (x86-64)
util_amd64.go

# 适用于 ARM64
util_arm64.go

# 适用于 386 (32-bit x86)
util_386.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：arch_amd64.go
package arch

import "fmt"

func GetArchInfo() string {
    return "AMD64 (64-bit x86)"
}

func ExampleSpecialFeature() {
    fmt.Println("AMD64 specific feature") // AMD64 specific feature
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：arch_arm64.go
package arch

import "fmt"

func GetArchInfo() string {
    return "ARM64 (64-bit ARM)"
}

func ExampleSpecialFeature() {
    fmt.Println("ARM64 specific feature") // ARM64 specific feature
}

1
2
3
4
5
6
7
8

# Linux AMD64 专用
util_linux_amd64.go

# Windows ARM64 专用
util_windows_arm64.go

# macOS ARM64 专用
util_darwin_arm64.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：native_linux_amd64.go
package native

import "fmt"

func GetNativeInfo() string {
    return "Linux AMD64"
}

func RunBenchmark() {
    fmt.Println("Running on Linux AMD64...") // Running on Linux AMD64...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：native_darwin_arm64.go
package native

import "fmt"

func GetNativeInfo() string {
    return "macOS ARM64"
}

func RunBenchmark() {
    fmt.Println("Running on macOS ARM64...") // Running on macOS ARM64...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 文件：feat_linux_amd64.go

//go:build debug

package feat

// 这个文件必须满足：
// 1. 文件名约束：linux + amd64
// 2. 注释约束：debug 标签
func GetInfo() string {
    return "Linux AMD64 DEBUG"
}

1
2
3

# 只有同时满足平台和标签才会编译
go build -tags debug  # 在 Linux amd64 上会编译
go build              # 不会编译（缺少 debug 标签）

1

//go:generate stringer -type=Weekday

1
2
3
4
5

# 执行所有 //go:generate 指令
go generate ./...

# 或者只执行特定包的
cd mypackage && go generate

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

//go:generate stringer -type=Weekday -linecomment

package time

type Weekday int

const (
    Sunday    Weekday = iota // Sunday
    Monday                   // Monday
    Tuesday                  // Tuesday
    Wednesday                // Wednesday
    Thursday                 // Thursday
    Friday                   // Friday
    Saturday                 // Saturday
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Code generated by stringer -type=Weekday -linecomment; DO NOT EDIT.

package time

import "strconv"

func _() {
    // An invalid auxiliary input for Weekday.
    _ = p[September:Uint8]
}

const Weekday_name = "SundayMondayTuesdayWednesdayThursdayFridaySaturday"

var Weekday_index = [...]uint8{0, 6, 12, 19, 28, 36, 41, 48}

func (i Weekday) String() string {
    i -= Sunday
    return Weekday_name[Weekday_index[i]:Weekday_index[i+1]]
}

1
2
3
4
5
6
7
8

//go:generate mockgen -destination=mocks/mock_calculator.go -package=mocks Calculator

package calculator

type Calculator interface {
    Add(a, b int) int
    Multiply(a, b int) int
}

1

//go:linkname runtime.memclr0 runtime.memclr0

1
2
3
4
5
6
7

package myruntime

import _ "unsafe"

//go:linkname time_now time.now

// 这是合法的使用场景：访问 runtime 包的内部函数

1
2
3
4
5
6

//go:nosplit

func FastMemmove(dst, src unsafe.Pointer, n uintptr) {
    // 这个函数必须非常快，不能有栈增长检查的开销
    // 使用汇编实现，零栈帧
}

1
2
3
4
5
6
7

//go:nosplit

func gogo(gp *g) {
    // 这是 runtime 包中的一个关键函数
    // 用于 goroutine 调度
    // 必须保持最小栈帧以避免递归
}

1
2
3
4
5
6

//go:noescape

func Memcpy(dst, src unsafe.Pointer, n uintptr) {
    // 编译器会假设参数不会逃逸
    // 从而避免在堆上分配内存
}

1
2
3
4
5
6

//go:noescape

func SimdMemcpy(dst, src unsafe.Pointer, n uintptr) {
    // SIMD 内存拷贝，零拷贝开销
    // 使用汇编实现的高性能内存拷贝
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//go:noinline

func ComplexCalculation(x int) int {
    // 这个函数不会被内联
    // 便于在 profile 中看到它
    result := x * x
    for i := 0; i < x; i++ {
        result += i
    }
    return result
}

1
2
3
4
5
6

//go:noinline

func DebugPrintStack() {
    // 方便调试时看到完整的栈信息
    // 不会被内联到调用者
}

1
2
3
4
5
6

//go:systemstack

func writeBarrier() {
    // 这段代码必须在系统栈上运行
    // 因为它可能被一个正在栈增长的 goroutine 调用
}

1
2
3
4
5
6

//go:systemstack

func morestack() {
    // runtime 的 morestack 函数
    // 用于处理栈增长
}

1
2
3
4
5
6

//go:nowritebarrier

func SimpleAssign(dst, src unsafe.Pointer, size uintptr) {
    // 在这个函数中不能使用写屏障
    // 用于避免在某些关键路径上的 GC 开销
}

1
2
3
4
5

//go:yeswritebarrierrec

func WriteBarrierRecursive(ptr unsafe.Pointer, val interface{}) {
    // 递归调用时允许使用写屏障
}

1
2

// mylib.h
int add(int a, int b);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/*
#include "mylib.h"
*/
import "C"

import (
    "fmt"
)

//void add(int, int);
//go:linkname add github.com/my/pkg.add
//go:cgo_import_dynamic add add "mylib.dll"

1

//go:cgo_import_dynamic clib add "mylib.so"

1

//go:cgo_import_static clib add

1

//go:cgo_import_static mypkg_add

1

//go:cgo_ldflag -lpthread

1
2

//go:cgo_ldflag -L/usr/local/lib
//go:cgo_ldflag -lm

1

//go:cgo_export_static GoAdd

1
2
3
4
5
6

//export GoAdd
func GoAdd(a, b int32) int32 {
    return a + b
}

//go:cgo_export_static GoAdd

1

//go:cgo_export_dynamic GoMultiply

1
2
3
4
5
6

//export GoMultiply
func GoMultiply(a, b int32) int32 {
    return a * b
}

//go:cgo_export_dynamic GoMultiply

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package main

import _ "embed"

//go:embed hello.txt
var greeting string

func main() {
    println(greeting)
}

1
2

Hello, World!

1

// Hello, World!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main

import _ "embed"

//go:embed templates
var templates embed.FS

func main() {
    data, _ := templates.ReadFile("templates/index.html")
    println(string(data))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
    "embed"
    "fmt"
)

//go:embed *.go
var sourceFiles embed.FS

//go:embed "data/*.json"
var dataFiles embed.FS

//go:embed textfile.txt
var textContent string

//go:embed image.png
var imageData []byte

    fmt.Println("文本内容:", textContent) // 文本内容: // Hello, World!
    fmt.Println("文本内容:", textContent) // 文本内容: // Hello, World!
    fmt.Printf("图片大小: %d bytes\n", len(imageData)) // 图片大小: <file_size> bytes
}

1

//go:mod github.com/my/project v1.2.3

1

//go:sum github.com/pkg/errors v0.9.1 h1: LWQ1pSpb5y95X0N6y8eRM...

1

//go:debug local

1

//go:fix uuid

1
2
3
4
5
6
7
8

// file: stat_linux.go
//go:build linux

package sys

func GetFileInfo(path string) (os.FileInfo, error) {
    return os.Stat(path)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("OS:", runtime.GOOS) // OS: windows (示例)
    fmt.Println("Arch:", runtime.GOARCH) // Arch: amd64 (示例)
}

1
2
3
4

util.go           # 所有平台共享
util_linux.go    # Linux 专用
util_windows.go  # Windows 专用
util_darwin.go   # macOS 专用

1
2
3

//go:build linux && !cgo

package util

1
2
3
4
5

platform/
├── platform.go      # 共享代码
├── platform_linux.go
├── platform_windows.go
└── platform_bsd.go  // FreeBSD, OpenBSD, NetBSD 共用

1
2
3
4

// platform_bsd.go
//go:build freebsd || openbsd || netbsd

package platform

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// file: cache_test.go
//go:build integration

package cache

import "testing"

func TestCacheIntegration(t *testing.T) {
    // 集成测试，需要外部依赖
}

1
2
3
4
5

# 运行普通测试
go test ./...

# 运行包含集成测试
go test -tags integration ./...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# .github/workflows/cross-compile.yml
name: Cross Compile

on: [push]

jobs:
  build:
    strategy:
      matrix:
        goos: [linux, windows, darwin]
        goarch: [amd64, arm64]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build
        env:
          GOOS: ${{ matrix.goos }}
          GOARCH: ${{ matrix.goarch }}
        run: |
          go build -o myapp-${{ matrix.goos }}-${{ matrix.goarch }}

1
2
3
4

// file: foo_linux.go
//go:build darwin  // ❌ 错误！文件名说是 Linux，注释说是 Darwin

package foo

1
2
3
4
5
6

# 如果只有
feat_linux.go   # Linux 专用
feat_windows.go # Windows 专用

# 但忘了 feat.go（通用版本）
# 那么在 macOS 上编译会失败！

1
2
3
4
5
6
7
8

# ❌ 过度使用：代码碎片化严重
feat_linux.go
feat_windows.go
feat_darwin.go
feat_debug.go
feat_release.go
feat_aws.go
feat_azure.go

1
2
3
4
5
6
7
8

# 编译时指定标签
go build -tags "debug,prod" ./...

# 忽略构建约束
go build -tags "ignore_constraints" ./...

# 查看构建约束
go list -f '{{.GoFiles}}' ./...

1
2
3
4
5
6
7
8
9

//go:build linux && amd64

package main

import "fmt"

func main() {
    fmt.Println("Built for Linux AMD64") // Built for Linux AMD64
}

1
2
3
4
5
6
7
8

# 查看包的文件列表
go list -f '{{.GoFiles}}' mypackage

# 查看所有平台可用的文件
go list -f '{{.TestGoFiles}}' mypackage

# 查看 C 文件
go list -f '{{.CgoFiles}}' mypackage

1
2
3
4
5

# 查看构建约束
go list -f '{{.Constraints}}' ./...

# 更详细的输出
go list -json -f '{{.Constraints}}' mypackage

1
2
3
4
5
6

{
    "go.toolsEnvVars": {
        "GOOS": "linux",
        "GOARCH": "amd64"
    }
}

1
2
3
4
5

# 静态分析会检查构建约束
go vet ./...

# 检查特定平台
GOOS=linux GOARCH=amd64 go vet ./...

1
2
3
4
5

# .golangci.yml
run:
  tags:
    - debug
    - integration