web-dev-qa-db-fra.com

Allez golang, erreur de syntaxe: inattendu ++, attend:

  func test(args ...string) {
    var msg map[string] interface{}

    i := 0
    msg["product"] = args[i++]
    msg["key"] = args[i++]
    msg["signature"] = args[i++]
    msg["string_to_sign"] = args[i++]
  }

  go build utils.go

après la compilation, j'obtiens le message d'erreur

    ./utils.go:28: syntax error: unexpected ++, expecting :
    ./utils.go:28: missing statement after label
    ./utils.go:29: syntax error: unexpected ++, expecting :
    ./utils.go:30: syntax error: unexpected ++, expecting :
    ./utils.go:31: syntax error: unexpected ++, expecting :
    ./utils.go:36: syntax error: unexpected ++, expecting :
    ./utils.go:37: syntax error: unexpected ++, expecting :

pourquoi ne puis-je pas mettre i ++ dans l'index de tranche? y a-t-il une limitation de l'indice de tranche?

syntaxgo
31
HardySimpson

Aller à la foire aux questions (FAQ)

Pourquoi les instructions ++ et - et non les expressions? Et pourquoi le suffixe, pas le préfixe?

Sans arithmétique de pointeur, la valeur de commodité des opérateurs d'incrémentation pré et postfix diminue. En les supprimant complètement de la hiérarchie des expressions, la syntaxe des expressions est simplifiée et les problèmes compliqués concernant l'ordre d'évaluation de ++ et considérez f (i ++) et p [i] = q [++ i]) sont également éliminés. . La simplification est importante. En ce qui concerne le suffixe par rapport au préfixe, l'un ou l'autre fonctionnerait bien, mais la version du suffixe est plus traditionnelle; l'insistance sur le préfixe est apparue avec la STL, une bibliothèque pour une langue dont le nom contient, ironiquement, un incrément postfixé.

--- (La spécification du langage de programmation Go

instructions IncDec

Les instructions "++" et "-" incrémentent ou décrémentent leurs opérandes de la constante non typée 1. Comme pour une affectation, l'opérande doit être adressable ou une expression d'index de mappage.

IncDecStmt = Expression ( "++" | "--" ) .

Les instructions d'affectation suivantes sont sémantiquement équivalentes:

IncDec statement    Assignment
x++                 x += 1
x--                 x -= 1

Écrire,

func test(args ...string) {
    var msg map[string]interface{}
    i := 0
    msg["product"] = args[i]
    i++
    msg["key"] = args[i]
    i++
    msg["signature"] = args[i]
    i++
    msg["string_to_sign"] = args[i]
}

Ce qui, dans votre cas particulier, se simplifie,

func test(args ...string) {
    var msg map[string]interface{}
    msg["product"] = args[0]
    msg["key"] = args[1]
    msg["signature"] = args[2]
    msg["string_to_sign"] = args[3]
}
40
peterSO

Selon la spécification de langue, http://golang.org/ref/spec#IncDec_statements , i ++ est un IncDec statements, qui est un statement, mais pas un expression. Quant à args[index], l'index doit être un expression. Vous voulez plus de détails, lisez-le simplement Go Language Specification, c'est exactement ce que la langue demande.

14
frank.lin

Comme d'autres l'ont dit i++ est une instruction dans go, pas une expression comme dans c. go a une manière différente d'exprimer la même intention en utilisant l'affectation multiple:

func test(args ...string) {
    msg := make(map[string]string)
    i := 0

    msg["product"], i = args[i], i+1
    msg["key"], i = args[i], i+1
    msg["signature"], i = args[i], i+1
    msg["string_to_sign"], i = args[i], i+1

    fmt.Printf("%v\n", msg)
}

Votre définition de map aurait également échoué lors de l'exécution.

11
AndrewN

++ l'opérateur est décevant. Voici mon hack:

func test(args ...string) {
    i := 0
    inc := func(i *int) int { *i++; return i }
    var msg map[string] interface{}

    msg["product"] = args[inc(&i)]
    msg["key"] = args[inc(&i)]
    msg["signature"] = args[inc(&i)]
    msg["string_to_sign"] = args[inc(&i)]
  }
1
Schultz9999