Linter: 规范从软约束变成硬门禁

func FetchRate(ctx context.Context, client *http.Client, url string) (*RateResponse, error) {
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	// 致命缺陷:未调用 resp.Body.Close()
	// 底层 TCP 连接无法放回空闲连接池(Idle Pool),高并发下迅速耗尽操作系统 socket 文件描述符
	var rate RateResponse
	if err := json.NewDecoder(resp.Body).Decode(&rate); err != nil {
		return nil, err
	}
	return &rate, nil
}

func FetchRate(ctx context.Context, client *http.Client, url string) (*RateResponse, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, fmt.Errorf("build request failed: %w", err)
	}

	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("execute request failed: %w", err)
	}
	// 确保在确认 resp 存在后立即注册延迟关闭,保障底层连接安全放回 Client 的 Transport 连接池
	defer resp.Body.Close()

	var rate RateResponse
	if err := json.NewDecoder(resp.Body).Decode(&rate); err != nil {
		return nil, fmt.Errorf("decode rate payload failed: %w", err)
	}
	return &rate, nil
}

func ExtractClaims(rawToken any, w http.ResponseWriter) error {
	// 缺陷 1 (裸断言):一旦入参为 nil 或数据结构发生漂移,直接在线上触发 Panic 导致协程崩溃
	claims := rawToken.(map[string]any)
	tenantID := claims["tenant_id"].(string)

	respBytes := []byte("welcome:" + tenantID)
	// 缺陷 2 (下划线忽略错误):在 I/O 写入失败(如客户端主动断开连接)时静默吞噬异常,伪造成功假象
	_ = w.Write(respBytes)
	return nil
}

func ExtractClaims(rawToken any, w http.ResponseWriter) error {
	claims, ok := rawToken.(map[string]any)
	if !ok {
		return errors.New("invalid token payload: expected map[string]any")
	}

	tenantID, ok := claims["tenant_id"].(string)
	if !ok || tenantID == "" {
		return errors.New("invalid or missing tenant_id claim")
	}

	respBytes := []byte("welcome:" + tenantID)
	if _, err := w.Write(respBytes); err != nil {
		return fmt.Errorf("write response failed: %w", err)
	}
	return nil
}

func QueryOrder(ctx context.Context, db *sql.DB, id int64) (*Order, error) {
	var ord Order
	err := db.QueryRowContext(ctx, "SELECT id, sn FROM orders WHERE id = ?", id).Scan(&ord.ID, &ord.SN)
	if err != nil {
		// 缺陷 1:使用裸 == 比较哨兵错误。若驱动返回的错误经过中间件包装,等号比较直接失效返回 false
		if err == sql.ErrNoRows {
			return nil, ErrOrderNotFound
		}
		// 缺陷 2:使用 %v 格式化错误。包装链路被完全切断,外部调用方无法使用 errors.Is 展开根因
		return nil, fmt.Errorf("query order %d failed: %v", id, err)
	}
	return &ord, nil
}

func QueryOrder(ctx context.Context, db *sql.DB, id int64) (*Order, error) {
	var ord Order
	err := db.QueryRowContext(ctx, "SELECT id, sn FROM orders WHERE id = ?", id).Scan(&ord.ID, &ord.SN)
	if err != nil {
		// 使用 errors.Is 递归解包错误树,确保精准捕获根因
		if errors.Is(err, sql.ErrNoRows) {
			return nil, ErrOrderNotFound
		}
		// 使用 %w 保留完备的错误溯源证据链
		return nil, fmt.Errorf("query order %d failed: %w", id, err)
	}
	return &ord, nil
}

func ForwardRequest(traceID, token string) *http.Request {
	req, _ := http.NewRequest(http.MethodPost, "https://api.internal/v1/sync", nil)
	// 致命缺陷:直接通过 map 字面量赋非标准大小写的 Header
	// Envoy / Nginx 等反向代理在 HTTP/1.1 与 HTTP/2 协议转换时可能按 Canonical 查找而导致追踪头丢失
	req.Header = http.Header{
		"x-request-id":   []string{traceID},
		"content-type":   []string{"application/json"},
		"authorization":  []string{"Bearer " + token},
	}
	return req
}

func ForwardRequest(traceID, token string) *http.Request {
	req, _ := http.NewRequest(http.MethodPost, "https://api.internal/v1/sync", nil)
	// 严格遵循 MIME 规范定义的标准首字母大写格式
	req.Header = http.Header{
		"X-Request-Id":  []string{traceID},
		"Content-Type":  []string{"application/json"},
		"Authorization": []string{"Bearer " + token},
	}
	return req
}

