go - ordenado - Cómo declarar un mapa constante

recorrer un map java

Question

Estoy tratando de declarar constante en Go, pero está arrojando 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 {

Answer 1

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

Answer 2

Puedes 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 puedes crear una constante enum:

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

No puede crear constantes de mapas, matrices y está escrito de manera efectiva :

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 del tiempo de compilación, las expresiones que los 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 de función a math.Sin debe ocurrir en tiempo de ejecución.

Answer 3

Puedes emular un mapa con un cierre:

package main

import (
    "fmt"
)

// http://.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 parque infantil Go

Answer 4

Tu sintaxis es incorrecta Para hacer un mapa literal (como una pseudo-constante), puedes 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 func puedes declararlo así:

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

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

Pruébalo en el patio de Go.

Answer 5

Y como 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 conveniencia del tipo de mapa sin el envoltorio de 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)
        }

Pruebe esto en play.golang.org.