golang

Go 1.18 any 类型：告别 interface{} 的冗长

Go 1.18 any 类型：告别 interface{} 的冗长。Go 1.18 引入了一个简单但意义重大的改进：any 类型。它是 interface{} 的内置别名，让代码更加简洁易读。虽然只是一个小的语法改进，但它体现了 Go 团队对开发者体验的持续关注。

Leeting Yan 9 分钟阅读 4021 字

Go 1.18 any 类型：告别 interface{} 的冗长

Go 1.18 引入了一个简单但意义重大的改进：any 类型。它是 interface{} 的内置别名，让代码更加简洁易读。虽然只是一个小的语法改进，但它体现了 Go 团队对开发者体验的持续关注。在这篇文章中，我们将深入探讨 any 的本质、使用场景、与泛型的关系、性能差异以及迁移指南。

从 interface{} 到 any

之前的写法

在 Go 1.18 之前，当需要接受或返回任意类型的值时，我们使用的都是 interface{}：

package main

import "fmt"

// 接受任意类型的参数
func Print(v interface{}) {
    fmt.Println(v)
}

// 存储任意类型
type Container struct {
    data interface{}
}

// 返回任意类型
func GetAny() interface{} {
    return 42
}

// Map 的 value 是任意类型
type AnyMap map[string]interface{}

func main() {
    Print("hello")
    Print(123)

    c := Container{data: "world"}
    fmt.Println(c.data)

    m := AnyMap{
        "name": "Alice",
        "age":  30,
    }
    fmt.Println(m)
}

interface{} 有两个问题：

  1. 冗长：到处写 interface{} 很占屏幕空间
  2. 不直观：新手看到 interface{} 不知道这是"任意类型"的意思

现在的写法

package main

import "fmt"

// 更简洁！
func Print(v any) {
    fmt.Println(v)
}

type Container struct {
    data any
}

func GetAny() any {
    return 42
}

type AnyMap map[string]any

func main() {
    Print("hello")
    Print(123)

    c := Container{data: "world"}
    fmt.Println(c.data)

    m := AnyMap{
        "name": "Alice",
        "age":  30,
    }
    fmt.Println(m)
}

代码行数没变，但可读性大大提高，any 一眼就能看出这是接受任意类型的函数。

any 的本质

any 并不是一个新的类型，它只是 interface{} 的预定义别名（builtin alias）：

// 在 builtin 包中定义
type any = interface{}

这意味着 any 和 interface{} 是完全等价的，没有性能差异：

package main

import "fmt"

func main() {
    var a any = 42
    var b interface{} = 42

    // 完全相同
    fmt.Printf("%T == %T: %v\n", a, b, a == b) // true

    // 可以互相赋值
    var c interface{} = a
    var d any = b

    fmt.Println(c, d) // 42 42

    // 类型断言也完全相同
    val1 := a.(int)
    val2 := b.(int)
    fmt.Println(val1, val2) // 42 42
}

换一个角度理解：编译器在词法分析阶段就把 any 替换成了 interface{}。所以使用 any 不会引入任何运行时开销，也不会改变接口的底层表示（两个指针：类型信息 + 数据地址）。

在泛型中使用 any

any 在泛型代码中特别有用，作为最宽松的类型约束：

package main

import "fmt"

// 作为类型约束：T 可以是任意类型
func First[T any](slice []T) (T, bool) {
    if len(slice) == 0 {
        var zero T
        return zero, false
    }
    return slice[0], true
}

// 在泛型结构体中：A 和 B 各自独立
type Pair[A, B any] struct {
    First  A
    Second B
}

// 在泛型接口中：Processor 可以处理任意类型
type Processor[T any] interface {
    Process(T) error
    Name() string
}

// 适用于 any 类型的工具函数
func MapAny(slice []any, f func(any) any) []any {
    result := make([]any, len(slice))
    for i, v := range slice {
        result[i] = f(v)
    }
    return result
}

func main() {
    // 使用 any 约束的泛型函数
    nums := []int{1, 2, 3}
    first, ok := First(nums)
    fmt.Println(first, ok) // 1 true

    // 泛型结构体
    p := Pair[string, int]{First: "age", Second: 30}
    fmt.Println(p) // {age 30}

    // any 类型的切片
    items := []any{1, "hello", 3.14, true}
    for _, item := range items {
        fmt.Printf("%v (%T)\n", item, item)
    }
}

在泛型参数列表中写 [T any] 比 [T interface{}] 清晰得多，这也是 any 存在的主要动机之一。关于 Go 泛型的更多内容，可以参考 Go 泛型详解 。

any 的常见使用场景详解

