variables in Go

Introduction:

In the world of programming, variables serve as essential building blocks. They enable us to store and manipulate data, making it possible for a computer program to perform useful tasks. In this beginner-friendly guide, we will explore the concept of variables in the Go programming language (often referred to as Golang).

Variables are like containers in programming. They are used to store and manage data in your programs. Think of them as labeled boxes where you can put different types of information, such as numbers, text, or true/false values.

Variable Types

Go has various data types for different kinds of values. Here are some common ones:

int for integers (e.g., 1, 42, -10)
float64 for floating-point numbers (e.g., 3.14, -0.5)
string for text (e.g., "Hello, Go!")
bool for true or false values (e.g., true, false)

You declare a variable's type when you create it, like var age int. Although these are the types that are used generally, If we want to squeeze more performance, we can specifically mention what type of variable it should be

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128

Declaring Variables

Declaring a variable means telling the computer that you want to use a specific box (variable) to store data. You specify the variable's name and its type, like saying, "I want a box called 'age' to store integers." In Go, you declare a variable using the var keyword, followed by the variable name and its data type. Here's a simple example:

var age int // Declares an integer variable named 'age'

You can also initialize a variable when declaring it:

var name string = "John" // Declares and initializes a 
                         //string variable named 'name'

Initializing Variables

Initializing a variable is like putting something inside the box for the first time. You give it an initial value. For instance, you might say, "I'm putting the number 25 inside the 'age' box." After initialization, you can change the value of the box as needed in your program.

var score int = 100 // Initializes an integer
                    // variable 'score' with a value of 100

Short Variable Declaration and Type Inference

Go allows you to declare and initialize variables concisely using the := operator, which infers the variable's type from the assigned value. For example:

codemessage := "Hello, World!"
count := 42
pi := 3.14159265359
isTrue := true

In the above examples, Go automatically infers the types of these variables based on the assigned values. This feature makes your code concise and readable while reducing the need for explicit type declarations.

codemessage is assigned the default type string because it's initialized with a string literal.
count is assigned the default type int as it's initialized with an integer literal.
pi is assigned the default type float64 since it's initialized with a floating-point literal.
isTrue is assigned the default type bool because it's initialized with a boolean literal.

The := operator in Go is used for short variable declarations with type inference. It has a limited scope, typically confined to the block or function in which it is used. This means that variables declared using := are only accessible within the block in which they are defined. Once you move out of that block, the variables are no longer in scope and cannot be accessed. This scoping behavior helps maintain code clarity and prevents unintended variable pollution in broader contexts, making Go code less error-prone and easier to reason about.

Same-Line Declaration

You can declare multiple variables of the same type on a single line:

var(
    name    string
    age     int
    country string
)

This syntax is especially handy when you have multiple variables of the same type.

Constants

Constants are immutable values that you can define using the const keyword. Once set, they cannot be changed during program execution:

const(
    daysInWeek = 7
    pi         = 3.14159265359
    greeting   = "Hello, Go!"
)

Conditionals

Conditionals in Go are pretty straightforward. You can use if, else if, and else to create decision-making structures in your code. Here's an example:

var age := 25
if age < 18 {
    fmt.Println("You're a minor.")
} else if age >= 18 && age < 65 {
    fmt.Println("You're an adult.")
} else {
    fmt.Println("You're a senior citizen.")
}

Conclusion

Congratulations! You've just scratched the surface of Go's basics, including the powerful feature of type inference. These concepts are the building blocks of your Go programming journey. In future blog posts, we'll dive deeper into functions, loops, and more advanced topics.

Remember, practice is the key to mastering any programming language. Experiment with the examples provided and explore Go's documentation to deepen your understanding. Happy coding!

References:

Official Go Website: Comprehensive Go documentation, tutorials, and downloads.
image credit: ashley

01-Understanding Variables in Go (Golang) - A Beginner's Guide

Table of contents