golang 1.27.0 更新全解：泛型方法、JSON v2、UUID、后量子签名、SIMD 一次看懂

网易专栏3天前发布 nxnqh

10 0 0

发布时间：2026-08-22 01:11:08

#开发技术 | #Go 1.27

来源：网易专栏作者：moonfdd
🔗 查看原文

🤖 AI总结

主题

Go 1.27 版本更新全面解析，涵盖语言特性、标准库、性能优化等。

摘要

Go 1.27 带来泛型方法、新标准库与性能优化，全面提升开发体验和运行效率。

关键信息

1 泛型方法、结构体提升字段、泛型推断等语言能力增强。
2 新增 UUID、后量子签名、JSON v2、SIMD 等标准库功能。
3 内存分配优化、Goroutine 标签和泄漏检测等运行时改进。

golang 1.27.0 更新全解：泛型方法、JSON v2、UUID、后量子签名、SIMD 一次看懂

Go 1.27 已经到来。相比过去几个版本主要围绕工具链、运行时和标准库持续打磨，Go 1.27 带来了不少开发者“等了很久”的能力：泛型方法终于落地、结构体字面量支持提升字段选择器、泛型函数推断范围扩大、标准库新增 UUID、后量子签名、JSON v2 正式可用，以及实验性的可移植 SIMD。

这一版的变化并不只是“多几个 API”。有些能力会直接改变日常代码的写法，有些则会让现有程序在无需修改代码的情况下获得性能收益和更好的排障体验。

本文基于官方发布说明与 Go 源码内容整理，重点用可运行示例讲清楚 Go 1.27 的核心更新、使用方式与注意事项。为了让示例更聚焦，部分代码省略了完整错误处理；生产环境中仍应认真处理每一个错误。

一、泛型方法终于来了：类型的方法可以拥有自己的类型参数

这是 Go 1.27 最受关注的变化之一。

在 Go 1.27 之前，泛型只能用于类型定义和顶层函数。方法可以使用接收者类型已有的类型参数，但方法本身不能额外声明新的类型参数。

这意味着，如果一个泛型容器希望提供能改变元素类型的操作，例如 Map，那么过去通常只能把它写成包级函数，而不是类型的方法。

Go 1.27 开始，方法可以声明独立于接收者的类型参数。

package main

 import (
    "fmt"
)

 type Box[T any] struct {
    v T
}

 // 方法自己声明了类型参数 U。
func (b Box[T]) Map[U any](f func(T) U) Box[U] {
    return Box[U]{v: f(b.v)}
}

 func main() {
    b := Box[int]{v: 21}

     doubled := b.Map(func(n int) int {
        return n * 2
    })

     label := doubled.Map(func(n int) string {
        return fmt.Sprintf("value=%d", n)
    })

     fmt.Println(label.v)
}

输出结果：

value=42

这里发生了两次类型转换：

• 第一次：Box[int]经过Map仍然得到Box[int]

• 第二次：Box[int]经过Map转换为Box[string]

这种写法让泛型容器、数据处理链、转换器等抽象更自然。过去必须写成类似MapBox(b, f)的包级函数，现在可以直接通过b.Map(f)调用，API 的可读性和组织方式都有明显提升。

不过，这项能力有一个重要限制：接口仍然不能声明带类型参数的方法，泛型方法也不能用于满足接口。

下面的代码仍然无法编译：

type Mapper interface {
    Map[U any](f func(int) U) any
}

编译器会报错：

interface method must have no type parameters

因此，Go 1.27 支持“类型拥有泛型方法”，但暂不支持“接口拥有泛型方法”。在设计抽象时，仍然需要通过顶层泛型函数、普通接口方法或具体类型来组合能力。

二、结构体字面量支持提升字段选择器

Go 1.27 对结构体复合字面量进行了一个看似很小、实际非常实用的改进。

以前，在结构体字面量中指定字段时，只能直接写该结构体最顶层声明的字段名。如果字段来自嵌入结构体，即提升字段，就必须显式初始化嵌入字段。

例如：

type Base struct {
    ID int
}


 type User struct {
    Base
    Name string
}

在 Go 1.27 之前，需要这样初始化：

u := User{
    Base: Base{ID: 7},
    Name: "Mittens",
}

Go 1.27 开始，可以直接使用提升字段作为字面量的键：

