Golang type assertion

One , How to detect and convert the types of interface variables

stay Go Linguistic interface Can be of any type , therefore Go The type assertion is given to judge the type contained in the interface at a certain time , For example, now give an interface , be known as InterfaceText:

x,err:=interfaceText.(T)//T Is a certain type

The above formula is the general form of interface assertion , Because this method may not work well every time , therefore err The function of is to judge whether something is wrong . So general interface assertions are often written as follows ：

if v,err:=InterfaceText.(T);err {//T It's a type of 
    possess(v)// Handle v
    return
}

If the conversion is legal , be v by InterfaceText Convert to type T Value ,err by ture, conversely err by false.

It is worth noting that ：InterfaceText Must be an interface type ！！！

Sometimes if you just want to judge whether there are types T, Can be written as ：

if _,err:=InterfaceText.(T);err{
    //..
    return 
}

Here is a specific example to help understand ：

package main

import (
	"fmt"
    "math"
)

type Square struct{
    slide float32
}
type Circle struct{
    radius float32
}
type Figure interface{
    Area() float32
}
func main(){
    var fi Figure
    sq:=new(Square)
    sq.slide=5
    fi=sq
    if v,err:=fi.(*Square);err {
        fmt.Printf("fi contain a variable of type : %v\n",v)
    }else {
        fmt.Println("fi does not contain a variable of Square")
    }
    if v2,ok:=fi.(*Circle);ok {
        fmt.Printf("fi contain a variable of type : %v\n",v2)
    }else {
        fmt.Println("fi does not contain a variable of Circle")
    }
}
func (s *Square) Area() float32{
    return s.slide*s.slide
}
func (c *Circle) Area() float32{
    return c.radius*c.radius*math.Pi
}

Running results ：

  Two , Type judgment ：type-switch

This is another type of judgment , This method and switch Very similar . Look directly at the code ：

switch x:=InterfaceText.(type) {
    case *Square:
        fmt.Printf("text:%v",i)
    case *Circle:
        //..
    case nil:
        //..
    default:
        //..
    //..and so forth
}

Understanding ideas and switch Very similar , If InterfaceText There is *Square,*Circle,nil Three types of , The corresponding code will be executed , If none of them , Will perform default Code in .

If only judge , Instead of using a value, it can be written as ：

switch InterfaceText.(type) {
    case *Square:
        fmt.Printf("text:%v",i)
    case *Circle:
        //..
    case nil:
        //..
    default:
        //..
    //..and so forth
}

Sometimes for convenience , We can package it into a function to judge some unknown types ：

func classify(items...interface{}){
    for i,x:=range items {
        switch x.(type) {
        case bool:
            fmt.Printf("text:%v",i)
        case int:
            //..
        case float32:
            //..
        default:
            //..
        //..and so forth
        }
    }
}

You can call this method like this ：classifier(13, -14.3, false) .

Of course, other types can also be added , It depends on the specific situation .

ending~~