// 缺陷 1:手写 8 行循环仅为比对切片成员是否存在
func IsPermittedRole(roles []string, currentRole string) bool {
	for _, r := range roles {
		if r == currentRole {
			return true
		}
	}
	return false
}

// 缺陷 2:手写三元模拟分支计算极值
func ClampTimeout(configured int, maxLimit int) int {
	if configured > maxLimit {
		return maxLimit
	}
	return configured
}

import "slices"

// 现代化内建原语:一行代码直接表达领域意图
func IsPermittedRole(roles []string, currentRole string) bool {
	return slices.Contains(roles, currentRole)
}

// 采用 Go 1.21 内建 min 原语,直观且享受编译器内联优化
func ClampTimeout(configured int, maxLimit int) int {
	return min(configured, maxLimit)
}

func Dispatch(w http.ResponseWriter, r *http.Request) {
	// 缺陷 1:手写方法字符串,可能因拼写手误(如多一个空格)导致路由拦截失效
	if r.Method != "POST" {
		// 缺陷 2:裸硬编码数字状态码,降低代码可读性
		w.WriteHeader(405)
		w.Write([]byte("method not allowed"))
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	w.Write([]byte(`{"status":"ok"}`))
}

func Dispatch(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.WriteHeader(http.StatusMethodNotAllowed)
		w.Write([]byte("method not allowed"))
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write([]byte(`{"status":"ok"}`))
}

// 性能灾难:微服务高频缓存调用路径中,无脑使用 fmt.Sprintf
func BuildMetricKeys(tenantID int64, metric string, isAlert bool) (string, string) {
	// 缺陷 1:fmt.Sprintf 内部调用 reflect 遍历格式化占位符,且入参装箱逃逸到堆
	key := fmt.Sprintf("tenant:%d:%s", tenantID, metric)

	// 缺陷 2:简单布尔转字符串调用 Sprintf 产生多次堆分配
	flag := fmt.Sprintf("%t", isAlert)

	return key, flag
}

import "strconv"

func BuildMetricKeys(tenantID int64, metric string, isAlert bool) (string, string) {
	// 使用原生字符串连接与单周期 strconv 转换,彻底消除堆逃逸与反射开销
	key := "tenant:" + strconv.FormatInt(tenantID, 10) + ":" + metric
	flag := strconv.FormatBool(isAlert)

	return key, flag
}

type PacketHeader struct {
	Signature [256]byte
	Metadata  [512]byte
	SeqNumber int64
}

// 缺陷 1 (rangeValCopy):每次循环都将 776 字节的结构体完整拷贝到局部变量 p 中
func CalculateChecksum(packets []PacketHeader) int64 {
	var sum int64
	for _, p := range packets {
		sum += p.SeqNumber
	}
	return sum
}

// 缺陷 2 (singleCaseSwitch):只有一个分支的 switch 语句,增加控制流层级
func HandleEvent(ev string) {
	switch ev {
	case "rebalance":
		doRebalance()
	}
}

type PacketHeader struct {
	Signature [256]byte
	Metadata  [512]byte
	SeqNumber int64
}

func CalculateChecksum(packets []PacketHeader) int64 {
	var sum int64
	// 仅迭代切片索引,通过下标直接访问数组槽位,彻底消除内存拷贝开销
	for i := range packets {
		sum += packets[i].SeqNumber
	}
	return sum
}

func HandleEvent(ev string) {
	// 提炼为平坦直观的单层 if 判定
	if ev == "rebalance" {
		doRebalance()
	}
}

// 缺陷:签名中保留了 enableAuditing 形参,但函数内部因重构删除了审计逻辑
// 外部调用方传递 true 时,以为已经开启了审计,产生虚假的安全承诺!
func FreezeAccount(ctx context.Context, accountID int64, enableAuditing bool) error {
	// 实际只调用了底层冻结接口,根本未感知 enableAuditing
	return repo.UpdateStatus(ctx, accountID, "FROZEN")
}

// 彻底清理无用参数,使签名与行为达成真实一致的契约
func FreezeAccount(ctx context.Context, accountID int64) error {
	return repo.UpdateStatus(ctx, accountID, "FROZEN")
}

// 若属于满足外部 interface 约束的实现,则显式使用下划线标识废弃
func (a *AccountHandler) OnEvent(ctx context.Context, _ int64) error {
	return nil
}