इस गोलांग संरचना में ब्रेसिज़ की दूसरी जोड़ी क्या हैं?

Question

var cache = struct { 
    sync.Mutex 
    mapping map[string]string 
} { 
    mapping: make(map[string]string), 
} 

यह एक एम्बेडेड फ़ील्ड sync.Mutex के साथ एक स्ट्रक्चर की तरह दिखता है लेकिन मैं ब्रेसिज़ के दूसरे सेट के आसपास अपना सिर नहीं प्राप्त कर सकता। यह संकलित करता है और निष्पादित करता है लेकिन क्या हो रहा है? मेक निर्देश मामले (यह करता है) और अल्पविराम पर लेबल क्यों है? सिवाय अपने उदाहरण में आप Cache का एक प्रकार नहीं घोषित करते हैं और बदले में एक गुमनाम struct है

type Cache struct { 
    sync.Mutex 
    mapping map[string]string 
} 

cache := Cache{ 
    mapping: make(map[string]string), 
} 

: धन्यवाद ...

Answer 1

उदाहरण आपके पास करने के लिए बराबर है। अपने उदाहरण में, के रूप में मेरे Cache प्रकार के विरोध करते हैं, प्रकार पूरे

struct { 
    sync.Mutex 
    mapping map[string]string 
} 

तो

cache := Cache{ 
    mapping: make(map[string]string), 
} 

भाग के रूप में ब्रेसिज़ के दूसरी जोड़ी के बारे में सोच रहा है।

make एक अंतर्निहित फ़ंक्शन है जो सी के calloc() के समान काम करता है जो गो के मामले में 0'd मानों से भरे डेटा संरचना को प्रारंभ करता है, कुछ डेटा संरचनाओं को इस तरह से प्रारंभ करने की आवश्यकता होती है, अन्य (अधिकांश भाग structs के लिए)) स्वचालित रूप से 0'd मानों के साथ शुरू किया जाता है। इस क्षेत्र की आवश्यकता है ताकि संकलक अब cache.mapping खाली map[string]string है।

अल्पविराम वहाँ जाओ के प्रारूपण का हिस्सा है, आप सभी को एक ही लाइन पर Cache{mapping: make(map[string]string)} कर सकते हैं, लेकिन इस समय क्षेत्र के असाइनमेंट उद्घाटन और समापन ब्रेसिज़ तुलना में एक अलग लाइन पर है, यह एक अल्पविराम की आवश्यकता है।

Answer 2

इसे "स्ट्रक्चरल शाब्दिक" या "अज्ञात संरचना" कहा जाता है और वास्तव में, आप हमेशा गो में structs कैसे बनाते हैं, यह तुरंत स्पष्ट नहीं हो सकता है क्योंकि आप संरचना के लिए नए प्रकार बनाने के लिए उपयोग किए जा सकते हैं उन्हें थोड़ा कम वर्बोज़ घोषित करने के लिए प्रकार।

एक संपूर्ण संरचना परिभाषा वास्तव में int या []byte या string की तरह गो में एक प्रकार है। आप कर सकते हैं बस के रूप में:

type NewType int 
var a NewType = 5 // a is a NewType (which is based on an int) 

या:

a := 5 // a is an int 

और दोनों अलग-अलग प्रकार है कि ints की तरह लग रहे हैं, आप भी structs के साथ एक ही बात कर सकते हैं:

// a is type NewType (which is a struct{}). 
type NewType struct{ 
    A string 
} 
a := NewType{ 
    A: "test string", 
} 

// a is type struct{A string} 
a := struct{ 
    A string 
}{ 
    A: "test string", 
} 

टाइप नाम (NewType) को अभी स्ट्रक्चर के प्रकार, struct{A string} के साथ बदल दिया गया है। ध्यान दें कि वे तुलना या असाइनमेंट के उद्देश्य के लिए एक ही प्रकार (उपनाम) नहीं हैं, लेकिन वे समान अर्थशास्त्र साझा करते हैं।