python的装饰器和go的filter

python的装饰器：

# python的装饰器写法，接收函数做为参数，返回内部定义的函数
def log(func):
	def wrapper(*args, **kwargs):
		print("call %s(): " % func.__name__)
		return func(*args, **kwargs)
	return wrapper

def log2(func):
	return lambda *args, **kwargs: func(*args, **kwargs)

@log
def now():
	print("2022-01-01")


if __name__ == "__main__":
	now()

go的filter写法，接收函数作为参数，返回同类型的函数：

package main

import (
	"fmt"
	"time"
)

type handleFunc func(c *Context)

// FilterBuilder 是一个接收Filter
type FilterBuilder func(next Filter) Filter

// Filter 是一个函数
type Filter func(c *Context)

// MetricsFilterBuilder 一个实现FilterBuilder的例子
// 不就是在原来的函数上做了一下包装？类似于装饰器？
func MetricsFilterBuilder(next Filter) Filter {
	return func(c *Context) {
		start := time.Now().Nanosecond()
		next(c)
		end := time.Now().Nanosecond()
		fmt.Printf("cost time: %v\n", end - start)
	}
}

比如，如下对一个函数进行包装：

// 一个函数原型
type handleFunc func(path string) error

// 对handleFn进行包装, 使得调用此函数会打印其耗费时间
func filter (f handleFunc) handleFunc {
	return func(path string) error {
		start := time.Now()
		defer func() {
			fmt.Printf("cost time: %v\n", time.Since(start))
		}()
		return f(path)
	}
}

func dirPath(path string) error {
	fmt.Println("start Dir")
	time.Sleep(5 * time.Second)
	fmt.Println("end Dir")

	return nil
}

func main() {
	dirPath := filter(dirPath)
	if err := dirPath("home"); err != nil {
		fmt.Println(err)
	}

}