Aller: opération non valide - type *carte[key]valeur ne prend pas en charge l'indexation

Je suis en train d'écrire une fonction qui modifie la carte originale qui est passé par pointeur, mais Aller ne le permet pas. Disons que j'ai une grosse carte et ne souhaitez pas copier d'avant en arrière.

Le code qui utilise le passage par valeur est de travailler et de faire ce dont j'ai besoin, mais implique le passage par valeur (aire de jeux):

package main

import "fmt"

type Currency string

type Amount struct {
    Currency Currency
    Value float32
}

type Balance map[Currency]float32

func (b Balance) Add(amount Amount) Balance {
    current, ok := b[amount.Currency]
    if ok {
        b[amount.Currency] = current + amount.Value
    } else {
        b[amount.Currency] = amount.Value
    }
    return b
}

func main() {
    b := Balance{Currency("USD"): 100.0}
    b = b.Add(Amount{Currency: Currency("USD"), Value: 5.0})

    fmt.Println("Balance: ", b)
}

Mais si j'essaie de passer le paramètre comme pointeur comme ici (aire de jeux):

func (b *Balance) Add(amount Amount) *Balance {
    current, ok := b[amount.Currency]
    if ok {
        b[amount.Currency] = current + amount.Value
    } else {
        b[amount.Currency] = amount.Value
    }
    return b
}

Je suis d'erreur de compilation:

prog.go:15: invalid operation: b[amount.Currency] (type *Balance does not support indexing)
prog.go:17: invalid operation: b[amount.Currency] (type *Balance does not support indexing)
prog.go:19: invalid operation: b[amount.Currency] (type *Balance does not support indexing)

Comment dois-je faire avec cela?

Double Possible de Allez mise à jour de la tranche d'itération d'erreur "ne prend pas en charge l'indexation"

OriginalL'auteur Alexander Trakhimenok | 2016-04-06

go pass-by-reference

28

Vous essayez d'index sur le pointeur plutôt que la carte elle-même. Un peu déroutant parce que d'habitude, avec des pointeurs vs valeurs de référence est automatique pour les structures. Si votre structure est juste une carte, cependant, c'est passé par référence, de toute façon si vous n'avez pas à vous soucier de la création de méthodes qui agissent sur les pointeurs pour éviter la copie de l'ensemble de la structure à chaque fois. Le code suivant est équivalent à votre premier extrait, mais en utilisant un pointeur de type.
```
package main

import "fmt"

type Currency string

type Amount struct {
    Currency Currency
    Value float32
}

type Balance map[Currency]float32

func (b *Balance) Add(amount Amount) *Balance {
    current, ok := (*b)[amount.Currency]
    if ok {
        (*b)[amount.Currency] = current + amount.Value
    } else {
        (*b)[amount.Currency] = amount.Value
    }
    return b
}

func main() {
    b := &Balance{Currency("USD"): 100.0}
    b = b.Add(Amount{Currency: Currency("USD"), Value: 5.0})

    fmt.Println("Balance: ", (*b))
}
```
Mais pour répondre à la façon de traiter avec elle: si votre structure est juste le type de carte, je ne serais pas s'inquiéter à propos de la rédaction de votre réception de fonctions pour prendre des pointeurs, et de recevoir la valeur, car la valeur n'est qu'une référence, de toute façon. Faire comme dans l'original de votre extrait.

OriginalL'auteur Serdmanczyk

Vous pouvez simplement déréférencer b: (*b)

https://play.golang.org/p/Xq6qFy4_PC

func (b *Balance) Add(amount Amount) *Balance {
    current, ok := (*b)[amount.Currency]
    if ok {
        (*b)[amount.Currency] = current + amount.Value
    } else {
        (*b)[amount.Currency] = amount.Value
    }
    return b
}

Mise à jour

@Serdmanczyk fait un bon point... vous pouvez en toute sécurité passer une carte autour de la valeur, la carte sous-jacente sera mis à jour, pas une copie de la carte. C'est-à-dire, passer par valeur, dans le cas d'une carte signifie en passant l'adresse de la carte, pas le contenu de la carte.

Voir https://play.golang.org/p/i7Yz4zMq4v

type foo map[string]string

func main() {
    a := foo{}
    a["hello"] = "world"
    fmt.Printf("%#v\n", a)
    mod(a)
    fmt.Printf("%#v\n", a)

}

func mod(f foo) {
    f["hello"] = "cruel world"
}

Sorties:

main.foo{"hello":"world"}
main.foo{"hello":"cruel world"}

OriginalL'auteur John Weldon

Vous devez vous connecter pour publier un commentaire.