1. JSON 处理

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // 解析未知结构的 JSON
    jsonData := `{"name":"Alice","age":30,"hobbies":["reading","coding"]}`

    var data any
    json.Unmarshal([]byte(jsonData), &data)

    fmt.Printf("%+v\n", data)
    // map[age:30 hobbies:[reading coding] name:Alice]

    // 类型断言访问
    if m, ok := data.(map[string]any); ok {
        fmt.Println("Name:", m["name"])
        fmt.Println("Age:", m["age"])

        // 嵌套类型断言
        if hobbies, ok := m["hobbies"].([]any); ok {
            for _, h := range hobbies {
                fmt.Println("  -", h)
            }
        }
    }
}

⚠️ JSON 数字陷阱：JSON 中的所有数字在反序列化为 any 时都会被解析为 float64。如果需要整型，必须显式转换：int(m["age"].(float64))。

2. 通用容器

package main

import "fmt"

// 通用栈
type Stack struct {
    items []any
}

func (s *Stack) Push(item any) {
    s.items = append(s.items, item)
}

func (s *Stack) Pop() (any, bool) {
    if len(s.items) == 0 {
        return nil, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

func (s *Stack) Size() int {
    return len(s.items)
}

func main() {
    stack := &Stack{}

    stack.Push(42)
    stack.Push("hello")
    stack.Push(3.14)
    stack.Push([]int{1, 2, 3})

    for {
        item, ok := stack.Pop()
        if !ok {
            break
        }

        switch v := item.(type) {
        case int:
            fmt.Printf("Integer: %d\n", v)
        case string:
            fmt.Printf("String: %s\n", v)
        case float64:
            fmt.Printf("Float: %.2f\n", v)
        default:
            fmt.Printf("Other: %v\n", v)
        }
    }
}

3. 缓存系统

package main

import (
    "fmt"
    "sync"
    "time"
)

// 通用缓存
type Cache struct {
    mu    sync.RWMutex
    items map[string]cacheItem
}

type cacheItem struct {
    value     any
    expiresAt time.Time
}

func NewCache() *Cache {
    return &Cache{
        items: make(map[string]cacheItem),
    }
}

func (c *Cache) Set(key string, value any, ttl time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = cacheItem{
        value:     value,
        expiresAt: time.Now().Add(ttl),
    }
}

func (c *Cache) Get(key string) (any, bool) {
    c.mu.RLock()
    item, ok := c.items[key]
    c.mu.RUnlock()

    if !ok || time.Now().After(item.expiresAt) {
        return nil, false
    }
    return item.value, true
}

func (c *Cache) Delete(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.items, key)
}

func main() {
    cache := NewCache()

    cache.Set("user:1", map[string]string{"name": "Alice"}, 1*time.Minute)
    cache.Set("count", 42, 10*time.Second)

    if val, ok := cache.Get("user:1"); ok {
        if user, ok := val.(map[string]string); ok {
            fmt.Println("User name:", user["name"])
        }
    }
}

4. 事件总线

package main

import (
    "fmt"
    "sync"
)

type Event struct {
    Type    string
    Payload any
}

type EventBus struct {
    mu       sync.RWMutex
    handlers map[string][]func(any)
}

func NewEventBus() *EventBus {
    return &EventBus{
        handlers: make(map[string][]func(any)),
    }
}

func (eb *EventBus) Subscribe(eventType string, handler func(any)) {
    eb.mu.Lock()
    defer eb.mu.Unlock()
    eb.handlers[eventType] = append(eb.handlers[eventType], handler)
}

func (eb *EventBus) Publish(event Event) {
    eb.mu.RLock()
    handlers := eb.handlers[event.Type]
    eb.mu.RUnlock()

    for _, handler := range handlers {
        handler(event.Payload)
    }
}

func main() {
    bus := NewEventBus()

    bus.Subscribe("user.created", func(payload any) {
        if data, ok := payload.(map[string]any); ok {
            fmt.Printf("User created: %s\n", data["name"])
        }
    })

    bus.Subscribe("order.placed", func(payload any) {
        if data, ok := payload.(map[string]any); ok {
            fmt.Printf("Order placed: #%v ($%.2f)\n",
                data["id"], data["amount"])
        }
    })

    bus.Publish(Event{
        Type: "user.created",
        Payload: map[string]any{
            "name":  "Alice",
            "email": "alice@example.com",
        },
    })

    bus.Publish(Event{
        Type: "order.placed",
        Payload: map[string]any{
            "id":     12345,
            "amount": 99.99,
        },
    })
}

5. 通用 Map 工具函数

package main

import "fmt"

// Keys 返回 map 的所有 key
func Keys[M ~map[K]V, K comparable, V any](m M) []K {
    keys := make([]K, 0, len(m))
    for k := range m {
        keys = append(keys, k)

    }
    return keys
}

// Values 返回 map 的所有 value
func Values[M ~map[K]V, K comparable, V any](m M) []V {
    values := make([]V, 0, len(m))
    for _, v := range m {
        values = append(values, v)
    }
    return values
}

// Filter 过滤 map 中的元素
func Filter[M ~map[K]V, K comparable, V any](m M, f func(K, V) bool) M {
    result := make(M)
    for k, v := range m {
        if f(k, v) {
            result[k] = v
        }
    }
    return result
}

// Map 对 map 的每个 value 进行转换
func Map[M ~map[K]V, K comparable, V, U any](m M, f func(V) U) map[K]U {
    result := make(map[K]U, len(m))
    for k, v := range m {
        result[k] = f(v)
    }
    return result
}

// 使用示例：处理 map[string]any
func main() {
    data := map[string]any{
        "name":  "Alice",
        "age":   30,
        "email": "alice@example.com",
    }

    keys := Keys(data)
    fmt.Println("Keys:", keys)

    values := Values(data)
    fmt.Println("Values:", values)

    // 过滤出 string 类型的值
    strings := Filter(data, func(k string, v any) bool {
        _, ok := v.(string)
        return ok
    })
    fmt.Println("String values:", strings)

    // 将所有值转为字符串
    asStrings := Map(data, func(v any) string {
        return fmt.Sprintf("%v", v)
    })
    fmt.Println("As strings:", asStrings)
}

这些工具函数结合泛型和 any，为 map 操作提供了极大的便利。需要注意的是，在 Go 1.21+ 中，标准库引入了 golang.org/x/exp/maps 包，提供了类似功能，但自己动手实现能更好地理解类型系统的运作。

any vs 泛型：决策矩阵

很多初学者困惑于什么时候用 any，什么时候该用泛型。以下是一个清晰的决策指南：

使用 any 的场景

// ✅ 真正运行时类型不确定的场景
func ParseJSON(data []byte) (any, error) {
    var result any
    err := json.Unmarshal(data, &result)
    return result, err
}

// ✅ 日志/打印函数
func Log(level string, message string, fields ...any) {
    fmt.Printf("[%s] %s %v\n", level, message, fields)
}

// ✅ 通用容器（牺牲类型安全换取灵活性）
type Stack struct {
    items []any
}

使用泛型的场景

// ✅ 需要编译时类型安全
func Max[T ~int | ~float64](a, b T) T {
    if a > b {
        return a
    }
    return b
}

// ✅ 保持类型信息（不需要类型断言）
func Map[T, U any](slice []T, f func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = f(v)
    }
    return result
}

