Constante și iota

Constantele sunt valori imuabile cunoscute la momentul compilării. În Go sunt declarat cu const și poate fi tactilat sau netyped. Cele netipizate au a superputere: se adaptează tipului cerut de context, scutindu-te de a trebui să scrie conversii explicite.

Sintaxa de bază

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

MaxRetry este introdus (int): îl puteți atribui numai unui int. PI și Name sunt netipizate: se comportă ca „literale” și se adaptează la contextul.

const PI = 3.14

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

const blocuri

Puteți grupa mai multe constante într-un bloc:

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

iota: contorul de enumerare

În interiorul unui bloc const, identificatorul special iota începe la 0 și crește cu 1 pe fiecare linie. Este limbajul pentru a face enumerari:

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

Rândurile ulterioare moștenesc expresia dacă nu oferă una. De aceea scrierea Tuesday este suficientă fără a repeta = iota.

Modele cu expresii

iota poate apărea în interiorul expresiilor arbitrare:

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

Omiterea unei valori

Dacă nu doriți să atribuiți o valoare unei linii (pentru că doriți ca iota să increment oricum), utilizați identificatorul necompletat _:

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

Rândul tău

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

Recapitulare

• const pentru valorile imuabile cunoscute la momentul compilării.
• Constantele Netipizate se adaptează contextului: nu este necesară conversia.
• const ( ... ) blochează valorile asociate grupului.
• iota începe de la 0 în fiecare bloc și crește linie cu linie.
• Modele: enumerare (= iota), bitmask (= 1 << iota), unități (= 1 << (10*iota)).