Golang変換リストは、私は2つの構造体を持っている文字列

Question

に反対します。 bankcodesは、bankcodesのみを含んでいます。それは[]string

2つの機能を使うほど簡単です。

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のようなものは動作しません。しかし、インタフェースは共通のフィールドではなく関数を記述できるだけなので、ゲッター（本質的に）を実装する必要があります。

// 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

あなたはそうのように一つの共通の機能を使用することができます。コード（The Go Playgroundにしてみてください）

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 
} 

---

：あなたの答えのための

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 
}