மாறிலிகள் மற்றும் அயோட்டா

மாற்றுகள் என்பது தொகுக்கும் நேரத்தில் அறியப்படும் மாறாத மதிப்புகள். கோ அவர்கள் const உடன் அறிவிக்கப்பட்டது மற்றும் typed அல்லது typed ஆகலாம். தட்டச்சு செய்யப்படாதவை ஒரு வல்லரசு: அவை சூழலுக்குத் தேவையான வகைக்கு ஏற்றவாறு, உங்களைக் காப்பாற்றும் வெளிப்படையான மாற்றங்களை எழுத வேண்டியதிலிருந்து.

அடிப்படை தொடரியல்

const PI = 3.14
const MaxRetry int = 5
const Name = "eLearner"

MaxRetry தட்டச்சு செய்யப்பட்டுள்ளது (int): நீங்கள் அதை int க்கு மட்டுமே ஒதுக்க முடியும். PI மற்றும் Name ஆகியவை ** தட்டச்சு செய்யப்படாதவை**: அவை "எழுத்துகள்" போல நடந்து கொள்கின்றன. சூழல்.

const PI = 3.14

var f float32 = PI  // ok: PI è non tipata, diventa float32
var d float64 = PI  // ok

const தொகுதிகள்

ஒரு தொகுதியில் பல மாறிலிகளை நீங்கள் தொகுக்கலாம்:

const (
    StateInitial = "INIT"
    StateReady   = "READY"
    StateError   = "ERROR"
)

iota: கணக்கீட்டு கவுண்டர்

ஒரு const தொகுதிக்குள், சிறப்பு அடையாளங்காட்டி iota 0 இல் தொடங்குகிறது மற்றும் ஒவ்வொரு வரியிலும் 1 அதிகரிப்பு. இது கணக்கீடுகளை உருவாக்குவதற்கான பழமொழி:

const (
    Monday = iota // 0
    Tuesday       // 1
    Wednesday     // 2
    Thursday      // 3
    Friday        // 4
)

அடுத்தடுத்த வரிகள் ** வெளிப்பாட்டைப் பெறுகின்றன** ஒன்றை வழங்கவில்லை என்றால். அதனால்தான் = iota என்று மீண்டும் எழுதாமல் Tuesday என்று எழுதினால் போதும்.

வெளிப்பாடுகள் கொண்ட வடிவங்கள்

iota தன்னிச்சையான வெளிப்பாடுகளுக்குள் தோன்றலாம்:

const (
    KB = 1 << (10 * (iota + 1)) // 1 << 10 = 1024
    MB                          // 1 << 20
    GB                          // 1 << 30
    TB                          // 1 << 40
)

மதிப்பைத் தவிர்க்கிறது

நீங்கள் ஒரு வரிக்கு மதிப்பை ஒதுக்க விரும்பவில்லை என்றால் (ஏனெனில் iota வேண்டும் எப்படியும் அதிகரிப்பு), வெற்று அடையாளங்காட்டியைப் பயன்படுத்தவும் _:

const (
    _  = iota // scarta 0
    KB        // 1
    MB        // 2
)

உங்கள் முறை

const (
    A = iota * 2
    B
    C
)
fmt.Println(A, B, C)

மறுபரிசீலனை

• const தொகுக்கும் நேரத்தில் அறியப்பட்ட மாறாத மதிப்புகளுக்கு.
• ** தட்டச்சு செய்யப்படாத** மாறிலிகள் சூழலுக்கு ஏற்றவாறு: மாற்றம் தேவையில்லை.
• const ( ... ) குழு தொடர்பான மதிப்புகளைத் தடுக்கிறது.
• iota ஒவ்வொரு தொகுதியிலும் 0 இல் தொடங்குகிறது மற்றும் வரிக்கு வரி அதிகரிக்கும்.
• வடிவங்கள்: enum (= iota), பிட்மாஸ்க் (= 1 << iota), அலகுகள் (= 1 << (10*iota)).