Dlaczego powinny być zwracane nazwy parametrów?

Question

Jakie korzyści wynikają z nazewnictwa parametrów zwracanych przez funkcję?

func namedReturn(i int) (ret int) { 
    ret = i 
    i += 2 
    return 
} 

func anonReturn(i int) int { 
    ret := i 
    i += 2 
    return ret 
} 

Answer 1

Istnieją pewne korzyści dla ich nazewnictwa:

• Służy jako dokumentacji.
• Są one automatycznie zadeklarowane i zainicjowane na wartości zerowe.
• Jeśli masz wiele witryn zwrotnych, nie musisz ich zmieniać, jeśli zmienisz wartości zwracane przez funkcję, ponieważ po prostu powiesz "return".

Istnieją również wady, głównie że łatwo jest przypadkowo je zacienić, deklarując zmienną o tej samej nazwie.

Efektywny Go ma section on named result parameters.

Answer 2

Jest to przydatne w co najmniej dwóch przypadkach:

1. Ilekroć trzeba zadeklarować zmienne, które zamierzamy powrócić. Na przykład.

   func someFunc() (int, error) { 
       var r int 
       var e error 
       ok := someOtherFunc(&r) // contrived, I admit 
       if !ok { 
        return r, someError() 
       } 
       return r, nil 
   } 
   

   vs.

   func someFunc() (r int, e error) { 
       ok := someOtherFunc(&r) 
       if !ok { 
        e = someError() 
       } 
       return 
   } 
   

   ten staje się coraz bardziej ważne, jak liczba ścieżek wykonawczej przez wzrasta funkcyjnych.

2. Podczas dokumentowania wartości zwracanych i chcesz odwoływać się do nich po nazwie. godoc uwzględnia zmienne zwracane jako część podpisu funkcji.

Answer 3

Na przykład nazwane parametry powrotu są dostępne za pomocą, no, nazwa.

func foo() (a, b, c T) { 
     // ... 
     if qux { 
       b = bar() 
     } 
     // ... 
     return 
} 

To nie jest łatwe do powielenia bez nazwanych parametrów zwracanych. Należy wprowadzić zmienne lokalne o zasadniczo takiej samej funkcjonalności, co nazwane parametry zwracane:

func foo() (T, T, T) { 
     var a, b, c T 
     // ... 
     if qux { 
       b = bar() 
     } 
     // ... 
     return a, b, c 
} 

Łatwiej jest to dopuścić bezpośrednio.

Dodatkowo są przystępnie również w drugą stronę:

func foo() (a, b, c T) { 
     // ... 
     if a > c { 
       b = bar() 
     } 
     // ... 
     return 
} 

Itd

Answer 4

Innym specjalnego przeznaczenia dla zmiennej o nazwie powrotną ma zostać przechwycone przez odroczony funkcji dosłownym. Niewielka ilustracja:

package main 

import (
    "errors" 
    "fmt" 
) 

func main() { 
    fmt.Println(f()) 
} 

var harmlessError = errors.New("you should worry!") 

func f() (err error) { 
    defer func() { 
     if err == harmlessError { 
      err = nil 
     } 
    }() 
    return harmlessError 
} 

Wyjście to <nil>. W bardziej praktycznych sytuacjach funkcja odroczona może obsługiwać panikę i może modyfikować inne wartości zwracane poza wynikiem błędu. Magia powszechna jednak polega na tym, że odroczony literał ma szansę zmodyfikować wartości zwracane przez f po tym jak f jest zakończone, albo normalnie, albo przez panikę.