Go语言断言和类型查询的实现

左丘海

目录

• 1、类型断言
  
• 2、类型查询
  

1、类型断言

类型断言(Type Assertion)是一个使用在接口值上的操作，用于检查接口类型变量所持有的值是否实现了期望的接口或者具体的类型。
在Go语言中类型断言的语法格式如下：

1. // i.(TypeNname)
   
2. value, ok := x.(T)

复制代码

其中，x 表示一个接口的类型，如果是具体类型变量，则编译器会报

1. non-interface type xxx on left

复制代码

，T 表示一个具体的类型(也可为接口类型)。
该断言表达式会返回 x 的值（也就是 value）和一个布尔值（也就是 ok），可根据该布尔值判断 x 是否为 T 类型：

• 如果 T 是具体某个类型，类型断言会检查 x 的动态类型是否等于具体类型 T。如果检查成功，类型断言返回的结果是 x 的动态值，其类型是 T。
  
• 如果 T 是接口类型，类型断言会检查 x 的动态类型是否满足 T。如果检查成功，x 的动态值不会被提取，返回值是一个类型为 T 的接口值。
  
• 无论 T 是什么类型，如果 x 是 nil 接口值，类型断言都会失败。
  

示例代码如下：

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5. )
   
6. 
   
7. func main() {
   
8.         var x interface{}
   
9.         x = 10
   
10.         value, ok := x.(int)
    
11.         // 10,true
    
12.         fmt.Print(value, ",", ok)
    
13. }

复制代码

运行结果如下：

1. # 程序结果10,true

复制代码

需要注意如果不接收第二个参数也就是上面代码中的 ok，断言失败时会直接造成一个 panic，如果 x 为 nil 同样也会 panic。
示例代码如下：

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5. )
   
6. 
   
7. func main() {
   
8.         var x interface{}
   
9.         x = "Hello"
   
10.         value := x.(int)
    
11.         fmt.Println(value)
    
12. }

复制代码

运行结果如下：

1. # 输出结果panic: interface conversion: interface {} is string, not int

复制代码

接口断言通常可以使用 comma,ok 语句来确定接口是否绑定某个实例类型，或者判断接口绑定的实例类型是否实现另一个接口。

1. re,ok := body.(io.ReadCloser)
   
2. if,ok :=  r.Body.(*maxBytesReader);

复制代码

2、类型查询

接口类型查询的语法格式如下：

1. switch v := i.(type){
   
2.         case typel:
   
3.                 XXXX
   
4.         case type2:
   
5.                 XXXX
   
6.         default:
   
7.                 XXXX
   
8. }

复制代码

接口查询有两层语义，一是查询一个接口变量底层绑定的底层变量的具体类型是什么，二是查询接口变量绑定的底
层变量是否还实现了其他接口。
(1)、i 必须是接口类型
具体类型实例的类型是静态的，在类型声明后就不再变化，所以具体类型的变量不存在类型查询，类型查询一定是
对一个接口变量进行操作。也就是说，上文中的i必须是接口变量，如果i是未初始化接口变量，则v的值是 nil。

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "io"
   
6. )
   
7. 
   
8. func main() {
   
9.         var i io.Reader
   
10.         //此处i是为未初始化的接口变量,所以v为nil
    
11.         switch v := i.(type) {
    
12.         case nil:
    
13.                 //<nil>
    
14.                 fmt.Printf("%T\n", v)
    
15.         default:
    
16.                 fmt.Printf("default")
    
17.         }
    
18. }

复制代码

(2)、case 字句后面可以跟非接口类型名，也可以跟接口类型名，匹配是按照 case 子句的顺序进行的。

• 如果 case 后面是一个接口类型名，且接口变量i绑定的实例类型实现了该接口类型的方法，则匹配成，v的类型是接口类型，v底层绑定的实例是i绑定具体类型实例的副本。
  
• 如果 case 后面是一个具体类型名，且接口变量i绑定的实例类型和该具体类型相同，则匹配成功，此时v 就是该具体类型变量，v的值是i绑定的实例值的副本。
  
• 如果 case 后面跟着多个类型，使用逗号分隔，接口变量i绑定的实例类型只要和其中一个类型匹配，则直接使用o赋值给v，相当于 v:=o。这个语法有点奇怪，按理说编译器不应该允许这种操作，语言实现者可能想让type switch 语句和普通的 switch 语句保持一样的语法规则，允许发生这种情况。
  
