Golang学习笔记_24——泛型

最新推荐文章于 2025-04-12 19:55:32 发布
最新推荐文章于 2025-04-12 19:55:32 发布
阅读量817 收藏 9
点赞数 12
分类专栏： Golang学习笔记 文章标签： golang 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LuckyLay/article/details/145137075
版权

Golang学习笔记_21——Reader
Golang学习笔记_22——Reader示例
Golang学习笔记_23——error补充

文章目录

泛型

Go语言从1.18版本开始引入了泛型，这是Go语言的一个重要特性，它允许函数、类型和接口在定义时不必绑定到特定的类型上，而是可以在后续使用时再指定具体的类型。这极大地增强了代码的复用性和灵活性。

1. 泛型中的类型参数

类型参数是泛型函数、泛型类型和泛型接口定义中声明的占位符，它们用于表示在泛型实例化时可以指定的具体类型。

1.1 类型参数声明

在泛型定义中，类型参数通过方括号[]中的类型参数列表进行声明。

func Print[T any](x T) {...}
type Pair[T, U any] struct {...}
type Describer[T any] interface {...}
1.2 类型参数的约束

类型参数可以受到约束，这意味着它们必须满足特定的接口。这通过类型约束来实现。

// Generics type constraints
type Number interface {
	int | int64 | float64 // 使用联合类型表示约束
}

func Sum[T Number](nums []T) T {
	var sum T
	for _, num := range nums {
		sum += num
	}
	return sum
}

测试方法

func TestSum(t *testing.T) {

	type args[T Number] struct {
		nums []T
	}
	type testCase[T Number] struct {
		name string
		args args[T]
		want T
	}
	intTests := []testCase[int]{
		{
			name: "int add",
			args: args[int]{
				nums: []int{1, 2, 3},
			},
			want: 6,
		},
	}

	floatTests := []testCase[float64]{
		{
			name: "float add",
			args: args[float64]{
				nums: []float64{1.1, 2.2, 3.3},
			},
			want: 6.6,
		},
	}

	strTests := []testCase[string]{
		{
			name: "string add",
			args: args[string]{
				nums: []string{"1", "2", "3"},
			},
			want: "123",
		},
	}
	for _, tt := range strTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Sum(tt.args.nums); got != tt.want {
				t.Errorf("Sum() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range intTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Sum(tt.args.nums); got != tt.want {
				t.Errorf("Sum() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range floatTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Sum(tt.args.nums); got != tt.want {
				t.Errorf("Sum() = %v, want %v", got, tt.want)
			}
		})
	}

}

输出结果

strTests 测试结果
# Golang/generics_demo [Golang/generics_demo.test]
./generics_demo_test.go:37:25: string does not satisfy Number (string missing in int | int64 | float64)
./generics_demo_test.go:40:15: string does not satisfy Number (string missing in int | int64 | float64)
./generics_demo_test.go:48:17: string does not satisfy Number (string missing in int | int64 | float64)

intTests floatTests 测试结果
=== RUN   TestSum
=== RUN   TestSum/int_add
=== RUN   TestSum/float_add
--- PASS: TestSum (0.00s)
    --- PASS: TestSum/int_add (0.00s)
    --- PASS: TestSum/float_add (0.00s)
PASS
1.3 类型参数的实例化

在调用泛型函数、创建泛型类型的实例或赋值给泛型接口时，类型参数会被具体化（实例化）。这可以显式地通过类型参数列表进行，也可以由编译器自动推断。

Print[int](42)           // 显式指定T为int类型
Print(3.14)              // 编译器自动推断T为float64类型
var p Pair[int, string]  // 显式指定T为int，U为string类型

2. 泛型函数

泛型函数允许在函数签名中声明类型参数，这些参数将在函数调用时具体化。

func genericFuncDemo[T any](value T) {
	fmt.Println(value)
}

func testGenericFuncDemo() {
	genericFuncDemo(1)
	genericFuncDemo("hello")
	genericFuncDemo(1.1)
}

测试方法

=== RUN   Test_testGenericFuncDemo
1
hello
1.1
--- PASS: Test_testGenericFuncDemo (0.00s)
PASS

3. 泛型类型

type Pair[T, U any] struct {
	First  T
	Second U
}

func PairDemo() {
	pair := Pair[int, string]{First: 10, Second: "hello"}
	fmt.Println(pair.First, pair.Second)
}

测试方法

func TestPairDemo(t *testing.T) {
	PairDemo()
}

输出结果

=== RUN   TestPairDemo
10 hello
--- PASS: TestPairDemo (0.00s)
PASS

4. 泛型接口

// generics interface
type Describer[T any] interface {
	Describe(T) string
}

type IntDescriber struct {
}

func (num IntDescriber) Describe(i int) string {
	return fmt.Sprintf("类型是：%d", i)
}

