go语言类型判断

一句话总结：利用类型判断可以判断接口是否属于某个具体的接口或者类型，另外.(type)仅用于switch语句。

注意主体是接口类型，

另外待判断对象的类型跟：

接收方法若为值，判断对象可以是值或者指针；接收方法若为指针，判断对象也要是指针；接收方法若为值和指针，判断对象也要是指针。

对象若未实现全部接口的方法，则该对象不属于该接口。

方法的接收对象是值

package main

import (

	"fmt"

)

type Biology interface {

	getName() string

	getAge() int

}

type person struct {

	name string

	age  int

}

func (p person) getName() string {

	return p.name

}

func (p person) getAge() int {

	return p.age

}

func do(i interface{}) {

	o, ok := i.(Biology)

	fmt.Println(o, ok)

}

func main() {

	var p person = person{"jack", 33}

	k, v := (interface{})(p).(Biology)

	fmt.Println(k, v) //{jack 33} true

	k, v = (interface{})(&p).(Biology)

	fmt.Println(k, v) //&{jack 33} true

	do(p)             //{jack 33} true

	do(&p)            //&{jack 33} true

}

方法接收的对象是指针、指针和值结果是一样的

package main

import (

	"fmt"

)

type Biology interface {

	getName() string

	getAge() int

}

type person struct {

	name string

	age  int

}

func (p *person) getName() string {

	return p.name

}

func (p *person) getAge() int {

	return p.age

}

func do(i interface{}) {

	o, ok := i.(Biology)

	fmt.Println(o, ok)

}

func main() {

	var p person = person{"jack", 33}

	k, v := (interface{})(p).(Biology)

	fmt.Println(k, v) //<nil> false

	k, v = (interface{})(&p).(Biology)

	fmt.Println(k, v) //&{jack 33} true

	do(p)             //<nil> false

	do(&p)            //&{jack 33} true

}

对象未实现接口的全部方法

package main

import (

	"fmt"

)

type Biology interface {

	getName() string

	getAge() int

}

type person struct {

	name string

	age  int

}

func (p *person) getName() string {

	return p.name

}

func do(i interface{}) {

	o, ok := i.(Biology)

	fmt.Println(o, ok)

}

func main() {

	var p person = person{"jack", 33}

	k, v := (interface{})(p).(Biology)

	fmt.Println(k, v) //<nil> false

	k, v = (interface{})(&p).(Biology)

	fmt.Println(k, v) //<nil> false

	do(p)             //<nil> false

	do(&p)            //<nil> false

}

.(type)仅用于switch语句

package main

import (

	"fmt"

)

type person struct {

	name string

}

func (p person) getname() string {

	return p.name

}

func getType(i interface{}) {

	switch v := i.(type) {

	case int:

		fmt.Println("int", v)

	case string:

		fmt.Println("string", v)

	case person:

		fmt.Println("person", v)

	default:

		fmt.Println("none")

	}

}

func main() {

	p := person{"jack"}

	switch (interface{})(p).(type) {

	case person:

		fmt.Println("person") //person

	case *person:

		fmt.Println("*person")

	default:

		fmt.Println("none")

	}

	switch (interface{})(&p).(type) {

	case person:

		fmt.Println("person")

	case *person:

		fmt.Println("*person") //*person

	default:

		fmt.Println("none")

	}

	getType(p) //person {jack}

	var i int = 12

	getType(i) //int 12

	var s string = "hello"

	getType(s) //string hello

	k, v := (interface{})(s).(string)

	fmt.Println(k, v) //hello true

}