• 如果所有的case字句都不满足，则执行 default 语句，此时执行的仍然是 v:=o，最终v的值是o。此时使用v没有任何意义。
  
• fallthrough 语句不能在 Type Switch 语句中使用。
  

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5.         "io"
   
6.         "log"
   
7.         "os"
   
8. )
   
9. 
   
10. func main() {
    
11.         var i io.Reader
    
12.         // 此处i是为未初始化的接口变量,所以v为nil
    
13.         switch v := i.(type) {
    
14.         case nil:
    
15.                 // <nil>
    
16.                 fmt.Printf("%T\n", v)
    
17.         default:
    
18.                 fmt.Printf("default")
    
19.         }
    
20.         f, err := os.OpenFile("notes.txt", os.O_RDWR|os.O_CREATE, 0755)
    
21.         if err != nil {
    
22.                 log.Fatal(err)
    
23.         }
    
24.         defer f.Close()
    
25.         i = f
    
26.         switch v := i.(type) {
    
27.         // i的绑定的实例是*osFile类型，实现了io.ReadWriter接口，所以下面case匹配成功
    
28.         case io.ReadWriter:
    
29.                 // v是io.ReadWriter接口类型，所以可以调用Write方法
    
30.                 v.Write([]byte("io.ReadWriter\n"))
    
31.                 // Type Switch Result: io.ReadWriter
    
32.                 fmt.Println("Type Switch Result: io.ReadWriter")
    
33.         // 由于上一个case已经匹配，就算这个case也匹配，也不会走到这里
    
34.         case *os.File:
    
35.                 v.Write([]byte("*os.File\n"))
    
36.                 fmt.Println("Type Switch Result: *os.File")
    
37.                 //这里可以调用具体类型方法
    
38.                 v.Sync()
    
39.         default:
    
40.                 fmt.Println("Type Switch Result: unknown")
    
41.                 return
    
42.         }
    
43. 
    
44.         switch v := i.(type) {
    
45.         // 匹配成功，v的类型就是具体类型*os.File
    
46.         case *os.File:
    
47.                 v.Write([]byte("*os.File\n"))
    
48.                 // Type Switch Result: *os.File
    
49.                 fmt.Println("Type Switch Result: *os.File")
    
50.                 v.Sync()
    
51.         //由于上一个case已经匹配，就算这个case也匹配，也不会走到这里
    
52.         case io.ReadWriter:
    
53.                 //v是io.ReadWriter接口类型，所以可以调用Write方法
    
54.                 v.Write([]byte("io.ReadWriter\n"))
    
55.                 fmt.Println("Type Switch Result: io.ReadWriter")
    
56.         default:
    
57.                 fmt.Println("Type Switch Result: unknown")
    
58.                 return
    
59.         }
    
60. 
    
61.         switch v := i.(type) {
    
62.         //多个类型，f满足其中任何一个就算匹配
    
63.         case *os.File, io.ReadWriter:
    
64.                 // 此时相当于执行力v := i ,v和i是等价的，使用v没有意义。
    
65.                 if v == i {
    
66.                         // true
    
67.                         fmt.Println(true)
    
68.                 }
    
69.         default:
    
70.                 return
    
71.         }
    
72. }

复制代码

1. # 程序输出<nil>Type Switch Result: io.ReadWriterType Switch Result: *os.Filetrue 

复制代码

1. package main
   
2. 
   
3. import (
   
4.         "fmt"
   
5. )
   
6. 
   
7. func main() {
   
8.         var a int
   
9.         a = 10
   
10.         // the type of a is int
    
11.         getType(a)
    
12. }
    
13. 
    
14. func getType(a interface{}) {
    
15.         switch a.(type) {
    
16.         case int:
    
17.                 fmt.Println("the type of a is int")
    
18.         case string:
    
19.                 fmt.Println("the type of a is string")
    
20.         case float64:
    
21.                 fmt.Println("the type of a is float")
    
22.         default:
    
23.                 fmt.Println("unknown type")
    
24.         }
    
25. }

复制代码

1. # 程序输出the type of a is int

复制代码

到此这篇关于Go语言断言和类型查询的实现的文章就介绍到这了,更多相关Go语言断言和类型查询内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

梦随风释渭

感谢楼主分享。

123459843

顶顶更健康！！！