Wie man konstante Karte in Golang erklärt

Question

Ich bin neu im Golang. Ich versuche zu erklären, konstant zu gehen. Aber es wirft einen Fehler auf. Könnte mir bitte jemand mit der Syntax helfen, eine Konstante in go zu deklarieren?

Dies 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 { 

Answer 1

Ihre Syntax ist falsch. Um eine wörtliche Karte zu machen (als pseudo-Konstante), können Sie tun:

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

Innerhalb eines func können Sie erklären es mögen:

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

Und in Go gibt es nicht so etwas wie ein konstante Karte. Weitere Informationen finden Sie unter here.

Try it out on the Go playground.

Answer 2

Sie mit einem Verschluss Karte emulieren kann:

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

Try it on the Go playground

Answer 3

Sie 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 auch erstellen eine Enum-Konstante:

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

Sie können keine Konstanten von Karten, Arrays erstellen und es wird in effective go geschrieben:

Konstanten in Go ist nur, dass-Konstante. Sie werden beim Kompilieren Mal erstellt, auch wenn sie als Locals in Funktionen definiert sind, und können nur Zahlen, Zeichen (Runen), Strings oder Booleans sein. Aufgrund der Kompilierungszeitbeschränkung müssen die Ausdrücke, die sie definieren, konstante Ausdrücke sein, die vom Compiler ausgewertet werden können. Zum Beispiel ist 1 < ein konstanter Ausdruck, während math.Sin (math.Pi/4) nicht, weil der Funktionsaufruf zu math.Sin zur Laufzeit auftreten muss.

Answer 4

Wie oben erwähnt, um eine Karte als Konstante zu definieren, ist nicht möglich. Aber Sie können eine globale Variable deklarieren, die eine Struktur ist, die eine Karte enthält.

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 5

Und wie oben vorgeschlagen, durch Siu Ching Pong -Asuka Kenji mit der Funktion, die meiner Meinung nach mehr Sinn macht und läßt Dich mit der Bequemlichkeit des Kartentypen ohne die Funktion Wrapper um:

Die Initialisierung würde wie folgt aussehen:

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

Try this at play.golang.org.