go语言的"泛型函数or模板函数"

最新推荐文章于 2025-07-14 17:17:00 发布
最新推荐文章于 2025-07-14 17:17:00 发布
阅读量5.4k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： golang 文章标签： golang go语言 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/easy_mind/article/details/52884974
本文介绍了一种在Golang中实现泛型功能的方法，通过使用interface{}

首先大家知道golang是没有JAVA的泛型函数或者C++的模板函数这种语法的，今天学到了一种很有用的类似泛型操作的语法，拿来和大家分享

以大家喜闻乐见的Add函数来说明，目的是来实现一个泛型的Add函数

先写了三个ADD函数

package main

import (
	"fmt"
)

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)
}

在把三个ADD函数统一起来前，先学习一个简单的Interface{}的用法，注意int,int32,int64在setvalue的泛型判断中是不同的类型
package main

import (
	"fmt"
)

func SetValue(ret interface{}) {
	switch data := ret.(type) {
	case *float32:
		*data = 3.14
	case *int:
		*data = 23333
	case *int32:
		*data = 32
	case *int64:
		*data = 64
	default:
		fmt.Println("unknow type")
	}
}

func main() {
	var a1 int
	var a2 int32
	var a3 float32
	var a4 int64
	SetValue(&a1)
	SetValue(&a2)
	SetValue(&a3)
	SetValue(&a4)
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3, "a4 =", a4)
}


相信到这里大部分同学都明白了，我们是要通过switch data:=input.(type)这样的类型判断来实现所谓的泛型，先按照最常规的
伪代码：Add(a,b){return a+b} 来实现
package main

import (
	"fmt"
)

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)

	b1 := GeneralAdd0(3, 5)
	switch data := b1.(type) {
	case int:
		fmt.Println("b1=", data)
	}
	b2 := GeneralAdd0(1.33, 6.82)
	switch data := b2.(type) {
	case float64:
		fmt.Println("b2=", data)
	}
	b3 := GeneralAdd0("hello ", "add0")
	switch data := b3.(type) {
	case string:
		fmt.Println("b3=", data)
	}
	fmt.Println("b1 =", b1, "b2 =", b2, "b3 =", b3)
}

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func GeneralAdd0(a, b interface{}) interface{} {
	switch data := b.(type) {
	case float32:
		switch ta := a.(type) {
		case float32:
			data = data + ta
			return data
		}
	case float64:
		switch ta := a.(type) {
		case float64:
			data = data + ta
			return data
		}
	case int:
		switch ta := a.(type) {
		case int:
			data = data + ta
			return data
		}
	case string:
		switch ta := a.(type) {
		case string:
			data = data + ta
			return data
		}
	default:
		fmt.Println("unknow type")
		return nil
	}

	return nil
}

ps:这里b2其实是个float64类型

也可以传指针
package main

import (
	"fmt"
)

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)

	b1 := GeneralAdd0(3, 5)
	switch data := b1.(type) {
	case int:
		fmt.Println("b1=", data)
	}
	b2 := GeneralAdd0(1.33, 6.82)
	switch data := b2.(type) {
	case float64:
		fmt.Println("b2=", data)
	}
	b3 := GeneralAdd0("hello ", "add0")
	switch data := b3.(type) {
	case string:
		fmt.Println("b3=", data)
	}
	fmt.Println("b1 =", b1, "b2 =", b2, "b3 =", b3)

	var c1, cret1 int = 10, 42
	GeneralAdd1(&c1, &cret1)
	var c2, cret2 float32 = 5.11, 6.22
	GeneralAdd1(&c2, &cret2)
	var c3, cret3 string = "add1", "I am "
	GeneralAdd1(&c3, &cret3)
	fmt.Println("cret1 =", cret1, "cret2 =", cret2, "cret3 =", cret3)
}

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func GeneralAdd0(a, b interface{}) interface{} {
	switch data := b.(type) {
	case float32:
		switch ta := a.(type) {
		case float32:
			data = data + ta
			return data
		}
	case float64:
		switch ta := a.(type) {
		case float64:
			data = data + ta
			return data
		}
	case int:
		switch ta := a.(type) {
		case int:
			data = data + ta
			return data
		}
	case string:
		switch ta := a.(type) {
		case string:
			data = data + ta
			return data
		}
	default:
		fmt.Println("unknow type")
		return nil
	}

	return nil
}

