Go में किसी ऑब्जेक्ट का प्रकार कैसे पता करें?

Question

मुझे गो में किसी वस्तु का प्रकार कैसे मिलेगा? पायथन में, मैं सिर्फ typeofऑब्जेक्ट के प्रकार को लाने के लिए उपयोग करता हूं । इसी तरह गो में, क्या इसे लागू करने का कोई तरीका है?

यहाँ कंटेनर है जहाँ से मैं पुनरावृत्ति कर रहा हूँ:

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

मैं इस मामले में ऑब्जेक्ट लाइनों के प्रकार को प्राप्त करने में सक्षम नहीं हूं जो कि स्ट्रिंग की एक सरणी है।

Comments

मेरे कार्यक्रम में काम कर रहे मानक संदर्भ। मुझे स्रोत कोड को मेरा बुरा शामिल करना चाहिए था।

— राहुल

fmt.Printf("%T\n", var)

— meh

Answer 1

गो प्रतिबिंब पैकेज में चर के प्रकार का निरीक्षण करने के तरीके हैं।

निम्नलिखित स्निपेट एक स्ट्रिंग, पूर्णांक और फ्लोट के प्रतिबिंब प्रकार को प्रिंट करेगा।

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

Comments

मेरे लिए काम कर रहे चिंतन को प्रतिबिंबित करें। मैंने सवाल अपडेट किया है। मैंने इस मामले में कोड स्निपेट शामिल किया है।

— राहुल

Answer 2

मुझे रनवे पर चर के प्रकार को वापस करने के 3 तरीके मिले:

स्ट्रिंग स्वरूपण का उपयोग करना

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"
    }
}

हर विधि का एक सबसे अच्छा उपयोग मामला है:

• स्ट्रिंग स्वरूपण - लघु और निम्न पदचिह्न (पैकेज को प्रतिबिंबित करने के लिए आयात करने के लिए आवश्यक नहीं)

• पैकेज को प्रतिबिंबित करें - जब हमें पूर्ण प्रतिबिंब क्षमताओं तक पहुंच के प्रकार के बारे में अधिक जानकारी की आवश्यकता होती है

• प्रकार के दावे - समूहीकरण प्रकारों की अनुमति देता है, उदाहरण के लिए सभी int32, int64, uint32, uint64 प्रकारों को पहचानें "

Comments

ऐसा लगता है कि आप चर से छुटकारा पा सकते हैं t, इसलिए t := v.(type)बन जाता है v.(type), और _ = tअब इसकी आवश्यकता नहीं है।

— अकवाल २all ’

एक नंगे पैर

— माइक रैपादास

case 'T': p.fmt.fmtS(reflect.TypeOf(arg).String())। fmt पैकेज प्रिंट प्रकार को दर्शाते हुए उपयोग करता है

— काल्पनिक_RQG

Answer 3

प्रतिबिंबित पैकेज का उपयोग करें :

पैकेज रन-टाइम प्रतिबिंब को प्रतिबिंबित करता है, जिससे प्रोग्राम को मनमाने प्रकार के साथ ऑब्जेक्ट्स में हेरफेर करने की अनुमति मिलती है। विशिष्ट उपयोग स्थैतिक प्रकार के इंटरफ़ेस {} के साथ एक मान लेने के लिए और TypeOf पर कॉल करके इसकी गतिशील प्रकार की जानकारी निकालने के लिए है, जो एक प्रकार देता है।

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

खेल का मैदान

Comments

प्रतिबिंबित केवल मानक प्रकार प्रदर्शित करता है। मैं एक सूची कंटेनर के तत्वों के प्रकार प्राप्त करने में सक्षम नहीं हूं।

— राहुल

मैंने स्ट्रिंग्स के एक स्लाइस को शामिल करने के लिए अपना जवाब अपडेट किया है। रिफ्लेक्ट किसी भी प्रकार के लिए काम करता है। कृपया डॉक्स पढ़ें: golang.org/pkg/reflect & blog.golang.org/laws-of-reflection पर्याप्त होना चाहिए, हालांकि गो में परावर्तन से संबंधित कई SO प्रश्न हैं जो आपकी मदद करने के साथ-साथ आपकी मदद भी करते हैं।

— इंटरमेरनेट

uhhh, मैं कैसे निर्धारित कर सकता हूं कि प्रकार एक स्ट्रिंग है? if reflect.TypeOf(err) == string?

— अलेक्जेंडर मिल्स

Answer 4

एक स्ट्रिंग प्रतिनिधित्व प्राप्त करने के लिए:

से 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

Comments

बहुत ही व्यावहारिक दृष्टिकोण +1

— बिजान

Answer 5

मैं चिंतन से दूर रहूंगा। पैकेज। इसके बजाय% 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)
 }

Answer 6

सबसे अच्छा तरीका है Google में प्रतिबिंब अवधारणा का उपयोग करना।
reflect.TypeOfपैकेज नाम के साथ
reflect.TypeOf().Kind()प्रकार देता है अंडरलाइनिंग प्रकार देता है

Comments

यह मुझे लगता है कि एक बेहतर जवाब है

— Ezio

Answer 7

संक्षिप्त होने के लिए, कृपया fmt.Printf("%T", var1) fmt पैकेज में या इसके अन्य वेरिएंट का उपयोग करें ।

Answer 8

आप "प्रतिबिंबित" संकुल 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)
}

Answer 9

संरचना में फ़ील्ड के प्रकार प्राप्त करने के लिए

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 में देखें

Answer 10

आप उपयोग कर सकते हैं reflect.TypeOf।

• बुनियादी प्रकार (जैसे: int, string): यह अपने नाम वापस आ जाएगी (जैसे: int, string)
• struct: यह प्रारूप में कुछ वापस आ जाएगी <package name>.<struct name>(जैसे: main.test)

Answer 11

यदि हमारे पास यह चर हैं:

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: प्रतिबिंबित। टाइपऑफ़ फ़ंक्शन: इस सुविधा का उपयोग करने के लिए आपको "प्रतिबिंबित" आयात करना चाहिए

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

3: प्रतिबिंबित। ValueOf (X) .Kind () : इस सुविधा का उपयोग करने के लिए आपको "प्रतिबिंबित" आयात करना चाहिए

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

Answer 12

आप 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)
      }
    }
}

Answer 13

प्रतिबिंबित पैकेज बचाव के लिए आता:

reflect.TypeOf(obj).String()

इस डेमो की जाँच करें

Answer 14

आप बस fmt पैकेज fmt.Printf () विधि, अधिक जानकारी: https://golang.org/pkg/fmt/ का उपयोग कर सकते हैं

उदाहरण: https://play.golang.org/p/aJG5MOxjBJD