脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go系列教程之反射的用法

Go系列教程之反射的用法

2020-05-22 09:42Noluye Golang

这篇文章主要介绍了Go系列教程之反射的用法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

反射是 Go 语言的高级主题之一。我会尽可能让它变得简单易懂。

本教程分为如下小节。

  • 什么是反射？
  • 为何需要检查变量，确定变量的类型？
  • reflect 包
    • reflect.Type 和 reflect.Value
    • reflect.Kind
    • NumField() 和 Field() 方法
    • Int() 和 String() 方法
  • 完整的程序
  • 我们应该使用反射吗？

让我们来逐个讨论这些章节。

什么是反射？

反射就是程序能够在运行时检查变量和值，求出它们的类型。你可能还不太懂，这没关系。在本教程结束后，你就会清楚地理解反射，所以跟着我们的教程学习吧。

为何需要检查变量，确定变量的类型？

在学习反射时，所有人首先面临的疑惑就是：如果程序中每个变量都是我们自己定义的，那么在编译时就可以知道变量类型了，为什么我们还需要在运行时检查变量，求出它的类型呢？没错，在大多数时候都是这样，但并非总是如此。

我来解释一下吧。下面我们编写一个简单的程序。

?
1
2
3
4
5
6
7
8
9
10
package main
 
import (
 "fmt"
)
 
func main() {
 i := 10
 fmt.Printf("%d %T", i, i)
}

在 playground 上运行

在上面的程序中，i 的类型在编译时就知道了，然后我们在下一行打印出 i。这里没什么特别之处。

现在了解一下，需要在运行时求得变量类型的情况。假如我们要编写一个简单的函数，它接收结构体作为参数，并用它来创建一个 SQL 插入查询。

考虑下面的程序：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
 
import (
 "fmt"
)
 
type order struct {
 ordId  int
 customerId int
}
 
func main() {
 o := order{
  ordId:  1234,
  customerId: 567,
 }
 fmt.Println(o)
}

在 playground 上运行

在上面的程序中，我们需要编写一个函数，接收结构体变量 o 作为参数，返回下面的 SQL 插入查询。

?
1
insert into order values(1234, 567)

这个函数写起来很简单。我们现在编写这个函数。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main
 
import (
 "fmt"
)
 
type order struct {
 ordId  int
 customerId int
}
 
func createQuery(o order) string {
 i := fmt.Sprintf("insert into order values(%d, %d)", o.ordId, o.customerId)
 return i
}
 
func main() {
 o := order{
  ordId:  1234,
  customerId: 567,
 }
 fmt.Println(createQuery(o))
}

在 playground 上运行

在第 12 行，createQuery 函数用 o 的两个字段（ordId 和 customerId），创建了插入查询。该程序会输出：

?
1
insert into order values(1234, 567)

现在我们来升级这个查询生成器。如果我们想让它变得通用，可以适用于任何结构体类型，该怎么办呢？我们用程序来理解一下。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
 
type order struct {
 ordId  int
 customerId int
}
 
type employee struct {
 name string
 id int
 address string
 salary int
 country string
}
 
func createQuery(q interface{}) string {
}
 
func main() {
 
}

我们的目标就是完成 createQuery 函数（上述程序中的第 16 行），它可以接收任何结构体作为参数，根据结构体的字段创建插入查询。

例如，如果我们传入下面的结构体：

?
1
2
3
4
o := order {
 ordId: 1234,
 customerId: 567
}

createQuery 函数应该返回：

?
1
insert into order values (1234, 567)

类似地，如果我们传入：

?
1
2
3
4
5
6
7
e := employee {
 name: "Naveen",
 id: 565,
 address: "Science Park Road, Singapore",
 salary: 90000,
 country: "Singapore",
}

该函数会返回：

?
1
insert into employee values("Naveen", 565, "Science Park Road, Singapore", 90000, "Singapore")

由于 createQuery 函数应该适用于任何结构体，因此它接收 interface{} 作为参数。为了简单起见，我们只处理包含 string 和 int 类型字段的结构体，但可以扩展为包含任何类型的字段。

