大家好，我是Coder哥，最近在用Go語言寫項目，也在用泛型解決一些問題，但是也發(fā)現(xiàn)了一些問題，今天我們就來聊聊Go語言中泛型函數(shù)和泛型方法。

起因是這樣的，作為java開發(fā)，發(fā)現(xiàn)Go沒有類似于java8 stream一樣的流處理框架，導致有些邏輯一行能實現(xiàn)的卻要寫好多行來解決，剛好Go語言也出了泛型，想著用泛型來寫應該能和stream一個效果，于是就有了Go-Stream 這個項目，在寫Go Stream和用的時候發(fā)現(xiàn)了一個關于Golang泛型的一個很有意思的問題，想著拿出來聊一下。咱還是循序漸進的展開分析：

1. go-stream框架的簡介
2. 發(fā)現(xiàn)問題的過程。
3. Go泛型為什么不支持泛型方法?
4. go-stream框架是怎么解決這個問題的。

go-stream簡介

Go-Stream實現(xiàn)了 java8 stream框架常用的操作，包括 過濾(Filter)，轉(zhuǎn)換一對一(Map), 轉(zhuǎn)換一對多(FlatMap)，轉(zhuǎn)Map(toMap), 聚合(Reduce)，數(shù)據(jù)統(tǒng)計(Statistic), 分組(GroupingBy)已經(jīng)分組后對各組排序 等功能，基本滿足99%的開發(fā)需求。

【Go-Stream】用Go 泛型實現(xiàn)了個 Java-Stream流處理框架

Go-stream代碼地址：https://github.com/todocoder/go-stream

使用可參閱測試類：https://github.com/todocoder/go-stream/blob/master/stream/stream_test.go

require github.com/todocoder/go-stream v1.1.0

圖片

發(fā)現(xiàn)問題

科普一下：

方法：是一個代碼塊,由與對象關聯(lián)的名稱調(diào)用。

函數(shù)：函數(shù)是按名稱調(diào)用的代碼，不需要與對象關聯(lián)。

寫完第一版，基本上能實現(xiàn)一堆花里胡哨的鏈式調(diào)用，看起來也很絲滑，比如我想對一個切片做一系列操作，最后得出結果，代碼如下：

func TestStream(t *testing.T) {
  items := []TestItem{
      {itemNum: 7, itemValue: "item7"},{itemNum: 6, itemValue: "item6"},
      {itemNum: 1, itemValue: "item1"},{itemNum: 2, itemValue: "item2"},
      {itemNum: 3, itemValue: "item3"},{itemNum: 4, itemValue: "item4"},
      {itemNum: 5, itemValue: "item5"},{itemNum: 5, itemValue: "item5"},
      {itemNum: 5, itemValue: "item5"},{itemNum: 8, itemValue: "item8"},
    }
    res := Of(items...).Filter(func(item TestItem) bool {
      // 過濾掉1的值
      return item.itemNum != 4
    }).Distinct(func(item TestItem) any {
      // 按itemNum 去重
      return item.itemNum
    }).Sorted(func(a, b TestItem) bool {
      // 按itemNum升序排序
      return a.itemNum < b.itemNum
    }).Skip(1).Limit(6).Reverse().ToSlice()
    fmt.Println(res)
}

1. 使用Filter過濾掉1的值
2. 通過Distinct對itemNum 去重(在第1步的基礎上，下面同理在上一步的基礎上)
3. 通過Sorted 按itemNum升序排序
4. 用Skip 從下標為1的元素開始
5. 使用Limit截取排在前6位的元素
6. 使用Reverse 對流中元素進行返轉(zhuǎn)操作
7. 使用collect終止操作將最終處理后的數(shù)據(jù)收集到Slice中

看到上面的流程作為一個多年的Javer感覺如此絲滑堪稱完美，輸出的結果也是原來的類型TestItem。

但是我們用stream處理問題僅僅是因為一些簡單的單一類型的場景么，那肯定不是了，有人說我想通過這個實現(xiàn)一些類型轉(zhuǎn)換，或者分組，再對各個組的列表按某個字段排列，比如如下的問題：

