Golang包的正确编写顺序是什么

Golang包的正确编写顺序是什么 当我询问顺序时，我指的是这样的结构：

// 解释包如何工作的注释

package name

import (
  [...]
)

const  (
  [...]
)

var  (
  [...]
)

type SomeNameOfStruct struct {
  [...]
}

// 可导出的函数
func Action() {
   [...]
}

// 每个结构体的方法
func (s *SomeNameOfStruct) Get(name string)  error {
   [...]
}

// 不可导出的函数
func miniActions() {
 [...]
}

// 还缺少什么？

那么，这个顺序是否与我可能遇到的大多数包所遵循的一致风格相符呢？


更多关于Golang包的正确编写顺序是什么的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

我认为最常见的约定是将 package 放在首位，原因显而易见，其次是 import 语句。

之后的内容通常按功能分组，而不是强制遵循一个随意选择、毫无依据的顺序。

更多关于Golang包的正确编写顺序是什么的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


标准库是唯一的真理之源：

  1. 包名和导入
  2. 类型
  3. 全局常量和变量（以及可能存在的 init() 函数）
  4. 类型方法

工具函数（或私有方法）应紧随其他工具函数或调用它们的类型方法之后。 仅在特定函数或方法中使用的常量，应在该函数/方法之前定义。 Go语言的一个优点是声明的自由性，例如接口可以在你需要它们的时候再声明。

是的，这个顺序与Go社区广泛遵循的约定完全一致。以下是标准顺序的详细说明和示例：

// 包注释（可选但推荐）
// 包 math 提供基本的数学函数。
package math

// 导入分组：标准库、第三方库、本地包
import (
    "fmt"
    "strings"
    
    "github.com/some/thirdparty"
    
    "myproject/internal/utils"
)

// 常量（按相关性和可见性分组）
const (
    // 可导出的常量
    MaxValue = 100
    MinValue = 0
    
    // 内部常量
    defaultSize = 10
)

// 变量（按相关性和可见性分组）
var (
    // 可导出的变量
    GlobalConfig *Config
    
    // 内部变量
    cache map[string]interface{}
)

// 类型定义（通常按依赖关系排序）
type (
    // 接口优先（如果存在）
    Reader interface {
        Read(p []byte) (n int, err error)
    }
    
    // 结构体
    Config struct {
        Host string
        Port int
    }
    
    // 其他类型
    Status int
)

// 可导出的函数
func NewConfig(host string, port int) *Config {
    return &Config{Host: host, Port: port}
}

// 结构体方法（按接收者类型分组）
func (c *Config) Address() string {
    return fmt.Sprintf("%s:%d", c.Host, c.Port)
}

// 不可导出的函数
func validateConfig(c *Config) error {
    if c.Port <= 0 {
        return fmt.Errorf("invalid port: %d", c.Port)
    }
    return nil
}

你可能会看到的一些变体：

  1. 有时将init()函数放在变量声明之后：
var cache map[string]interface{}

func init() {
    cache = make(map[string]interface{})
}
  1. 对于测试文件，通常将测试辅助函数放在文件末尾：
func TestSomething(t *testing.T) {
    // 测试代码
}

func testHelper(t *testing.T) {
    // 测试辅助函数
}

这个顺序的主要原则是：

  • 从最通用到最具体
  • 按可见性分组（导出在前，非导出在后）
  • 按类型分组（常量、变量、类型、函数）
  • 保持相关代码在一起

你的示例完全符合这些约定。

回到顶部