Comment déclarer une carte constante en Golang ?

Question

J'essaie de déclarer une constante en Go, mais une erreur se produit. Quelqu'un pourrait-il m'aider avec la syntaxe de la déclaration d'une constante en Go ?

Voici mon code :

const romanNumeralDict map[int]string = {
  1000: "M",
  900 : "CM",
  500 : "D",
  400 : "CD",
  100 : "C",
  90  : "XC",
  50  : "L",
  40  : "XL",
  10  : "X",
  9   : "IX",
  5   : "V",
  4   : "IV",
  1   : "I",
}

Voici l'erreur

# command-line-arguments
./Roman_Numerals.go:9: syntax error: unexpected {

Answer 1

Votre syntaxe est incorrecte. Pour faire une carte littérale (comme une pseudo-constante), vous pouvez faire :

var romanNumeralDict = map[int]string{
  1000: "M",
  900 : "CM",
  500 : "D",
  400 : "CD",
  100 : "C",
  90  : "XC",
  50  : "L",
  40  : "XL",
  10  : "X",
  9   : "IX",
  5   : "V",
  4   : "IV",
  1   : "I",
}

A l'intérieur d'un func vous pouvez le déclarer comme :

romanNumeralDict := map[int]string{
...

Et au Go, il n'existe pas de carte constante. Vous trouverez de plus amples informations aquí .

Essayez-le sur le terrain de jeu Go.

Answer 2

Vous pouvez créer des constantes de plusieurs façons différentes :

const myString = "hello"
const pi = 3.14 // untyped constant
const life int = 42 // typed constant (can use only with ints)

Vous pouvez également créer une constante enum :

const ( 
   First = 1
   Second = 2
   Third = 4
)

Vous ne pouvez pas créer de constantes de cartes, de tableaux et c'est écrit en aller efficace :

Les constantes en Go sont juste ce qu'elles sont : des constantes. Elles sont créées à la compilation même lorsqu'elles sont définies en tant que locales dans les fonctions, et peuvent seulement être des nombres, des caractères (runes), des chaînes de caractères ou des booléens. En raison de cette restriction au moment de la compilation, les expressions qui les définissent doivent être des expressions constantes, évaluables par le compilateur. Par exemple, 1<<3 est une expression constante, alors que math.Sin(math.Pi/4) ne l'est pas car l'appel de fonction à math.Sin doit être évalué par le compilateur. car l'appel de fonction à math.Sin doit se produire au moment de l'exécution.

Answer 3

Vous pouvez émuler une carte avec une fermeture :

package main

import (
    "fmt"
)

// http://stackoverflow.com/a/27457144/10278

func romanNumeralDict() func(int) string {
    // innerMap is captured in the closure returned below
    innerMap := map[int]string{
        1000: "M",
        900:  "CM",
        500:  "D",
        400:  "CD",
        100:  "C",
        90:   "XC",
        50:   "L",
        40:   "XL",
        10:   "X",
        9:    "IX",
        5:    "V",
        4:    "IV",
        1:    "I",
    }

    return func(key int) string {
        return innerMap[key]
    }
}

func main() {
    fmt.Println(romanNumeralDict()(10))
    fmt.Println(romanNumeralDict()(100))

    dict := romanNumeralDict()
    fmt.Println(dict(400))
}

Essayez-le sur l'aire de jeu en mouvement

Answer 4

Et comme suggéré ci-dessus par Siu Ching Pong -Asuka Kenji avec la fonction, ce qui, à mon avis, est plus logique et vous permet de bénéficier de la commodité du type de carte sans l'enveloppe de la fonction :

   // romanNumeralDict returns map[int]string dictionary, since the return
       // value is always the same it gives the pseudo-constant output, which
       // can be referred to in the same map-alike fashion.
       var romanNumeralDict = func() map[int]string { return map[int]string {
            1000: "M",
            900:  "CM",
            500:  "D",
            400:  "CD",
            100:  "C",
            90:   "XC",
            50:   "L",
            40:   "XL",
            10:   "X",
            9:    "IX",
            5:    "V",
            4:    "IV",
            1:    "I",
          }
        }

        func printRoman(key int) {
          fmt.Println(romanNumeralDict()[key])
        }

        func printKeyN(key, n int) {
          fmt.Println(strings.Repeat(romanNumeralDict()[key], n))
        }

        func main() {
          printRoman(1000)
          printRoman(50)
          printKeyN(10, 3)
        }

Essayez ceci à play.golang.org.

Answer 5

Comme indiqué ci-dessus, il est impossible de définir une carte comme constante. Mais vous pouvez déclarer une variable globale qui est une structure contenant une carte.

L'initialisation ressemblerait à ceci :

var romanNumeralDict = struct {
    m map[int]string
}{m: map[int]string {
    1000: "M",
    900: "CM",
    //YOUR VALUES HERE
}}

func main() {
    d := 1000
    fmt.Printf("Value of Key (%d): %s", d, romanNumeralDict.m[1000])
}