# 格式化單個文件（輸出到標(biāo)準(zhǔn)輸出）
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 .
# 區(qū)別：
# go fmt    → 操作包級別的代碼（當(dāng)前目錄和子目錄）
# gofmt     → 更靈活，可以操作任意文件

// 格式化前（可能使用了空格縮進）
func main() {
        if true {
            fmt.Println("hello")
        }
}
// 格式化后（統(tǒng)一使用Tab縮進）
func main() {
	if true {
		fmt.Println("hello")
	}
}

// ? 正確：大括號與函數(shù)聲明在同一行
func add(a, b int) int {
    return a + b
}
// ? 錯誤：大括號換行會導(dǎo)致編譯錯誤
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
// 簡化前（在數(shù)組/切片字面量內(nèi)）
arr := []T{T{a, b}, T{c, d}}
// 簡化后 → 可以省略內(nèi)部類型
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寬度（默認(rèn)8，建議保持默認(rèn)）
gofmt -tabwidth=4 main.go
# 僅列出需要格式化的文件（CI中常用）
gofmt -l .

# 語法: gofmt -r 'pattern -> replacement'
# 示例1：修改函數(shù)調(diào)用
gofmt -r 'oldFunc(a) -> newFunc(a)' -w main.go
# 示例2：交換參數(shù)順序
gofmt -r 'a[b:len(a)] -> a[b:]' -w .
# 示例3：簡化表達式
gofmt -r 'a != a -> false' -w .
# 示例4：類型轉(zhuǎn)換（需要指定文件）
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

# 格式化并管理導(dǎo)入
goimports -w main.go
# 格式化整個項目
goimports -w .
# 查看差異
goimports -d main.go

// 原始代碼（沒有導(dǎo)入fmt）
package main
func main() {
    fmt.Println("hello") // 缺少fmt的導(dǎo)入
    os.Exit(0)           // 缺少os的導(dǎo)入
}
// gofmt 結(jié)果：只格式化，不管理導(dǎo)入
// 代碼依然缺少導(dǎo)入聲明
// goimports 結(jié)果：
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 "代碼格式不符合規(guī)范"
    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 "以下文件格式不符合規(guī)范:"
    echo "$unformatted"
    echo ""
    echo "請運行 go fmt ./... 后重新提交"
    exit 1
fi
echo "代碼格式檢查通過"
exit 0

// 以下命名風(fēng)格gofmt都不會改變
var my_variable int  // 下劃線風(fēng)格（Go不推薦）
var myVariable int   // 駝峰風(fēng)格（Go推薦）
var MyVariable int   // 首字母大寫（導(dǎo)出變量）
// 在Go中推薦使用駝峰式：myVariable, MyStruct, doSomething

// gofmt不會幫你拆分這個長行
result := someVeryLongFunctionName(parameter1, parameter2, parameter3, parameter4, parameter5)

//go:noformat
func specialTable() {
    // 這個函數(shù)中的手動對齊不會被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 ./...