Golang运行时值解析与验证的Zod风格插件：Zog

在JavaScript生态中，Zod是一个非常流行的运行时类型验证库。在Go语言中，我们可以构建类似的运行时值解析与验证工具。下面我将介绍如何实现一个类似Zod风格的Go插件"Zog"。

Zog核心设计

Zog的设计目标是提供一种声明式、链式调用的API来定义和验证数据结构，类似于Zod的风格：

package zog

type Schema[T any] interface {
    Parse(data interface{}) (T, error)
    // 其他验证方法...
}

基本类型验证

首先实现基础类型的验证器：

func String() *StringSchema {
    return &StringSchema{}
}

type StringSchema struct {
    checks []func(string) error
}

func (s *StringSchema) Parse(data interface{}) (string, error) {
    str, ok := data.(string)
    if !ok {
        return "", fmt.Errorf("expected string, got %T", data)
    }
    
    for _, check := range s.checks {
        if err := check(str); err != nil {
            return "", err
        }
    }
    
    return str, nil
}

func (s *StringSchema) Min(length int) *StringSchema {
    s.checks = append(s.checks, func(str string) error {
        if len(str) < length {
            return fmt.Errorf("string must be at least %d characters", length)
        }
        return nil
    })
    return s
}

func (s *StringSchema) Max(length int) *StringSchema {
    s.checks = append(s.checks, func(str string) error {
        if len(str) > length {
            return fmt.Errorf("string must be at most %d characters", length)
        }
        return nil
    })
    return s
}

对象结构验证

实现类似Zod的对象结构验证：

func Object[T any](shape map[string]Schema) *ObjectSchema[T] {
    return &ObjectSchema[T]{
        shape: shape,
    }
}

type ObjectSchema[T any] struct {
    shape map[string]Schema
}

func (s *ObjectSchema[T]) Parse(data interface{}) (T, error) {
    var result T
    m, ok := data.(map[string]interface{})
    if !ok {
        return result, fmt.Errorf("expected object, got %T", data)
    }
    
    // 使用反射构建结果
    v := reflect.ValueOf(&result).Elem()
    t := v.Type()
    
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        key := field.Tag.Get("json")
        if key == "" {
            key = field.Name
        }
        
        if schema, ok := s.shape[key]; ok {
            val, err := schema.Parse(m[key])
            if err != nil {
                return result, fmt.Errorf("field %s: %w", key, err)
            }
            
            fv := v.Field(i)
            if fv.CanSet() {
                fv.Set(reflect.ValueOf(val))
            }
        }
    }
    
    return result, nil
}

使用示例

下面是如何使用Zog进行验证的示例：

type User struct {
    Name     string `json:"name"`
    Age      int    `json:"age"`
    Email    string `json:"email"`
}

userSchema := zog.Object[User](map[string]zog.Schema{
    "name": zog.String().Min(3).Max(50),
    "age": zog.Number().Min(18).Max(120),
    "email": zog.String().Email(),
})

func HandleRequest(data []byte) error {
    var input map[string]interface{}
    if err := json.Unmarshal(data, &input); err != nil {
        return err
    }
    
    user, err := userSchema.Parse(input)
    if err != nil {
        return fmt.Errorf("validation error: %w", err)
    }
    
    // 使用验证后的user...
    return nil
}

高级特性实现

1. 自定义验证器:

func (s *StringSchema) Custom(fn func(string) error) *StringSchema {
    s.checks = append(s.checks, fn)
    return s
}

// 使用示例
zog.String().Custom(func(s string) error {
    if s != strings.ToLower(s) {
        return errors.New("must be lowercase")
    }
    return nil
})

1. 联合类型:

func Union(schemas ...Schema) *UnionSchema {
    return &UnionSchema{schemas: schemas}
}

type UnionSchema struct {
    schemas []Schema
}

func (s *UnionSchema) Parse(data interface{}) (interface{}, error) {
    var lastErr error
    
    for _, schema := range s.schemas {
        if val, err := schema.Parse(data); err == nil {
            return val, nil
        } else {
            lastErr = err
        }
    }
    
    return nil, fmt.Errorf("no matching schema found: %w", lastErr)
}

性能考虑

在Go中实现运行时验证需要注意性能：

1. 使用缓存反射类型信息
2. 避免不必要的内存分配
3. 提供编译时验证选项（如代码生成）

总结

通过构建Zog这样的库，我们可以在Go中获得类似Zod的开发体验：

• 声明式的模式定义
• 链式API调用
• 丰富的内置验证器
• 类型安全的解析结果
• 清晰的错误信息

虽然Go是静态类型语言，但这样的运行时验证在处理外部输入（如JSON、表单数据）时仍然非常有用，可以提供更好的错误处理和更健壮的系统边界。

完整的实现需要考虑更多细节，如嵌套对象、数组验证、可选字段等，但以上代码已经展示了核心概念。