Come dichiarare la mappa costante in golang

Question

Sono nuovo per il golang. Sto cercando di dichiarare di essere costante. Ma sta generando un errore. Qualcuno potrebbe per favore aiutarmi con la sintassi di dichiarare una costante in partenza?

Questo è il mio codice:

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

Questo è l'errore

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

Answer 1

la sintassi non è corretta. Per fare una mappa letterale (come pseudo-costante), si può fare:

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

All'interno di un func è possibile dichiarare le cose come:

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

E in Go non v'è alcuna cosa come un mappa costante Maggiori informazioni possono essere trovate here.

Try it out on the Go playground.

Answer 2

Si può emulare una mappa con una chiusura:

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

È possibile creare costanti in molti modi diversi:

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

è anche possibile creare una costante enum:

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

Non è possibile creare le costanti di mappe, matrici ed è scritto in effective go:

Costanti a Go sono proprio questo costante. Vengono creati al momento della compilazione , anche se definiti come locali nelle funzioni e possono essere solo numeri , caratteri (rune), stringhe o booleani. A causa della limitazione in fase di compilazione , le espressioni che li definiscono devono essere espressioni costanti , valutabili dal compilatore. Ad esempio, 1 < è un'espressione costante, mentre math.Sin (math.Pi/4) non è perché la chiamata di alla matematica.Sin deve avvenire in fase di esecuzione.

Answer 4

Come detto sopra per definire una mappa come costante non è possibile. Ma puoi dichiarare una variabile globale che è una struttura che contiene una mappa.

L'inizializzazione sarebbe simile a questa:

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

E come suggerito in precedenza dal Siu Ching Pong -Asuka Kenji con la funzione che a mio parere ha più senso e ti lascia con la comodità del tipo di mappa senza la funzione wrapper:

// 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.