निरंतर मानचित्र कैसे घोषित करें

Question

मैं गो में निरंतर घोषणा करने की कोशिश कर रहा हूं, लेकिन यह एक त्रुटि है। किसी को भी गो में एक स्थिर घोषित करने के वाक्य रचना के साथ मेरी मदद कर सकते हैं?

यह मेरा कोड है:

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

यह त्रुटि है

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

Answer 1

आपका सिंटैक्स गलत है। शाब्दिक नक्शा (छद्म-स्थिरांक के रूप में) बनाने के लिए, आप यह कर सकते हैं:

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

अंदर funcआप इसे घोषित कर सकते हैं जैसे:

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

और गो में स्थिर मानचित्र जैसी कोई चीज नहीं है। अधिक जानकारी यहां पाई जा सकती है ।

जाओ खेल के मैदान पर इसे आज़माएं।

Comments

यह non-declaration statement outside function bodyवास्तव में संकलन समय पर फेंकता है । कैसे?

— एलेडियाफरिया

@AlessandroDiaferia मुझे ऐसी कोई त्रुटि नहीं है। आप इसका उपयोग कैसे कर रहे हैं?

— स्क्विजु

@AlessandroDiaferia var romanNumeralDict map[int]string = map[int]string{...}ऐसे मामले में प्रयास करें ।

— बी-स्केन

@alediaferia आपको :=किसी फ़ंक्शन के बाहर का उपयोग करने पर वह त्रुटि मिलती है ।

— जेफरी मार्टिनेज

"छद्म-स्थिरांक" क्या है?

— गैरेट

Answer 2

आप कई अलग-अलग तरीकों से स्थिरांक बना सकते हैं:

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

आप एक एनम स्थिरांक भी बना सकते हैं:

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

आप नक्शे, सरणियों के स्थिरांक नहीं बना सकते हैं और यह प्रभावी रूप से लिखा गया है :

गो में स्थिरांक बस स्थिर हैं। वे संकलित समय पर बनाए जाते हैं, यहां तक ​​कि जब कार्यों में स्थानीय के रूप में परिभाषित किया जाता है, और केवल संख्या, वर्ण (रन), तार या बूलियन हो सकते हैं। संकलन-समय प्रतिबंध के कारण, उन्हें परिभाषित करने वाले भावों को निरंतर अभिव्यक्ति, संकलक द्वारा मूल्यांकन योग्य होना चाहिए। उदाहरण के लिए, 1 << 3 एक स्थिर अभिव्यक्ति है, जबकि math.Sin (math.Pi / 4) नहीं है क्योंकि फ़ंक्शन math.in पर कॉल करता है। रन टाइम पर होने की आवश्यकता है।

Comments

तो यह एक C ++ 11 की तरह अधिक है ... क्यों math.Sin एक constexpr फ़ंक्शन नहीं है, फिर!

— फ्रांसेस्को डोंडी

आपके कथन सही हैं, लेकिन प्रश्न एक मानचित्र बनाने के बारे में था जो निरंतर है।

— जेजेर

@ jzer7 क्या आप मुझे समझा सकते हैं कि मेरा उत्तर अप्रासंगिक क्यों है? उन्होंने पूछा कि कुछ कैसे बनाया जाए, मैंने उनसे कहा कि यह संभव नहीं है। समझाया कि क्या संभव है और डॉक्स से प्रशस्ति पत्र दिया कि वास्तव में वह क्यों नहीं करना चाहता है जो वह चाहता है।

— साल्वाडोर डाली

Answer 3

आप नक्शे को बंद करने का अनुकरण कर सकते हैं:

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

इसे गो खेल के मैदान पर आजमाएं

Comments

(TestMostSoldRecommender?)

— twotwotwo

यह वास्तव में एक संभव समाधान है। हालांकि, चूंकि लेखक ने कुछ भी नहीं समझाया (और एक अजीब नाम वाले परीक्षण के मामले में सब कुछ डाल दिया), जवाब गलत लग रहा है। तर्क यह है: (1) एक अनाम फ़ंक्शन बनाएँ (2) अनाम फ़ंक्शन इनकैप्सुलेट करता है map(3) अनाम फ़ंक्शन "एक फ़ंक्शन को स्वीकार करता है जो एक इंट को स्वीकार करता है और एक स्ट्रिंग लौटाता है" (4) लौटाया गया फ़ंक्शन int -> string करता है map(5) का उपयोग करके मैपिंग अनाम फ़ंक्शन को तुरंत निष्पादित करें और लौटे फ़ंक्शन को एक चर में असाइन करें। यह चर एक फ़ंक्शन की तरह इस्तेमाल किया जा सकता है, और प्रभाव एक नक्शे की तरह है।

— सियु चिंग पोंग -आसुका केंजी- 16

Answer 4

और जैसा कि सिउ चिंग पोंग -आसुका केंजी ने कार्य के ऊपर सुझाया है , जो मेरी राय में अधिक समझ में आता है और आपको बिना फंक्शन रैपर के बिना मैप प्रकार की सुविधा के साथ छोड़ देता है:

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

Play.golang.org पर यह प्रयास करें।

Answer 5

जैसा कि ऊपर कहा गया है कि मानचित्र को परिभाषित करना संभव नहीं है। लेकिन आप एक वैश्विक चर घोषित कर सकते हैं जो एक संरचना है जिसमें एक नक्शा होता है।

आरंभ इस तरह दिखेगा:

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

Comments

सिर्फ मानचित्र को ही वैश्विक चर क्यों नहीं बनाया जाए? इसे संरचना में क्यों लपेटें?

— हरिकेन हैमिल्टन

यह मानचित्र को स्थिर नहीं बनाता है, आप अभी भी कर सकते हैंromanNumeralDict.m[1000] = "New value"

— ब्रैंडो