createQuery 函数应该适用于所有的结构体。因此，要编写这个函数，就必须在运行时检查传递过来的结构体参数的类型，找到结构体字段，接着创建查询。这时就需要用到反射了。在本教程的下一步，我们将会学习如何使用 reflect 包来实现它。

reflect 包

在 Go 语言中，reflect 实现了运行时反射。reflect 包会帮助识别 interface{} 变量的底层具体类型和具体值。这正是我们所需要的。createQuery 函数接收 interface{} 参数，根据它的具体类型和具体值，创建 SQL 查询。这正是 reflect 包能够帮助我们的地方。

在编写我们通用的查询生成器之前，我们首先需要了解 reflect 包中的几种类型和方法。让我们来逐个了解。

reflect.Type 和 reflect.Value

reflect.Type 表示 interface{} 的具体类型，而 reflect.Value 表示它的具体值。reflect.TypeOf() 和 reflect.ValueOf() 两个函数可以分别返回 reflect.Type 和 reflect.Value。这两种类型是我们创建查询生成器的基础。我们现在用一个简单的例子来理解这两种类型。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main
 
import (
 "fmt"
 "reflect"
)
 
type order struct {
 ordId  int
 customerId int
}
 
func createQuery(q interface{}) {
 t := reflect.TypeOf(q)
 v := reflect.ValueOf(q)
 fmt.Println("Type ", t)
 fmt.Println("Value ", v)
 
 
}
func main() {
 o := order{
  ordId:  456,
  customerId: 56,
 }
 createQuery(o)
 
}

在 playground 上运行

在上面的程序中，第 13 行的 createQuery 函数接收 interface{} 作为参数。在第 14 行，reflect.TypeOf 接收了参数 interface{}，返回了reflect.Type，它包含了传入的 interface{} 参数的具体类型。同样地，在第 15 行，reflect.ValueOf 函数接收参数 interface{}，并返回了 reflect.Value，它包含了传来的 interface{} 的具体值。

上述程序会打印：

Type  main.order
Value  {456 56}

从输出我们可以看到，程序打印了接口的具体类型和具体值。

relfect.Kind

reflect 包中还有一个重要的类型：Kind。

在反射包中，Kind 和 Type 的类型可能看起来很相似，但在下面程序中，可以很清楚地看出它们的不同之处。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main
 
import (
 "fmt"
 "reflect"
)
 
type order struct {
 ordId  int
 customerId int
}
 
func createQuery(q interface{}) {
 t := reflect.TypeOf(q)
 k := t.Kind()
 fmt.Println("Type ", t)
 fmt.Println("Kind ", k)
 
 
}
func main() {
 o := order{
  ordId:  456,
  customerId: 56,
 }
 createQuery(o)
 
}

在 playground 上运行

上述程序会输出：

Type  main.order
Kind  struct

我想你应该很清楚两者的区别了。Type 表示 interface{} 的实际类型（在这里是 main.Order)，而 Kind 表示该类型的特定类别（在这里是 struct）。

NumField() 和 Field() 方法

NumField() 方法返回结构体中字段的数量，而 Field(i int) 方法返回字段 i 的 reflect.Value。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main
 
import (
 "fmt"
 "reflect"
)
 
type order struct {
 ordId  int
 customerId int
}
 
func createQuery(q interface{}) {
 if reflect.ValueOf(q).Kind() == reflect.Struct {
  v := reflect.ValueOf(q)
  fmt.Println("Number of fields", v.NumField())
  for i := 0; i < v.NumField(); i++ {
   fmt.Printf("Field:%d type:%T value:%v\n", i, v.Field(i), v.Field(i))
  }
 }
 
}
func main() {
 o := order{
  ordId:  456,
  customerId: 56,
 }
 createQuery(o)
}

在 playground 上运行

在上面的程序中，因为 NumField 方法只能在结构体上使用，我们在第 14 行首先检查了 q 的类别是 struct。程序的其他代码很容易看懂，不作解释。该程序会输出：

Number of fields 2
Field:0 type:reflect.Value value:456
Field:1 type:reflect.Value value:56

Int() 和 String() 方法

