interface {} 값의 "실제"유형을 결정하는 방법은 무엇입니까?

interface{}유형 사용에 대한 좋은 리소스를 찾지 못했습니다 . 예를 들면

package main

import "fmt"

func weirdFunc(i int) interface{} {
    if i == 0 {
        return "zero"
    }
    return i
}
func main() {
    var i = 5
    var w = weirdFunc(5)

    // this example works!
    if tmp, ok := w.(int); ok {
        i += tmp
    }

    fmt.Println("i =", i)
}

Go의 사용에 대한 좋은 소개를 알고 interface{}있습니까?

구체적인 질문 :

• w의 "실제"유형을 어떻게 얻습니까?
• 유형의 문자열 표현을 얻는 방법이 있습니까?
• 값을 변환하기 위해 유형의 문자열 표현을 사용하는 방법이 있습니까?

귀하의 예가 작동합니다. 여기에 단순화 된 버전이 있습니다.

package main

import "fmt"

func weird(i int) interface{} {
    if i < 0 {
        return "negative"
    }
    return i
}

func main() {
    var i = 42
    if w, ok := weird(7).(int); ok {
        i += w
    }
    if w, ok := weird(-100).(int); ok {
        i += w
    }
    fmt.Println("i =", i)
}

Output:
i = 49

유형 어설 션을 사용합니다 .

유형 스위치를 수행 할 수도 있습니다.

switch v := myInterface.(type) {
case int:
    // v is an int here, so e.g. v + 1 is possible.
    fmt.Printf("Integer: %v", v)
case float64:
    // v is a float64 here, so e.g. v + 1.0 is possible.
    fmt.Printf("Float64: %v", v)
case string:
    // v is a string here, so e.g. v + " Yeah!" is possible.
    fmt.Printf("String: %v", v)
default:
    // And here I'm feeling dumb. ;)
    fmt.Printf("I don't know, ask stackoverflow.")
}

리플렉션 ( reflect.TypeOf())을 사용 하여 무언가의 유형을 가져올 수 있으며, 그것이 제공하는 값 ( Type)에는 String인쇄 할 수 있는 문자열 표현 ( 메서드)이 있습니다.

다음은 스위치와 리플렉션을 모두 사용하여 일반 맵을 디코딩하는 예입니다. 따라서 유형이 일치하지 않는 경우 리플렉션을 사용하여 파악한 다음 다음에 유형을 추가하십시오.

var data map[string]interface {}

...

for k, v := range data {
    fmt.Printf("pair:%s\t%s\n", k, v)   

    switch t := v.(type) {
    case int:
        fmt.Printf("Integer: %v\n", t)
    case float64:
        fmt.Printf("Float64: %v\n", t)
    case string:
        fmt.Printf("String: %v\n", t)
    case bool:
        fmt.Printf("Bool: %v\n", t)
    case []interface {}:
        for i,n := range t {
            fmt.Printf("Item: %v= %v\n", i, n)
        }
    default:
        var r = reflect.TypeOf(t)
        fmt.Printf("Other:%v\n", r)             
    }
}

유형 스위치는 반사 재료와 함께 사용할 수도 있습니다.

var str = "hello!"
var obj = reflect.ValueOf(&str)

switch obj.Elem().Interface().(type) {
case string:
    log.Println("obj contains a pointer to a string")
default:
    log.Println("obj contains something else")
}

리플렉션 종류의 인수를 로컬 형식 수신기에 전달하여 부울을 반환하는 방법을 제공 할 것입니다 (이와 같은 것을 찾을 수 없기 때문에).

먼저 익명 유형의 reflect.Value를 선언합니다.

type AnonymousType reflect.Value

그런 다음 모든 잠재적 유형 (인터페이스)을 취할 수있는 로컬 유형 AnonymousType에 대한 빌더를 추가합니다.

func ToAnonymousType(obj interface{}) AnonymousType {
    return AnonymousType(reflect.ValueOf(obj))
}

그런 다음 reflect.Kind에 대해 주장하는 AnonymousType 구조체에 대한 함수를 추가합니다.

func (a AnonymousType) IsA(typeToAssert reflect.Kind) bool {
    return typeToAssert == reflect.Value(a).Kind()
}

이를 통해 다음을 호출 할 수 있습니다.

var f float64 = 3.4

anon := ToAnonymousType(f)

if anon.IsA(reflect.String) {
    fmt.Println("Its A String!")
} else if anon.IsA(reflect.Float32) {
    fmt.Println("Its A Float32!")
} else if anon.IsA(reflect.Float64) {
    fmt.Println("Its A Float64!")
} else {
    fmt.Println("Failed")
}

여기에서 더 긴 작동 버전을 볼 수 있습니다. https://play.golang.org/p/EIAp0z62B7

유형의 문자열 표현을 가져 오는 방법에는 여러 가지가 있습니다. 사용자 유형과 함께 스위치를 사용할 수도 있습니다.

var user interface{}
user = User{name: "Eugene"}

// .(type) can only be used inside a switch
switch v := user.(type) {
case int:
    // Built-in types are possible (int, float64, string, etc.)
    fmt.Printf("Integer: %v", v)
case User:
    // User defined types work as well  
    fmt.Printf("It's a user: %s\n", user.(User).name)
}

// You can use reflection to get *reflect.rtype
userType := reflect.TypeOf(user)
fmt.Printf("%+v\n", userType)

// You can also use %T to get a string value
fmt.Printf("%T", user)

// You can even get it into a string
userTypeAsString := fmt.Sprintf("%T", user)

if userTypeAsString == "main.User" {
    fmt.Printf("\nIt's definitely a user")
}

플레이 그라운드 링크 : https://play.golang.org/p/VDeNDUd9uK6