[golang] 如何在没有泛型的强类型语言中写一个通用的map-reduce函数

最新推荐文章于 2024-07-27 17:41:39 发布
最新推荐文章于 2024-07-27 17:41:39 发布
阅读量537 收藏
点赞数
分类专栏： golang 泛型 文章标签： golang 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Myriad_Dreamin/article/details/102895808
版权
本文探讨如何在不支持泛型的Golang中编写通用的map和reduce函数。通过使用反射、接口和特定的优化，实现了接近原生效率的通用map操作。同时提到，对于追求极致效率的情况，可能需要牺牲封装性，回归原始的复制粘贴代码方式。reduce部分作为课后习题留给读者思考。
摘要由CSDN通过智能技术生成

map篇

在C语言时代，一个map函数可能长成下面这个样子

func mapF(f IntMapFunc, i ...int) []int {
	y := make([]int, len(i), cap(i))
	for j := range i {
		y[j] = f(i[j])
	}
	return y
}

func mapFInplace(f IntMapFunc, i ...int) []int {
	for j := range i {
		i[j] = f(i[j])
	}
	return i
}

看起来不错，但这个函数只适用于int，如果是int8，那么golang强类型的坑会让你抓瞎。不得不又复制一份。最终得到的结果是这会让所有的程序设计者如鲠在喉。

如果不考虑效率？你能想到的最优美的写法是什么？
如果只用reflect包，那么会是下面这个样子


import "reflect"

func MapR(fi interface{}) functional.Function {
	var f = reflect.ValueOf(fi)
	return func(in []reflect.Value) (out []reflect.Value) {
		slice := in[0]
		sliceMap := reflect.MakeSlice(slice.Type(), slice.Len(), slice.Cap())
		for i := slice.Len() - 1; i >= 0; i-- {
			in[0] = slice.Index(i)
			sliceMap.Index(i).Set(f.Call(in)[0])
		}
		out = append(out, sliceMap)
		return out
	}
}

func MapRInplace(fi interface{}) functional.Function {
	var f = reflect.ValueOf(fi)
	return func(in []reflect.Value) []reflect.Value {
		slice := in[0]
		for i := slice.Len() - 1; i >= 0; i-- {
			in[0] = slice.Index(i)
			slice.Index(i).Set(f.Call(in)[0])
		}
		in[0] = slice
		return in
	}
}

在golang中，一个function的interface{}形式是type Function=func(in []reflect.Value) []reflect.Value。如果一个变量类型是Function，那么它可以被绑定到一个地址上。我们使用下面的胶水函数，完成这两个函数的全部封装。

func Map(fi, fm interface{}) {
	functional.MakeFunc(MapR(fi), fm)
	return
}

func MapInplace(fi, fm interface{}) {
	functional.MakeFunc(MapRInplace(fi), fm)
	return
}

我们对这两个函数做一个测试。


func BenchmarkMap(b *testing.B) {
	var x func(i ...int) []int
	Map(func(i int) int { return i + 1 }, &x)
	var s = make([]int, 100000)
	for i := 0; i < b.N; i++ {
		s = x(s...)
	}
}

func BenchmarkMapInplace(b *testing.B) {
	var x func(i ...int) []int
	Map(func(i int) int { return i + 1 }, &x)
	var s = make([]int, 100000)
	for i := 0; i < b.N; i++ {
		x(s...)
	}
}

func BenchmarkMap100000Raw(b *testing.B) {
	var s = make([]int, 100000)
	for i := 0; i < b.N; i++ {
		s = mapF(add1, s...)
	}
}

func BenchmarkMap100000RawInplace(b *testing.B) {
	var s = make([]int, 100000)
	for i := 0; i < b.N; i++ {
		s = mapFInplace(add1, s...)
	}
}


=== RUN   TestMap
[2 3]
[3 4]
--- PASS: TestMap (0.00s)

BenchmarkMap-12                     	      50	  24199896 ns/op
BenchmarkMapInplace-12              	      50	  24840064 ns/op
BenchmarkMap100000Raw-12            	    5000	    319601 ns/op
BenchmarkMap100000RawInplace-12     	   10000	    226000 ns/op