func DescribeDemo() {
	var test Describer[int]
	test = IntDescriber{}
	fmt.Println(test.Describe(100))
}

测试方法

func TestDescribeDemo(t *testing.T) {
	DescribeDemo()
}

输出结果

=== RUN   TestDescribeDemo
类型是：100
--- PASS: TestDescribeDemo (0.00s)
PASS

源码

// generics_demo.go 文件
package generics_demo

import "fmt"

// Generics type constraints
type Number interface {
	int | int64 | float64 // 使用联合类型表示约束
}

func Sum[T Number](nums []T) T {
	var sum T
	for _, num := range nums {
		sum += num
	}
	return sum
}

func genericFuncDemo[T any](value T) {
	fmt.Println(value)
}

func testGenericFuncDemo() {
	genericFuncDemo(1)
	genericFuncDemo("hello")
	genericFuncDemo(1.1)
}

type Pair[T, U any] struct {
	First  T
	Second U
}

func PairDemo() {
	pair := Pair[int, string]{First: 10, Second: "hello"}
	fmt.Println(pair.First, pair.Second)
}

// generics interface
type Describer[T any] interface {
	Describe(T) string
}

type IntDescriber struct {
}

func (num IntDescriber) Describe(i int) string {
	return fmt.Sprintf("类型是：%d", i)
}

func DescribeDemo() {
	var test Describer[int]
	test = IntDescriber{}
	fmt.Println(test.Describe(100))
}

// generics_demo_test.go 文件
package generics_demo

import (
	"testing"
)

func TestSum(t *testing.T) {

	type args[T Number] struct {
		nums []T
	}
	type testCase[T Number] struct {
		name string
		args args[T]
		want T
	}
	intTests := []testCase[int]{
		{
			name: "int add",
			args: args[int]{
				nums: []int{1, 2, 3},
			},
			want: 6,
		},
	}

	floatTests := []testCase[float64]{
		{
			name: "float add",
			args: args[float64]{
				nums: []float64{1.1, 2.2, 3.3},
			},
			want: 6.6,
		},
	}

	//strTests := []testCase[string]{
	//	{
	//		name: "string add",
	//		args: args[string]{
	//			nums: []string{"1", "2", "3"},
	//		},
	//		want: "123",
	//	},
	//}
	//for _, tt := range strTests {
	//	t.Run(tt.name, func(t *testing.T) {
	//		if got := Sum(tt.args.nums); got != tt.want {
	//			t.Errorf("Sum() = %v, want %v", got, tt.want)
	//		}
	//	})
	//}

	for _, tt := range intTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Sum(tt.args.nums); got != tt.want {
				t.Errorf("Sum() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range floatTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Sum(tt.args.nums); got != tt.want {
				t.Errorf("Sum() = %v, want %v", got, tt.want)
			}
		})
	}

}

func Test_testGenericFuncDemo(t *testing.T) {
	testGenericFuncDemo()
}

func TestPairDemo(t *testing.T) {
	PairDemo()
}

