Go语言代码格式化入门及gofmt使用教程

# 格式化单个文件（输出到标准输出）
gofmt main.go
# 格式化并覆盖原文件
gofmt -w main.go
# 格式化整个目录
gofmt -w .
# 格式化整个项目
gofmt -w ./...
# 显示格式化差异（不实际修改文件）
gofmt -d main.go
# 显示被格式化的文件列表
gofmt -l .
# 列出所有语法错误
gofmt -e main.go

# go fmt 是 gofmt 的封装，等价于：
gofmt -l -w .
# 区别：
# go fmt    → 操作包级别的代码（当前目录和子目录）
# gofmt     → 更灵活，可以操作任意文件

// 格式化前（可能使用了空格缩进）
func main() {
        if true {
            fmt.Println("hello")
        }
}
// 格式化后（统一使用Tab缩进）
func main() {
	if true {
		fmt.Println("hello")
	}
}

// ✅ 正确：大括号与函数声明在同一行
func add(a, b int) int {
    return a + b
}
// ❌ 错误：大括号换行会导致编译错误
func add(a, b int) int
{
    return a + b
}
// ✅ 正确：if语句同理
if x > 0 {
    fmt.Println("positive")
}
// ❌ 错误
if x > 0
{
    fmt.Println("positive")
}

// 格式化前
func add(a,b int)int{
return a+b
}
// 格式化后
func add(a, b int) int {
	return a + b
}

// 以下情况不会自动换行
func add(a, b, c, d, e, f int) int {
    return a + b + c + d + e + f // 可能超长但不会自动换行
}
// 多行表达式需要手动换行
result := veryLongFunctionName(
    argument1,
    argument2,
    argument3,
)
// 长字符串可以这样处理
longStr := "第一部分" +
    "第二部分" +
    "第三部分"

// 格式化前
package main
import "fmt"
func main() {
    fmt.Println("hello")
}
// 格式化后
package main
import "fmt"
func main() {
	fmt.Println("hello")
}

// 格式化前
import "os"
import "fmt"
import "github.com/gin-gonic/gin"
import "strings"
import "net/http"
// 格式化后（goimports会自动分组和排序）
import (
    "fmt"
    "net/http"
    "os"
    "strings"
    "github.com/gin-gonic/gin"
)

// 简化前
arr := [3]int{0, 1, 2}
// 简化后 → 不需要写长度
arr := [...]int{0, 1, 2}
// 简化前
var s = []int{}
// 简化后 → nil切片更简洁
var s []int
// 简化前（在数组/切片字面量内）
arr := []T{T{a, b}, T{c, d}}
// 简化后 → 可以省略内部类型
arr := []T{{a, b}, {c, d}}
// 简化前（range中的冗余变量）
for i, _ := range s { }
// 简化后
for i := range s { }

# 格式化并简化
gofmt -s -w main.go
# go fmt 也支持简化
go fmt -s ./...

gofmt -d main.go

diff main.go gofmt/main.go
--- /tmp/gofmt12345	2024-01-15 10:30:00
+++ /tmp/gofmt67890	2024-01-15 10:30:00
@@ -3,4 +3,4 @@
 import "fmt"
 func main(){
-fmt.Println("hello")
+	fmt.Println("hello")
 }

# 使用空格代替Tab（一般不推荐）
gofmt -tabs=false main.go
# 指定Tab宽度（默认8，建议保持默认）
gofmt -tabwidth=4 main.go
# 仅列出需要格式化的文件（CI中常用）
gofmt -l .

# 语法: gofmt -r 'pattern -> replacement'
# 示例1：修改函数调用
gofmt -r 'oldFunc(a) -> newFunc(a)' -w main.go
# 示例2：交换参数顺序
gofmt -r 'a[b:len(a)] -> a[b:]' -w .
# 示例3：简化表达式
gofmt -r 'a != a -> false' -w .
# 示例4：类型转换（需要指定文件）
gofmt -r 'int(x) -> int64(x)' -w math.go

# 将 ioutil.ReadAll 迁移到 io.ReadAll (Go 1.16+)
gofmt -r 'ioutil.ReadAll -> io.ReadAll' -w $(gofmt -l .)
gofmt -r 'ioutil.ReadFile -> os.ReadFile' -w $(gofmt -l .)
gofmt -r 'ioutil.WriteFile -> os.WriteFile' -w $(gofmt -l .)