package main

 import (
    "fmt"
)

 type Base struct {
    ID int
}

 type User struct {
    Base
    Name string
}

 func main() {
    u := User{
        ID:   7,
        Name: "Mittens",
    }

     fmt.Println(u.ID, u.Name)
}

输出：

7 Mittens

这项变化减少了嵌入结构体初始化时的层级嵌套。尤其是在模型对象、配置对象、领域实体中广泛使用嵌入结构体时，代码会更加紧凑。

例如常见的审计字段：

type Audit struct {
    CreatedAt int64
    UpdatedAt int64
}


 type Article struct {
    Audit
    Title string
}

现在可以直接写：

a := Article{
    CreatedAt: 100,
    UpdatedAt: 200,
    Title:     "Go 1.27",
}

不再必须写成：

a := Article{
    Audit: Audit{
        CreatedAt: 100,
        UpdatedAt: 200,
    },
    Title: "Go 1.27",
}

三、泛型函数类型推断更强：切片、转换和复合字面量都能自动推断

Go 1.27 扩大了泛型函数类型推断适用的场景。

此前，泛型函数赋值给一个明确类型的变量时，编译器已经能够根据目标函数类型推断类型参数。但在类型转换、复合字面量等上下文中，往往仍然需要手动写出类型实参。

例如，定义两个泛型函数：

func first[T any](s []T) T {
    return s[0]
}


 func last[T any](s []T) T {
    return s[len(s)-1]
}

现在可以直接将它们放到函数切片中：

package main

 import (
    "fmt"
)

 func first[T any](s []T) T {
    return s[0]
}

 func last[T any](s []T) T {
    return s[len(s)-1]
}

 func main() {
    ops := []func([]int) int{
        first,
        last,
    }

     for _, op := range ops {
        fmt.Println(op([]int{10, 20, 30}))
    }
}

输出：

10
30

这里切片元素类型是：

func([]int) int

编译器可以据此推导出：

first[int]
last[int]

在 Go 1.27 之前，这样写会报错，通常需要显式写成：

ops := []func([]int) int{
    first[int],
    last[int],
}

这项改进的价值在于减少泛型代码中的视觉噪音。未来在注册回调、构造函数表、策略列表、适配器集合等场景中，泛型函数更容易被直接传递和组合。

四、小对象分配更快：部分内存分配性能最高提升约三成

Go 1.27 的运行时和编译器针对小内存分配进行了优化。

编译器现在会生成对“按大小专门优化的内存分配例程”的调用。对于部分小于 80 字节的对象分配，分配成本最多可降低约 30%。

需要注意的是，这并不意味着每个程序都会快 30%。性能收益取决于具体工作负载、分配模式、对象大小和逃逸情况。整体来看，分配较密集的真实程序预计可获得约 1% 的性能提升。

这项优化不要求修改任何业务代码。升级到 Go 1.27 后，已有程序就可能自动受益。

对应的代价是二进制文件大小会增加约 60KB，并且这个增加量与工作负载无关。

如果因为特殊原因需要关闭该优化，可以在构建时设置：

GOEXPERIMENT=nosizespecializedmalloc

这一关闭选项预计会在 Go 1.28 被移除。

对于大多数项目而言，不需要做任何额外操作。更值得做的是升级后重新运行基准测试，观察实际业务场景下的吞吐量、延迟和内存分配变化。

五、调用栈加入 Goroutine 标签：线上排障更容易定位请求上下文

Go 1.27 开始，当模块的go.mod中 Go 版本设置为 1.27 或更高时，运行时输出的 Goroutine 调用栈会包含runtime/pprof的 Goroutine 标签。

如果项目已经使用pprof.Do给 Goroutine 添加标签，那么这些上下文信息现在也会出现在以下场景中：

• panic 崩溃调用栈

• SIGQUIT 输出的 Goroutine 转储

•runtime.Stack输出

• 其他包含 Goroutine 栈信息的运行时诊断结果

示例：

package main

 import (
    "context"
    "fmt"
    "runtime"
    "runtime/pprof"
)

 func main() {
    ctx := context.Background()

     pprof.Do(ctx, pprof.Labels("request", "42"), func(ctx context.Context) {
        buf := make([]byte, 1<<12)
        n := runtime.Stack(buf, false)
        fmt.Printf("%s", buf[:n])
    })
}

Go 1.27 的输出中，Goroutine 头部会在运行状态之后附加标签信息，形式类似：

goroutine 1 [running] {request: 42}:

其中具体的内存地址、文件路径、行号和栈帧内容会因运行环境而不同，但{request: 42}就是新增的标签信息。

