Golang中如何为API响应定义通用的成功/错误结果结构

在Go中实现类似TypeScript的联合类型，可以使用接口和自定义类型。以下是两种常见方案：

方案1：使用接口和自定义错误类型

package main

import (
	"encoding/json"
	"fmt"
)

type Result[T any] interface{}

type Success[T any] struct {
	IsSuccessful bool `json:"isSuccessful"`
	Value        T    `json:"value"`
}

type Failure struct {
	IsSuccessful bool   `json:"isSuccessful"`
	Code         string `json:"code"`
	Message      string `json:"message"`
}

func NewSuccess[T any](value T) Success[T] {
	return Success[T]{
		IsSuccessful: true,
		Value:        value,
	}
}

func NewFailure(code, message string) Failure {
	return Failure{
		IsSuccessful: false,
		Code:         code,
		Message:      message,
	}
}

// 使用示例
func handleResult[T any](result Result[T]) {
	switch r := result.(type) {
	case Success[T]:
		fmt.Printf("Success: %v\n", r.Value)
	case Failure:
		fmt.Printf("Error: %s - %s\n", r.Code, r.Message)
	}
}

func main() {
	// 成功响应
	successResult := NewSuccess(map[string]string{"name": "John"})
	successJSON, _ := json.Marshal(successResult)
	fmt.Println(string(successJSON))
	// 输出: {"isSuccessful":true,"value":{"name":"John"}}

	// 错误响应
	errorResult := NewFailure("NOT_FOUND", "Resource not found")
	errorJSON, _ := json.Marshal(errorResult)
	fmt.Println(string(errorJSON))
	// 输出: {"isSuccessful":false,"code":"NOT_FOUND","message":"Resource not found"}

	// 类型判断
	handleResult(successResult)
	handleResult(errorResult)
}

方案2：使用带标签的联合体（更接近你的需求）

package main

import (
	"encoding/json"
	"fmt"
)

type Result[T any] struct {
	IsSuccessful bool   `json:"isSuccessful"`
	Value        T      `json:"value,omitempty"`
	Code         string `json:"code,omitempty"`
	Message      string `json:"message,omitempty"`
}

func NewSuccessResult[T any](value T) Result[T] {
	return Result[T]{
		IsSuccessful: true,
		Value:        value,
	}
}

func NewErrorResult(code, message string) Result[any] {
	return Result[any]{
		IsSuccessful: false,
		Code:         code,
		Message:      message,
	}
}

// 辅助函数检查结果类型
func (r Result[T]) IsSuccess() bool {
	return r.IsSuccessful
}

func (r Result[T]) GetValue() (T, bool) {
	return r.Value, r.IsSuccessful
}

func (r Result[T]) GetError() (string, string, bool) {
	return r.Code, r.Message, !r.IsSuccessful
}

// 使用示例
type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

func main() {
	// 成功响应
	user := User{ID: 1, Name: "Alice"}
	success := NewSuccessResult(user)
	successJSON, _ := json.Marshal(success)
	fmt.Println(string(successJSON))
	// 输出: {"isSuccessful":true,"value":{"id":1,"name":"Alice"}}

	// 错误响应
	err := NewErrorResult("VALIDATION_ERROR", "Invalid input")
	errJSON, _ := json.Marshal(err)
	fmt.Println(string(errJSON))
	// 输出: {"isSuccessful":false,"code":"VALIDATION_ERROR","message":"Invalid input"}

	// 使用辅助函数
	if success.IsSuccess() {
		value, _ := success.GetValue()
		fmt.Printf("User: %+v\n", value)
	}

	if !err.IsSuccess() {
		code, msg, _ := err.GetError()
		fmt.Printf("Error %s: %s\n", code, msg)
	}
}

方案3：使用指针和omitempty（更简洁的JSON输出）

package main

import (
	"encoding/json"
	"fmt"
)

type Result[T any] struct {
	IsSuccessful bool    `json:"isSuccessful"`
	Value        *T      `json:"value,omitempty"`
	Error        *Error  `json:"error,omitempty"`
}

type Error struct {
	Code    string `json:"code"`
	Message string `json:"message"`
}

func NewSuccess[T any](value T) Result[T] {
	return Result[T]{
		IsSuccessful: true,
		Value:        &value,
	}
}

func NewError(code, message string) Result[any] {
	return Result[any]{
		IsSuccessful: false,
		Error: &Error{
			Code:    code,
			Message: message,
		},
	}
}

func main() {
	// 成功响应
	success := NewSuccess("operation completed")
	successJSON, _ := json.Marshal(success)
	fmt.Println(string(successJSON))
	// 输出: {"isSuccessful":true,"value":"operation completed"}

	// 错误响应
	err := NewError("INTERNAL_ERROR", "Something went wrong")
	errJSON, _ := json.Marshal(err)
	fmt.Println(string(errJSON))
	// 输出: {"isSuccessful":false,"error":{"code":"INTERNAL_ERROR","message":"Something went wrong"}}
}

第一种方案最接近TypeScript的联合类型语义，第二种方案更实用且易于序列化，第三种方案提供最干净的JSON输出。根据你的具体需求选择合适方案。