// ❌ 使用 any 会失去类型安全
func MapAny(slice []any, f func(any) any) []any {
    // 调用方传入和接收类型都不受约束
    // 错误只能在运行时才能发现
    return nil
}

any vs 泛型对比表

维度any泛型
类型安全运行时检查（可能 panic）编译时检查
内存开销有（接口包装）无（单态化）
代码啰嗦度需要类型断言不需要
适用场景动态类型、外部数据算法、数据结构
编译速度无影响可能增加编译时间
二进制体积较小可能膨胀（单态化）

性能分析

any 的开销

package main

import (
    "fmt"
    "testing"
)

func BenchmarkAny(b *testing.B) {
    items := make([]any, 1000)
    for i := 0; i < len(items); i++ {
        items[i] = i
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        var sum int
        for _, item := range items {
            sum += item.(int)
        }
        _ = sum
    }
}

func BenchmarkTyped(b *testing.B) {
    items := make([]int, 1000)
    for i := 0; i < len(items); i++ {
        items[i] = i
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        var sum int
        for _, item := range items {
            sum += item
        }
        _ = sum
    }
}

func main() {
    fmt.Println("Run: go test -bench=. -benchmem")
    // any 版本通常慢 2-5 倍，且产生更多堆分配
}

性能差异的原因：

  1. 装箱（boxing）：值类型存储为 any 时需要包装为接口（两个指针）
  2. 类型断言：运行时动态检查类型，有分支预判失败的可能
  3. 内存分配：小值（如 int）可能被分配到堆上
  4. Cache 不友好：接口数据的类型指针和数据指针大概率不在同一个缓存行

最佳实践

1. 避免过度使用 any

// ❌ 不好：失去了类型安全
type User struct {
    ID    any
    Name  any
    Email any
}

// ✅ 好：明确的类型
type User struct {
    ID    int64
    Name  string
    Email string
}

2. 使用类型断言时检查 ok

// ❌ 不好：可能 panic
func process(data any) {
    str := data.(string) // panic 如果 data 不是 string
}

// ✅ 好：安全断言
func process(data any) {
    str, ok := data.(string)
    if !ok {
        return
    }
    // 使用 str
}

3. 优先使用类型 switch