这对于线上故障诊断非常有帮助。假设一个服务同时处理多个租户、请求、任务或消息队列事件，那么可以通过标签区分原本调用栈完全相同的 Goroutine。

例如可以附加以下维度：

pprof.Labels(
    "request_id", "abc",
    "tenant", "t001",
    "task_type", "export",
)

如果标签包含敏感信息，不希望出现在调用栈中，可以通过下面的环境变量关闭：

GODEBUG=tracebacklabels=0

该开关此前已经加入，并且预计会长期保留。

六、Goroutine 泄漏分析正式可用

Go 1.26 曾以实验形式引入 Goroutine 泄漏检测能力。到了 Go 1.27，这项功能正式成为常规 profile，无需再开启实验选项。

现在可以通过runtime/pprof获取名为goroutineleak的 profile。

所谓“泄漏的 Goroutine”，指的是一个永久阻塞、且理论上再也无法取得进展的 Goroutine。典型情况包括：

• 向永远不会被接收的 channel 发送数据

• 永远无法获得的锁

• 没有任何唤醒可能的同步等待

• 资源引用关系导致的永久阻塞

下面是一个经典的 channel 发送泄漏示例：

package main

 import (
    "os"
    "runtime"
    "runtime/pprof"
)

 func leak() {
    ch := make(chan int)
    ch <- 1
}

 func main() {
    go leak()

     runtime.Gosched()

     pprof.Lookup("goroutineleak").WriteTo(os.Stdout, 1)
}

这里的ch只在leak函数内部创建，只有当前 Goroutine 能访问它。但这个 Goroutine 试图执行：

ch <- 1

由于没有任何其他 Goroutine 能拿到ch并接收数据，因此它会永久阻塞。

goroutineleakprofile 会触发一次基于 GC 的扫描，用于识别这种无法继续执行的 Goroutine，并报告对应的调用栈。

在真实服务中，通常不需要手工写到标准输出，而是通过net/http/pprof暴露的端点采集：

/debug/pprof/goroutineleak

这对于长期运行的服务尤其重要。很多 Goroutine 泄漏不会立刻导致崩溃，但会随着请求量不断累积，最终造成内存增加、调度压力上升、连接耗尽甚至服务不可用。

七、后量子数字签名进入标准库：crypto/mldsa

Go 1.27 新增crypto/mldsa包，实现了 FIPS 204 中定义的 ML-DSA 后量子数字签名算法。

后量子密码学的目标，是在未来可能出现大规模量子计算能力的情况下，仍能提供可靠的加密和签名安全性。

crypto/mldsa提供三个参数集：

•MLDSA44

•MLDSA65

•MLDSA87

它们在密钥大小、签名大小和安全级别之间进行权衡。

下面是一个签名和验证示例：

package main

 import (
    "crypto"
    "crypto/rand"
    "crypto/mldsa"
    "fmt"
)

 func main() {
    priv, _ := mldsa.GenerateKey(mldsa.MLDSA65())

     msg := []byte("victoria metrics")

     sig, _ := priv.Sign(rand.Reader, msg, crypto.Hash(0))

     fmt.Println("scheme:  ", mldsa.MLDSA65())
    fmt.Println("sig size:", mldsa.MLDSA65().SignatureSize())
    fmt.Println(
        "verified:",
        mldsa.Verify(priv.PublicKey(), msg, sig, nil) == nil,
    )
}

该能力不仅限于独立签名接口，也扩展到了以下标准库组件：

•crypto/x509：支持相关私钥、公钥和签名

•crypto/tls：TLS 1.3 支持新的 MLDSA44、MLDSA65、MLDSA87 签名方案

对于需要长期保存签名、构建高安全基础设施、研究后量子迁移方案的项目来说，这是一个重要的标准库能力补充。

八、标准库终于有 UUID：uuid 包正式加入

Go 1.27 新增顶层uuid包，用于生成和解析符合 RFC 9562 的 UUID。

过去，Go 项目通常依赖第三方 UUID 库。现在，常见 UUID 需求终于可以直接使用标准库完成。

示例：

package main

 import (
    "fmt"
    "uuid"
)

 func main() {
    a := uuid.MustParse("f81d4fae-7dec-11d0-a765-00a0c91e6bf6")

     fmt.Println("parsed:", a)
    fmt.Println("nil:   ", uuid.Nil())
    fmt.Println("max:   ", uuid.Max())
}

