गोलांग में गतिशील प्रकार की संरचना कैसे वापस करें?

Question

मैं कुछ वेब प्रोजेक्ट के लिए गोलांग रीवेल का उपयोग कर रहा हूं और मुझे अब तक 12 परियोजनाएं पसंद आईं। उन सभी में मेरे पास रिटर्न प्रकारों के कारण बहुत सी कोड रिडंडेंसी है। इन दो कार्यों को देखें:

func (c Helper) Brands() []*models.Brand{ 

    //do some select on rethinkdb and populate correct model 
    var brands []*models.Brand 
    rows.All(&brands) 

    return brands 

} 

func (c Helper) BlogPosts() []*models.Post{ 

    //do some select on rethinkdb and populate correct model 
    var posts []*models.Post 
    rows.All(&posts) 

    return posts 

} 

जैसा कि आप देख सकते हैं कि वे दोनों एक ही प्रकार के डेटा (प्रकार संरचना) लौटाते हैं। मेरा विचार सिर्फ इस तरह स्ट्रिंग वर पारित करने के लिए किया गया था:

func (c Helper) ReturnModels(modelName string) []*interface{} { 

    //do rethinkdb select with modelName and return []*interface{} for modelName 
} 

इस तरह मैं के बजाय डेटा प्रकार लौट विभिन्न मॉडलों लेकिन एक ही डेटा प्रकार के लिए फिर से अधिक से अधिक एक ही बात करने के लिए सिर्फ एक सहायक हो सकता है।

मेरे प्रश्न हैं:

1. यदि हाँ तुम मुझे सही डॉक्स
2. नहीं हैं को इंगित कर सकते हैं सभी
3. पर यह संभव है, मैं अपने जवाब :)
वापस जाने के लिए और अधिक तो खुश हो जाएगा

Answer 1

हां यह संभव है हालांकि आपका फ़ंक्शन interface{} और []*interface पर वापस नहीं होना चाहिए।

func (c Helper) ReturnModels(modelName string) interface{} {} 

इस मामले में आप Type Switches and/or Type Assertions का उपयोग वापसी मान कास्ट करने के लिए में मूल प्रकार है सकता है।

उदाहरण

नोट: मैं रेवेल उपयोग नहीं किया है, लेकिन निम्नलिखित स्निपेट आप एक एक सामान्य विचार देना चाहिए:

Playground

package main 

import "fmt" 

type Post struct { 
    Author string 
    Content string 
} 

type Brand struct { 
    Name string 
} 

var database map[string]interface{} 

func init() { 
    database = make(map[string]interface{}) 

    brands := make([]Brand, 2) 
    brands[0] = Brand{Name: "Gucci"} 
    brands[1] = Brand{Name: "LV"} 

    database["brands"] = brands 

    posts := make([]Post, 1) 
    posts[0] = Post{Author: "J.K.R", Content: "Whatever"} 

    database["posts"] = posts 
} 

func main() { 
    fmt.Println("List of Brands: ") 
    if brands, ok := ReturnModels("brands").([]Brand); ok { 
     fmt.Printf("%v", brands) 
    } 

    fmt.Println("\nList of Posts: ") 
    if posts, ok := ReturnModels("posts").([]Post); ok { 
     fmt.Printf("%v", posts) 
    } 

} 

func ReturnModels(modelName string) interface{} { 

    return database[modelName] 
}