Go Constants

Introduction

Constants in Go are immutable values which, once set, cannot be changed throughout the program. They are useful for defining fixed values that remain the same and improve code readability and maintainability. In this chapter, you will learn how to declare and use constants in Go, along with examples and best practices.

Declaring Constants

Constants are declared using the const keyword, followed by the name of the constant, its type (optional), and its value.

Basic Declaration

const pi float64 = 3.14159

Here, pi is declared as a constant of type float64 with the value 3.14159.

Implicit Type

If the type is not specified, Go infers the type based on the value.

const e = 2.71828

Here, e is declared as a constant with an inferred type based on its value.

Multiple Constants

You can declare multiple constants in a single line or using a block.

Single Line

const width, height = 100, 200

Here, width and height are both declared as constants with their respective values.

Block Declaration

const (
    hello = "Hello, Go!"
    goodbye = "Goodbye, Go!"
)

Here, hello and goodbye are declared as constants in a block.

Typed and Untyped Constants

Typed Constants

A typed constant is explicitly given a type.

const typedInt int = 123

Untyped Constants

An untyped constant does not have an explicitly declared type and can be used flexibly.

const untyped = 123

Constants with Expressions

Constants can be declared using expressions.

const x = 10
const y = 20
const sum = x + y  // sum is 30

Enumerated Constants

Go supports creating enumerated constants using the iota identifier, which simplifies the creation of a sequence of related constants.

Example

const (
    Sunday = iota  // Sunday is 0
    Monday         // Monday is 1
    Tuesday        // Tuesday is 2
    Wednesday      // Wednesday is 3
    Thursday       // Thursday is 4
    Friday         // Friday is 5
    Saturday       // Saturday is 6
)

Here, iota is used to create a sequence of constants representing the days of the week.

Example with Bitwise Shifts

const (
    _  = iota             // ignore first value by assigning to blank identifier
    KB = 1 << (10 * iota) // 1 KB is 1024 bytes
    MB                    // 1 MB is 1048576 bytes
    GB                    // 1 GB is 1073741824 bytes
)

Best Practices

Use descriptive names: Constant names should be clear and descriptive, reflecting their purpose.
```
const maxUsers = 100
```
Group related constants: Use a block to group related constants together for better organization.
```
const (
    minAge = 18
    maxAge = 65
)
```
Use constants for fixed values: Use constants for values that do not change to make your code more readable and maintainable.
```
const pi = 3.14159
```
Prefer untyped constants when possible: Untyped constants offer more flexibility and can be used in different contexts without type conversion.
```
const length = 100
```

Conclusion

Constants in Go provide a way to define immutable values that improve code readability and maintainability. By understanding how to declare and use constants, you can write more robust and understandable code. Use constants for fixed values and follow best practices to keep your code clean and organized.