De retour d'erreur du canal

Quand j'écris une fonction en Aller, il doit retourner une valeur et un message d'erreur comme

func createHashedPassword(password string) string, error {
    //code
}

Je veux exécuter cette createHashedPassword dans une goroutine et je pense que pour transmettre des données via le canal.
Mais ma question est, comment puis-je gérer l'erreur ici ou dans la goroutine?

OriginalL'auteur zero_coding | 2014-08-05

27

Il est courant de regrouper plusieurs sorties dans un struct, et de revenir ensemble sur un seul canal.
```
type Result struct {
    Message string
    Error error
}

ch := make(chan Result)
```
Dois-je passer ici une référence de type de droite? J'ai lu quelque part, lorsqu'il est possible d'éviter de passer le type de référence sur canal, c'est vrai?
c'est incorrect, et voulez-vous dire un pointeur? Il n'y a aucun officiel de la notion de "type de référence', mais les tranches et les cartes sont souvent appelés "types de référence". Vous pouvez entrer ce que vous voulez par le biais d'un canal, avec la même sémantique que n'importe quel autre appel ou de la cession.
L'Aller slogan est "Ne pas communiquer par le partage de la mémoire; au lieu de cela, partager de la mémoire par la communication". Les canaux de vous donner un moyen de communication entre les threads sans avoir besoin de les protéger contre l'accès à la mémoire en même temps. Vous pouvez ainsi partager un pointeur, mais (si je comprends droit) faire en sorte que vous n'aurez pas deux ou plusieurs threads accèdent à la mémoire en même temps. Un thread peut recevoir un pointeur, faire des travaux sur la mémoire de points, puis l'abandonner et de passer le pointeur sur à travers un canal. Seul un thread de travail sur le pointeur à un moment donné.

OriginalL'auteur JimB

Vous pouvez passer à une erreur de canal ainsi qu'un résultat de canal.

errors := make(chan error, 0)
results := make(chan string, 0)

password := "test"

go func() {
    result, err := createHashedPassword(string password)
    if err != nil {
        errors <- err
        return
    }

    results <- result
}()

//do something else

//When you are ready to read from goroutine do this:
select {
    case err := <- errors:
        println(err)
    case res := <- results:
        println(res)
}

OriginalL'auteur rauyran

Voici deux de mes méthodes préférées:

Deux canaux, enveloppé

C'est le "deux voies", mais enveloppée dans une fonction pour le faire ressembler au modèle commun:

func createHashedPasswordAsynchronously(password string) (chan string, chan error) {
    resultCh := make(chan string)
    errorCh := make(chan error)

    go func(password string) {
        //code
        if err != nil {
            errorCh <- errors.New("Does not compute")
        } else {
            resultCh <- "8badf00d"
        }
    }(password)

    return resultCh, errorCh
}

Et appelé comme ceci:

resultCh, errorCh := createHashedPasswordAsynchronously("mysecret")
select {
case result := <- resultCh:
  storeHashedPassword(result)
case err := <- errorCh:
  log.Println(err.Error())
}

Anonyme struct

C'est le "anonyme struct", similaire à @saward réponse, mais sans nommer les les membres de la structure de manière explicite:

ch := make(chan struct{string; error})

go func(password string, ch chan struct {string; error}) {
    //code
    if err != nil {
        ch <- struct{string; error}{"", errors.New("Does not compute")}
    } else {
        ch <- struct{string; error}{"8badf00d", nil}
    }
}("mysecret", ch)

r := <-ch
if r.error != nil {
    log.Println(r.error.Error())
} else {
    storeHashedPassword(r.string)
}

OriginalL'auteur AndreKR

3

(puisque je ne peut pas commenter pour l'instant...)

Je fais écho à ce que JimB a dit:
```
type Result struct {
    Message string
    Error error
}

ch := make(chan Result)
```
Le problème avec les deux canaux distincts, l'un pour le résultat, et un autre pour l'erreur, c'est que (comme je le comprends), il ne prend pas en charge threads simultanés de la boîte.

Vous pourriez, par exemple, ont deux fils de l'envoi des données à la fois, où les réponses sortir de la commande. Qui est, vous recevez le résultat de fil 1 en premier, mais l'erreur de thread 2 premiers.

Il est facile de créer de nouveaux types comme JimB a suggéré, et devrait bien fonctionner avec goroutines.

OriginalL'auteur saward

Vous devez vous connecter pour publier un commentaire.