[go] Go에서 개체 유형을 찾는 방법은 무엇입니까?

Go에서 개체 유형을 어떻게 찾습니까? 파이썬에서는 typeof객체 유형을 가져 오는 데 사용 합니다. 마찬가지로 Go에서도 동일한 구현 방법이 있습니까?

반복하는 컨테이너는 다음과 같습니다.

for e := dlist.Front(); e != nil; e = e.Next() {
    lines := e.Value
    fmt.Printf(reflect.TypeOf(lines))
}

이 경우 문자열 배열 인 객체 줄의 유형을 얻을 수 없습니다.

답변

Go reflection 패키지에는 변수 유형을 검사하는 방법이 있습니다.

다음 스 니펫은 문자열, 정수 및 부동의 반사 유형을 인쇄합니다.

package main

import (
    "fmt"
    "reflect"
)

func main() {

    tst := "string"
    tst2 := 10
    tst3 := 1.2

    fmt.Println(reflect.TypeOf(tst))
    fmt.Println(reflect.TypeOf(tst2))
    fmt.Println(reflect.TypeOf(tst3))

}

산출:

Hello, playground
string
int
float64

실제로 보려면 http://play.golang.org/p/XQMcUVsOja 를 참조하십시오 .

더 많은 문서는 여기에 있습니다 : http://golang.org/pkg/reflect/#Type

답변

런타임에 변수 유형을 반환하는 세 가지 방법을 찾았습니다.

문자열 형식 사용

func typeof(v interface{}) string {
    return fmt.Sprintf("%T", v)
}

리플렉션 패키지 사용

func typeof(v interface{}) string {
    return reflect.TypeOf(v).String()
}

타입 주장 사용하기

func typeof(v interface{}) string {
    switch v.(type) {
    case int:
        return "int"
    case float64:
        return "float64"
    //... etc
    default:
        return "unknown"
    }
}

모든 방법에는 다른 최상의 사용 사례가 있습니다.

문자열 형식-짧고 작은 공간 (반사 패키지를 가져올 필요가 없음)
리플렉션 패키지-전체 리플렉션 기능에 액세스 할 수있는 유형에 대한 자세한 정보가 필요한 경우
type assertions-그룹화 유형을 허용합니다 (예 : 모든 int32, int64, uint32, uint64 유형을 “int”로 인식)

답변

리플렉션 패키지를 사용하십시오 .

패키지 반영은 런타임 반영을 구현하여 프로그램이 임의 유형의 객체를 조작 할 수 있도록합니다. 일반적으로 정적 유형 인터페이스 {}로 값을 가져 와서 TypeOf를 호출하여 동적 유형 정보를 추출하여 Type을 반환합니다.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    b := true
    s := ""
    n := 1
    f := 1.0
    a := []string{"foo", "bar", "baz"}

    fmt.Println(reflect.TypeOf(b))
    fmt.Println(reflect.TypeOf(s))
    fmt.Println(reflect.TypeOf(n))
    fmt.Println(reflect.TypeOf(f))
    fmt.Println(reflect.TypeOf(a))
}

생산 :

bool
string
int
float64
[]string

운동장

사용 예 ValueOf(i interface{}).Kind():

package main

import (
    "fmt"
    "reflect"
)

func main() {
    b := true
    s := ""
    n := 1
    f := 1.0
    a := []string{"foo", "bar", "baz"}

    fmt.Println(reflect.ValueOf(b).Kind())
    fmt.Println(reflect.ValueOf(s).Kind())
    fmt.Println(reflect.ValueOf(n).Kind())
    fmt.Println(reflect.ValueOf(f).Kind())
    fmt.Println(reflect.ValueOf(a).Index(0).Kind()) // For slices and strings
}

생산 :

bool
string
int
float64
string

운동장

답변

문자열 표현을 얻으려면 :

에서 http://golang.org/pkg/fmt/

% T 값 유형의 구문 구문 표현

package main
import "fmt"
func main(){
    types := []interface{} {"a",6,6.0,true}
    for _,v := range types{
        fmt.Printf("%T\n",v)
    }
}

출력 :

string
int
float64
bool

답변

나는 반사에서 멀리 떨어져있을 것입니다. 꾸러미. 대신 % T를 사용하십시오.

package main

import (
    "fmt"
)

func main() {
    b := true
    s := ""
    n := 1
    f := 1.0
    a := []string{"foo", "bar", "baz"}

    fmt.Printf("%T\n", b)
    fmt.Printf("%T\n", s)
    fmt.Printf("%T\n", n)
    fmt.Printf("%T\n", f)
    fmt.Printf("%T\n", a)
 }

답변

가장 좋은 방법은 Google에서 반사 개념을 사용하는 것입니다.
reflect.TypeOf패키지 이름과 함께 유형을
reflect.TypeOf().Kind()제공합니다. 밑줄 유형을 제공합니다.

답변

간단히 말해, fmt.Printf("%T", var1) fmt 패키지에서 또는 다른 변형을 사용하십시오.