So deklarieren Sie eine konstante Karte

Ich versuche, in Go die Konstante zu deklarieren, aber es wird ein Fehler ausgegeben. Könnte mir bitte jemand bei der Syntax helfen, eine Konstante in Go zu deklarieren?

Das ist mein 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",
}

Dies ist der Fehler

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

Ihre Syntax ist falsch. Um eine Literalkarte (als Pseudokonstante) zu erstellen, haben Sie folgende Möglichkeiten:

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

In a können funcSie es wie folgt deklarieren:

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

Und in Go gibt es keine konstante Karte. Weitere Informationen finden Sie hier .

Probieren Sie es auf dem Go-Spielplatz aus.

Sie können Konstanten auf viele verschiedene Arten erstellen:

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

Sie können auch eine Aufzählungskonstante erstellen:

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

Sie können keine Konstanten von Maps, Arrays erstellen und es ist in effektiver Form geschrieben :

Konstanten in Go sind genau das - Konstante. Sie werden zur Kompilierungszeit erstellt, auch wenn sie in Funktionen als lokale Elemente definiert sind. Sie können nur Zahlen, Zeichen (Runen), Zeichenfolgen oder Boolesche Werte sein. Aufgrund der Einschränkung der Kompilierungszeit müssen die Ausdrücke, die sie definieren, konstante Ausdrücke sein, die vom Compiler ausgewertet werden können. Zum Beispiel ist 1 << 3 ein konstanter Ausdruck, während math.Sin (math.Pi / 4) dies nicht ist, weil der Funktionsaufruf von math.Sin zur Laufzeit erfolgen muss.

Sie können eine Karte mit einem Abschluss emulieren:

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

Probieren Sie es auf dem Go-Spielplatz aus

Und wie oben von Siu Ching Pong-Asuka Kenji mit der Funktion vorgeschlagen, die meiner Meinung nach sinnvoller ist und Ihnen den Komfort des Kartentyps ohne den Funktionsumbruch bietet:

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

Versuchen Sie dies auf play.golang.org.

Wie oben angegeben, ist es nicht möglich, eine Karte als konstant zu definieren. Sie können jedoch eine globale Variable deklarieren, bei der es sich um eine Struktur handelt, die eine Karte enthält.

Die Initialisierung würde folgendermaßen aussehen:

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