Sabit harita nasıl beyan edilir

Go'da sabit ilan etmeye çalışıyorum ama bir hata veriyor. Biri lütfen Go'da bir sabit beyan etme sözdizimi konusunda bana yardım edebilir mi?

Bu benim kodum:

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

Bu hata

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

Sözdiziminiz yanlış. Değişmez bir harita yapmak için (sözde sabit olarak) şunları yapabilirsiniz:

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

A'nın içinde funcşu şekilde ilan edebilirsiniz:

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

Ve Go'da sabit harita diye bir şey yoktur. Daha fazla bilgiyi burada bulabilirsiniz .

Go oyun alanında deneyin.

Sabitleri birçok farklı şekilde oluşturabilirsiniz:

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

Ayrıca bir enum sabiti de oluşturabilirsiniz:

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

Haritaların, dizilerin sabitlerini oluşturamazsınız ve etkili go :

Go'daki sabitler sadece budur - sabittir. İşlevlerde yerel olarak tanımlansalar bile derleme zamanında oluşturulurlar ve yalnızca sayılar, karakterler (runlar), dizeler veya booleler olabilirler. Derleme zamanı kısıtlaması nedeniyle, onları tanımlayan ifadelerin derleyici tarafından değerlendirilebilen sabit ifadeler olması gerekir. Örneğin, 1 << 3 sabit bir ifadedir, oysa math.Sin (math.Pi / 4), math.Sin işlevinin çalışma zamanında olması gerektiği için değildir.

Kapanışı olan bir haritayı taklit edebilirsiniz:

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

Go oyun alanında deneyin

Ve yukarıda Siu Ching Pong -Asuka Kenji tarafından önerildiği gibi , bana göre daha mantıklı olan ve işlev sarmalayıcı olmadan size harita türünün rahatlığını bırakan işlevle:

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

Bunu play.golang.org adresinde deneyin.

Yukarıda belirtildiği gibi bir haritayı sabit olarak tanımlamak mümkün değildir. Ancak, harita içeren bir yapı olan global bir değişken tanımlayabilirsiniz.

Başlatma şu şekilde görünecektir:

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