Go Enumerations: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
Line 48: Line 48:
Only the first constant in the series declares its type and an expression involving <code>iota</code>.  
Only the first constant in the series declares its type and an expression involving <code>iota</code>.  


The simplest expression involving <code>iota</code> is <code>iota</code> itself, but more complex expressions can be used. During the initialization, the compiler advances through the list of constants, and for each advancement, <code>iota</code> takes the zero-based line number at which <code>iota</code> is declared in the <code>const()</code> sequence. This behavior is explained here.
The simplest expression involving <code>iota</code> is <code>iota</code> itself, but more complex expressions can be used. Different declarations for enums part of the same set can use different iota expressions, and for those enum declaration that do not have an explicit declaration, the last one applies.


<syntaxhighlight lang='go'>
<syntaxhighlight lang='go'>
type ByteSize float64
type ByteSize float64
const (
const (
  _          = iota // ignore the first value, which is zero, by assigning it to a blank identifier
UNDEFINED ByteSize = iota             // assign the first value, which is zero, and the zero value for it, to an 'UNDEFINED' enum element
  KB ByteSize = 1 << (10 * iota)
KB       ByteSize = 1 << (10 * iota) // gets 1024
  MB
MB                                   // gets 1048576
  GB
GB                                   // ...
  TB
TB
  PB
PB
  EB
EB
  ZB
ZB
  YB
YB
)
)</syntaxhighlight>
</syntaxhighlight>


To make the enumeration constants visible outside the package, they need to start with a capital letter.
To make the enumeration constants visible outside the package, they need to start with a capital letter.

Revision as of 20:16, 13 September 2024

External

Internal

Overview

Go does not have formal enums, but the language allows for sets of related, yet distinct int constants. They represent a property that has several distinct possible int values, like the days of the weeks or the months of the year.

These auto-incrementing int constants are declared using a special syntax involving the const keyword, parentheses, a type and the pre-declared constant iota:

type SomeType int

const (
  UndefinedEnum SomeType = iota
  EnumOne
  EnumTwo
  ...
)

This article explains how iota is used to generate values for enumeration members:

How Does the Compiler Assign Values to iota

The short story is that iota takes the zero-based index of the constant declaration, as it appears in the const() list.

Example:

type DayOfTheWeek int
const (
  UNDEFINED_DAY DayOfTheWeek = iota // iota is equal with 0, which is the zero value for int
  MON 
  TUE
  WED
  THU
  FRI
  SAT
  SUN
)

Only the first constant in the series declares its type and an expression involving iota.

The simplest expression involving iota is iota itself, but more complex expressions can be used. Different declarations for enums part of the same set can use different iota expressions, and for those enum declaration that do not have an explicit declaration, the last one applies.

type ByteSize float64

const (
	UNDEFINED ByteSize = iota             // assign the first value, which is zero, and the zero value for it, to an 'UNDEFINED' enum element
	KB        ByteSize = 1 << (10 * iota) // gets 1024
	MB                                    // gets 1048576
	GB                                    // ...
	TB
	PB
	EB
	ZB
	YB
)

To make the enumeration constants visible outside the package, they need to start with a capital letter.

String Representation

const enums can take advantage go the possibility of attaching a String() method to any type, including the enum type, to provide a string representation.

type DayOfTheWeek int

const (
	MON DayOfTheWeek = iota
	TUE
	WED
	THU
	FRI
	SAT
	SUN
)

var dayOfTheWeekToString = []string{
	"Monday",
	"Tuesday",
	"Wednesday",
	"Thursday",
	"Friday",
	"Saturday",
	"Sunday",
}

func (s DayOfTheWeek) String() string {
	return dayOfTheWeekToString[s]
}

func StringToDayOfTheWeek(s string) DayOfTheWeek {
	for i, v := range dayOfTheWeekToString {
		if s == v {
			return DayOfTheWeek(i)
		}
	}
	return DayOfTheWeek(-1)
}