Variables and Data Types in Go

In Go, variables are explicitly declared and used by the compiler to check type correctness. Go supports various data types, including integers, floats, strings, and booleans. Variables are essential for storing and manipulating data in programs.

Declaring Variables

Variables in Go can be declared using the var keyword or using the shorthand := syntax. The shorthand syntax is preferred for brevity and readability.


// Using var keyword
var age int = 25

// Using shorthand syntax
name := "Alice"

Common Data Types

Go provides several built-in data types to represent different kinds of data:

int: Represents whole numbers (e.g., 10, -5).
float64: Represents decimal numbers (e.g., 3.14, -0.001).
string: Represents text data (e.g., "Hello", 'Go').
bool: Represents true or false values.
byte: Represents a single byte (8 bits).
rune: Represents a Unicode code point (32 bits).

Type Inference

Go supports type inference, meaning the compiler can automatically determine the type of a variable based on the assigned value.


package main

import "fmt"

func main() {
    var age = 25 // Type inferred as int
    name := "Alice" // Type inferred as string
    isStudent := true // Type inferred as bool

    fmt.Println("Name:", name)
    fmt.Println("Age:", age)
    fmt.Println("Is Student:", isStudent)
}

Constants

Constants are fixed values that cannot be changed during program execution. They are declared using the const keyword.


package main

import "fmt"

const Pi = 3.14159

func main() {
    fmt.Println("Value of Pi:", Pi)
}

Variable Scope

The scope of a variable determines where it can be accessed in a program. Variables can have:

Local Scope: Variables declared inside a function are local to that function.
Global Scope: Variables declared outside all functions are global and can be accessed anywhere in the program.


package main

import "fmt"

var globalVar = 10 // Global variable

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

Zero Values

In Go, variables declared without an explicit initial value are given their zero value. The zero value depends on the type:

0 for numeric types.
false for booleans.
"" (empty string) for strings.


package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string

    fmt.Println("int zero value:", i)
    fmt.Println("float64 zero value:", f)
    fmt.Println("bool zero value:", b)
    fmt.Println("string zero value:", s)
}

Best Practices

Use Descriptive Names: Choose meaningful names for variables to improve code readability.
Initialize Variables: Always initialize variables to avoid undefined behavior.
Use Constants: Use const for values that should not change.
Limit Scope: Declare variables in the smallest scope possible to avoid unintended side effects.
Prefer Shorthand Syntax: Use the := syntax for brevity and readability.

Next: Control Structures