func TestDescribeDemo(t *testing.T) {
	DescribeDemo()
}
Golang底层原理学习笔记（一）
lcynone的博客
01-13 439
Golang底层原理
Golang反射实现简易ORM框架实战
最新发布
Golang编程笔记的博客
04-21 760
本文旨在通过Golang反射机制实现一个轻量级ORM框架，解决对象与关系型数据库（如MySQL）之间的映射问题。结构体到数据库表的元数据映射（表名、字段名、数据类型）基于反射的SQL语句动态生成（SELECT/INSERT/UPDATE/DELETE）数据库连接管理与事务处理基础实现典型CRUD操作的封装与实战应用目标框架需支持主流关系型数据库驱动（以MySQL为例），适配常见数据类型（字符串、整数、时间、布尔等），并提供类型安全的API接口。背景知识。
Golang 泛型介绍
chinusyan的专栏
04-19 2097
Golang 泛型介绍
【golang】泛型学习
huangfengnt的博客
09-04 1954
go泛型
【Golang】泛型与类型约束
IT部落格
03-31 981
简单讲解下Golang中的泛型
Golang 泛型详解
07-25 2649
/ 自定义一个新类型 MapTT：类型形参。定义 MapT 时 T 代表的类型并不确定，类似一个占位符。：类型约束。指定 T 仅可接受哪些类型。中括号内定义形参类型，称为形参类型列表。其中，类型约束可以包上 interface{}m[T] = valreturn m// 或简写为type T interface{int|int32|float32|string} // 自定义类型约束。
golang泛型
Jcduhdt的博客
04-03 7475
泛型 go1.18版本开始支持 在函数上使用[T 支持的类型] 表示泛型，比如 func AddSum[T int|float64](params ...T)(sum T){ // 一些操作 return sum } 自带泛型： any 表示任何类型，即interface comparable 表示可以被比较的类型 comparable is an interface that is implemented by all comparable types (booleans, numbers,
leetcode算法学习笔记，Python，Golang，Java.zip
02-21
《LeetCode算法学习笔记——Python、Golang与Java篇》 在编程领域，LeetCode是一个备受推崇的在线平台，它提供了丰富的算法题目，旨在帮助开发者提升编程技能，特别是解决算法问题的能力。本压缩包文件“leetcode...
Golang超详细入门教程
席万里的博客
11-15 2186
Golang详细入门教程
Golang时间轮实现：高效定时任务管理
Golang编程笔记的博客
04-12 971
在分布式系统、微服务架构和实时数据处理场景中，定时任务管理是核心功能之一。传统基于堆结构的定时任务调度方案存在时间复杂度较高（O(logN)级插入和删除）、内存开销大等问题。时间轮算法通过环形数据结构将时间复杂度优化至O(1)级，成为高性能定时任务系统的首选方案。本文将详细解析时间轮的核心原理，提供工业级Golang实现方案，并涵盖并发控制、任务持久化、性能优化等关键技术点。时间轮核心概念与架构设计核心算法原理与Golang实现细节数学模型分析与性能优化公式完整项目实战与代码解析。
Golang泛型
bai1112的博客
02-01 945
golang泛型
golang泛型介绍
uxff的专栏
01-11 5688
go开发团队与2021.12.15将泛型发布在go1.18beta1版本中。本文将介绍如何在golang中使用泛型，以及golang泛型与其他语言(c++,java,c#)比较。golang泛型正式发布将于2022年2月的1.18版本与大家见面。
golang 泛型详解
擅长后端研发
02-28 2367
Go 在1.18 中添加了泛型，这样Go 就可以在定义时不定义类型，而是在使用时进行类型的定义，并且还可以在编译期间对参数类型进行校验。Go 目前只支持泛型方法，还不支持泛型接口，下面我会详细介绍Go的泛型使用以及常见的使用错误。其他概念性的东西我不想说太多，大家可以自己百度。
Golang 泛型学习
u013433591的博客
01-23 1797
Golang泛型函数定义、泛型函数定义、泛型类型约束
golang.18泛型
chenyulancn的专栏
04-12 1679
写一段段冒泡排序的代码，但是这个bubbleSort函数参数类型只能为int64，也就是说我们只能传入一个类型为int64切片，如果我需要传入其他类型的数据，那么我们就需要重新写一个函数逻辑是相同的代码片段但是类型又不同，这就是没有泛型带来的痛苦. package main import "fmt" func bubbleSort(sequence []int64) { for i := 0; i < len(sequence)-1; i++ { for j := ..
【魅力golang】之-泛型
网络风云的博客
12-28 5316
早期的golang版本是不支持泛型的，这对于从其它语言转型做go开发的程序员来说，非常不友好，自 1.18开始golang正式支持泛型，解决了开发者在编写通用代码时的需求。Go 中的泛型通过类型参数和类型约束，使开发者能够编写更加灵活、高效的代码。泛型就是广泛的数据类型，或者叫扩展的类型、增加的类型，其本质是参数化类型，指在定义函数或数据结构时使用类型参数，以便可以在调用时指定具体的类型。在 Go 的早期版本中，处理不同类型的通用逻辑需要使用接口或类型断言。通过类型约束，确保泛型函数支持的操作是合法的。
GoLang之泛型
weixin_52690231的博客
03-20 797
GoLang之泛型
关于Golang的泛型
席万里的博客
11-06 495
Go 泛型是一项强大的特性，能够显著提升代码复用性、类型安全性和性能。通过类型参数、约束和多种内建功能，开发者可以轻松地编写灵活而高效的代码。未来我们将进一步学习泛型的高级应用场景，如结合反射与泛型的动态类型处理等。
golang json 获取所有key_Golang —— JSON 大法
06-10
好的，您的问题是如何在 Golang 中获取 JSON 数据的所有键（key）？ 在 Golang 中，可以使用 `encoding/json` 包来处理 JSON 数据。要获取 JSON 数据的所有键，您可以先将其解码为 `map[string]interface{}` 类型，然后遍历该 map 并输出所有键。 以下是一个简单的示例代码： ```go package main import ( "encoding/json" "fmt" ) func main() { // 示例 JSON 数据 jsonData := `{ "name": "John Doe", "age": 30, "email": "johndoe@example.com" }` // 将 JSON 解码为 map[string]interface{} var data map[string]interface{} err := json.Unmarshal([]byte(jsonData), &data) if err != nil { panic(err) } // 输出所有键 for key := range data { fmt.Println(key) } } ``` 输出结果： ``` name age email ``` 希望这能解决您的问题！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值