虽然特别优美，对于任意函数func(T) T，都能绑定到一个函数指针func(...T) []T或者func([]T) []T上，并且它也实现了功能，但这也太慢了！比非通用的函数要慢100倍，也就是说这两个函数如果使用到工程中，99%的时间会用在reflect上，这能玩？

注意到runtime-call是一个大量消耗cpu的点。我们使用接口对这种特性进行封装。

type Handler interface {
	Call(f interface{}, index int)
}

type Mapper struct {
	F func(slice interface{}) Handler
	FInplace(slice interface{}) Handler
}

type MapperF interface {
	F(slice interface{}) Handler
	FInplace(slice interface{}) Handler
}

type Mapper struct {
	MapperF
	CoreCount int
}

func (m Mapper) MapR(fi interface{}) functional.Function {
	t := reflect.SliceOf(reflect.TypeOf(fi).In(0))
	return func(in []reflect.Value) (out []reflect.Value) {
		slice := in[0]
		sliceMap := m.F(slice.Interface())
		for i := slice.Len()-1; i >= 0; i-- {
			sliceMap.Call(fi, i)
		}
		return append(out, reflect.ValueOf(sliceMap).Convert(t).Value())
	}
}

func (m Mapper) MapR(fi interface{}) functional.Function {
	t := reflect.SliceOf(reflect.TypeOf(fi).In(0))
	return func(in []reflect.Value) (out []reflect.Value) {
		slice := in[0]
		sliceMap := m.FInplace(slice.Interface())
		for i := slice.Len()-1; i >= 0; i-- {
			sliceMap.Call(fi, i)
		}
		return append(out, reflect.ValueOf(sliceMap).Convert(t).Value())
	}
}

注意到for循环彼此无关，我们再把for/Handler提出来。


import "sync"

func mapSlice(handler Handler, l, r int, f interface{}) {
	for i := l; i < r; i++ {
		handler.Call(f, i)
	}
}

func MapSlice(handler Handler, l, r, coreCount int, f interface{}) Handler {
	step := (r - l + coreCount - 1) / coreCount
	if coreCount <= 1 || step <= 0 {
		mapSlice(handler, l, r, f)
	} else {
		var wg sync.WaitGroup
		wg.Add(coreCount)
		for i := l; i < r; i += step {
			go func(i int) {
				mapSlice(handler, i, min(i+step, r), f)
				wg.Done()
			}(i)
		}
		wg.Wait()
	}
	return handler
}

对Mapper略微修改

func (m Mapper) MapR(fi interface{}) functional.Function {
	if m.CoreCount == 0 {
		m.CoreCount = 1
	}
	t := reflect.SliceOf(reflect.TypeOf(fi).In(0))
	return func(in []reflect.Value) []reflect.Value {
		slice := in[0]
		in[0] = reflect.ValueOf(MapSlice(m.F(slice.Interface()),
			0, slice.Len(), m.CoreCount, fi)).Convert(t)
		return in
	}
}

func (m Mapper) MapRInplace(fi interface{}) functional.Function {
	if m.CoreCount == 0 {
		m.CoreCount = 1
	}
	t := reflect.SliceOf(reflect.TypeOf(fi).In(0))
	return func(in []reflect.Value) []reflect.Value {
		slice := in[0]
		in[0] = reflect.ValueOf(MapSlice(m.FInplace(slice.Interface()),
			0, slice.Len(), m.CoreCount, fi)).Convert(t)
		return in
	}
}

因为Mapper的特性被提出为MapperF，这时如果MapperF没有被初始化，将会导致错误。因此我们再做一个自动反向注入的Mapper类。

type MapperTraits struct {
	Mapper
	functional.BaseTraitsInterface
}

func NewMapperTraits(handler interface{}, options ...interface{}) MapperTraits {
	t := MapperTraits{
		BaseTraitsInterface: functional.NewBaseTraits(handler),
	}
	for i := range options {
		switch option := options[i].(type) {
		case int:
			t.CoreCount = option
		}
	}
	return t
}

func (m MapperTraits) F(sliceI interface{}) Handler {
	slice := reflect.ValueOf(sliceI)
	handler := reflect.MakeSlice(m.GetTypeInfo(), slice.Len(), slice.Cap())
	reflect.Copy(handler, slice)
	return handler.Interface().(Handler)
}

