चर और प्रकार

गो में प्रत्येक वेरिएबल का एक स्थैतिक प्रकार होता है जो कंपाइलर को ज्ञात होता है: एक बार घोषित, एक चर प्रकार नहीं बदल सकता। यह कठोरता - बहुत अलग जावास्क्रिप्ट या पायथन से - वह कीमत है जो आप संकलन-समय प्राप्त करने के लिए चुकाते हैं रनटाइम के बजाय त्रुटियाँ, छोटे बायनेरिज़ और पूर्वानुमान योग्य प्रदर्शन.

घोषणा के दो रूप

var स्पष्ट प्रकार के साथ

var name string = "Ada"
var age int = 36
var active bool

जब आप मान हटाते हैं (जैसा कि var active bool में है) तो वेरिएबल प्राप्त होता है इसके प्रकार का शून्य मान - हम अगले पाठ में इस पर वापस आएंगे।

संक्षिप्त घोषणा :=

किसी फ़ंक्शन के अंदर आप := का उपयोग कर सकते हैं, जो फ़ंक्शन के प्रकार का अनुमान लगाता है दाहिनी ओर अभिव्यक्ति. यह मुहावरेदार रूप है और आप इसका प्रयोग करेंगे 90% समय:

name := "Ada"   // string
age := 36        // int
pi := 3.14       // float64
active := true   // bool

बुनियादी प्रकार आपको तुरंत मिलेंगे

int8/16/32/64, uint8/16/32/64, float32 और complex64/128 भी हैं जब आपको सटीक आकार (बाइनरी पार्सिंग, इंटरॉप, आदि) की आवश्यकता हो।

एकाधिक घोषणाएँ

आप var-ब्लॉक या बहुवचन := के साथ कई वेरिएबल घोषित कर सकते हैं:

var (
    name   string = "Ada"
    age    int    = 36
    active bool
)

x, y := 10, 20
a, b, c := "a", 2, true   // different types: no problem

वेरिएबल घोषित किए गए लेकिन उपयोग नहीं किए गए

गो सख्त है: एक वेरिएबल घोषित और कभी उपयोग नहीं किया गया एक संकलन है त्रुटि, चेतावनी नहीं. यही बात अप्रयुक्त imports पर भी लागू होती है।

func main() {
    x := 42
    // error: x declared and not used
}

नियम को अस्थायी रूप से शांत करने के लिए आप _ (रिक्त पहचानकर्ता) का उपयोग करें:

_ = x

आपकी बारी

// (a)
var name string = "Ada"

// (b)
age := 36

// (c)
const PI = 3.14

संक्षिप्त

• स्थिर प्रकार, स्वचालित रूप से := द्वारा अनुमान लगाया जाता है या var द्वारा घोषित किया जाता है।
• := केवल अंदर के फ़ंक्शन; केवल पैकेज स्तर पर var/const।
• अप्रयुक्त चर और आयात = संकलन त्रुटि: उन्हें शांत करने के लिए _ का उपयोग करें।
• int/float64/string/bool रोजमर्रा के 90% मामलों को कवर करता है।