编程概念 on nayun blog

泛型

Wed, 06 Aug 2025 10:31:06 +0800

泛型（Generics）是编程语言中一种允许在定义函数、数据结构或类时使用类型参数的特性。通过泛型，开发者可以编写更通用、灵活的代码，而无需为每种具体类型重复实现相同的逻辑。

1. 泛型的核心概念
#

（1）类型参数（Type Parameters）
#

在定义函数或结构体时，可以声明一个或多个类型参数，用方括号 [] 包裹（Go 语言风格，其他语言可能用 <>）。
例如：

</>
go


1// T 是类型参数，可以是任何类型
2func identity[T any](value T) T {
3 return value
4}

（2）类型约束（Type Constraints）
#

限制类型参数的范围，例如要求类型必须支持某些操作（如比较大小、相加等）。

Go 中通过接口定义约束：

</>
go


1type Number interface {
2 int | float64 // 约束 T 只能是 int 或 float64
3}
4
5func add[T Number](a, b T) T {
6 return a + b
7}

其他语言（如 Java）通过泛型边界（<T extends Comparable>）实现类似功能。

（3）泛型数据结构
#

泛型不仅用于函数，还可用于定义通用的数据结构（如链表、队列等）。
例如，Go 中的泛型切片：

中间件工厂

Tue, 05 Aug 2025 17:02:12 +0800

概念
#

在函数式编程和软件架构中，中间件工厂是一种创建中间件的高阶函数模式。它是在函数工厂（能够生成其他函数的函数）概念基础上的扩展应用。

定义
#

中间件工厂是一个函数，它接收配置参数并返回一个中间件函数。这种模式常见于Web框架（如Express、Koa）和数据处理流程中。

</>
javascript


 1// 中间件工厂示例
 2function createMiddleware(config) {
 3 return function middleware(req, res, next) {
 4 // 使用config和实现中间件逻辑
 5 if (config.condition) {
 6 // 做一些事情
 7 }
 8 next();
 9 };
10}
11
12// 使用
13const myMiddleware = createMiddleware({ condition: true });
14app.use(myMiddleware);

核心意义
#

1. 配置与复用性
#

中间件工厂通过参数化配置，使得单个中间件实现可以适应多种使用场景，大大提高了代码的复用性。

闭包

Mon, 14 Jul 2025 11:35:25 +0800

在创建时封装当时状态，并使当时的状态生存周期延长至与闭包生存周期一致
闭包思想产物：
1. python装饰器
2. 回调函数
3. 函数工厂
4. 惰性求值
…

典型用法
#

1. python装饰器
#

</>
python


1def execute(f):
2 f()
3
4@execute
5def execute_when_defined():
6 print('executed')

2. 函数工厂
#

保存调用函数工厂时的参数
调用生成的函数时，使用函数工厂创建函数时的参数上下文

示例
#

python api函数工厂

</>
python


1def get_table_grids_wp(cli:Client, docid):
2 def func(tableid):
3 return [c['children'][0] for c in cli.fetchblocks(docid, tableid)['data']['items']]
4 return func
5
6get_table_grids = get_table_grids_wp(cli, docid)
7get_table_grids(tid)

go 基础函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 函数工厂：返回一个加法函数
 6func makeAdder(addend int) func(int) int {
 7 return func(x int) int {
 8 return x + addend
 9 }
10}
11
12func main() {
13 add5 := makeAdder(5) // 创建一个加5的函数
14 add10 := makeAdder(10) // 创建一个加10的函数
15
16 fmt.Println(add5(3)) // 输出: 8 (3 + 5)
17 fmt.Println(add10(3)) // 输出: 13 (3 + 10)
18}

go 中间件工厂
带配置的函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5type GreeterConfig struct {
 6 Prefix string
 7 Suffix string
 8}
 9
10// 创建问候函数
11func NewGreeter(config GreeterConfig) func(string) string {
12 return func(name string) string {
13 return fmt.Sprintf("%s, %s%s", config.Prefix, name, config.Suffix)
14 }
15}
16
17func main() {
18 friendlyGreeter := NewGreeter(GreeterConfig{
19 Prefix: "Hello",
20 Suffix: "! Welcome!",
21 })
22
23 formalGreeter := NewGreeter(GreeterConfig{
24 Prefix: "Dear",
25 Suffix: ", we are pleased to meet you",
26 })
27
28 fmt.Println(friendlyGreeter("Alice")) // 输出: Hello, Alice! Welcome!
29 fmt.Println(formalGreeter("Bob")) // 输出: Dear, Bob, we are pleased to meet you
30}

缓存函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 创建带缓存的函数
 6func makeCachedFunc(fn func(int) int) func(int) int {
 7 cache := make(map[int]int)
 8 return func(x int) int {
 9 if result, found := cache[x]; found {
10 fmt.Printf("Cache hit for %d\n", x)
11 return result
12 }
13 result := fn(x)
14 cache[x] = result
15 fmt.Printf("Calculated for %d\n", x)
16 return result
17 }
18}
19
20func expensiveCalculation(x int) int {
21 // 模拟耗时计算
22 return x * x
23}
24
25func main() {
26 cachedCalc := makeCachedFunc(expensiveCalculation)
27
28 fmt.Println(cachedCalc(5)) // 输出: Calculated for 5 \n 25
29 fmt.Println(cachedCalc(5)) // 输出: Cache hit for 5 \n 25
30}

编程概念 on nayun blog

泛型

1. 泛型的核心概念 #

（1）类型参数（Type Parameters） #

（2）类型约束（Type Constraints） #

（3）泛型数据结构 #

中间件工厂

概念 #

定义 #

核心意义 #

1. 配置与复用性 #

闭包

典型用法 #

1. python装饰器 #

2. 函数工厂 #

示例 #