// ✅ 好：清晰、可扩展
func process(data any) {
    switch v := data.(type) {
    case string:
        fmt.Println("String:", v)
    case int:
        fmt.Println("Int:", v)
    case []byte:
        fmt.Println("Bytes:", len(v))
    case map[string]any:
        fmt.Println("Map keys:", len(v))
    default:
        fmt.Println("Unknown type:", v)
    }
}

4. 在 API 设计中谨慎使用 any

// ❌ 不好：API 不明确
func Process(data any) error

// ✅ 好：明确的接口
type Processable interface {
    Process() error
}
func Process(data Processable) error

// ✅ 好：使用泛型
func Process[T Processable](data T) error

5. 类型断言错误要包装

func GetString(data any, key string) (string, error) {
    val, ok := data.(string)
    if !ok {
        return "", fmt.Errorf("expected string, got %T", data)
    }
    return val, nil
}

迁移指南

从 interface{} 迁移到 any

# 使用 gofmt 自动转换（Go 1.18+）
gofmt -w -r 'interface{} -> any' .

# 或者手动替换（在 IDE 中使用全局替换）

版本兼容性注意事项

// ✅ 可以直接替换
var x interface{} = 42  →  var x any = 42

// ✅ 函数签名
func f(v interface{})   →  func f(v any)

// ✅ 类型定义
type T interface{}      →  type T any

// ✅ map、slice 类型
type M map[string]interface{}  →  type M map[string]any

// ⚠️ 但要注意：如果代码需要支持 Go 1.17 及以下，不要使用 any
// 因为旧版本不认识 any 关键字

常见问题 FAQ

Q1: any 是新的类型吗？
不是。any 是 interface{} 的内置别名，在编译时会被完全替换。它们生成的机器码完全相同。

Q2: 什么时候会引入 any 的新功能？
Go 目前没有给 any 添加额外功能的计划（比如 C# 的 dynamic）。Go 团队保持 any == interface{} 的等价性，确保不会因引入 any 而造成语言复杂度上升。

Q3: 我需要把所有 interface{} 换成 any 吗？
不需要。any 完全等价于 interface{}，旧代码不需要迁移。但对于新代码，推荐使用 any 以获得更好的可读性。可以用 gofmt -r 做一键批量迁移。

Q4: type switch 中用 any 和 interface{} 有区别吗？
没有，switch v := data.(type) 的行为完全一致。type switch 中也不会因为用了 any 就多出什么新能力。

Q5: 泛型函数可以同时约束 any 和其他类型吗？
不可以。any 已经是最宽泛的约束，任何在它之上的约束都是多余的。[T any | ~string] 这样的写法会编译失败。

Q6: 使用 any 会让代码变慢吗？
any 本身的类型别名没有开销，但它指向的接口赋值和类型断言有运行时开销。如果你把大量数值类型存入 []any，性能会比 []int 差 2-5 倍。

Q7: JSON 中数字反序列化到 any 为什么是 float64？
这是 JSON 的标准问题：JSON 没有整数类型。如果你需要确切的类型，应该反序列化到具体的 struct，而不是 any。

Q8: any 的 nil 和 nil 有什么区别？
var x any = nil 创建了一个 nil 接口值（类型和数据指针都是 nil），这和未赋值的 any 变量是同一种状态。但有些初学者容易混淆 nil 接口值和具体类型的 nil 指针（如 var s *string = nil; var x any = s 中 x 不为 nil）。

Q9: 如何在 Go 1.17 兼容的库中使用 any？
无法在 Go 1.17 中使用 any 关键字。如果你的库需要兼容旧版本 Go，必须继续使用 interface{}。建议在 go.mod 中标注 go 1.18 后再开始迁移。

延伸阅读

如果你想更深入理解 Go 的类型系统、性能优化和设计哲学，推荐继续阅读：

总结

any 类型的引入虽然简单，但意义重大：

  1. 更简洁：any 比 interface{} 更短、更直观
  2. 更一致：与泛型的 any 约束统一了表达形式
  3. 更易读：代码意图更清晰，降低了新手的理解门槛

使用原则：

  • 真正需要动态类型时使用 any
  • 需要类型安全且类型已知时使用泛型
  • 类型明确时不要用 any
  • 注意接口装箱/拆箱的性能开销
  • 类型断言永远要检查 ok 值
  • 优先使用类型 switch 处理多类型分支

any 不是万能的，它只是工具箱中的一个工具。在合适的场景使用合适的工具，才能写出优秀的 Go 代码。Go 1.18 引入的这些改进（any、泛型、workspace、fuzzing），让这门语言在保持简洁的同时更加完善和强大。

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「golang」更多文章

  1. 《Go 语言编程实战》目录
  2. 《Go 语言编程实战》18.3 上线、观测与迭代
  3. 《Go 语言编程实战》18.2 故障演练