Enums in Golang: Techniques, Best Practices, & Use Cases

Relia Software

Relia Software

Thuoc Nguyen

Relia Software


Enums provide a way to represent a set of named constants. While Go lacks a built-in enum type, developers can emulate enum-like behavior by constants/custom types.

Enums in Golang

Table of Contents

Enums play a vital role in programming languages, providing a concise and expressive way to define a set of named constants. While some languages like Java or C# offer built-in support for enums, Go takes a different approach. In Go, enums are not a native language feature, but developers have several techniques at their disposal to achieve similar functionality.

This article delves into the world of enums in Golang, exploring the various techniques used to define and utilize them effectively. Through code examples, comparisons, and real-world use cases, we aim to equip you with the knowledge to master enums and leverage them efficiently in your Golang projects.

>> Read more about Golang coding:

Understanding Enum

In Golang, enums (short for enumerations) provide a way to represent a set of named constants. While Go doesn't have a built-in enum type like some other languages, developers can emulate enum-like behavior using constants or custom types. Let's delve into the purpose and syntax of enums in Go:


  • Readability and Maintainability: Enums make code more readable and self-explanatory by assigning meaningful names to specific values. This enhances code maintainability as it's easier to understand the purpose of each constant.
  • Type Safety: Enums help enforce type safety by restricting variables to a predefined set of values. This reduces the likelihood of runtime errors caused by using incorrect values.


  • Using Constants:

package main

import "fmt"