uuid包提供了多个生成方式：

package main

 import (
    "fmt"
    "uuid"
)

 func main() {
    fmt.Println(uuid.NewV4())
    fmt.Println(uuid.NewV7())
}

其中：

•uuid.New()：选择适用于大多数场景的生成方式

•uuid.NewV4()：生成纯随机 UUID

•uuid.NewV7()：生成时间有序 UUID

UUID v7 特别适合数据库主键、事件编号、日志记录标识等场景，因为它在排序时更接近创建时间顺序。

随机部分的 UUID 是可比较类型，因此可以直接使用==：

if id1 == id2 {
    fmt.Println("same uuid")
}

也可以直接作为 map 的键：

m := map[uuid.UUID]string{}

对于大量依赖 UUID 的 Go 服务而言，标准库支持意味着依赖更少、API 更统一、升级与审计成本也更低。

九、JSON v2 默认可用，经典 JSON 包底层也切换到新实现

encoding/json/v2曾经以实验形式存在。Go 1.27 中，它正式可用，不再需要设置GOEXPERIMENT=jsonv2。

同时，低层文本处理包encoding/json/jsontext也正式可用。

更重要的是：传统的encoding/json包在底层也开始使用 v2 实现。

对于大部分既有项目，这个切换是透明的，通常不需要迁移代码。原有行为会尽可能保持兼容，主要可能出现的是部分错误消息文本不同。

如果出现兼容性问题，可以通过以下方式恢复旧实现：

GOEXPERIMENT=nojsonv2

对于常见用法，v2 的 API 与 v1 非常接近：

package main

 import (
    "fmt"

     json "encoding/json/v2"
)

 type Point struct {
    X int `json:"x"`
    Y int `json:"y"`
}

 func main() {
    data, err := json.Marshal(Point{
        X: 1,
        Y: 2,
    })

     fmt.Println(string(data), err)
}

输出：

{"x":1,"y":2}

有一个行为差异尤其值得关注：传统encoding/json会始终对 map 键排序，而 JSON v2 默认不排序。

不排序的优势是性能更好，尤其是 map 数据量较大、JSON 编码频繁的服务。

但如果需要稳定输出，例如：

• Golden Test

• 快照测试

• 需要对 JSON 文本做固定字符串比较

• 需要得到稳定构建产物

• 需要生成确定性序列化结果

则应使用json.Deterministic选项。

因此，升级 Go 1.27 后，建议检查测试代码中是否隐式依赖 map JSON 输出顺序。如果依赖，应显式启用确定性输出，而不是继续假设 map 一定按固定键顺序编码。

十、可移植 SIMD 实验功能：让 Go 更接近向量化计算

Go 1.27 新增实验性simd包，用于提供可移植、向量宽度无关的 SIMD 编程能力。

启用方式：

GOEXPERIMENT=simd

SIMD 即单指令多数据，适合批量数值计算、图像处理、音频处理、科学计算、机器学习前处理、信号处理等场景。

与直接绑定某个 CPU 指令集不同，Go 的simd包设计为“向量长度无关”。也就是说，开发者不必假设向量一定有 4 个、8 个或 16 个元素。

例如，Float32s在某一台机器上可能包含 4 个通道，在另一台机器上可能包含 16 个通道。底层会根据硬件能力使用实际的向量指令；如果硬件条件不支持，则回退到纯 Go 模拟实现。

示例：

package main

 import (
    "fmt"
    "simd"
)

 func main() {
    a := []float32{
        1, 2, 3, 4,
        5, 6, 7, 8,
        9, 10, 11, 12,
        13, 14, 15, 16,
    }

     b := []float32{
        10, 20, 30, 40,
        50, 60, 70, 80,
        90, 100, 110, 120,
        130, 140, 150, 160,
    }

     va := simd.LoadFloat32s(a)
    vb := simd.LoadFloat32s(b)

     sum := va.Add(vb)

     out := make([]float32, sum.Len())
    sum.Store(out)

     fmt.Println(out[:4])
}

这里：

va := simd.LoadFloat32s(a)

会从切片中读取恰好va.Len()个元素。

然后：

sum := va.Add(vb)

执行逐元素加法。底层可能会被编译为真实的硬件向量指令，从而一次处理多个元素。

Go 1.27 的 SIMD 仍然是实验能力，适合性能敏感领域进行探索和基准测试。普通业务系统不必急于引入，但对于计算密集型项目，这将是值得持续关注的方向。

