Forma idiomática de hacer una aserción de conversión/tipo en valores de retorno múltiples en Ir

Question

¿Cuál es la forma idiomática de emitir valores de retorno múltiples en Go?

¿Puede hacerlo en una sola línea, o necesita usar variables temporales como las que he hecho en mi ejemplo a continuación?

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") 
    } 
} 

Por cierto, se llama casting cuando se trata de interfaces?

i := interface.(int) 

Answer 1

No puede hacerlo en una sola línea. Su enfoque de variable temporal es el camino a seguir.

Por cierto, ¿se llama fundición cuando se trata de interfaces?

En realidad se llama type assertion. Un tipo fundido conversión es diferente:

var a int 
var b int64 

a = 5 
b = int64(a) 

Answer 2

template.Must es el enfoque de la biblioteca estándar para devolver sólo el primer valor de retorno en un comunicado. Se podría hacer lo mismo para su caso:

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

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

Mediante el uso de must que básicamente dice que nunca debería haber un error, y si la hay, entonces el programa no puede (o al menos no debería) mantener operativo , y entrará en pánico.

Answer 3

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

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

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

pero es más probable lo que realmente quiere es utilizar un interruptor de tipo, al igual-a-esto:

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. 
} 

Go es realmente más sobre la corrección de lo que se trata de concisión.

Answer 4

O simplemente en un solo caso:

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

Go se hará cargo de los actores dentro de la cláusula y si le permiten acceder a las propiedades del tipo de fundido.