在v站看到一篇文章,说到了golang实现python装饰器的方法,有两个实现方式
其中一种是用类方式实现的,当时泛览了下代码,觉得 emmm...实现方式挺花哨的,貌似看懂了就没怎么在意,当时特意把代码复制到goland中作为参考了
某天上班摸鱼,仔细看了下这段代码,梳理细节后忽然发现没get到其中逻辑
郁闷很久未参透
有空就特意调试打印下这段代码
好几天才整明白,这大概就是菜比の理解能力了吧
代码如下:
// with interface. which we need create a `point` first. and use it later
package main
import "fmt"
type FibI interface {
Fib(n int) int
Wrap(fib FibI) FibI
}
type Fib struct {
Wrapper FibI
}
func (this *Fib) Fib(n int) int {
//wrapper := this.Wrapper
if this.Wrapper == nil {
this.Wrapper = this
}
fmt.Printf("我执行了...%T...%v\n", this.Wrapper, n)
if n == 0 {
return 0
}
if n == 1 {
return 1
}
// call son
fmt.Printf("leixing9...%T...\n", this.Wrapper)
return this.Wrapper.Fib(n-1) + this.Wrapper.Fib(n-2)
}
func (this *Fib) Wrap(fib FibI) FibI {
fmt.Printf("leixing1...%T...\n", this.Wrapper)
this.Wrapper = fib
fmt.Printf("leixing2...%T...\n", this.Wrapper)
fmt.Println("fib 调用", this)
return this
}
type CacheFib struct {
Wrapper FibI
cache map[int]int
}
func (this *CacheFib) Wrap(fib FibI) FibI {
this.Wrapper = fib
fmt.Printf("leixing6...%T...\n", this.Wrapper)
return this
}
func (this *CacheFib) Fib(n int) int {
if this.cache == nil {
this.cache = make(map[int]int)
}
if ans, ok := this.cache[n]; ok {
return ans
}
ans := this.Wrapper.Fib(n)
this.cache[n] = ans
return ans
}
type CounterFib struct {
Wrapper FibI
Counter int
}
func (this *CounterFib) Wrap(fib FibI) FibI {
this.Wrapper = fib
fmt.Printf("leixing...%T...\n", this.Wrapper)
return this
}
func (this *CounterFib) Fib(n int) int {
this.Counter++
return this.Wrapper.Fib(n)
}
func main() {
fib := new(Fib)
//fmt.Println("result fib", fib.Fib(10))
cacheFib := new(CacheFib)
//f := cacheFib.Wrap(fib.Wrap(cacheFib))
//fmt.Println(f.Fib(10), "heihei")
counterFib := new(CounterFib)
counterCacheFib := cacheFib.Wrap(counterFib.Wrap(fib.Wrap(cacheFib)))
fmt.Println("result cache:counter:fib", counterCacheFib.Fib(10))
fmt.Printf("count: %d, cache: %v", counterFib.Counter, cacheFib.cache)
}
本文的目的没有那么高大上,就是简单的理解一下,这种装饰器实现及其后的核心原理
讲真,这个代码实现的挺花哨的>_<
所以,我把自己的那些调试打印信息也一并给出了
首先第一步:
背景:用装饰器的原理实现斐波那契数列的计算
如果有golang语法基础,相信这些main函数之前的代码应该理解起来不难
其中Fib结构是一个实现了FibI接口的对象
乍看之下好像仅此而已
CacheFib结构也同样实现了此接口,不过提供了一个map数据结构,会把之前计算过的数值缓存起来,后面调用直接取缓存
CounterFib结构就简单啦,它计算了CounterFib实例调用Fib方法的次数
三个Fib类的Wrap方法实现方式都一样:就是把自身的Wrapper属性赋值为参数中的(实现了)FibI值
一直到main函数之前,这些代码还都不难理解
最后注意下主函数内的调用方法
cacheFib.Wrap(counterFib.Wrap(fib.Wrap(cacheFib)))
瞬间懵逼有木有
乍看之下,为什么cacheFib会出现两次,看起来好像是自己引用了自己(递归也是自己调用自己,好好参悟一下)
嗯,那些能明白这行代码的童鞋可以先行告退了,没懂得同学咱门继续
不明白的话就运行一遍代码:
斐波那契数列计算完美,有计算次数,也优化了计算逻辑(缓存了)
但这并不妨碍咱们的懵逼状态ing~
整个方法的调用链是怎样的呢
我在各个位置加了打印信息,其核心就是Fib方法
通过打印可以发现,每次计算n数值的时候都会调用Fib 对象的Fib 方法(有点绕)
打印Fib 对象的Wrapper类型, 显示为main.CacheFib类型
所以,我们重新回顾下Fib对象,其实它没那么简单,首先对象的Wrapper 属性本身类型就是实现了FibI 接口的类型,其次对象本身也实现FibI 接口
Fib 对象的Fib 方法中调用了 Fib 对象的Wrapper属性的Fib方法(还是很绕,注意区分下Fib对象和Fib方法,这是两个概念)
那么回头来看main函数中的实现,cacheFib 是CacheFib类的实例,cacheFib使用Wrap方法用counterFib对象来装饰自身,但是counterFib对象的Wrapper被fib对象装饰了,同时fib对象又被cacheFib自身装饰了,那么当我们执行counterCacheFib.Fib(10)
是时候,经过层层装饰,其实调用的方法是fib对象的Fib方法,fib对象的Fib方法在每次执行的时候又会调用自身Wrapper的Fib方法(不过这是一个类似递归的操作,只有当参数n大于1的时候才会调用自身的Wrapper的Fib方法),不过Fib.Wrapper又被cacheFib装饰了,所以绕了一圈又回来了,只要入参n大于1,就会一直递归往复(这是一个有退出条件的闭环), 所以小伙伴们都绕明白了吗
有疑问加站长微信联系(非本文作者)