func GeneralAdd1(a, ret interface{}) {
	switch data := ret.(type) {
	case *float32:
		switch ta := a.(type) {
		case *float32:
			*data = *data + *ta
		}
	case *int:
		switch ta := a.(type) {
		case *int:
			*data = *data + *ta
		}
	case *string:
		switch ta := a.(type) {
		case *string:
			*data = *data + *ta
		}
	default:
		fmt.Println("unknow type")
	}
}

看到这里有没有想到一个问题，如果我的add函数是 伪代码：add(a,b,c){return a+b+c}，难道我要switch case嵌套3次？这样的代码看着也太难受了
因此自定义的数据类型也是可以判断的哦

package main

import (
	"fmt"
)

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)

	b1 := GeneralAdd0(3, 5)
	switch data := b1.(type) {
	case int:
		fmt.Println("b1=", data)
	}
	b2 := GeneralAdd0(1.33, 6.82)
	switch data := b2.(type) {
	case float64:
		fmt.Println("b2=", data)
	}
	b3 := GeneralAdd0("hello ", "add0")
	switch data := b3.(type) {
	case string:
		fmt.Println("b3=", data)
	}
	fmt.Println("b1 =", b1, "b2 =", b2, "b3 =", b3)

	var c1, cret1 int = 10, 42
	GeneralAdd1(&c1, &cret1)
	var c2, cret2 float32 = 5.11, 6.22
	GeneralAdd1(&c2, &cret2)
	var c3, cret3 string = "add1", "I am "
	GeneralAdd1(&c3, &cret3)
	fmt.Println("cret1 =", cret1, "cret2 =", cret2, "cret3 =", cret3)

	d1 := IntStruct{a: 9, b: 45, ret: 0}
	GeneralAdd2(&d1)
	d2 := Float32Struct{a: 4.77, b: 7.99, ret: 0.0}
	GeneralAdd2(&d2)
	d3 := StringStruct{a: "I am", b: "stringstruct", ret: ""}
	GeneralAdd2(&d3)
	fmt.Println("d1 =", d1.ret, "d2 =", d2.ret, "d3 =", d3.ret)
}

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func GeneralAdd0(a, b interface{}) interface{} {
	switch data := b.(type) {
	case float32:
		switch ta := a.(type) {
		case float32:
			data = data + ta
			return data
		}
	case float64:
		switch ta := a.(type) {
		case float64:
			data = data + ta
			return data
		}
	case int:
		switch ta := a.(type) {
		case int:
			data = data + ta
			return data
		}
	case string:
		switch ta := a.(type) {
		case string:
			data = data + ta
			return data
		}
	default:
		fmt.Println("unknow type")
		return nil
	}

	return nil
}

func GeneralAdd1(a, ret interface{}) {
	switch data := ret.(type) {
	case *float32:
		switch ta := a.(type) {
		case *float32:
			*data = *data + *ta
		}
	case *int:
		switch ta := a.(type) {
		case *int:
			*data = *data + *ta
		}
	case *string:
		switch ta := a.(type) {
		case *string:
			*data = *data + *ta
		}
	default:
		fmt.Println("unknow type")
	}
}

type Float32Struct struct {
	a   float32
	b   float32
	ret float32
}

type IntStruct struct {
	a   int
	b   int
	ret int
}

type StringStruct struct {
	a   string
	b   string
	ret string
}

func GeneralAdd2(ret interface{}) {
	switch data := ret.(type) {
	case *Float32Struct:
		data.ret = data.a + data.b
	case *IntStruct:
		data.ret = data.a + data.b
	case *StringStruct:
		data.ret = data.a + data.b
	default:
		fmt.Println("unknow type")
	}
}
通过自定义IntStruct, Float32Struct, StringStruct这结构体来实现，这样的代码看着就舒服多了