func (m MapperTraits) FInplace(slice interface{}) Handler {
	return reflect.ValueOf(slice).Convert(m.GetTypeInfo()).Interface().(Handler)
}

func (m MapperTraits) MapR(fi interface{}) functional.Function {
	if m.MapperF == nil {
		m.MapperF = m
	}
	return m.Mapper.MapR(fi)
}

func (m MapperTraits) Map(fi, fm interface{}) {
	functional.MakeFunc(m.MapR(fi), fm)
}

func (m MapperTraits) MapRInplace(fi interface{}) functional.Function {
	if m.MapperF == nil {
		m.MapperF = m
	}
	return m.Mapper.MapRInplace(fi)
}

func (m MapperTraits) MapInplace(fi, fm interface{}) {
	functional.MakeFunc(m.MapRInplace(fi), fm)
}

测试如下

func TestMap(t *testing.T) {
	var z func(i ...int) []int
	var i = []int{1, 2}

	var mapper = NewMapperTraits(IntHandler{})
	mapper.Map(add1, &z)
	i = z(i...)
	fmt.Println(i)

	var mapper2 = NewMapperTraits(IntHandler{}, 2)
	mapper2.Map(add1, &z)
	i = z(i...)
	fmt.Println(i)
}

func BenchmarkMapRaw(b *testing.B) {
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = mapF(add1, s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapRawInplace(b *testing.B) {
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = mapFInplace(add1, s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapper(b *testing.B) {
	var x func(i ...int) []int
	functional.MakeFunc(IntMapper{}.MapR(func(i int) int { return i + 1 }), &x)
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = x(s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapperTraits(b *testing.B) {
	var x func(i ...int) []int
	functional.MakeFunc(NewMapperTraits(IntHandler{}).MapR(func(i int) int { return i + 1 }), &x)
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = x(s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapperInplaceTraits(b *testing.B) {
	var x func(i ...int) []int
	functional.MakeFunc(NewMapperTraits(IntHandler{}).MapRInplace(func(i int) int { return i + 1 }), &x)
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = x(s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapperTraits8(b *testing.B) {
	var x func(i ...int) []int
	functional.MakeFunc(NewMapperTraits(IntHandler{}, 8).MapR(func(i int) int { return i + 1 }), &x)
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = x(s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapperInplaceTraits4(b *testing.B) {
	var x func(i ...int) []int
	functional.MakeFunc(NewMapperTraits(IntHandler{}, 4).MapRInplace(func(i int) int { return i + 1 }), &x)
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = x(s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapperInplaceTraits8(b *testing.B) {
	var x func(i ...int) []int
	functional.MakeFunc(NewMapperTraits(IntHandler{}, 8).MapRInplace(func(i int) int { return i + 1 }), &x)
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = x(s...)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapRaw4(b *testing.B) {
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = MapSlice(IntHandler(s), 0, factor, 4, func(a int) int { return a + 1 }).(IntHandler)
	}
	//fmt.Println("|", s[0], "|")
}

func BenchmarkMapRaw8(b *testing.B) {
	var s = make([]int, factor)
	for i := 0; i < b.N; i++ {
		s = MapSlice(IntHandler(s), 0, factor, 8, func(a int) int { return a + 1 }).(IntHandler)
	}
	//fmt.Println("|", s[0], "|")
}

=== RUN   TestMap
[2 3]
[3 4]
--- PASS: TestMap (0.00s)

goos: windows
goarch: amd64
pkg: github.com/Myriad-Dreamin/functional-go/mr
// 100000000
BenchmarkMapRaw-12                  	       3	 371668433 ns/op
BenchmarkMapRawInplace-12           	       5	 240799760 ns/op
BenchmarkMapper-12                  	       2	 628998950 ns/op
BenchmarkMapperTraits-12            	       2	 623999250 ns/op
BenchmarkMapperInplaceTraits-12     	       2	 513511500 ns/op
BenchmarkMapperTraits8-12           	       5	 281000660 ns/op
BenchmarkMapperInplaceTraits4-12    	      10	 158599680 ns/op
BenchmarkMapperInplaceTraits8-12    	      10	 126300010 ns/op
BenchmarkMapRaw4-12                 	      10	 147497270 ns/op
BenchmarkMapRaw8-12                 	      10	 126496710 ns/op

// 100000
BenchmarkMap-12                               50          24939844 ns/op
BenchmarkMapInplace-12                        50          24620058 ns/op

测试结果是非原地Mapper的耗时为0.028s/1e8次运算，与不适用此方法的Map几乎相同。不错，这样的map函数应该已经恰到好处了。

Conclusion

最终我们得到了什么。
如果对效率需求不高，那么可以使用Map直接生成Map函数。如果对效率的需求略高，只需要写一个Slice的配接器。在此例中，为：

type IntHandler []int

func (handler IntHandler) Call(f interface{}, index int) {
	handler[index] = f.(func(int) int)(handler[index])
}

如果你对效率的需求真的特别特别高，那么大可重新干回老本行，复制粘贴文本替换。。

func r(i ...int) []int {
	y := make([]int, len(i), cap(i))
	for j := range i {
		y[j] = i[j] + 1
	}
	return y
}

func rInplace(i ...int) []int {
	for j := range i {
		i[j] = i[j] + 1
	}
	return i
}

对于这个耦合度极高的Map函数而言，效率如下：

BenchmarkMapRaw-12                            10         166700110 ns/op
BenchmarkMapRawInplace-12                     20          85599920 ns/op

换来的只不过是要复制粘贴很多次，失去了封装的好处！

顺便说一下，在同等情况下c语言的运算力为0.6s/1e8次。果然是时代变了，大人。

Reduce篇

留作课后习题

Reference

所有的代码见github

Myriad_Dreamin
关注
专栏目录
Go语言学习笔记——Golang 1.18新特性泛型
qq_39280718的博客
09-09 3357
泛型的英文是Generics，就是函数的参数，或者容器元素的类型，支持更广泛的类型，不再是特定的类型。
golang泛型介绍
uxff的专栏
01-11 5564
go开发团队与2021.12.15将泛型发布在go1.18beta1版本中。本文将介绍如何在golang中使用泛型，以及golang泛型与其他语言(c++,java,c#)比较。golang泛型正式发布将于2022年2月的1.18版本与大家见面。
GoLang之泛型
weixin_52690231的博客
03-20 746
GoLang之泛型
【golang】泛型学习
huangfengnt的博客
09-04 1752
go泛型
golang Map Reduce Filter 业务和控制分离
qfzhangwei的专栏
07-27 333
package main import ( "fmt" "strings" ) func Filter(arr []int, fn func(n int) bool) []int { var newArray = []int{} for _, it := range arr { if fn(it) { newArray = append(newArray, it) } } return newArray } func Reduce(arr []string, fn func.
Golang并发工具库MapReduce简单实践
Avtionの秘密房间
06-02 1173
mapReduce可以有效提高并发编程效率
golang使用泛型实现mapreduce操作
xyz的博客
07-31 1267
缺点：golang有点挫的在于不能在方法里面返回新的泛型类型，比如从student返回一个int类型。虽然能通过在struct定义俩个类型 但是万一要生成第三种类型就无能为力了，不可能一直往后加类型吧（这会导致定义类型超级长 写起来超级丑）。优缺点：这种方式能搞将一种容器类型转化为另一种。缺点就是写过java的会吐血。2.通过函数的方式实现（简单举个例子）1.使用面向对象的方式写。
Golang 使用接口实现泛型的方法示例
09-19
**接口(interface)** 是 Go 语言中的一个核心特性，它定义了一组方法签名的集合，而具体实现这些方法的类型则可以是任何满足这些方法签名的对象。接口在 Go 语言中可以用于实现多态性，即不同的类型可以共享相同的...
Go-mapstructure-Go库用于解码泛型map值成Go结构体
03-09
`go-mapstructure`库的核心功能是它的`Decode`函数，它接受一个`map[string]interface{}`类型的值和一个目标结构体指针，然后尝试将映射中的键值对填充到结构体中。这使得我们可以轻松地将接收到的任意映射数据转换...
Golang中函数式编程，并发和泛型的代码生成-Golang开发
05-26
goderive goderive派生了您不想维护的普通golang函数，并使它们保持最新状态。...示例在下面的代码中，将发现generateEqual函数是未实现（或先前已推导）且具有前缀deriveEqual的函数。 包主要类型MyStru
Golang实现对map的并发读写的方法示例
01-03
在Golang多协程的情况下使用全局map时，如果不做线程同步，会出现panic的情况。 为了解决这个问题，通常有两种方式： 第一种是最常见的使用互斥锁或者读写锁的方法； 第二种是比较符合Golang特色的方法，启动单个协程对map进行读写，当其他协程需要读写map时，通过channel向这个协程发送信号即可。 写了一个模拟程序对map中的一项进行读或者写，后台一直运行的协程阻塞的接受读写信号，并对map进行操作，但是读操作的时候没想好怎么返回这个值。 后来想到用传引用的方式，定义结构体，第一个参数是读写的标志，第二个参数是读成功或者写成功后的值的channel，定义的channe
RestTemplate.postForObject泛型丢失返回LinkedHashMap问题解决
Keen to coding 的博客
08-25 7806
在使用RestTemplate.postForObject方法远程调用接口 返回的时候会自动转成LinkedHashMap，造成ClassCastException类型转换异常 /** * post * @param url 请求地址 * @param param 参数 * @param returnClass 返回类型 * @return ...
调用泛型对象方法List＜T＞并返回泛型结果Map ＜String，Object＞，参数为具体对象集合，根据不同对象类型进行不同操作
dmlcq的博客
09-08 1745
然后调用公共方法getChoosePlansMap()，公共方法可能是不同对象集合。到方法里再根据传入的对象类型，实现不同的处理逻辑。首先要对集合处理，取集合其中某几条的数据，业务方法getRequireMap()。遍历集合，获取参数的实例化对象desObj。最后对泛型map进行实例化转换操作。根据不同类型进行操作。
Go语言学习(四)常用类型介绍
mChenys的博客
03-26 4797
1.布尔类型var v1 bool v1 = true; v2 := (1==2) // v2也会被推导为bool类型 2.整型类 型 长度（字节） 值 范 围 int8 1  128 ~ 127 uint8（即byte）1 0 ~ 255 int16 2  32 768 ~ 32 767 uint16 2
MapStruct 1-- 多个类需要转换时，泛型接口使用方式及场景
RainStorm and RainBow
03-09 4641
多个类需要转换时，使用【内部类】继承BaseConvertor 泛型接口方便管理
Go map 如何实现“泛型”？
qfzhangwei的专栏
10-22 294
1 思考 go是没有泛型的语言，他是如何制止假泛型的呢？ 以上两个图，帮助大家理解
Go语言中的泛型
胡海龙
06-08 867
本文介绍了Go中泛型的基础知识。使用泛型，你可以声明和使用具有为调用代码提供的一组类型的函数或类型。在下面，我们将声明两个简单的非泛型函数，然后我们用一个泛型函数来实现相同的功能。
gomap支持泛型
最新发布
leijmdas的专栏
07-27 369
Range 方法用于遍历 MyMap 中的所有元素，它接受一个函数作为参数，该函数定义了如何处理每个键值对。此外，Go 语言的标准库 map 仍然是 Go 语言中处理键值对的首选方式，因为它经过了优化，并且在 Go 社区中得到了广泛的使用和测试。Go 语言的泛型是在 Go 1.18 版本中引入的，但标准库中的 map 类型并没有立即采用泛型。// 创建一个整数键和字符串值的 MyMap。// Range 遍历 MyMap 中的所有键值对。// MyMap 是一个泛型 map 结构体。
Golang泛型的使用
Ivan_n_的博客
07-07 329
Golang泛型使用
Goderive自动化派生Golang函数 实现函数式编程与泛型
它作为一个代码生成器，为Go语言社区提供了一个新颖的工具来扩展语言的功能，尽管这些功能并没有直接在语言中实现。 压缩包子文件的文件名称列表包含了"goderive-master"，这表明可能存在一个包含goderive工具主...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值