班級有一組學號{1,2,3,....,12}，對應12個人的信息在內(nèi)存里面存著

type Student struct {
 Num   int
 Score int
 Age   int
 Name  string
}
studentMap := map[int]Student{
  1: {Num: 1, Name: "小明", Score: 3, Age: 26},
  2: {Num: 2, Name: "小紅", Score: 4, Age: 27},
  3: {Num: 3, Name: "小李", Score: 5, Age: 24},
  4: {Num: 4, Name: "老王", Score: 1, Age: 23},
  5: {Num: 5, Name: "小王", Score: 2, Age: 24},
  6: {Num: 6, Name: "小綠", Score: 2, Age: 24},
  7: {Num: 7, Name: "小藍", Score: 3, Age: 29},
  8: {Num: 8, Name: "小橙", Score: 3, Age: 30},
  9: {Num: 9, Name: "小黃", Score: 4, Age: 29},
  10: {Num: 10, Name: "小黑", Score: 5, Age: 15},
  11: {Num: 11, Name: "小紫", Score: 3, Age: 15},
  12: {Num: 12, Name: "小劉", Score: 2, Age: 15},
}

我想把這學號轉(zhuǎn)換成具體的**Student** 類，然后過濾掉**Score**為 1的，并且再按評分 Score分組，最后對分好后的各組按照Age 降序排列，按最初v1.0.*版本的代碼是這樣的：

// v1.0.* 的代碼這樣實現(xiàn)
res := Of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).Map(func(n int) any {
  return studentMap[n]
 }).Filter(func(s any) bool {
  // 這里需要強轉(zhuǎn)
  tempS := s.(Student)
  // 過濾掉1的
  return tempS.Score != 1
 }).Collect(collectors.GroupingBy(func(t any) int {
  return t.(Student).Score
 }, func(t any) any {
  return t
 }, func(t1 []any) {
  sort.Slice(t1, func(i, j int) bool {
   return t1[i].(Student).Age < t1[j].(Student).Age
  })
 }))
 println(res)

上面這個代碼有個問題是 經(jīng)過Map轉(zhuǎn)換后會丟失類型需要用 any 接收，在用的時候需要強轉(zhuǎn)成目標類型，并且最后得到res 的結果是 any類型的，用的時候也需要轉(zhuǎn)換成目標類型，這樣用起來非常麻煩，但是如果按這樣的流式處理，這個問題不能避免。因為官方明確說明，目前Go語言不支持泛型方法

如果支持泛型方法，按找目前的編譯機制，可能需要修改編譯器而且會比較復雜

為什么Go泛型不好實現(xiàn)泛型方法?

有興趣的可以查看官方說明：https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md#no-parameterized-methods

如果支持泛型方法，考慮下面一個例子，一共有四個package:

package p1
// S 是一個普通的struct,但是包含一個泛型方法Identity.
type S struct{}
// Identity 一個泛型方法，支持任意類型.
func (S) Identity[T any](v T) T { return v }

package p2
// HasIdentity 定義了一個接口，支持任意實現(xiàn)了泛型方法Identity的類型.
type HasIdentity interface {
 Identity[T any](T) T
}

package p3
import "p2"
// CheckIdentity 是一個普通函數(shù)，檢查實參是不是實現(xiàn)了HasIdentity接口，如果是，則調(diào)用這個接口的泛型方法Identity.
func CheckIdentity(v interface{}) {
 if vi, ok := v.(p2.HasIdentity); ok {
  if got := vi.Identity[int](0); got != 0 {
   panic(got)
  }
 }
}

package p4
import (
 "p1"
 "p3"
)
// CheckSIdentity 傳參S給CheckIdentity.
func CheckSIdentity() {
 p3.CheckIdentity(p1.S{})
}

作為一個多年用Java的人，一切看起來都沒有問題，但是問題是package p3不知道p1.S類型，整個程序中如果也沒有其它地方調(diào)用p1.S.Identity,依照現(xiàn)在的Go編譯器的實現(xiàn)，是沒有辦法為p1.S.Identity[int]生成對應的代碼的。

