Constant provides a way to create immutable values in programming. It is useful when you want to store something in a variable that won't change later.
In Golang, a constant is a named identifier representing a fixed value. Once a constant is assigned a value, it cannot be changed or reassigned during program execution.
It is often used to define values that remain fixed throughout the program's execution, such as mathematical constants, configuration values, or flags.
There are 2 types of constants in Golang:
- Typed Constant
- Untyped Constant
Both of them will do the same thing only difference is how we declare them. Let's learn about constants in Golang – how to create them and how to create multiple constants in a block.
Declaring (Creating) Typed Constant in Golang
When you declare a typed constant in Go, you are specifying the data type of the constant explicitly. This helps ensure type safety and clarity in your code.
To declare a typed constant, you use the const
keyword followed by the constant name, its type, and the assigned value.
This is the syntax:
const constantName type = value
For example, let's say you want to declare a constant called maxValue
with the type int
and assign it the value of 100
. Here's how you would do it in Golang.
const maxValue int = 100
In this example, const
is the keyword that indicates you're declaring a constant. The maxValue
is the name you've chosen for the constant.
The int
is the type of constant, which is explicitly specified. And finally, 100
is the value assigned to the maxValue
constant.
Once you've declared the typed constant, you can use it in your code just like any other variable of that type. For instance, you can assign the constant value to a variable, use it in mathematical operations, or print its value.
package main
import "fmt"
func main() {
const maxValue int = 100
var currentValue int = 50
fmt.Println("The maximum value is:", maxValue)
fmt.Println("The current value is:", currentValue)
// You can perform operations with the constant
var newValue int = currentValue + maxValue
fmt.Println("The new value is:", newValue)
}
In this example, we declare the maxValue
constant with a type of int
and assign it the value 100
. Now you can print this constant to the console like a normal variable.
You can also perform mathematical operations with other variables like adding maxValue
and currentValue
, and store the result in the newValue
variable.
package main
import "fmt"
func main() {
const (
Pi = 3.14159
Radius = 5.0
SquareSide = 10
TriangleBase = 6
TriangleHeight = 8
CircleArea = Pi * Radius * Radius
)
fmt.Println("The area of the circle is:", CircleArea)
fmt.Println("The perimeter of the square is:", SquareSide*4)
fmt.Println("The area of the triangle is:", 0.5*TriangleBase*TriangleHeight)
}
In this code snippet, we utilize the declared constants within the main
function to calculate and print the area of the circle, the perimeter of the square, and the area of the triangle.
Also Read: Understanding All Data Types in Golang: A Complete Guide
Declaring Untyped Constant in Golang
When you declare an untyped constant in Go, you don't explicitly specify its type. Instead, the type of the constant is determined based on the value assigned to it.
This allows for more flexibility in using the constant in different contexts. To declare an untyped constant, you use the const
keyword followed by the constant name and the assigned value.
This is the syntax:
const constantName = value
For example, let's say you want to declare an untyped constant called pi
and assign it the value of 3.14159
. Here's how you would do it in Golang.
const pi = 3.14159
In this pi constant, we are not explicitly setting the type. That's why it is known as an untyped constant. The compiler will determine its type based on the value.
In this case, the compiler will infer the type of pi
constant as float64
because the value is a decimal.
Also Read: Golang Variable: Different Ways to Create Variables in Golang
Differences Between Typed and UnTyped Constants
There are some differences between typed and untyped constants in Golang even though both of them will store fixed values:
Typed Constants | Untyped Constants | |
---|---|---|
Declaration | Explicitly declared type | Inferred type based on assigned value |
Type Safety | Ensures type safety | Allows implicit conversions to compatible types |
Type Conversion | Requires explicit type conversions | Implicitly converts to compatible types |
Expressions | Retains specific types of expressions | Adapts to the type of operations or assignments |
Compiler Checks | Subject to type checks by the Go compiler | No explicit type checks performed |
Flexibility | Less flexible in terms of type adaptability | More flexible, can be used with different types implicitly |
These differences highlight how typed constants provide strict type checking and preserve their specific type throughout expressions, while untyped constants offer flexibility and implicit conversions based on context.
The choice between typed and untyped constants depends on the desired level of type safety and the specific requirements of your code.
How to Declare Multiple Constants in a Block
In Go, you have the option to declare multiple constants within a single block using the const
keyword. This approach allows you to group related constants together to improve code organization and readability.
To declare multiple constants in a block, you use the following syntax:
const (
constant1 = value1
constant2 = value2
constant3 = value3
// more constants...
)
Let's say you want to declare a block of constants related to geometric shapes. You can declare them within a single block using the const
keyword.
const (
Pi = 3.14159
Radius = 5.0
SquareSide = 10
TriangleBase = 6
TriangleHeight = 8
CircleArea = Pi * Radius * Radius
)
In this example, we declare multiple constants within a block. By organizing these related constants within a block, it becomes easier to manage and understand their purpose in the code.
Naming Conventions for Golang Constants
Using capital letters for constants is the naming convention in most programming languages. But in Golang, if you start the name of a variable with a capital letter, it automatically gets exported from the package.
Therefore, if you don't want to expose your constants from your package, you must start the name with a small letter.
We often use camelCase for naming variables in Golang. For example: firstName
, lastName
etc. You can also use the same style for constant names.
But if you want to name your constants differently to identify the difference between a normal variable and a constant, you can use the underscore ( _ ) symbol. For example: max_value
, total_amount
, etc.
It's totally up to you how you want to name your constants. Golang doesn't have any fixed rules for naming variables, constants, or functions. But it is good practice to use the same style throughout the entire application to improve code readability and maintainability.
Differences Between Constants and Variables in Golang
Constants and variables are used to store and manage values in Go. But they have some important differences you should remember.
- Use Cases: Constants are commonly used to represent fixed values that won't change. Variables, on the other hand, are used to store and manage data that can change during program execution.
- Immutability: Constants store fixed values. You can't change or assign a new value to it once defined. On the other hand, variables can be assigned different values at different points in your code.
- Declaration and Initialization: When you declare a constant, you must assign a value to it right away. Variables, however, can be declared without an initial value and assigned a value later in your code.
- Compiler Evaluations: Constants are evaluated at compile-time, which means their values are known and substituted in the code during compilation. Variables, on the other hand, are evaluated at runtime when the program is running.
- Memory Allocation: Constants are usually not allocated memory at runtime because they are directly replaced with their values during compilation. Variables, however, require memory allocation to store their values.
- Performance Implications: Constants can provide performance benefits in certain situations. Since the compiler knows their values at compile time. On the other hand, variables may have slight overhead due to runtime memory allocation and the potential for value changes.
Understanding these differences between constants and variables helps you choose the appropriate approach based on whether you need a value to be constant or subject to change throughout your program.
How Golang Constant is Different Than Other Languages
Most programming languages have the option to create constants. Golang treats constant values differently. Because the Golang compiler evaluates them at the compile time.
This means that the compiler analyzes and calculates the values of constants during the compilation phase of your program and replaces those constants with their values.
package main
import "fmt"
func main() {
const maxValue = 100
const initialValue = maxValue / 2
fmt.Println("Initial value:", initialValue)
fmt.Println("Double the initial value:", initialValue*2)
}
In this example, we have two constants: maxValue
and initialValue
. maxValue
is set to 100, and initialValue
is calculated by dividing maxValue
by 2.
During the compilation phase, the Go compiler will replace initialValue
with the result of 100 / 2
, which is 50
, before executing the program.
The important point to note here is that the compiler performs the division operation maxValue / 2
during compilation, not at runtime. Therefore, this calculation is performed once during compilation, and the compiled code contains the value 50
directly.
Conclusion
By declaring constants, you can ensure that specific values remain fixed throughout your program. This immutability of constants prevents accidental modifications and helps maintain data stability.
You have seen how you can declare constants in your Go application. You also have learned the differences between typed and untyped constants.
If you need to create multiple constants which are related to each other, you can declare them in a block. It will help you to organize and maintain your code.