go install golang.org/x/tools/cmd/goimports@latest

# 格式化并管理导入
goimports -w main.go
# 格式化整个项目
goimports -w .
# 查看差异
goimports -d main.go

// 原始代码（没有导入fmt）
package main
func main() {
    fmt.Println("hello") // 缺少fmt的导入
    os.Exit(0)           // 缺少os的导入
}
// gofmt 结果：只格式化，不管理导入
// 代码依然缺少导入声明
// goimports 结果：
package main
import (
    "fmt"
    "os"
)
func main() {
    fmt.Println("hello")
    os.Exit(0)
}

{
    "go.formatTool": "goimports",
    "go.useLanguageServer": true,
    "[go]": {
        "editor.formatOnSave": true,
        "editor.codeActionsOnSave": {
            "source.organizeImports": true
        }
    }
}

# 推荐的工作流
# 1. 写代码
vim main.go
# 2. 保存后立即格式化
go fmt ./...
# 3. 运行测试
go test ./...
# 4. 提交（如果格式化后有变化，再次提交）
git add .
git commit -m "feat: 添加新功能"

# 方法一：检查是否有未格式化的文件
if [ -n "$(gofmt -l .)" ]; then
    echo "以下文件未被格式化:"
    gofmt -l .
    exit 1
fi
# 方法二：gofmt -d 检查差异
if ! gofmt -d . 2>&1 | read; then
    echo "代码格式不符合规范"
    exit 1
fi

name: Go Code Check
on: [push, pull_request]
jobs:
  fmt:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.22'
      - name: Check formatting
        run: |
          unformatted=$(gofmt -l .)
          if [ -n "$unformatted" ]; then
            echo "以下文件需要格式化:"
            echo "$unformatted"
            exit 1
          fi
      - name: Run go vet
        run: go vet ./...
      - name: Run tests
        run: go test -race ./...

# .git/hooks/pre-commit
#!/bin/bash
echo "检查代码格式..."
# 获取所有暂存的.go文件
files=$(git diff --cached --name-only --diff-filter=ACM | grep '\.go$')
if [ -z "$files" ]; then
    echo "没有Go文件被修改"
    exit 0
fi
# 检查格式
unformatted=$(gofmt -l $files)
if [ -n "$unformatted" ]; then
    echo "以下文件格式不符合规范:"
    echo "$unformatted"
    echo ""
    echo "请运行 go fmt ./... 后重新提交"
    exit 1
fi
echo "代码格式检查通过"
exit 0

// 以下命名风格gofmt都不会改变
var my_variable int  // 下划线风格（Go不推荐）
var myVariable int   // 驼峰风格（Go推荐）
var MyVariable int   // 首字母大写（导出变量）
// 在Go中推荐使用驼峰式：myVariable, MyStruct, doSomething

// gofmt不会帮你拆分这个长行
result := someVeryLongFunctionName(parameter1, parameter2, parameter3, parameter4, parameter5)

//go:noformat
func specialTable() {
    // 这个函数中的手动对齐不会被gofmt破坏
    data := [][]string{
        {"Name",     "Age", "City"},
        {"Alice",    "30",  "New York"},
        {"Bob",      "25",  "London"},
        {"Charlie",  "35",  "Tokyo"},
    }
}

package main
import (
    "bytes"
    "fmt"
    "go/format"
    "go/parser"
    "go/token"
)
func main() {
    // 未格式化的Go代码
    src := `
package main
import "fmt"
func main(){
fmt.Println("hello")
}`
    // 解析为AST
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
    if err != nil {
        fmt.Println("解析错误:", err)
        return
    }
    // 格式化AST
    var buf bytes.Buffer
    if err := format.Node(&buf, fset, f); err != nil {
        fmt.Println("格式化错误:", err)
        return
    }
    fmt.Println("格式化后:")
    fmt.Println(buf.String())
}

# .golangci.yml
linters:
  enable:
    - gofmt
    - goimports
linters-settings:
  gofmt:
    simplify: true
  goimports:
    local-prefixes: github.com/yourcompany

golangci-lint run ./...