प्रतिबिंब का उपयोग कर गोलांग प्रकार का दावा। टाइप()

Question

मैंने स्ट्रिंग मान (नाम) के साथ एक संरचना की पहचान करने की कोशिश की है। reflect.TypeOfType देता है।

लेकिन प्रकार के दावे को type की आवश्यकता है।

मैं Type से type पर कैसे जा सकता हूं?

या इसे संभालने के लिए कोई सुझाव?

http://play.golang.org/p/3PJG3YxIyf

package main 

import (
"fmt" 
"reflect" 
) 
type Article struct { 
    Id    int64  `json:"id"` 
    Title   string  `json:"title",sql:"size:255"` 
    Content  string  `json:"content"` 
} 


func IdentifyItemType(name string) interface{} { 
    var item interface{} 
    switch name { 
    default: 
     item = Article{} 
    } 
    return item 
} 

func main() { 

    i := IdentifyItemType("name") 
    item := i.(Article) 
    fmt.Printf("Hello, item : %v\n", item) 
    item2 := i.(reflect.TypeOf(i)) // reflect.TypeOf(i) is not a type 
    fmt.Printf("Hello, item2 : %v\n", item2) 

} 

Answer 1

मुझे लगता है कि आप के लिए यहाँ देख रहे हैं एक प्रकार स्विच है। https://tour.golang.org/methods/16

Answer 2

एक प्रकार का दावा, वाक्य रचनात्मक रूप से, एक अभिव्यक्ति नहीं, कोष्ठक में एक प्रकार लेता है। तो यह एक वाक्यविन्यास त्रुटि है।

आप रनटाइम पर गणना की गई मान के साथ एक प्रकार का दावा करने की कोशिश कर रहे हैं। क्या इसका कोई मतलब है? आइए सोचें कि किस प्रकार का दावा है।

एक प्रकार अभिकथन दो बातें शामिल हैं: संकलन समय पर

1. : यह वांछित संकलन समय प्रकार के परिणामस्वरूप अभिव्यक्ति का कारण बनता है। अभिव्यक्ति x.(T) में संकलन-समय प्रकार T है। यह आपको अभिव्यक्ति को सामान T के साथ करने की अनुमति देता है, जिसे आप x के प्रकार से नहीं कर पाएंगे।
2. रनटाइम पर: यह जांचता है कि मान nil नहीं है और वास्तव में दिए गए प्रकार का है, और यदि नहीं, तो यह एक आतंक का कारण बनता है।

पहला भाग स्पष्ट रूप से रनटाइम पर गणना की गई एक प्रकार के लिए समझ में नहीं आता है। परिणामस्वरूप अभिव्यक्ति का संकलन-समय प्रकार किसी ऐसी चीज़ पर निर्भर नहीं हो सकता है जो संकलन-समय पर ज्ञात नहीं है।

दूसरा (रनटाइम चेक) रनटाइम पर गणना की गई एक प्रकार के साथ किया जा सकता है। कुछ ऐसा:

if reflect.TypeOf(x) != someTypeComputedAtRuntime { 
    panic(42) 
} 

Answer 3

यदि आपको बाहरी इंटरफ़ेस के प्रकार को स्विच करने की आवश्यकता है {} आपको प्रतिबिंब की आवश्यकता नहीं है।

switch x.(type){ 
    case int: 
    dosomething() 
} 

... लेकिन अगर आप एक अंतरफलक में विशेषताओं के प्रकार पर स्विच करने की आवश्यकता है तो आप ऐसा कर सकते हैं:

s := reflect.ValueOf(x) 
for i:=0; i<s.NumValues; i++{ 
    switch s.Field(i).Interface().(type){ 
    case int: 
     dosomething() 
    } 
} 

मैं एक क्लीनर रास्ता नहीं मिला है, मैं था यह जानना अच्छा लगता है कि यह मौजूद है या नहीं।

Answer 4

मुझे लगता है कि आप इस

item2 := reflect.ValueOf(i) 
fmt.Printf("Hello, item2 : %v\n", item2) 

Answer 5

हल करने के लिए उपयोग कर सकते हैं valueOf आप शोर संभालने के लिए और एक अतिरिक्त तरीका है जिसके सभी प्रकार जैसे लागू लागू कर सकते हैं, तो 'टाइप() स्ट्रिंग', आप ऐसा कुछ कर सकते हैं:

 ve := &ValidationError{} 
     nf := &NotFound{} 

     switch err.Type() { 
     case ve.Type() : 
      SendBadRequest(w, err) 
     case nf.Type() : 
      http.NotFound(w, r) 
     default: 
      SendInternalError(w, err) 
     } 
     return