Antwoord.

In Go zijn er twee soorten constanten — ongetypeerde (untyped) en getypeerde (typed). Historisch gezien is dit gerelateerd aan de wens van de taal om systemen van types flexibel en veilig te maken, waardoor de compiler fouten kan opsporen tijdens de compilatiefase, en typeconversie alleen daar plaatsvindt waar dit is toegestaan.

Probleem ontstaat wanneer een programmeur deze twee categorieën niet van elkaar kan onderscheiden en vertrouwt op het gedrag van de constante, zonder de type-eisen in functie- en interface-declaraties in overweging te nemen. Dit kan leiden tot fouten bij typeconversie, onverwachte compilatiefouten of onverwachte "schommelende" compatibiliteit bij functie-aanroepen.

Oplossing bestaat uit het helder begrijpen:

Buiten de toewijzing aan een specifiek type heeft de constante geen vast type en kan het zich "aanpassen" aan het verwachte type bij overdracht aan een functie.
Na het specificeren van het type (bijvoorbeeld const x int = 42) is verder gebruik van deze constante beperkt tot het opgegeven type.

Voorbeeldcode:

const Pi = 3.14 // ongetypeerde
const Answer int64 = 42 // getypeerde

func printInt(a int) {
    fmt.Println(a)
}

func main() {
    printInt(Pi) // Fout: Pi is geen int (maar kan expliciet worden omgezet)
    printInt(int(Pi)) // Ok
    printInt(Answer) // Ok, want Answer is al int64, en int64 naar int is expliciete conversie
}

Belangrijke kenmerken:

Ongetypeerde constanten maken flexibele typeconversies mogelijk.
Getypeerde constanten zijn strikt gebonden aan het opgegeven type.
Veel operaties met constanten verschillen van operaties met variabelen — op het moment van compilatie zijn uitgebreide optimalisatie en overflow-controle mogelijk.

Vragen met een valstrik.

Kan een ongetypeerde constante zonder conversie aan een int-variabele worden toegewezen als deze een drijvend-kommawaarde (float) heeft?

Nee. Hoewel een ongetypeerde constante kan worden gebruikt in een uitdrukking van een ander type, zal de poging om een float-constante aan een int-variabele toe te wijzen een compilatiefout veroorzaken. Een expliciete conversie is vereist:

const Pi = 3.14
var x int = Pi // de compiler geeft een foutmelding
var y int = int(Pi) // Ok

Verandert het type van een ongetypeerde constante naar haar type bij de eerste toewijzing?

Nee, de constante krijgt geen type tot deze wordt gebruikt in een context waar een specifiek type wordt verwacht, of tot deze expliciet wordt gedeclareerd. In andere gevallen blijft deze ongetypeerd.

Kunnen grote numerieke constanten met een ongetypeerd type worden gebruikt om variabelen van een kleiner type te initialiseren, als de waarden passen?

Ja, als de absolute waarde binnen het bereik van het doeltype valt. Anders geeft de compiler een overflow-fout.

Voorbeeld:

const Big = 1 << 62
var x int32 = Big // Fout: Big past niet in int32
var y int64 = Big // Ok

Typische fouten en antipatterns

Het negeren van het verschil tussen ongetypeerde en getypeerde constanten
Pogingen om waarden van constanten toe te wijzen of te gebruiken buiten het geldige bereik van types
Onbedachtzaam gebruik van numerieke literalen zonder het verwachte type te definiëren

Levensecht voorbeeld

Negatieve case

In een complex financieel project hebben ontwikkelaars een aantal constanten (percentages, coëfficiënten) gedeclareerd als ongetypeerd. Op een gegeven moment vereisten enkele functies float32 in plaats van float64. De automatische type-aanpassing leidde tot verlies van precisie in berekeningen, wat niet onmiddellijk werd opgemerkt.

Voordelen:

Flexibiliteit en eenvoud in het declareren van constanten

Nadelen:

Verlies van precisie is niet duidelijk
Fouten ontstaan als het verwachte type niet wordt bijgehouden

Positieve case

In een andere deel van het systeem zijn alle constanten duidelijk als getypeerd gedeclareerd, en conversies worden expliciet gedaan:

const Discount float64 = 0.05