81、Go语言中的接口与泛型详解
06-20 52
本文详细介绍了Go语言中的核心概念，包括接口、泛型、类型系统、并发编程、结构体以及错误处理等主题。通过代码示例和深入解析，帮助开发者更好地理解和掌握Go语言的特性与应用。
从API到服务：使用Go语言构建Web应用程序的流程和最佳实践
AI天才研究院
07-20 5008
作者：禅与计算机程序设计艺术 在现代互联网时代，开发者不仅要处理前端界面设计、后端业务逻辑开发，还需要将其打包成一个产品供用户使用。为了实现这一目标，许多公司开发出了“云服务”，并通过接口调用的方式提供不同的服务。这其中最著名的就是“RESTful API”。云服务主要基于HTTP协议，采用REST风格定义接口，因此也称为RESTful
go语言基础之泛型
liu289747235的专栏
01-28 4021
当我们编写的是操作 Go 语言定义的特殊容器类型（slice、map和chennel）的函数。如果函数具有包含这些类型的参数，并且函数的代码并不关心元素的类型，那么使用类型参数可能是有用的。例如：返回任何类型map中所有的key// MapKeys 返回m中所有key组成的切片return s。
golang 基础 泛型编程
呵呵哒!的博客
07-18 1067
（一） 示例1这段代码展示了如何使用 Go 语言中的泛型、结构体和通道进行数据处理和打印。导入fmt包用于格式化输入输出userIDNameAgeaddressIDProvinceCitympkTchmapToList6.ListMapTTTypeCaseMapTList。
Go泛型完全指南：从基础到实战应用
最新发布
2301_80152021的博客
07-14 485
Go泛型实战指南：从基础到数据结构实现 本文全面介绍Go 1.18引入的泛型特性，包括核心概念、设计原理和实际应用。主要内容： 泛型基础：通过类型参数化实现代码复用，避免为不同类型重复编写逻辑 设计实现：Go采用Gcshape stenciling方案，平衡编译速度和运行性能 语法详解： 泛型函数（如Sum[T int|float64]） 泛型结构体和接口 类型集运算（并集、交集、底层类型约束） 使用限制：基础类型、匿名结构体/函数、类型操作等限制条件 实战案例： 实现泛型队列（支持任意类型） 构建泛型堆（
深入浅出 Go 语言：泛型编程
软件架构师笔记
12-08 1193
泛型是一种编程机制，允许你在编写代码时使用占位符（称为类型参数）来表示未知的类型。编译器会在编译时根据具体的类型参数推导出实际的类型，并生成相应的代码。这样，你就可以编写一个函数或数据结构，使其能够处理多种不同的类型，而不需要为每种类型都编写单独的实现。func 函数名[类型参数列表](参数列表) 返回值 {// 函数体其中，类型参数列表是一个方括号内的逗号分隔的类型参数列表，每个类型参数可以用type关键字显式声明。参数列表和返回值与普通函数相同。除了使用内置约束外，你还可以定义自己的类型约束。
【golang】泛型学习
huangfengnt的博客
09-04 2053
go泛型
golang泛型
热门推荐
weixin_44961320的博客
06-15 1万+
1.18go泛型
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
01-21
算法由模板函数体现,这些函数不是容器类的成员函数，是独立的函数,它们可以用于STL容器,也可以用于普通的C++数组等. 头文件：#include 在STL的泛型算法中有4类基本的算法： 1)变序型队列算法: 可以改变容器内的数据...
Go编程语言评估报告
尹成的技术博客
05-21 1290
 Go编程语言评估报告 1. Go简介 Go是由Google于2007年9月21日开始开发，2009年11月10日开放源码，2012年3月28日推出第一个正式版本的通用型编程语言。它为系统编程而7设计，是强类型化的语言，具有垃圾回收机制，并显式支持并发编程。Go程序由包构造，以此来提供高效的依赖管理功能。当前的编译器实现使用传统的“编译-链接”模型来生成可执行的二进制文件。十年以来，主流的系统级编...
Go语言接口与多态的完美结合：高级教程与案例分析
Go语言的接口是一种抽象类型，它定义了一组方法（method），这些方法可以被其他任何类型实现。在Go中，接口是类型系统的核心部分，它允许我们定义一些动作的规范，而不关心谁来实现这些动作。接口是完全由用户定义的...
golang中使用泛型
猛犸象
04-21 7496
泛型支持 go >= 1.18 为什么需要泛型 编写一个函数用来比较两个数的大小，对于golang这种强类型的语言，要么针对不同的类型分别实现一遍，要么使用 interface{} 类型。 func CompareInt64(a, b int64) bool { if a >= b { return true } else { return false } } func CompareFloat64(a, b float64) bool { if a >= b { r
Go泛型详解
清风的博客
07-11 1502
官网文档：https://go.dev/blog/intro-generics。
golang 泛型编程
冷月醉雪的博客
02-23 1146
    众所周知，Golang中不支持类似C++/Java中的标记式泛型，所以对于常用算法，比如冒泡排序算法，有些同学容易写出逻辑上重复的代码，即整型是第一套代码，字符串型是第二套代码，用户自定义类型是第三套代码。     重复是万恶之源，我们当然不能容忍，所以要消除重复，使得代码保持在最佳的状态。本文通过一个实际使用的简单算法的演进过程，初次体验了Golang的泛型编程，消除了重复代码，非常自...
Golang 泛型详解
07-25 2760
/ 自定义一个新类型 MapTT：类型形参。定义 MapT 时 T 代表的类型并不确定，类似一个占位符。：类型约束。指定 T 仅可接受哪些类型。中括号内定义形参类型，称为形参类型列表。其中，类型约束可以包上 interface{}m[T] = valreturn m// 或简写为type T interface{int|int32|float32|string} // 自定义类型约束。
Go语言学习——泛型
jiajixi的博客
05-25 978
基础类型不能只有类型形参// 错误，类型形参不能单独使用。
GO - 泛型编程
qq_45887694的博客
04-07 2191
类型参数列表使用方括号括起来，并在其中声明一个或多个类型参数。
Golang 1.x版本泛型编程
weixin_34026276的博客
04-23 328
Go是一门天生为服务器程序设计的简洁的语言，因此Go的设计原则聚焦在可扩展性、可读性和并发性，而多态性并不是这门语言的设计初衷，因此就被放在了一边。虽然在2.0版本之前还没有泛型的支持，但是Go自带的一些语言特性可以满足一些类似“泛型”的要求，比如内置类型：arrayslicemapchan这四种类型可以用任意类型的元素初始化，例如map[yourtype]bool就可以用来实现任意元素的集合。G...
【Go】泛型
陈戏猿
12-09 2381
Go1.17引入了泛型的特性，1.18正式开放泛型，本文介绍了Go语言泛型的基本语法，使用示例，以及简要的实现原理，帮助你了解Go的泛型。
go语言泛型声明，类型约束，泛型函数与结构体
02-18
### Go语言中的泛型 #### 泛型的声明方式 自Go 1.18版本起，Go语言正式引入了对泛型的支持。这使得开发者能够编写更加灵活和可重用的代码[^1]。 对于函数而言，在其名称后的方括号内指定类型参数列表即可实现泛型化： ```go func Name[T any](param T) { // function body } ``` 这里`T`代表了一个占位符类型的标识符，而`any`则表示该类型可以接受任何种类的数据输入。当然也可以采用更具体的约束条件来替代`any`关键字。 当涉及到结构体时，则是在定义struct的时候加入类型参数部分: ```go type Stack[T any] struct { elements []T } func (s *Stack[T]) Push(v T){ s.elements = append(s.elements, v) } func (s *Stack[T]) Pop()(v T, ok bool){ if len(s.elements)==0{ return nil,false }else{ v=s.elements[len(s.elements)-1] s.elements=s.elements[:len(s.elements)-1] return v,true } } ``` 上述例子展示了如何创建一个名为`Stack`的栈数据结构，并为其提供了基本的操作方法——压入(`Push`)与弹出(`Pop`)元素的功能。 #### 类型约束的应用 为了使泛型具有更强的表现力并能更好地适应实际应用场景的需求，可以通过对接口施加一定的限制来进行类型约束。具体来说就是在声明泛型时利用接口的形式给出一组特定的方法集合作为限定条件，只有满足这些条件的对象才能被当作合法的类型参数传入。 例如下面这段代码就展示了一种基于标准库中`fmt.Stringer`接口所构建出来的字符串转换工具`Stringify`，它只接收实现了`String()`方法的对象数组作为输入参数[^2]: ```go package main import ( "fmt" ) func Stringify[T fmt.Stringer](s []T) (ret []string) { for _, v := range s { ret = append(ret, v.String()) } return ret } type MyString string func (s MyString) String() string { return string(s) } func main() { sl := Stringify([]MyString{"I", "love", "golang"}) fmt.Println(sl) // 输出：[I love golang] } ``` 另外一种常见的做法就是通过组合多个基础类型形成复合性的约束规则，如下所示的例子中定义了一个叫做`mixType`的新接口，它可以容纳浮点数或整数值之间的运算操作[^3]: ```go type mixType interface { float32 | int | float64 } func add[T mixType](a, b T) T { c := a + b return c } ``` 这种形式不仅简化了代码书写过程还提高了程序逻辑上的清晰度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值