go-dev

Original：🇨🇳 Chinese

Translated

Go Development Guidelines, including naming conventions, error handling, concurrent programming, testing specifications, etc.

1installs

Sourcedoccker/cc-use-exp

Added on2026-02-26

NPX Install

npx skill4agent add doccker/cc-use-exp go-dev

SKILL.md Content (Chinese)

View Translation Comparison →

Go Development Guidelines

Reference Sources: Effective Go, Go Code Review Comments, uber-go/guide

Toolchain

bash

goimports -w .                    # Format and organize imports
go vet ./...                      # Static analysis
golangci-lint run                 # Comprehensive check
go test -v -race -cover ./...     # Testing (including race detection and coverage)

Naming Conventions

Type	Rule	Example
Package Name	Lowercase words, no underscores	`user` , `orderservice`
Variable/Function	CamelCase, consistent case for abbreviations	`userID` , `HTTPServer`
Constant	Exported ones use CamelCase, private ones can use CamelCase or all uppercase	`MaxRetryCount`
Interface	Single-method interfaces use method name + er	`Reader` , `Writer`

Prohibited: Meaningless package names like

common

,

util

,

base

Import Order

go

import (
    "context"           // Standard library
    "fmt"

    "github.com/gin-gonic/gin"  // Third-party libraries

    "project/internal/model"     // Internal project code
)

Error Handling

Errors must be handled, cannot be ignored:

go

// ✅ Good: Add context
if err != nil {
    return fmt.Errorf("failed to query user %d: %w", userID, err)
}

// ❌ Bad: Ignore error
result, _ := doSomething()

Error Wrapping: Use

%w

to preserve error chain, use

errors.Is()

/

errors.As()

for checking

Concurrent Programming

Basic Principles:

Prioritize using channel communication
Before starting a goroutine, consider: Who will wait for it? How to stop it?
Use
```
context.Context
```
to control lifecycle

go

// ✅ Good: Control with context
func process(ctx context.Context) error {
    done := make(chan error, 1)
    go func() { done <- doWork() }()

    select {
    case err := <-done:
        return err
    case <-ctx.Done():
        return ctx.Err()
    }
}

Data Races: Use

go test -race

to detect

Testing Specifications

go

// Table-driven test
func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive", 1, 2, 3},
        {"zero", 0, 0, 0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Add(tt.a, tt.b)
            if got != tt.expected {
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.expected)
            }
        })
    }
}

Performance Optimization

Pitfall	Solution
String concatenation in loops	Use `strings.Builder`
Unpreallocated slice	`make([]T, 0, cap)`
N+1 queries	Batch queries + preloading
Unbounded concurrency	Use semaphore or worker pool