// Enum defining colors using constants
const (
    Red   = iota // 0
    Green        // 1
    Blue         // 2

func main() {
    fmt.Println(Red, Green, Blue)
  • Using Custom Types:
package main

import "fmt"

// Enum defining colors using custom types
type CardType int

const (
    VISA CardType = iota // 0
    MASTER            // 1
    JCB             // 2

func main() {
    fmt.Println(VISA, MASTER, BlueJCB

In the above examples:

  • We define enums for colors using constants and custom types.
  • iota is used to automatically generate incrementing values starting from 0.
  • Constants are assigned to each enum value, and in the case of custom types, an underlying type is specified (usually int).

Enums in Go provide a flexible way to represent a fixed set of values, improving code clarity and type safety. However, it's essential to choose the appropriate method (constants or custom types) based on the specific requirements of your project.

Benefits and Limitations of Enums


  • Improved Readability: Enums enhance code readability by providing meaningful names to specific values. This makes the code more self-explanatory and easier to understand for developers.
  • Type Safety: Enums help enforce type safety by restricting variables to a predefined set of values. This reduces the risk of using incorrect or unexpected values, leading to fewer runtime errors.
  • Explicit Definition of Constants: Enums allow developers to explicitly define a set of constants, making it clear which values are valid for a particular variable or parameter.
  • Enhanced Maintainability: By using enums, developers can easily update or modify the set of allowed values in a single location, reducing the likelihood of inconsistencies or errors across the codebase.
  • Compiler Assistance: Enum values are checked by the compiler, providing early detection of any misuse or incorrect usage of enum constants.


  • No Built-in Enum Type: Unlike some other programming languages, Go does not have a built-in enum type. Developers must use workarounds such as constants or custom types to emulate enum-like behavior.
  • Verbose Syntax: Implementing enums in Go using constants or custom types can sometimes result in verbose syntax, especially when defining a large set of enum values.
  • Limited Expressiveness: Enums in Go lack some of the advanced features found in enums of other languages, such as the ability to associate values or behaviors with individual enum constants.
  • Potential Conflicts: When using constants for enums, there's a risk of conflicts if the same constant name is used in different contexts within the codebase. This can lead to unintended behavior or errors.
  • Extra Overhead: Implementing enums using custom types may introduce additional overhead, especially if associated methods or behaviors are defined for each enum constant.

Despite these limitations, enums in Go remain a valuable tool for improving code clarity, maintainability, and type safety, and developers can leverage them effectively by understanding their benefits and limitations.

Implementing Enum-like Functionality in Golang

Using iota Constant

  • iota is a built-in keyword in Go that represents successive integer constants within a const declaration.
  • It starts with 0 and increments by 1 for each subsequent constant.


package main

import "fmt"

// Enum for HTTP status codes using custom types
type HTTPStatusCode int

const (
    OK            HTTPStatusCode = 200
    Created                      = 201
    BadRequest                   = 400
    Unauthorized                 = 401
    NotFound                     = 404
    InternalServerError          = 500

// Method to get the description of an HTTP status code
func (c HTTPStatusCode) String() string {
    switch c {
    case OK:
        return "OK"
    case Created:
        return "Created"
    case BadRequest:
        return "Bad Request"
    case Unauthorized:
        return "Unauthorized"
    case NotFound:
        return "Not Found"
    case InternalServerError:
        return "Internal Server Error"
        return "Unknown Status Code"

func main() {
    fmt.Println("HTTP Status Codes:")
    fmt.Println("200:", OK)
    fmt.Println("201:", Created)
    fmt.Println("400:", BadRequest)
    fmt.Println("401:", Unauthorized)
    fmt.Println("404:", NotFound)
    fmt.Println("500:", InternalServerError)

    // Get the description of an HTTP status code
    status := OK
    fmt.Println("Description of", status, ":", status.String())

In this example, we define a custom type HTTPStatusCode to represent HTTP status codes. Each status code is assigned a constant value using iota, and a method String() is defined to get the description of a status code. This demonstrates the flexibility and type safety provided by custom types for implementing enums in Go.

Limitations of iota:

  • Non-modifiable values: Once constants are defined using iota, their values cannot be changed at runtime.
  • Potential for conflicts: If iota constants are mixed with other constants in the same codebase, there's a risk of conflicts, especially in larger projects.

Using Custom Types

  • Custom types in Go allow developers to define their own types based on existing types.
  • Custom types can be used to create enums by defining a new type and specifying its underlying type.


package main

import "fmt"

// Enum for days of the week using custom types
type DayOfWeek int

const (
    Sunday DayOfWeek = iota

func main() {
    fmt.Println("Days of the week:")
    fmt.Println("Sunday:", Sunday)
    fmt.Println("Monday:", Monday)
    fmt.Println("Tuesday:", Tuesday)
    fmt.Println("Wednesday:", Wednesday)
    fmt.Println("Thursday:", Thursday)
    fmt.Println("Friday:", Friday)
    fmt.Println("Saturday:", Saturday)

Benefits of Custom Types:

  • Flexibility: Custom types offer flexibility in defining enums with specific underlying types, allowing for more precise control.
  • Type Safety: Each custom type is distinct, providing type safety and preventing inadvertent type conversions.

Third-party Libraries

Several third-party libraries in Go offer enum-like functionality:

  • go-enum: A tool that generates Go code for enums from a simple definition format. (Click go-enum GitHub for further information).
  • stringer: A tool that automatically generates string methods for enums defined in Go source code. (Click stringer tool for more details).

Comparison of Techniques


Ease of Use


Type Safety


iota Constant




Values cannot be modified after compilation, potential conflicts

Custom Types




Provides more type safety, allows additional methods associated with the enum


Easy (with tooling)



Introduces external dependencies, potential compatibility issues, learning curve

Ease of Use

  • iota Constant: Simple to use as it requires minimal syntax, but can become verbose for large enum sets.
  • Custom Types: Requires a bit more syntax to define custom types, but offers more flexibility and type safety.
  • Libraries: Depending on the library, ease of use can vary. Some tools may automate enum generation, making it easier, but integration and learning curve might be required.


  • iota Constant: Limited flexibility, as it primarily generates sequential integer constants.
  • Custom Types: Provides high flexibility as developers can define custom types with specific underlying types and associated methods.
  • Libraries: Flexibility varies depending on the features provided by the library. Some libraries may offer additional features like string representation or automatic code generation.

Type Safety

  • iota Constant: Moderate type safety. While constants are checked by the compiler, there's still a risk of using incorrect values.
  • Custom Types: High type safety, as each enum has its own distinct type, preventing inadvertent type conversions.
  • Libraries: Type safety depends on the implementation of the library. Generally, libraries that generate code may provide better type safety.


  • iota Constant: Values cannot be modified after compilation, potential conflicts if constants clash with other constants.
  • Custom Types: Requires more effort to define custom types, especially for larger enum sets.
  • Libraries: Introduces external dependencies, potential compatibility issues with future Go releases, and may have a learning curve.

How to Choose the Most Suitable Approach?

  • Use iota Constant if simplicity is preferred, and the enum set is small with no need for additional features.
  • Use Custom Types for better type safety, flexibility, and if additional methods associated with the enum are required.
  • Consider using Libraries if automating enum generation or additional features like string representation are needed, but be cautious of dependencies and compatibility issues.

Best Practices of Golang Enums

  • Use Clear and Descriptive Names: Choose meaningful names for enum constants that accurately represent their purpose or value.
  • Consistent Naming Conventions: Follow a consistent naming convention for enum constants to enhance readability and maintainability across the codebase.
  • Avoid Magic Numbers: Use enums instead of magic numbers or arbitrary constants to improve code clarity and reduce the risk of errors.
  • Handle Edge Cases: Consider edge cases and define enum constants accordingly to handle all possible scenarios gracefully.
  • Group Related Constants: Group related enum constants together using custom types or constants blocks to organize them logically.
  • Document Enum Definitions: Provide documentation for enum definitions, including their purpose, allowed values, and usage examples to aid understanding for other developers.
  • Prefer Custom Types for Type Safety: When type safety is critical, prefer defining enums using custom types to prevent inadvertent type conversions and improve code robustness.
  • Avoid Overuse: Use enums judiciously and avoid overusing them for trivial or unnecessary scenarios to maintain code simplicity and readability.

Real-World Use Cases

  • Representing Weekdays:
type Weekday int

const (
    Sunday Weekday = iota
  • Access Levels:
type AccessLevel int

const (
    Guest AccessLevel = iota

Enums in Go provide a powerful mechanism for improving code clarity, maintainability, and type safety. By following best practices and leveraging enums effectively, developers can write more robust and readable code in their Go projects.

>> You may be interested in:

Final Thoughts

Throughout this guide, we explored various methods for implementing enums in Go language and discussed their respective benefits, limitations, and best practices.

In essence, enums in Go empower developers to write cleaner, more maintainable code by providing a structured way to represent a fixed set of values. By understanding the different techniques and best practices outlined in this guide, developers can leverage enums effectively to enhance their Go projects.

>>> Follow and Contact Relia Software for more information!

  • golang
  • coding
  • development