十一、strings.CutLast 和 bytes.CutLast：从最后一个分隔符切分

Go 1.18 加入了strings.Cut，用于按第一个分隔符切分字符串。

Go 1.27 新增：

•strings.CutLast

•bytes.CutLast

它们用于按照最后一个分隔符进行切分，可以替代很多“先 LastIndex，再手动切片”的写法。

示例：

package main

 import (
    "fmt"
    "strings"
)

 func main() {
    before, after, found := strings.CutLast("a/b/c", "/")
    fmt.Printf("%q %q %v\n", before, after, found)

     before, after, found = strings.CutLast("nosep", "/")
    fmt.Printf("%q %q %v\n", before, after, found)
}

输出：

"a/b" "c" true
"nosep" "" false

当分隔符不存在时，返回规则与strings.Cut一致：

•before为原始字符串

•after为空字符串

•found为false

例如解析文件路径、模块路径、镜像名称、版本后缀、URL 最后一级资源等场景时，这个 API 会更加直接。

过去可能这样写：

i := strings.LastIndex(s, "/")
if i >= 0 {
    before := s[:i]
    after := s[i+1:]
    _ = before
    _ = after
}

现在可以直接写：

before, after, found := strings.CutLast(s, "/")

代码更短，也更不容易出现边界错误。

十二、泛型哈希接口：hash/maphash 支持自定义比较与哈希策略

Go 1.27 中，hash/maphash包新增了泛型Hasher[T]接口。

这个接口为未来哈希表、布隆过滤器等哈希型数据结构提供统一的哈希与比较约定。

接口的核心包含两个能力：

•Hash：将值混入一个持续计算的哈希中

•Equal：判断两个值是否相等

最重要的约束是：

如果两个值相等，那么它们必须产生相同的哈希结果。

对于任何可比较类型，可以使用现成的ComparableHasher[T]。它按值进行哈希，并使用==比较。

更有价值的场景是自定义比较规则。例如，定义一个不区分大小写的字符串哈希器：

package main

 import (
    "hash/maphash"
    "strings"
)

 type ciHasher struct{}

 func (ciHasher) Hash(h *maphash.Hash, s string) {
    h.WriteString(strings.ToLower(s))
}

 func (ciHasher) Equal(x, y string) bool {
    return strings.EqualFold(x, y)
}

这里的Equal不区分大小写：

"Go" == "GO"

在这个自定义规则下应当视为相等。

那么Hash也必须使用统一的小写形式，否则就会违反“相等值必须有相同哈希”的规则。

完整示例：

package main

 import (
    "fmt"
    "hash/maphash"
    "strings"
)

 type ciHasher struct{}

 func (ciHasher) Hash(h *maphash.Hash, s string) {
    h.WriteString(strings.ToLower(s))
}

 func (ciHasher) Equal(x, y string) bool {
    return strings.EqualFold(x, y)
}

 func main() {
    var h maphash.Hasher[string] = ciHasher{}

     fmt.Println(h.Equal("Go", "GO"), h.Equal("Go", "Rust"))

     seed := maphash.MakeSeed()

     var a, b maphash.Hash
    a.SetSeed(seed)
    b.SetSeed(seed)

     h.Hash(&a, "Go")
    h.Hash(&b, "GO")

     fmt.Println(a.Sum64() == b.Sum64())
}

输出：

true false
true

这种能力对于实现不区分大小写的集合、规范化键、复杂对象索引、自定义缓存键和领域特定比较逻辑很有意义。

十三、math/big 支持指定舍入模式的整数除法

Go 1.27 为math/big.Int增加了Divide方法。

传统的Quo和Mod采用向零截断的整数除法规则。对于金融、计费、比例换算、负数计算等场景，开发者往往需要自行处理向上取整、向下取整或四舍五入逻辑。

现在可以通过Int.Divide显式指定舍入模式：

•Trunc

•Floor

•Round

•Ceil

示例：

package main

 import (
    "fmt"
    "math/big"
)

 func main() {
    x, y := big.NewInt(7), big.NewInt(2)
    q, r := new(big.Int), new(big.Int)

     q.Divide(x, y, r, big.Ceil)
    fmt.Printf("ceil:  q=%s r=%s\n", q, r)

     q.Divide(x, y, r, big.Floor)
    fmt.Printf("floor: q=%s r=%s\n", q, r)
}

输出：

ceil:  q=4 r=-1
floor: q=3 r=1

