golang 范型编程初学

写了一个批次执行函数的功能，采用范型，直接上代码

batch实现代码：

package utils

import (
	"time"
)

type batch[T any] struct {
	Array    []T
	Func     func(array []T)
	Count    int
	Interval float32
}

func (b *batch[T]) do() {
	arrayArray := b.sliceFun(b.Array, b.Count)
	for _, array := range arrayArray {
		b.Func(array)
		time.Sleep(time.Second * time.Duration(b.Interval))
	}
}

func (b *batch[T]) sliceFun(array []T, Count int) [][]T {
	if len(array) <= Count {
		return [][]T{array}
	}

	var arrayArray [][]T
	leftArray := array
	for len(leftArray) > 0 {
		if len(leftArray) > Count {
			arrayArray = append(arrayArray, leftArray[0:Count])
			leftArray = leftArray[Count:]
		} else {
			arrayArray = append(arrayArray, leftArray)
			leftArray = make([]T, 0)
		}
	}
	return arrayArray
}

type BatchOption[T any] func(*batch[T])

func SetBatchCount[T any](count int) BatchOption[T] {
	return func(b *batch[T]) {
		b.Count = count
	}
}

func SetBatchInterval[T any](interval float32) BatchOption[T] {
	return func(b *batch[T]) {
		b.Interval = interval
	}
}

func Batch[T any](
	Array []T,
	Func func(array []T),
	options ...BatchOption[T]) {

	b := &batch[T]{Array: Array, Func: Func}
	for _, o := range options {
		o(b)
	}

	if b.Count == 0 {
		b.Count = 500
	}
	if b.Interval == 0 {
		b.Interval = 0.1
	}

	b.do()
}

batch的调用方法是这样的：

	utils.Batch(adds, func(array []*authInterface.FactoryUser) {
		fmt.Printf("authUsers::OwnAllFactory batch: num:%d \n", len(array))
		addRes := (&authInterface.AddFactoryUserReq{
			Client: p.ErpClient,
			Array:  adds}).Request()
		if addRes.Code != web.SuccessJsonRes.Code {
			panic("error")
		}
	})

范型编程需要定义类型，直接any是没有范型的，曾经是这么以为。

红色的是类型参数范型函数的定义是采用中括号来定义：func Batch[T any](Array []T）

如果这样定义：func Batch(Array []any），那么仅仅是把any替换了interface{},填参数的时候需要转换，不然会提示类型不匹配

范型调用的时候不需要特殊处理，直接传参数就行。