Idiomatische Methode zur Konvertierung / Typzusicherung für mehrere Rückgabewerte in Go

Was ist die idiomatische Methode, um mehrere Rückgabewerte in Go umzuwandeln?

Können Sie dies in einer einzelnen Zeile tun oder müssen Sie temporäre Variablen verwenden, wie ich es in meinem Beispiel unten getan habe?

package main

import "fmt"

func oneRet() interface{} {
    return "Hello"
}

func twoRet() (interface{}, error) {
    return "Hejsan", nil
}

func main() {
    // With one return value, you can simply do this
    str1 := oneRet().(string)
    fmt.Println("String 1: " + str1)

    // It is not as easy with two return values
    //str2, err := twoRet().(string) // Not possible
    // Do I really have to use a temp variable instead?
    temp, err := twoRet()
    str2 := temp.(string)
    fmt.Println("String 2: " + str2 )


    if err != nil {
        panic("unreachable")
    }   
}

Wird es übrigens genannt, castingwenn es um Schnittstellen geht?

i := interface.(int)

Sie können es nicht in einer einzigen Zeile tun. Ihr temporärer variabler Ansatz ist der richtige Weg.

Wird es übrigens Casting genannt, wenn es um Schnittstellen geht?

Es wird eigentlich eine Typzusicherung genannt . Eine Art gegossene Umwandlung unterscheidet:

var a int
var b int64

a = 5
b = int64(a)

func silly() (interface{}, error) {
    return "silly", nil
}

v, err := silly()
if err != nil {
    // handle error
}

s, ok := v.(string)
if !ok {
    // the assertion failed.
}

Wahrscheinlicher ist jedoch, dass Sie einen Typschalter verwenden möchten, wie z.

switch t := v.(type) {
case string:
    // t is a string
case int :
    // t is an int
default:
    // t is some other type that we didn't name.
}

Bei Go geht es mehr um Korrektheit als um Knappheit.

Oder einfach nur in einem, wenn:

if v, ok := value.(migrater); ok {
    v.migrate()
}

Go kümmert sich um die Umwandlung in der if-Klausel und lässt Sie auf die Eigenschaften des umgesetzten Typs zugreifen.

template.Must ist der Ansatz der Standardbibliothek, bei dem nur der erste Rückgabewert in einer Anweisung zurückgegeben wird. Könnte für Ihren Fall ähnlich gemacht werden:

func must(v interface{}, err error) interface{} {
    if err != nil {
        panic(err)
    }
    return v
}

// Usage:
str2 := must(twoRet()).(string)

Wenn mustSie verwenden, sagen Sie im Grunde, dass es niemals einen Fehler geben sollte, und wenn dies der Fall ist, kann (oder sollte) das Programm nicht weiterarbeiten und gerät stattdessen in Panik.