Int 和 String 可以帮助我们分别取出 reflect.Value 作为 int64 和 string。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
 
import (
 "fmt"
 "reflect"
)
 
func main() {
 a := 56
 x := reflect.ValueOf(a).Int()
 fmt.Printf("type:%T value:%v\n", x, x)
 b := "Naveen"
 y := reflect.ValueOf(b).String()
 fmt.Printf("type:%T value:%v\n", y, y)
 
}

在 playground 上运行

在上面程序中的第 10 行，我们取出 reflect.Value，并转换为 int64，而在第 13 行，我们取出 reflect.Value 并将其转换为 string。该程序会输出：

type:int64 value:56
type:string value:Naveen

完整的程序

现在我们已经具备足够多的知识，来完成我们的查询生成器了，我们来实现它把。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package main
 
import (
 "fmt"
 "reflect"
)
 
type order struct {
 ordId  int
 customerId int
}
 
type employee struct {
 name string
 id  int
 address string
 salary int
 country string
}
 
func createQuery(q interface{}) {
 if reflect.ValueOf(q).Kind() == reflect.Struct {
  t := reflect.TypeOf(q).Name()
  query := fmt.Sprintf("insert into %s values(", t)
  v := reflect.ValueOf(q)
  for i := 0; i < v.NumField(); i++ {
   switch v.Field(i).Kind() {
   case reflect.Int:
    if i == 0 {
     query = fmt.Sprintf("%s%d", query, v.Field(i).Int())
    } else {
     query = fmt.Sprintf("%s, %d", query, v.Field(i).Int())
    }
   case reflect.String:
    if i == 0 {
     query = fmt.Sprintf("%s\"%s\"", query, v.Field(i).String())
    } else {
     query = fmt.Sprintf("%s, \"%s\"", query, v.Field(i).String())
    }
   default:
    fmt.Println("Unsupported type")
    return
   }
  }
  query = fmt.Sprintf("%s)", query)
  fmt.Println(query)
  return
 
 }
 fmt.Println("unsupported type")
}
 
func main() {
 o := order{
  ordId:  456,
  customerId: 56,
 }
 createQuery(o)
 
 e := employee{
  name: "Naveen",
  id:  565,
  address: "Coimbatore",
  salary: 90000,
  country: "India",
 }
 createQuery(e)
 i := 90
 createQuery(i)
 
}

在 playground 上运行

在第 22 行，我们首先检查了传来的参数是否是一个结构体。在第 23 行，我们使用了 Name() 方法，从该结构体的 reflect.Type 获取了结构体的名字。接下来一行，我们用 t 来创建查询。

在第 28 行，case 语句 检查了当前字段是否为 reflect.Int，如果是的话，我们会取到该字段的值，并使用 Int() 方法转换为 int64。if else 语句用于处理边界情况。请添加日志来理解为什么需要它。在第 34 行，我们用来相同的逻辑来取到 string。

我们还作了额外的检查，以防止 createQuery 函数传入不支持的类型时，程序发生崩溃。程序的其他代码是自解释性的。我建议你在合适的地方添加日志，检查输出，来更好地理解这个程序。

该程序会输出：

?
1
2
3
insert into order values(456, 56)
insert into employee values("Naveen", 565, "Coimbatore", 90000, "India")
unsupported type

至于向输出的查询中添加字段名，我们把它留给读者作为练习。请尝试着修改程序，打印出以下格式的查询。

?
1
insert into order(ordId, customerId) values(456, 56)

我们应该使用反射吗？

我们已经展示了反射的实际应用，现在考虑一个很现实的问题。我们应该使用反射吗？我想引用 Rob Pike 关于使用反射的格言，来回答这个问题。

清晰优于聪明。而反射并不是一目了然的。

反射是 Go 语言中非常强大和高级的概念，我们应该小心谨慎地使用它。使用反射编写清晰和可维护的代码是十分困难的。你应该尽可能避免使用它，只在必须用到它时，才使用反射。

本教程到此结束。希望你们喜欢。祝你愉快。希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://studygolang.com/articles/13178

  • 反射
  • GO语言

    • 延伸 · 阅读

    精彩推荐
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图