Was ist der Unterschied zwischen diesen beiden Varianten?

Question

Ich habe versucht, meinen eigenen Code für das Lernen, wie zurückzukehren mehrere Werte in Hauptfunktion zu machen:

package main 

import "fmt" 

func main() { 
    fmt.Println("Enter a integer:") 
    var I int 
    fmt.Scanf("%d", &I) 
    fmt.Println("Accepted:", I) 

    O := half(I) 
    fmt.Println("Returned:", O) 
} 

func half(N int) (int, bool) { 
    var NA int 
    NA = N/2 
    if NA%2 == 0 { 
     fmt.Println("even") 
     return NA, true 
    } else { 
     fmt.Println("odd") 
     return NA, false 
    } 
} 

Und da Fehler: half.go|11| multiple-value half() in single-value context. jedoch eine andere Variante arbeiten:

package main 

import (
    "fmt" 
) 

func half(number int) (int, bool) { 
    if x := int(number % 2); x == 0 { 
     return x, true 
    } else { 
     return x, false 
    } 
} 

func main() { 
    fmt.Println(half(1)) 
    fmt.Println(half(2)) 
} 

Was mache ich falsch? Wie überwinde ich meinen Fehler?

Answer 1

fmt.Println akzeptiert eine beliebige Anzahl von Argumenten, ist also in Ordnung, die Ergebnisse von half zu akzeptieren.

In der ersten müssen Sie Plätze für beide Variablen angeben. Entweder:

i,b := half(2)

oder

i, _ := half(2)

wenn Sie brauchen nicht auf die zweite Rückkehr.

Answer 2

Wenn eine Funktion 2 Rückgabewerte hat, müssen Sie beide oder gar keine "erwarten". Mehr dazu: Return map like 'ok' in Golang on normal functions

Ihre half() Funktion hat 2 Rückgabewert, so dass, wenn ein short variable declaration mit den zurückgegebenen Werten in Variablen zu speichern, müssen Sie zwei Variablen liefern:

O, even := half(I) 
fmt.Println("Returned:", O, even) 

Im zweiten Fall, Sie sind nicht die zurückgegebenen Werte zu speichern, bis Sie sie fmt.Println() sind, durch die der Signatur hat:

func Println(a ...interface{}) (n int, err error) 

fmt.Println() hat einen variadische Parameter, so dass Sie jede num passieren Argumente dafür. Was hier passiert, ist, dass alle multiplen Rückgabewerte von half() als Wert des Variadic-Parameters Println() übergeben werden. Dies ist erlaubt und detailliert in Spec: Calls:

As a special case, if the return values of a function or method g are equal in number and individually assignable to the parameters of another function or method f , then the call f(g(parameters_of_g)) will invoke f after binding the return values of g to the parameters of f in order. The call of f must contain no parameters other than the call of g , and g must have at least one return value. If f has a final ... parameter, it is assigned the return values of g that remain after assignment of regular parameters.

Beachten Sie, dass wenn sie dies tut, werden Sie zusätzliche Parameter nicht erlaubt passieren/bieten, so zum Beispiel des folgenden ist auch ein Fehler bei der Kompilierung:

fmt.Println("Returned:", half(10)) 
// Error: multiple-value half() in single-value context 

Schauen Sie sich diese ähnlichen Fragen:

Go: multiple value in single-value context

Avoid nesting from conjunction with function that returns 2 values in go?