Idiomatyczny sposób na konwersję/typ asercji dla wielu wartości zwracanych w Go

Question

Jaki jest idiomatyczny sposób przesyłania wielu wartości zwracanych w Go?

Czy możesz to zrobić w pojedynczej linii, czy też musisz użyć zmiennych tymczasowych, takich jak w poniższym przykładzie?

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

Nawiasem mówiąc, jest to nazywane casting jeśli chodzi o interfejsy?

i := interface.(int) 

Answer 1

Nie można tego zrobić w pojedynczej linii. Twoje tymczasowe zmienne podejście jest drogą do zrobienia.

Nawiasem mówiąc, czy to się nazywa casting, jeśli chodzi o interfejsy?

To tak naprawdę nazywa się type assertion. typ obsada konwersji jest inna:

var a int 
var b int64 

a = 5 
b = int64(a) 

Answer 2

template.Must jest podejście biblioteki standardowej dla powrocie tylko pierwszą wartość zwracaną w jednym sprawozdaniu. Można zrobić podobnie do przypadku:

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

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

Korzystając must można w zasadzie powiedzieć, że nigdy nie powinno być błędu, a jeśli nie jest, to program może nie (a przynajmniej nie powinien) prowadzić eksploatację i zamiast tego wpadnie w panikę.

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

ale bardziej prawdopodobne, co rzeczywiście chcesz jest użycie przełącznika typu, jak to-a-:

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 jest naprawdę więcej o poprawności niż o lapidarnością, jakiej.

Answer 4

lub tylko w jednym przypadku gdy:

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

Go zadba o obsadzie wewnątrz jeśli klauzulę oraz umożliwiają dostęp do właściwości lanego typu.