GoLang - Variables

7 minute read

In the realm of programming, variables serve as fundamental building blocks, allowing developers to store and manipulate data within their code. In the context of GoLang, variables play a crucial role in defining and managing information efficiently.

Now its time to see some other feature of a programming language. Let’s see what is a variable and how it works in Go Programming.

Why do you need variables?

In the world of computer you deal with data. Some data are permanent, which we store into a Database and some are temporary, which are use to perform some kind of operations, so we have variables to store the temporary data.

To store and operate on temporary data you need variables.

Variables in Go

In Programming, variables are names you give to the computer memory locations which are used to store values within it.

Here is how we declare a variable in Go Programming.

var number int


  • var : keyword use to declare variable
  • number : name of the variable
  • int : data type associated with the variable
Note: Every variable has a fixed data type in Go programming. The type of data that a variable can store is determines by its data type.

In above example, the `number` variable can only store integer data because its type is `int`.

We will learn different types of data types in next tutorial.

Initializing variables

Variables in GoLang can be initialized at the time of declaration or separately using the assignment operator. Let’s look at some examples:

var name string = "John"
var count int
count = 10

Variable types in GoLang

GoLang supports various data types such as integers, floats, strings, booleans, and more. Each data type has its own characteristics and uses.

var num int
var price float64
var message string
var isTrue bool

Constants in GoLang

Constants in GoLang are declared using the const keyword and cannot be changed once defined. They are useful for defining values that remain constant throughout the program.

package main

import "fmt"

func main() {
    const pi = 3.14
    const appName string = "MyApp"
    fmt.Println("Value of pi:", pi)
    fmt.Println("Application name:", appName)

Here, pi and appName are constants with values 3.14 and "MyApp" respectively.

Scope of variables

Variable scope refers to the visibility and accessibility of variables within different parts of the code. In GoLang, variables can have global or local scope.

package main

import "fmt"

// Global variable
var globalVar = 10

func main() {
    // Local variable
    var localVar = 20
    fmt.Println("Global variable:", globalVar)
    fmt.Println("Local variable:", localVar)

In this example, globalVar has global scope and can be accessed throughout the package, while localVar has local scope and is accessible only within the main function.

Type inference

GoLang features type inference, allowing the compiler to deduce the data type of a variable based on the assigned value. This eliminates the need for explicit type declarations in many cases.

package main

import "fmt"

func main() {
    // Type inference
    var age = 25 // Compiler infers type as int
    fmt.Println("Age:", age)

Here, GoLang compiler infers the type of the variable age as int based on the assigned value of 25.

Zero values

In GoLang, variables that are declared but not explicitly initialized are assigned a default value known as a zero value. For example, numeric types default to 0, strings default to an empty string, and booleans default to false.

package main

import "fmt"

func main() {
    var num int     // Zero value of int is 0
    var price float64 // Zero value of float64 is 0.0
    var isTrue bool // Zero value of bool is false
    fmt.Println("num:", num)
    fmt.Println("price:", price)
    fmt.Println("isTrue:", isTrue)

In this example, num defaults to 0 (zero value for int), price defaults to 0.0 (zero value for float64), and isTrue defaults to false (zero value for bool).

Shadowing variables

Variable shadowing occurs when a variable declared within a nested scope has the same name as a variable in the outer scope. In such cases, the inner variable takes precedence.

package main

import "fmt"

func main() {
    // Outer variable
    var name = "Alice"

    // Inner variable
    if true {
        var name = "Bob" // Shadowing outer variable
        fmt.Println("Inner name:", name)

    fmt.Println("Outer name:", name)

In this example, the inner variable name shadows the outer variable name within the if block, resulting in different values being printed.

Naming conventions for variables

It’s essential to follow proper naming conventions when defining variables in GoLang. Descriptive and meaningful names enhance code readability and maintainability.

package main

import "fmt"

func main() {
    var numStudents int // Camel case naming convention
    var totalMarks float64 // Camel case naming convention
    var isPassed bool // Camel case naming convention
    fmt.Println("Number of students:", numStudents)
    fmt.Println("Total marks:", totalMarks)
    fmt.Println("Passed?", isPassed)

Here, variables numStudents, totalMarks, and isPassed follow the camel case naming convention for variables in GoLang.

Pointers and variables

Pointers allow developers to directly manipulate memory addresses, enabling more efficient memory management and access to data.

package main

import "fmt"

func main() {
    var num = 10
    var ptr *int // Pointer to an integer
    ptr = &num // Assigning address of num to ptr
    fmt.Println("Value of num:", num)
    fmt.Println("Value pointed by ptr:", *ptr) // Dereferencing pointer

In this example, ptr is a pointer to an integer (*int) pointing to the address of num. Dereferencing ptr gives the value of num.

Working with multiple variables

GoLang supports the assignment of values to multiple variables simultaneously, which can streamline code and improve readability.

package main

import "fmt"

func main() {
    // Assigning values to multiple variables
    var name, age, city = "Alice", 30, "New York"
    fmt.Println("Name:", name)
    fmt.Println("Age:", age)
    fmt.Println("City:", city)

Here, values are assigned to multiple variables name, age, and city simultaneously.

Type conversion

Type conversion allows developers to convert variables from one data type to another, facilitating compatibility and interoperability between different data types.

package main

import (

func main() {
    var num1 int = 10
    var num2 float64 = 5.5

    // Converting int to float64
    result := float64(num1) + num2
    fmt.Println("Result:", result)

    // Converting float64 to string
    str := strconv.FormatFloat(num2, 'f', -1, 64)
    fmt.Println("String representation of num2:", str)

Here, num1 is converted to float64 before performing addition, and num2 is converted to a string using the strconv package.

Using variables in control structures

Variables are frequently used in control structures such as if statements, loops, and switch cases to make decisions and control program flow.

package main

import "fmt"

func main() {
    var age = 25
    // Using variables in if statement
    if age >= 18 {
        fmt.Println("You are an adult")

    // Using variables in for loop
    for i := 0; i < age; i++ {
        fmt.Println("Count:", i)

    // Using variables in switch case
    switch age {
    case 18:
        fmt.Println("You just turned 18")
    case 25:
        fmt.Println("You are 25 years old")
        fmt.Println("Your age is not special")

Here, the variable age is utilized in an if statement, a for loop, and a switch case to control program flow based on its value.


In this tutorial, we’ve explored the fundamentals of GoLang variables, including declaration, initialization, types, constants, scope, type inference, and more. Understanding these concepts is essential for mastering GoLang programming and building robust applications.


1. What are variables in GoLang?

Variables in GoLang are placeholders for storing data values that can be manipulated within a program. They play a fundamental role in programming and are used extensively in GoLang code.

2. How do you declare a variable in GoLang?

To declare a variable in GoLang, you use the var keyword followed by the variable name and its data type. For example:

var age int

3. Can variables in GoLang change their data type?

No, variables in GoLang are statically typed, meaning once a variable is declared with a specific data type, it cannot change its type during runtime.

4. What is variable shadowing in GoLang?

Variable shadowing occurs when a variable declared within a nested scope has the same name as a variable in the outer scope, causing the inner variable to take precedence.

5. Why is type inference beneficial in GoLang?

Type inference in GoLang eliminates the need for explicit type declarations, making the code more concise and readable while still ensuring type safety.

By addressing these common questions, we aim to provide further clarity on the topic of GoLang variables and empower developers to leverage them effectively in their projects.