స్థిరాంకాలు మరియు అయోటా

** స్థిరాంకాలు** అనేది కంపైల్ సమయంలో తెలిసిన మార్పులేని విలువలు. గో లో వారు ఉన్నారు constతో ప్రకటించబడింది మరియు typed లేదా untyped చేయవచ్చు. టైప్ చేయని వాటికి a సూపర్ పవర్: అవి సందర్భానికి అవసరమైన రకానికి అనుగుణంగా ఉంటాయి, మిమ్మల్ని విడిచిపెడతాయి స్పష్టమైన మార్పిడులను వ్రాయడం నుండి.

ప్రాథమిక వాక్యనిర్మాణం

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