Go语言中定义类型安全且私有的枚举式常量：iota与自定义类型实践

package mymodule // 假设这是你的模块

// 定义一个私有的底层整数类型
type opCode int

// 声明一组类型为 opCode 的常量
const (
    // iota 从 0 开始。通过 iota+1，第一个常量的值将是 1。
    lookupOp opCode = iota + 1 // lookupOp = 1
    forgetOp                  // forgetOp = 2
    getattrOp                 // getattrOp = 3
    setattrOp                 // setattrOp = 4
    readlinkOp                // readlinkOp = 5
    symlinkOp                 // symlinkOp = 6
    _                         // 使用空白标识符 '_' 跳过一个值，即 7
    mknodOp                   // mknodOp = 8
    // ... 更多常量可以依此类推
)

func main() {
    // 示例用法
    var code opCode = lookupOp
    println(code) // 输出 1

    // 类型安全：尝试将 opCode 类型赋值给 int 类型会引发编译错误
    // var x int = lookupOp // 编译错误: cannot use lookupOp (type opCode) as type int in assignment

    // 只能与同类型常量或直接的整型字面量比较
    if code == lookupOp {
        println("It's lookupOp")
    }
    if code == 1 { // 可以与整型字面量比较，但失去了部分类型安全优势
        println("Code is 1")
    }
}

package mymodule

// 私有底层类型
type opCode int

// 内部常量定义（与之前相同）
const (
    lookupOp opCode = iota + 1
    forgetOp
    // ... 其他常量
    mknodOp
)

// 公开的 OpCode 类型，封装了私有的 opCode
type OpCode struct {
    code opCode
}

// 示例：提供一个公共方法来获取 OpCode 实例
func GetLookupOp() OpCode {
    return OpCode{code: lookupOp}
}

// 示例：提供一个比较方法
func (o OpCode) Equal(other OpCode) bool {
    return o.code == other.code
}

// 示例：提供一个字符串表示方法
func (o OpCode) String() string {
    switch o.code {
    case lookupOp:
        return "LOOKUP_OP"
    case forgetOp:
        return "FORGET_OP"
    case mknodOp:
        return "MKNOD_OP"
    default:
        return "UNKNOWN_OP"
    }
}