是的，如果go編譯器做的比較復雜，在編譯的時候這個場景是可以識別出來的，但是它需要遍歷整體的程序調(diào)用鏈以便生成全部可能的泛型方法，對編譯時間和編譯器復雜性帶來很大的調(diào)整。另外一點，如果代碼中通過反射調(diào)用的話，編譯器可能會遺漏一些泛型方法的實現(xiàn)，這就很要命了。

如果在運行時實現(xiàn)呢？就需要JIT或者反射等技術，這會造成運行時性能的下降。

很難實現(xiàn)啊？如果規(guī)定泛型方法不能實現(xiàn)接口呢？那么這類的泛型方法的存在的意義是什么呢？

所以目前沒有太好的手段去實現(xiàn)泛型方法，暫時擱置了。

期待后面的版本加上。

問題是發(fā)現(xiàn)，但是要怎么解決這個問題呢，就是我想直接輸出可用的類型，而不是any,因為它用起來實在是太麻煩了

go-stream框架是怎么處理這樣的場景的呢

之前用過python 的 groupby 和map, python是這么做的

student_group = groupby(stus, key=lambda s: s['score'])

它是把數(shù)組作為groupby的方法傳過去，后面是我們的操作，那我們是不是也可以用類似這樣的方式來實現(xiàn)呢？剛好Go語言支持泛型函數(shù)，就開搞，于是就有了Go-Stream v1.1.0版了，加了幾個泛型轉(zhuǎn)換函數(shù)，API如下：

轉(zhuǎn)換函數(shù)

通過這幾個函數(shù)你可以實現(xiàn)類型轉(zhuǎn)換，分組，flatmap 等處理。

注意：這幾個函數(shù)非常有用，也是最常用的，由于Go語言泛型的局限性，Go語言方法不支持自己獨立的泛型，所以導致用Stream中的方法轉(zhuǎn)換只能用 interface{} 代替，這樣會有個非常麻煩的問題就是，轉(zhuǎn)換后用的時候必須得強轉(zhuǎn)才能用，所以我把這些寫成轉(zhuǎn)換函數(shù)，就不會受制于類(struct) 的泛型了。

通過這幾個函數(shù)實現(xiàn)上面的分組轉(zhuǎn)換功能要怎么操作呢？

V1.1.0 版本的實現(xiàn)

// v1.1.* 的代碼這樣實現(xiàn)
res := GroupingBy(Map(Of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), func(n int) Student {
  // 注意 這里的返回類型可以是目標類型了
  return studentMap[n]
 }).Filter(func(s Student) bool {
  // 這里過濾也不需要轉(zhuǎn)換類型
  // 過濾掉1的
  return s.Score != 1
 }), func(t Student) int {
   // key
  return t.Score
 }, func(t Student) Student {
    // v item
  return t
 }, func(t1 []Student) {
  // 按年齡降序排列
  sort.Slice(t1, func(i, j int) bool {
   return t1[i].Age > t1[j].Age
  })
 })
 println(res)

圖片

可以看到，中間處理的時候不用轉(zhuǎn)換，結果也都是強類似的。

res 類型：map[int] []Student  返回值的類型我們可以直接用不用轉(zhuǎn)換。

雖然我們不能流式的處理不同的類型，好在用泛型函數(shù)也能解決，期待官方后續(xù)的版本支持泛型方法，stream處理列表真的非常絲滑，用過的都說好。。哈哈哈。。。

最后

作為一個Java開發(fā)，用習慣了Stream操作，在網(wǎng)上也沒找到合適的輕量的stream框架，也不知道后續(xù)官方是否會出，在這之前，就只能先自己實現(xiàn)了，后面遇到復雜的處理流程會持續(xù)的更新到上面除了除了倉庫首頁README里面的功能，還有并行流處理，數(shù)據(jù)的統(tǒng)計，支持各種分組，轉(zhuǎn)換等等，有興趣可以自行查看體驗測試類:stream_test

有什么問題可以在github上提issues 留言或者公號搜：todocoder，看到后第一時間回復，感謝大家的支持！