Bagaimana mendeklarasikan peta konstan

Saya mencoba untuk menyatakan konstan di Go, tetapi itu membuat kesalahan. Adakah yang bisa membantu saya dengan sintaks mendeklarasikan konstanta di Go?

Ini kode saya:

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

Ini adalah kesalahannya

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

Sintaks Anda salah. Untuk membuat peta literal (sebagai konstanta semu), Anda dapat melakukan:

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

Di dalam a funcAnda bisa mendeklarasikannya seperti:

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

Dan di Go tidak ada yang namanya peta konstan. Informasi lebih lanjut dapat ditemukan di sini .

Cobalah di taman bermain Go.

Anda dapat membuat konstanta dengan berbagai cara:

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

Anda juga dapat membuat konstanta enum:

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

Anda tidak dapat membuat konstanta peta, array, dan ini ditulis dengan efektif :

Konstanta dalam Go hanya itu — konstan. Mereka dibuat pada waktu kompilasi, bahkan ketika didefinisikan sebagai lokal dalam fungsi, dan hanya dapat berupa angka, karakter (rune), string atau boolean. Karena batasan waktu kompilasi, ekspresi yang mendefinisikannya harus berupa ekspresi konstan, yang dapat dievaluasi oleh kompilator. Misalnya, 1 << 3 adalah ekspresi konstan, sedangkan math.Sin (math.Pi / 4) bukan karena pemanggilan fungsi math.Sin perlu terjadi pada waktu proses.

Anda dapat meniru peta dengan penutupan:

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

Cobalah di taman bermain Go

Dan seperti yang disarankan di atas oleh Siu Ching Pong-Asuka Kenji dengan fungsi yang menurut saya lebih masuk akal dan memberi Anda kenyamanan tipe peta tanpa fungsi pembungkus di sekitarnya:

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

Coba ini di play.golang.org.

Seperti yang dinyatakan di atas untuk mendefinisikan peta sebagai konstanta tidak mungkin. Tapi Anda bisa mendeklarasikan variabel global yang merupakan struct yang berisi peta.

Inisialisasi akan terlihat seperti ini:

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