Costanti Go

Il valore di una costante non può essere modificato durante l'esecuzione. Una volta assegnato un valore, non può essere modificato. Il suo valore può provenire solo da:

• Letterali
• Altri identificatori costanti
• Espressioni costanti
• Conversioni di tipo che risultano in costanti
• iota

Le costanti possono essere solo di tipo di dati di base, non possono essere

• Altri tipi oltre ai tipi di base, come strutture, interfacce, slice, array, ecc.
• Valori di ritorno di funzioni

Il valore di una costante non può essere modificato, altrimenti non supererà la compilazione

Inizializzazione

La dichiarazione di una costante richiede la parola chiave const. La costante deve essere inizializzata con un valore al momento della dichiarazione e il tipo della costante può essere omesso, ad esempio

const name string = "Jack" // Letterale

const msg = "hello world" // Letterale

const num = 1 // Letterale

const numExpression = (1+2+3) / 2 % 100 + num // Espressione costante

Se si dichiara semplicemente senza specificare un valore, non supererà la compilazione

const name string

Il compilatore segnala un errore

missing init expr for name

Per dichiarare più costanti in blocco, è possibile utilizzare () per migliorare la leggibilità. Possono esistere più () per ottenere l'effetto di raggruppamento.

const (
   Count = 1
   Name  = "Jack"
)

const (
   Size = 16
   Len  = 25
)

Nello stesso gruppo di costanti, le costanti che seguono una costante già assegnata possono non essere assegnate, il loro valore è per impostazione predefinita lo stesso del valore precedente, ad esempio

const (
  A = 1
  B // 1
  C // 1
  D // 1
  E // 1
)

iota

iota è un identificatore costante incorporato, solitamente utilizzato per rappresentare un numero intero senza tipo in una dichiarazione di costante, generalmente viene utilizzato tra parentesi.

const iota = 0

Ecco alcuni esempi di utilizzo

const (
   Num = iota // 0
   Num1 // 1
   Num2 // 2
   Num3 // 3
   Num4 // 4
)

Puoi anche scrivere così

const (
   Num = iota*2 // 0
   Num1 // 2
   Num2 // 4
   Num3 // 6
   Num4 // 8
)

Puoi anche

const (
   Num = iota << 2*3 + 1 // 1
   Num1 // 13
   Num2 // 25
   Num3 = iota // 3
   Num4 // 4
)

Dai precedenti esempi si può scoprire che iota è incrementale. La prima costante utilizza l'espressione del valore iota, e in base ai cambiamenti del valore del numero d'ordine, viene assegnato automaticamente alle costanti successive, fino a quando non viene reimpostato con un nuovo const. Questo numero d'ordine è in realtà il numero di riga relativo del codice, relativo al numero di riga iniziale del gruppo corrente. Guarda l'esempio seguente

const (
  Num  = iota<<2*3 + 1 // 1 prima riga
  Num2 = iota<<2*3 + 1 // 13 seconda riga
  _ // 25 terza riga
  Num3 //37 quarta riga
  Num4 = iota // 4 quinta riga
  _ // 5 sesta riga
  Num5 // 6 settima riga
)

Nell'esempio viene utilizzato l'identificatore anonimo _ per occupare una riga. Si può vedere che il valore di iota è essenzialmente la differenza tra la riga in cui si trova iota e la prima riga del gruppo const corrente. E i diversi gruppi const non si influenzano a vicenda.

Enumerazioni

Il linguaggio Go non ha progettato un tipo di dati separato per le enumerazioni, a differenza di altri linguaggi che di solito hanno un enum per rappresentarle. In Go, le enumerazioni sono generalmente implementate tramite tipo personalizzato + const + iota. Ecco un esempio semplice

type Season uint8

const (
  Spring Season = iota
  Summer
  Autumn
  Winter
)

Queste enumerazioni sono in realtà numeri. Go non supporta la conversione diretta in stringhe, ma possiamo aggiungere metodi al tipo personalizzato per restituire la loro rappresentazione come stringa, implementando l'interfaccia Stringer.

func (s Season) String() string {
  switch s {
  case Spring:
    return "spring"
  case Summer:
    return "summer"
  case Autumn:
    return "autumn"
  case Winter:
    return "winter"
  }
  return ""
}

In questo modo si ottiene una semplice implementazione di enumerazione. Puoi anche utilizzare lo strumento ufficiale Stringer per generare automaticamente le enumerazioni.

Tuttavia, presenta i seguenti svantaggi:

• Non sicuro dal punto di vista del tipo, poiché Season è un tipo personalizzato, è possibile convertire forzatamente altri numeri in questo tipo

  Season(6)

• Verbose, la rappresentazione come stringa deve essere implementata manualmente

• Debole capacità di espressione, poiché const supporta solo tipi di dati di base, questi valori di enumerazione possono essere rappresentati solo con stringhe e numeri

È qualcosa che l'autore non riesce proprio a capire perché non sia supportato a livello di linguaggio. Credo che questo sia assolutamente più vantaggioso che svantaggioso.