Wie überprüfe ich, ob die Schnittstelle {} eine Scheibe ist

Question

Ich bin noob in Go :) so meine Frage kann dumm sein, kann aber keine Antwort finden, so.

Ich brauche eine Funktion:

func name (v interface{}) { 
    if is_slice() { 
     for _, i := range v { 
      my_var := i.(MyInterface) 
      ... do smth 
     } 
    } else { 
     my_var := v.(MyInterface) 
     ... do smth 
    } 
} 

Wie kann ich is_slice in Go tun? Schätze jede Hilfe.

Answer 1

In Ihrem Fall die type switch ist die einfachste und bequemste Lösung:

func name(v interface{}) { 
    switch x := v.(type) { 
    case []MyInterface: 
     fmt.Println("[]MyInterface, len:", len(x)) 
     for _, i := range x { 
      fmt.Println(i) 
     } 
    case MyInterface: 
     fmt.Println("MyInterface:", x) 
    default: 
     fmt.Printf("Unsupported type: %T\n", x) 
    } 
} 

Die case Zweige aufzählen die möglichen Typen, und in ihnen die x Variable wird bereits von diesem Typ sein, so können Sie es verwenden damit.

Testing es:

type MyInterface interface { 
    io.Writer 
} 

var i MyInterface = os.Stdout 
name(i) 
var s = []MyInterface{i, i} 
name(s) 
name("something else") 

Output (versuchen Sie es auf dem Go Playground):

MyInterface: &{0x1040e110} 
[]MyInterface, len: 2 
&{0x1040e110} 
&{0x1040e110} 
Unsupported type: string 

Für einen einzigen Typ überprüfen Sie auch type assertion verwenden:

if x, ok := v.([]MyInterface); ok { 
    // x is of type []MyInterface 
    for _, i := range x { 
     fmt.Println(i) 
    } 
} else { 
    // x is not of type []MyInterface or it is nil 
} 

Es gibt auch andere Möglichkeiten, mit Paket reflect können Sie eine allgemeine (und schreiben langsamere) Lösung, aber wenn du gerade Go startest, solltest du noch nicht ins Nachdenken vertiefen.

Answer 2

icza's answer korrekt ist, aber wird nicht empfohlen, von go creators:

Schnittstelle {} sagt nichts

Ein besserer Ansatz eine Funktion für jeden Typ zu definieren sein können Sie haben:

func name(v MyInterface) { 
    // do something 
} 

func names(vs []MyInterface) { 
    for _, v := range(vs) { 
     name(v) 
    } 
}