Golang 类型断言

gopher Golang 120 次浏览 , 没有评论

示例

assert.go

package main

import "fmt"

type Point struct {
  x int
  y int
}

func main()  {
  var a interface{}
  var point Point = Point{1, 2}
  a = point
  var b Point
  b = a.(Point) //类型断言
  fmt.Println(b)
}

执行结果:

{1 2}

说明:在进行类型断言时,如果类型不匹配,就会报 panic,因此进行类型断言时,要确保原来的空接口指向的就是断言的类型。

类型断言检测

assert.go

package main

import (
  "fmt"
)

func main()  {
  var x interface{}
  var b float32 = 2.1
  x = b

  if y, ok := x.(float32); ok {
    fmt.Printf("y 的类型是 %T 值是=%v \n", y, y)
  } else {
    fmt.Println("convert fail")
  }
}

运行结果:

y 的类型是 float32 值是=2.1

最佳实践1

assert.go

package main

import "fmt"

// 定义一个接口
type Usb interface {
  // 声明两个没有实现的方法
  Start()
  Stop()
}

type Phone struct {
  Name string
}

// 让Phone 实现Usb接口的方法
func (p Phone) Start()  {
  fmt.Println("手机开始工作。。。")
}

func (p Phone) Stop()  {
  fmt.Println("手机停止工作。。。")
}

func (p Phone) Call()  {
  fmt.Println("手机打电话。。。")
}

type Camera struct {
  Name string
}

// 让 Camera 实现Usb接口的方法
func (p Camera) Start()  {
  fmt.Println("相机开始工作。。。")
}

func (p Camera) Stop()  {
  fmt.Println("相机停止工作。。。")
}

// 计算机
type Computer struct {

}

// 编写一个方法 Working 方法,接收一个Usb接口类型的变量
// 只要实现了Usb 接口(所谓实现 Usb 接口,就是指实现了 Usb 接口声明所有方法)
func (c Computer) Working(usb Usb)  { // usb 变量会根据传入的实参,来判断到底是Phone,还是camera
  // 通过 usb 接口变量来调用 Start 和 Stop 方法
  usb.Start()
  usb.Stop()

  //类型断言
  if phone, ok := usb.(Phone); ok {
    phone.Call()
  }
}

func main()  {
  var usbArr [3]Usb
  usbArr[0] = Phone{"Vivo"}
  usbArr[1] = Phone{"小米"}
  usbArr[2] = Camera{"尼康"}

  var computer Computer
  for _, v := range usbArr {
    computer.Working(v)
    fmt.Println()
  }
}

执行结果:

手机开始工作。。。
手机停止工作。。。
手机打电话。。。

手机开始工作。。。
手机停止工作。。。
手机打电话。。。

相机开始工作。。。
相机停止工作。。。

最佳实践2

assert.go

package main

import "fmt"

type Student struct{}

func TypeJudge(items... interface{})  {
  for k, v := range items {
    switch v.(type) {
    case bool:
      fmt.Printf("第%v个参数是 bool 类型, 值是%v \n", k, v)
    case float32:
      fmt.Printf("第%v个参数是 float32 类型, 值是%v \n", k, v)
    case float64:
      fmt.Printf("第%v个参数是 float64 类型, 值是%v \n", k, v)
    case int, int32, int64:
      fmt.Printf("第%v个参数是 整数 类型, 值是%v \n", k, v)
    case string:
      fmt.Printf("第%v个参数是 string 类型, 值是%v \n", k, v)
    case Student:
      fmt.Printf("第%v个参数是 Student 类型, 值是%v \n", k, v)
    case *Student:
      fmt.Printf("第%v个参数是 *Student 类型, 值是%v \n", k, v)
    default:
      fmt.Printf("第%v个参数是 类型 不确定, 值是%v \n", k, v)
    }
  }
}

func main()  {
  var n1 float32 = 1.1
  var n2 float64 = 2.1
  var n3 int = 30
  var name string = "tome"
  address := "北京"
  n4 := 300

  stu1 := Student{}
  stu2 := new(Student)

  TypeJudge(n1, n2, n3, name, address, n4, stu1, stu2)
}

执行结果:

第0个参数是 float32 类型, 值是1.1 
第1个参数是 float64 类型, 值是2.1 
第2个参数是 整数 类型, 值是30 
第3个参数是 string 类型, 值是tome 
第4个参数是 string 类型, 值是北京 
第5个参数是 整数 类型, 值是300 
第6个参数是 Student 类型, 值是{} 
第7个参数是 *Student 类型, 值是&{}

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

Go