Cómo declarar mapa constante

Estoy tratando de declarar constante en Go, pero arroja un error. ¿Podría alguien ayudarme con la sintaxis de declarar una constante en Go?

Este es mi código:

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",
}

Este es el error

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

Su sintaxis es incorrecta. Para hacer un mapa literal (como una pseudo-constante), puede hacer:

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",
}

Dentro de un funcpuede declararlo como:

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

Y en Go no existe un mapa constante. Más información se puede encontrar aquí .

Pruébalo en el parque infantil Go.

Puede crear constantes de muchas maneras diferentes:

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

También puede crear una enumeración constante:

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

No puede crear constantes de mapas, matrices y está escrito en go efectivo :

Las constantes en Go son solo eso, constantes. Se crean en tiempo de compilación, incluso cuando se definen como locales en funciones, y solo pueden ser números, caracteres (runas), cadenas o booleanos. Debido a la restricción de tiempo de compilación, las expresiones que las definen deben ser expresiones constantes, evaluables por el compilador. Por ejemplo, 1 << 3 es una expresión constante, mientras que math.Sin (math.Pi / 4) no se debe a que la llamada a la función math.Sin debe suceder en tiempo de ejecución.

Puede emular un mapa con un cierre:

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))
}

Pruébalo en el patio de juegos Go

Y como lo sugirió anteriormente Siu Ching Pong -Asuka Kenji con la función que en mi opinión tiene más sentido y te deja con la comodidad del tipo de mapa sin la envoltura de la función:

   // 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)
        }

Prueba esto en play.golang.org.

Como se indicó anteriormente, definir un mapa como constante no es posible. Pero puede declarar una variable global que es una estructura que contiene un mapa.

La inicialización se vería así:

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])
}