Golang轉換對象列表串

Question

我有兩個結構：

type A struct { 
    BankCode   string `json:"bankCode"` 
    BankName   string `json:"bankName"` 
} 

和：

type B struct { 
    A 
    extra   string `json:" extra"` 
} 

兩片：
listsA []A和listsB []B 我想從listA和listB得到bankCodes。 bankcodes只包含bankcodes。這是一個[]string

這將是如此簡單，使用兩個功能。

func getBankCodes(data []A) []string { 
    res := make([]string, len(data)) 
    for i := 0; i < len(data); i++ { 
     res[i] = data[i].BankCode 
    } 
    return res 
} 

func getBankCodes(data []B) []string { 
    res := make([]string, len(data)) 
    for i := 0; i < len(data); i++ { 
     res[i] = data[i].BankCode 
    } 
    return res 
} 

如何使用一個常用函數？

Answer 1

那麼幹淨的解決方案就是使用一個接口，因爲go不支持經典繼承，所以像[]parentclass這樣的東西不能工作。但是接口只能描述不是通用字段的函數，所以你必須實現一個Getter（本質上）。

// GetBankCoder provides a function that gives the BankCode 
type GetBankCoder interface { 
    getBankCode() string 
} 

// implement GetBankCoder for A (and indirectly for B) 
func (a A) getBankCode() string { 
    return a.BankCode 
} 

，使您的getBankCodes在該接口類型的工作，注意函數的參數以及循環內的語句：

func getBankCodes(data []GetBankCoder) []string { // <-- changed 
    res := make([]string, len(data)) 
    for i := 0; i < len(data); i++ { 
     res[i] = data[i].getBankCode()    // <-- changed 
    } 
    return res   
} 

還有其他的解決方案，其中，函數參數是interface{}然後反射用來確保你實際上可以做.BankCode，但我不喜歡那些，因爲它們不會增加更多的清晰度。

......但是，我不能讓golang操場正確地工作，而不必先把它放入[]GetBankCoder var，然後再給它函數。

banks := make([]GetBankCoder, 0) 
banks = append(banks, A{ BankCode: "ABC", BankName: "ABC Bank"}) 
getBankCodes(banks) 

Answer 2

你可以使用一個共同的功能，像這樣：

func BankCodes(data interface{}) []string { 
    if reflect.TypeOf(data).Kind() != reflect.Slice { 
     panic("err: data is not slice") 
    } 
    slice := reflect.Indirect(reflect.ValueOf(data)) 
    res := make([]string, slice.Len()) 
    for i := 0; i < slice.Len(); i++ { 
     a := slice.Index(i).Interface().(BankCoder) 
     res[i] = a.Bankcode() 
    } 
    return res 
} 

---

代碼（試穿The Go Playground）：

package main 

import (
    "fmt" 
    "reflect" 
) 

func main() { 
    bs := []B{B{A{"BC1", "BN"}, "e"}, B{A{"BC2", "BN"}, "e"}} 
    strs := BankCodes(bs) 
    fmt.Println(strs) 

    as := []A{A{"AC1", "BN"}, A{"AC2", "BN"}} 
    strs2 := BankCodes(as) 
    fmt.Println(strs2) 

} 

func BankCodes(data interface{}) []string { 
    if reflect.TypeOf(data).Kind() != reflect.Slice { 
     panic("err: data is not slice") 
    } 
    slice := reflect.Indirect(reflect.ValueOf(data)) 
    res := make([]string, slice.Len()) 
    for i := 0; i < slice.Len(); i++ { 
     a := slice.Index(i).Interface().(BankCoder) 
     res[i] = a.Bankcode() 
    } 
    return res 
} 

type A struct { 
    BankCode string `json:"bankCode"` 
    BankName string `json:"bankName"` 
} 

type B struct { 
    A 
    extra string `json:" extra"` 
} 
type BankCoder interface { 
    Bankcode() string 
} 

func (a A) Bankcode() string { 
    return a.BankCode 
}