Variables and constants are fundamental concepts in most programming languages. They are the building blocks for storing and managing data. In this article, we’ll explore how variables and constants work in Go.
What are Variables?
A variable is a storage location identified by a name (or identifier) that holds a value. This value can change (or vary) during a program’s execution, hence the name “variable.”
For example:
myName := "temitope"
fmt.Println(myName)
myName = "oyedele"
fmt.Println(myName)
We created a variable with the identifier myName
which holds a string value. We then changed the value to another string, demonstrating that variables are mutable.
Variables allow you to store data of different types, such as integers, floating-point numbers, strings, or objects.
How to Create a Variable
There are two primary ways to create a variable in Go: explicit declaration and shorthand declaration.
Explicit Declaration
This is the traditional way to create a variable in Go. It involves using the var
keyword and declaring the variable’s type, making your code more readable and clear.
package main
import "fmt"
func main() {
var age int = 25
var name string = "Temitope"
var height float64 = 5.7
fmt.Println(age, name, height)
}
For each variable, we declared its datatype before assigning a value to it.
Output:
25 Temitope 5.7
The var
keyword and data type can also be used without assigning an initial value:
package main
import "fmt"
func main() {
var age int
var name string
var height float64
age = 25
name = "Temitope"
height = 5.7
fmt.Println(age, name, height)
}
This way, the variables are declared first without an initial value. They are then assigned values later in the code, with the same output as the first example.
Shorthand Variable Declaration
The shorthand variable declaration syntax (:=
) is a more concise way to declare variables. This method allows you to declare and initialize a variable in a single line without explicitly stating its type, as the type is inferred from the value assigned.
package main
import "fmt"
func main() {
age := 25
name := "Temitope"
height := 5.7
fmt.Println(age, name, height)
}
Here, each variable was declared alongside its value, with Go inferring the datatype.
Output:
25 Temitope 5.7
One drawback of the shorthand variable declaration is that it can only be used inside a function.
Multiple Variable Declarations
You can declare and initialize multiple variables on the same line by separating each variable with a comma. This approach is simple and straightforward, commonly used when the variables are related or when you want to initialize them together. For example:
package main
import "fmt"
func main() {
var age, height int = 25, 180
var name, city string = "Temitope", "New York"
fmt.Println(age, height)
fmt.Println(name, city)
}
Output:
25 180
Temitope New York
You can also declare multiple variables in a block:
package main
import "fmt"
func main() {
var (
age int = 25
name string = "Temitope"
height int = 180
city string = "New York"
)
fmt.Println(age, name, height, city)
}
Output:
25 Temitope 180 New York
Zero Values
When variables are declared without being initialized, they are assigned zero values by default, depending on the type of variable. Below is an example of how you can declare default values:
package main
import "fmt"
func main() {
var intValue int
var floatValue float64
var boolValue bool
var stringValue string
var ptrValue *int
var sliceValue []int
var mapValue map[string]int
fmt.Println("Zero values:")
fmt.Println("int:", intValue)
fmt.Println("float64:", floatValue)
fmt.Println("bool:", boolValue)
fmt.Println("string:", stringValue)
fmt.Println("pointer:", ptrValue)
fmt.Println("slice:", sliceValue)
fmt.Println("map:", mapValue)
}
Output:
Zero values:
int: 0
float64: 0
bool: false
string:
pointer: <nil>
slice: []
map: map[]
What is Variable Scope?
The scope of a variable determines where it can be accessed and modified within your code. Variables can be declared either globally or locally.
Global Variables
Global variables are declared outside of any function, typically at the top of a file, and they can be accessed by any function within the same package. For example:
package main
import "fmt"
var globalCounter int = 0
func incrementCounter() {
globalCounter++
}
func main() {
fmt.Println("Initial Counter:", globalCounter)
incrementCounter()
fmt.Println("After Increment:", globalCounter)
}
In this example, globalCounter
is a global variable, accessible by both the incrementCounter
function and the main
function. The value of globalCounter
persists across function calls.
Local Variables
Local variables, on the other hand, are declared within a function or a block and are only accessible within that specific function or block. They are created when the function or block is executed and destroyed once it is completed. For example:
package main
import "fmt"
func incrementCounter() {
localCounter := 0
localCounter++
fmt.Println("Local Counter:", localCounter)
}
func main() {
incrementCounter()
incrementCounter()
}
In this example, localCounter
is a local variable inside the incrementCounter
function. Each time incrementCounter
is called, a new localCounter
is created, initialized to 0, and incremented. The value of localCounter
does not persist between function calls.
Naming Conventions in Go
Proper naming of variables is crucial for writing clean, readable, and maintainable code. Go has specific conventions and rules for naming variables:
-
Use descriptive names: Choose names that clearly describe the purpose or content of the variable, such as
age
,totalPrice
, oruserName
. - Use CamelCase for multi-word names: In Go, it’s common practice to use camelCase for variable names that consist of multiple words. The first word is lowercase, and the first letter of each subsequent word is capitalized.
- Avoid using underscores: Stick to camelCase to adhere to Go’s idiomatic style, avoiding underscores to separate words in variable names.
-
Use short names for short-lived variables: For short-lived variables, such as loop counters or indices, it’s acceptable to use short names like
i
,j
, ork
.
What are Constants in Go?
Constants are immutable values defined at compile time that cannot be modified throughout the program’s execution. They are useful for defining values that are known ahead of time and will remain the same.
For example, if you’re building an online store where the standard shipping fee is always $10, you can declare it as a constant. This allows you to use it throughout your program whenever shipping charges need to be applied. If the shipping rates change, you only need to update the value in one place.
How to Declare Constants in Go
You can declare constants using the const
keyword, followed by the name, the type (optional if the value implies the type), and the value of the constant. Here’s an example:
package main
import "fmt"
func main() {
const pi float64 = 3.14159
const greeting string = "Hello, World!"
fmt.Println("Pi:", pi)
fmt.Println("Greeting:", greeting)
}
If you try to change a constant after it has been declared, you’ll get a compile-time error.
Types of Constants in Go
Constants can be categorized as either typed or untyped. Both serve the same purpose—providing fixed, immutable values throughout the program—but they differ in how Go handles their types and how flexible they are when used.
Untyped Constants
Untyped constants are not assigned a type unless they are used in a context that requires a type. Go infers the type at the point where the constant is used, making untyped constants more flexible
because they can be used in various contexts without requiring type conversion.
package main
import "fmt"
const gravity = 9.81
func main() {
var height int = 10
var acceleration float64 = gravity * float64(height)
fmt.Println("Acceleration:", acceleration)
}
Here, gravity
is an untyped constant, allowing Go to infer its type based on its usage. When gravity
is used in a calculation with a float64
, Go automatically treats it as a float64
.
Typed Constants
Typed constants have an explicitly declared type, meaning they can only be used in contexts that match that type or can be converted to a compatible type. Typed constants are stricter, ensuring that the value is always treated as the specific type it was declared with.
package main
import "fmt"
const speedOfLight int = 299792458
func main() {
var distance int = speedOfLight * 2
fmt.Println("Distance:", distance)
}
Here, speedOfLight
is a typed constant with the type int
. It can only be used in operations with other int
values or converted explicitly to a different type.
That’s a Wrap
In this article, we explored what variables and constants are and how to declare them in Go. Variables and constants are critical tools in programming, allowing developers to efficiently manage and manipulate data. Understanding how to use them can significantly improve the quality of your code.
In case you have found a mistake in the text, please send a message to the author by selecting the mistake and pressing Ctrl-Enter.