创建常量类型并限制类型的值

Question

我有一个关于常量类型的问题，这些常量被限制在特定的值，以及在GO中如何实现这些。假设我创建了一个类型unary，它有两个常量值正(1)和负(-1)，我希望限制该类型(unary)的用户创建unary类型的其他值。是否通过创建包并使值为正和为负可见，并使类型为一元仅限于包含包来实现这一点？例如，请参见下面的代码

package unary

type unary int////not visible outside of the package unary

const (
    Positive unary = 1//visible outside of the package unary
    Negative unary = -1//visible outside of the package unary
)

func (u unary) String() string {//visible outside of the package unary
    if u == Positive {
        return "+"
    }
    return "-"
}

func (u unary) CalExpr() int {//visible outside of the package unary
    if u == Positive {
        return 1
    }
    return -1
}

这是将类型限制为某些常量值的正确方法吗？

Answer 1

您提出的解决方案并不是以您希望的方式安全的。可以使用非类型化整数常量创建一元的新值，其int值与1或-1不同。请参见此示例：

p := unary.Positive
fmt.Printf("%v %d\n", p, p)

p = 3
fmt.Printf("%v %d\n", p, p)

产出将是：

+ 1
- 3

我们可以更改p的值来存储int值3，该值显然不等于正或负。这是可能的，因为spec：可分配性：

在以下任何情况下，值X可赋值给T类型的变量（“X可赋值给T”）：

• ...
• x是一个非类型化常量，可由t类型的值表示。

3是一个非类型化常量，它可以由unary类型的值表示，该值具有int的基础类型。

由于上面提到的原因，在Go中，您不能使用“局外人”包不能为其创建新值的“安全”常量。因为如果您想在包中声明常量，您只能使用具有“非类型化”版本的表达式--其他包在赋值中也可能使用这些表达式（就像我们的示例中一样）。

如果要实现“安全”部分，可以使用未导出的struct，但不能在常量声明中使用它们。

示例：

type unary struct {
    val int
}

var (
    Positive = unary{1}
    Negative = unary{-1}
)

func (u unary) String() string {
    if u == Positive {
        return "+"
    }
    return "-"
}

func (u unary) CalExpr() int {
    return u.val
}

试图更改其值：

p := unary.Positive

p.val = 3 // Error: p.val undefined (cannot refer to unexported field or method val)

p = unary.unary{3} // Error: cannot refer to unexported name unary.unary
// Also error: implicit assignment of unexported field 'val' in unary.unary literal

请注意，由于我们现在使用的是struct，我们可以通过将值的struct表示形式添加到struct，进一步简化代码：

type unary struct {
    val int
    str string
}

var (
    Positive = unary{1, "+"}
    Negative = unary{-1, "-"}
)

func (u unary) String() string { return u.str }

func (u unary) CalExpr() int { return u.val }

unary.Positive = unary.Negative

var (
    positive = unary{1}
    negative = unary{-1}
)

func Positive() unary { return positive }

func Negative() unary { return negative }

然后获取/使用这些值：

p := unary.Positive()

如果您打算为“常数”使用接口类型，则必须小心。在Kaveh Shahbazian的回答中可以看到一个例子。一个未导出的方法用于阻止其他人实现接口，给你一种其他人真的不能实现的错觉：

type Unary interface {
    fmt.Stringer
    CalExpr() int
    disabler() // implementing this interface outside this package is disabled
}

var (
    Positive Unary = unary(1)  // visible outside of the package unary
    Negative Unary = unary(-1) // visible outside of the package unary
)

type unary int // not visible outside of the package unary

func (u unary) disabler() {}

func (u unary) String() string { /* ... */ }

func (u unary) CalExpr() int { /* ... */ }

然而，情况并非如此。用一个肮脏的把戏，这是可以规避的。可以嵌入导出的一元类型，并且可以使用现有的值来实现接口（以及未导出的方法），我们可以添加导出方法的自己的实现，执行/返回我们想要的任何操作。

下面是它的样子：

type MyUn struct {
    unary.Unary
}

func (m MyUn) String() string { return "/" }

func (m MyUn) CalExpr() int { return 3 }

测试它：

p := unary.Positive
fmt.Printf("%v %d\n", p, p)

p = MyUn{p}
fmt.Printf("%v %d\n", p, p.CalExpr())

产出：

+ 1
/ 3

正如Volker在他的评论中提到的，在您的特殊情况下，您可以使用

type unary bool

const (
    Positive unary = true
    Negative unary = false
)

作为类型，bool有两个可能的值:true和false，我们都使用了。因此，没有其他值可以被“利用”来创建我们常量类型的其他值。