TypeScript字符串联合类型在Go语言中的等价实现方式

Go语言没有TypeScript那种原生的字符串字面量联合类型，但可以通过自定义类型+约束逻辑来实现相同的取值限制效果，下面是几种常用的落地方案：

方案一：自定义类型+常量枚举（编译期校验） #

这种方式利用Go的类型系统和常量定义，在编译阶段就能拦截非法取值，适合固定场景下的硬编码赋值：

package main

import "fmt"

// 定义自定义类型S，底层为string类型
type S string

// 声明仅允许的常量取值
const (
    One   S = "one"
    Two   S = "two"
    Three S = "three"
)

func main() {
    // 合法赋值
    var validS S = One
    fmt.Println(validS) // 输出: one

    // 以下代码会直接编译报错，因为"four"不属于S类型的合法常量
    // var invalidS S = "four"
}

优势：编译阶段就能发现非法值，避免运行时错误；缺点：无法直接处理动态输入（如JSON解析、用户输入的字符串）。

方案二：自定义类型+验证函数（运行时校验） #

如果需要处理动态来源的字符串（比如从HTTP请求、配置文件读取），可以通过构造函数和验证方法确保只有合法值能被实例化：

package main

import (
    "errors"
    "fmt"
)

type S string

// 维护允许的取值集合
var allowedS = map[S]bool{
    "one":   true,
    "two":   true,
    "three": true,
}

// Validate 校验当前S值是否合法
func (s S) Validate() error {
    if !allowedS[s] {
        return errors.New("invalid value for type S")
    }
    return nil
}

// NewS 安全创建S类型实例的构造函数
func NewS(str string) (S, error) {
    s := S(str)
    if err := s.Validate(); err != nil {
        return "", err
    }
    return s, nil
}

func main() {
    // 合法创建实例
    s1, err := NewS("two")
    if err != nil {
        panic(err)
    }
    fmt.Println(s1) // 输出: two

    // 非法值会返回错误
    s2, err := NewS("four")
    if err != nil {
        fmt.Println(err) // 输出: invalid value for type S
    }
}

优势：支持动态输入校验，确保实例化的S类型值始终合法；缺点：校验逻辑在运行时执行，需要额外的错误处理。

方案三：枚举映射（整数枚举转字符串） #

如果希望用更高效的整数枚举管理取值，同时保留字符串语义，可以通过映射关系实现：

package main

import "fmt"

type S int

// 定义整数枚举
const (
    SOne S = iota
    STwo
    SThree
)

// 枚举值到字符串的映射
var sToString = map[S]string{
    SOne:   "one",
    STwo:   "two",
    SThree: "three",
}

// String 实现Stringer接口，方便打印和转换
func (s S) String() string {
    return sToString[s]
}

// ParseS 从字符串解析为S枚举
func ParseS(str string) (S, bool) {
    for k, v := range sToString {
        if v == str {
            return k, true
        }
    }
    return 0, false
}

func main() {
    s := SThree
    fmt.Println(s) // 输出: three

    parsed, ok := ParseS("one")
    if ok {
        fmt.Println(parsed) // 输出: one
    }
}

优势：内存占用小、取值比较效率高；缺点：需要维护枚举与字符串的映射关系，适合取值固定且不需要直接操作原始字符串的场景。

内容的提问来源于stack exchange，提问作者Abhijeet Khangarot