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 패키지에서 또는 다른 변형을 사용하십시오.

"reflect"패키지 TypeOf기능을 사용하거나 다음을 사용하여 런타임에 변수 / 인스턴스 유형을 확인할 수 있습니다 fmt.Printf().

package main

import (
   "fmt"
   "reflect"
)

func main() {
    value1 := "Have a Good Day"
    value2 := 50
    value3 := 50.78

    fmt.Println(reflect.TypeOf(value1 ))
    fmt.Println(reflect.TypeOf(value2))
    fmt.Println(reflect.TypeOf(value3))
    fmt.Printf("%T",value1)
    fmt.Printf("%T",value2)
    fmt.Printf("%T",value3)
}

구조체에서 필드 유형을 얻으려면

package main

import (
  "fmt"
  "reflect"
)

type testObject struct {
  Name   string
  Age    int
  Height float64
}

func main() {
   tstObj := testObject{Name: "yog prakash", Age: 24, Height: 5.6}
   val := reflect.ValueOf(&tstObj).Elem()
   typeOfTstObj := val.Type()
   for i := 0; i < val.NumField(); i++ {
       fieldType := val.Field(i)
       fmt.Printf("object field %d key=%s value=%v type=%s \n",
          i, typeOfTstObj.Field(i).Name, fieldType.Interface(),
          fieldType.Type())
   }
}

산출

object field 0 key=Name value=yog prakash type=string 
object field 1 key=Age value=24 type=int 
object field 2 key=Height value=5.6 type=float64

IDE에서 참조하십시오 https://play.golang.org/p/bwIpYnBQiE

사용할 수 있습니다 reflect.TypeOf.

• 기본 유형 (예 : int, string) : 이름을 반환합니다 (예 : int, string)
• 구조체 : 그것은 형식으로 뭔가를 반환합니다 <package name>.<struct name>(예 : main.test)

이 변수가 있다면 :

var counter int = 5
var message string  = "Hello"
var factor float32 = 4.2
var enabled bool = false

1 : fmt.Printf % T 형식 :이 기능을 사용하려면 "fmt"를 가져와야합니다.

fmt.Printf("%T \n",factor )   // factor type: float32

2 : reflect.TypeOf 함수 :이 기능을 사용하려면 "반사"를 가져와야합니다.

fmt.Println(reflect.TypeOf(enabled)) // enabled type:  bool

3 : reflect.ValueOf (X) .Kind () :이 기능을 사용하려면 "반영"을 가져와야합니다

fmt.Println(reflect.ValueOf(counter).Kind()) // counter type:  int

interface{}..(type)이 운동장 에서와 같이 사용할 수 있습니다.

package main
import "fmt"
func main(){
    types := []interface{} {"a",6,6.0,true}
    for _,v := range types{
        fmt.Printf("%T\n",v)
        switch v.(type) {
        case int:
           fmt.Printf("Twice %v is %v\n", v, v.(int) * 2)
        case string:
           fmt.Printf("%q is %v bytes long\n", v, len(v.(string)))
       default:
          fmt.Printf("I don't know about type %T!\n", v)
      }
    }
}

패키지가 구출되는 것을 반영 :

reflect.TypeOf(obj).String()

이 데모를 확인

fmt 패키지 fmt.Printf () 메소드를 사용할 수 있습니다. 자세한 내용은 https://golang.org/pkg/fmt/

예 : https://play.golang.org/p/aJG5MOxjBJD