interface{} をソートする

Slice のソート

シンプルに型アサーション (Type Assertions) を使います。

type Person struct {
    Name string
    Age  int
}

type People []Person

func (p People) Len() int           { return len(p) }
func (p People) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p People) Less(i, j int) bool { return p[i].Age < p[j].Age }

func Sort(v interface{}) interface{} {
    s, ok := v.(sort.Interface)
    if !ok {
        return v
    }
    sort.Sort(s)
    return s
}

func main() {
    people := People{{"Bob", 31}, {"John", 42}, {"Michael", 17}, {"Jenny", 26}}
    fmt.Println(people)  // [{Bob 31} {John 42} {Michael 17} {Jenny 26}]
    Sort(people)
    fmt.Println(people)  // [{Michael 17} {Jenny 26} {Bob 31} {John 42}]
}

interface{} が sort.Interface を実装した Slice であると期待できる場合、この方法で十分でしょう。

入れ子になった Slice のソート

入れ子になった Slice もソートしたい場合は、構造体のフィールドと Slice のインデックスを走査します。

func Sort(v interface{}) {
    switch values := reflect.ValueOf(v); values.Kind() {
    case reflect.Slice:
        for i := 0; i < values.Len(); i++ {
            if values.Index(i).CanSet() {
                Sort(values.Index(i).Interface())
            }
        }
    case reflect.Struct:
        for i := 0; i < values.NumField(); i++ {
            if values.Field(i).CanSet() {
                Sort(values.Field(i).Interface())
            }
        }
    case reflect.Ptr:
        Sort(values.Elem().Interface())
    }
    if s, ok := v.(sort.Interface); ok {
        sort.Sort(s)
        return
    }
    switch s := v.(type) {
    case []int:
        sort.Ints(s)
    case []float64:
        sort.Float64s(s)
    case []string:
        sort.Strings(s)
    }
}

sort.Interface が実装されていないフィールドが []int, []float64, []string のいずれかだったときは sort パッケージに用意されているデフォルト実装でソートを行うようにしています。