Variables and Data Types

Variables

The var statement declares one or more variables. Like function parameters, the type is specified at the end.

It can be used at both the package level and within functions.

package main

import "fmt"

var golang, python, c bool

func main() {
    var rust int
    fmt.Println(rust, golang, python, c)
}

Variables with Initializers

A var declaration can include initializers, one per variable.

If an initializer is provided, the type can be omitted. In such cases, the variable’s type is inferred from the initializer.

package main

import "fmt"

var i, j int = 1, 2

func main() {
    var golang, python, rust = true, false, "yes"
    fmt.Println(i, j, golang, python, rust)
}

Short variable declarations

When you are inside a function, you can use a shortcut := to declare and assign a variable all at once.

Go is smart enough to automatically infer the data type.

package main

import "fmt"

func main() {
    var i, j int = 1, 2
    k := 3
    golang, python, rust := true, false, "yes"

    fmt.Println(i, j, k, golang, python, rust)
}

Zero values

The zero value is:

• 0 for numeric types,
• false for the boolean type, and
• "" (the empty string) for strings.

package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

The Core Data Types

As a beginner, you will mostly work with these four basic types:

• string: For text (e.g., "Hello")
• int: For whole numbers (e.g., 10)
• float64: For decimal numbers (e.g., 10.5)
• bool: For true/false values (e.g., true)

package main

import "fmt"

func main() {
    // 1. The Standard Way: Explicitly stating the type
    var name string = "Alice"
    var age int = 25

    // 2. The Short Way: Go infers the type automatically
    height := 5.8       // inferred as float64
    isStudent := true   // inferred as bool

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

Type Conversions

In Go, type conversion is explicit. You must clearly specify when converting a value from one type to another.

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

Type Inference

In Go, you don’t always need to explicitly specify a variable’s type. When a variable is declared with an initializer, Go determines its type automatically based on the assigned value.

This applies when using both:

• short declaration syntax (:=)
• var with an initializer

var i int
j := i // j gets the same type as i (int)

If the assigned value already has a defined type, the new variable adopts that type.

Untyped Constants Behavior

When the assigned value is an untyped constant, Go decides the type based on the value’s form and precision.

i := 42           // inferred as int
f := 3.142        // inferred as float64
g := 0.867 + 0.5i // inferred as complex128

Constants

Constants are declared using the const keyword, similar to variables.

They can represent:

• character values
• strings
• booleans
• numeric values

Unlike variables, constants must be defined at compile time and cannot change.

package main

import "fmt"

const Pi = 3.14

func main() {
    const World = "世界"
    fmt.Println("Hello", World)
    fmt.Println("Happy", Pi, "Day")

    const Truth = true
    fmt.Println("Go rules?", Truth)
}

Key Rules

• Constants are immutable (their value cannot change)
• They must be assigned a value at the time of declaration
• The := syntax cannot be used with constants

const x = 10   // valid
x := 10        // invalid for constants

Common Doubts

f := 3.142 // f is float64
f = 8      // works fine

f = 8.0

f := 3.142         // f is float64
f = 8              // 8 adapts to float64 - fine

var x float32 = 8  // 8 adapts to float32 - also fine

f := 3.142
n := 8             // n is now a typed int (inferred)
f = n              // cannot use n (int) as float64