Go 泛型与 WebAssembly 的实用入门

Go 1.18 的泛型解决了重复代码和类型抽象问题，适合用于工具函数、容器类型和明确边界的类型约束；Go 1.11 支持的 WebAssembly 则适合把计算逻辑带到浏览器或其他环境，但要警惕与 JavaScript 频繁互调带来的开销。文章给出了 Map、Stack、Number 约束、WASM 编译与运行示例，并补充了一个泛型工具库、常见问题和实践建议，核心结论是：这两个特性都值得用，但要放在合适场景里，别为了新而新。

虚拟内存发布于 2026/6/30更新于 2026/9/1135 浏览

概述

Go 这几年的变化不算密集，但泛型和 WebAssembly 都是绕不开的两个点。前者补上了语言能力上的一块短板，后者则让 Go 多了一个运行场景。两者都不算'写了就立刻见效'的特性，真正有价值的地方，往往是在你碰到重复代码、或者想把一段逻辑塞进浏览器里跑的时候。

泛型

Go 1.18 引入泛型之后，很多原本靠 interface{} 和类型断言硬撑的代码，终于可以写得干净一点。不过它不是拿来'到处泛化'的，泛型写多了，代码也会变得不好读。我的经验是：能用在一类明确的工具函数、容器类型上，就已经够实用了。

基本用法

// 定义泛型函数
func Map[T, U any](s []T, f func(T) U) []U {
	result := make([]U, len(s))
	for i, v := range s {
		result[i] = f(v)
	}
	return result
}

// 使用泛型函数
func main() {
	ints := []int{1, 2, 3, 4, 5}
	squared := Map(ints, func(x int) int {
		return x * x
	})
	fmt.Println(squared) // 输出：[1 4 9 16 25]
	strings := []string{"a", "b", "c"}
	lengths := Map(strings, func(s string) int {
		return len(s)
	})
	fmt.Println(lengths) // 输出：[1 1 1]
}

泛型类型

相关免费在线工具

RSA密钥对生成器
生成新的随机RSA私钥和公钥pem证书。在线工具，RSA密钥对生成器在线工具，online
Mermaid 预览与可视化编辑
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。在线工具，Mermaid 预览与可视化编辑在线工具，online
随机西班牙地址生成器
随机生成西班牙地址（支持马德里、加泰罗尼亚、安达卢西亚、瓦伦西亚筛选），支持数量快捷选择、显示全部与下载。在线工具，随机西班牙地址生成器在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown转HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。在线工具，Markdown转HTML在线工具，online

// 定义泛型类型
type Stack[T any] struct {
	elements []T
}

func (s *Stack[T]) Push(v T) {
	s.elements = append(s.elements, v)
}

func (s *Stack[T]) Pop() (T, bool) {
	if len(s.elements) == 0 {
		var zero T
		return zero, false
	}
	v := s.elements[len(s.elements)-1]
	s.elements = s.elements[:len(s.elements)-1]
	return v, true
}

// 使用泛型类型
func main() {
	stack := &Stack[int]{}
	stack.Push(1)
	stack.Push(2)
	stack.Push(3)
	if v, ok := stack.Pop(); ok {
		fmt.Println(v) // 输出：3
	}
}

// 定义类型约束
type Number interface {
	int | float64 | float32
}

// 使用类型约束
func Sum[T Number](s []T) T {
	var sum T
	for _, v := range s {
		sum += v
	}
	return sum
}

// 使用泛型函数
func main() {
	ints := []int{1, 2, 3, 4, 5}
	fmt.Println(Sum(ints)) // 输出：15
	floats := []float64{1.1, 2.2, 3.3}
	fmt.Println(Sum(floats)) // 输出：6.6
}

# 编译为 WebAssembly
GOOS=js GOARCH=wasm go build -o main.wasm .

<!DOCTYPE html>
<html>
<head>
    <title>Go WebAssembly</title>
</head>
<body>
    <script src="wasm_exec.js"></script>
    <script>
        const go = new Go();
        WebAssembly.instantiateStreaming(fetch("main.wasm"), go.importObject).then((result) => {
            go.run(result.instance);
        });
    </script>
</body>
</html>

cp $(go env GOROOT)/misc/wasm/wasm_exec.js .

// main.go
package main

import (
	"fmt"
	"syscall/js"
)

func main() {
	// 导出函数到 JavaScript
	js.Global().Set("add", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
		a := args[0].Int()
		b := args[1].Int()
		return a + b
	}))

	// 调用 JavaScript 函数
	document := js.Global().Get("document")
	p := document.Call("createElement", "p")
	p.Set("innerHTML", "Hello from Go WebAssembly!")
	body := document.Get("body")
	body.Call("appendChild", p)

	// 保持程序运行
	select {}
}

generic-utils/
├── go.mod
├── main.go
└── utils/
    └── utils.go

// utils/utils.go
package utils

// Map 映射函数
func Map[T, U any](s []T, f func(T) U) []U {
	result := make([]U, len(s))
	for i, v := range s {
		result[i] = f(v)
	}
	return result
}

// Filter 过滤函数
func Filter[T any](s []T, f func(T) bool) []T {
	var result []T
	for _, v := range s {
		if f(v) {
			result = append(result, v)
		}
	}
	return result
}

// Reduce 归约函数
func Reduce[T, U any](s []T, initial U, f func(U, T) U) U {
	result := initial
	for _, v := range s {
		result = f(result, v)
	}
	return result
}

// Stack 泛型栈
type Stack[T any] struct {
	elements []T
}

func NewStack[T any]() *Stack[T] {
	return &Stack[T]{}
}

func (s *Stack[T]) Push(v T) {
	s.elements = append(s.elements, v)
}

func (s *Stack[T]) Pop() (T, bool) {
	if len(s.elements) == 0 {
		var zero T
		return zero, false
	}
	v := s.elements[len(s.elements)-1]
	s.elements = s.elements[:len(s.elements)-1]
	return v, true
}

func (s *Stack[T]) Len() int {
	return len(s.elements)
}

// main.go
package main

import (
	"fmt"
	"github.com/yourusername/generic-utils/utils"
)

func main() {
	// 测试 Map 函数
	ints := []int{1, 2, 3, 4, 5}
	squared := utils.Map(ints, func(x int) int {
		return x * x
	})
	fmt.Println("Map:", squared) // 输出：[1 4 9 16 25]

	// 测试 Filter 函数
	even := utils.Filter(ints, func(x int) bool {
		return x%2 == 0
	})
	fmt.Println("Filter:", even) // 输出：[2 4]

	// 测试 Reduce 函数
	sum := utils.Reduce(ints, 0, func(a, b int) int {
		return a + b
	})
	fmt.Println("Reduce:", sum) // 输出：15

	// 测试 Stack
	stack := utils.NewStack[int]()
	stack.Push(1)
	stack.Push(2)
	stack.Push(3)
	fmt.Println("Stack len:", stack.Len()) // 输出：3
	if v, ok := stack.Pop(); ok {
		fmt.Println("Pop:", v) // 输出：3
	}
	fmt.Println("Stack len:", stack.Len()) // 输出：2
}

Go 泛型与 WebAssembly 的实用入门

概述

泛型

基本用法

泛型类型

更多推荐文章

相关免费在线工具

类型约束

WebAssembly

编译为 WebAssembly

运行 WebAssembly

示例

一个更实在的泛型工具库

项目结构

代码实现

常见问题

泛型用得太多

WebAssembly 的性能不理想

版本兼容

学习成本

最佳实践

泛型

WebAssembly

版本兼容

学习与实践

总结

更多推荐文章

相关免费在线工具