需要注意余数的含义：

x = q × y + r

当7 / 2使用向上取整时：

7 = 4 × 2 + (-1)

所以商为4，余数为-1。

当使用向下取整时：

7 = 3 × 2 + 1

所以商为3，余数为1。

这让高精度整数计算的舍入行为变得明确、统一，也避免项目中散落各种手写除法修正逻辑。

十四、math/rand/v2 新增 Rand.N：从自定义随机源生成泛型范围随机数

math/rand/v2此前已经提供顶层泛型函数N。Go 1.27 进一步为Rand类型新增了方法：

(*Rand).N

这样就可以从自定义的Rand随机源中，生成指定上界以内的整数或 duration 类型随机数。

示例：

package main

 import (
    "fmt"
    "math/rand/v2"
)

 func main() {
    r := rand.New(rand.NewPCG(1, 2))

     fmt.Println(r.N(100))
}

这里：

r.N(100)

会生成一个范围在[0, 100)内的int随机数。

由于示例使用固定种子：

rand.NewPCG(1, 2)

所以每次运行可以得到可复现的随机序列。这对单元测试、模拟计算、随机算法调试和可重复基准测试非常有用。

相比只使用全局随机函数，(*Rand).N更适合需要明确管理随机源生命周期和种子的场景。

十五、关于合成时间休眠能力

Go 1.27 更新内容中还出现了“在合成时间中休眠”这一项标题，但当前提供的材料未包含对应 API、行为说明或示例代码。因此本文不对其使用方式做额外推断，以免引入材料之外的内容。

总结：Go 1.27 的重点不是一个功能，而是一整套开发体验升级

代码地址：github.com/golang/go

Go 1.27 的更新覆盖了语言能力、标准库、运行时性能、可观测性、安全性和数值计算多个方向。

最值得重点关注的变化包括：

• 泛型方法正式落地，泛型类型 API 更自然

• 结构体字面量支持直接设置提升字段

• 泛型函数在复合字面量等场景可自动推断类型

• 小对象内存分配进一步优化

• Goroutine 调用栈可显示 pprof 标签

•goroutineleakprofile 正式帮助定位 Goroutine 泄漏

•crypto/mldsa提供后量子数字签名能力

• 标准库新增uuid包

• JSON v2 正式可用，传统 JSON 底层也切换到新实现

• 实验性simd包开启可移植向量化计算探索

•strings.CutLast与bytes.CutLast简化最后分隔符切分

•hash/maphash新增泛型哈希策略接口

•math/big.Int.Divide支持明确舍入规则

•math/rand/v2的Rand.N支持泛型随机范围生成

对于普通业务项目，升级后最容易直接受益的是内存分配优化、JSON v2 底层升级、调用栈标签和新的字符串切分 API。

对于框架、基础库和高性能计算项目，泛型方法、泛型哈希、SIMD、后量子签名、Goroutine 泄漏检测等能力，则可能带来新的架构设计空间。

Go 1.27 不是一次只面向底层开发者的更新。它既让日常代码写得更简洁，也让高性能、可观测性和安全场景拥有了更现代的标准库支持。

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。

网易专栏 # Go 1.27 # 开发技术

文章版权归作者所有，未经允许请勿转载。

北京早高峰，用千问叫了辆车，我回不到过去了

网易专栏 # AI # 千问

5个月前

最强模型 Fable 5，四天就被「拔了网线」

网易专栏 # AI # Anthropic

2个月前

日均 120 万亿 Token，火山引擎两年前的赌注开始兑现

网易专栏 # AI # 火山引擎

5个月前

戴盟机器人完成亿元融资，阿里多模态大牛加盟攻关物理世界模型

网易专栏 # AI # 戴盟机器人

3个月前

golang 1.27.0 更新全解：泛型方法、JSON v2、UUID、后量子签名、SIMD 一次看懂

🤖 AI总结

主题

摘要

关键信息

1分钱9张图！DeepSeek视觉模型连夜实测

2026-08-22：可整除替换后的数组最小元素和。用go语言，给定一个整数数组。你可以反复执行这种操作：任意选出两个位置，如果其中一个位置

相关文章

北京早高峰，用千问叫了辆车，我回不到过去了

最强模型 Fable 5，四天就被「拔了网线」

日均 120 万亿 Token，火山引擎两年前的赌注开始兑现

戴盟机器人完成亿元融资，阿里多模态大牛加盟攻关物理世界模型