Numbers | Golang basics

Mahdi.Kh

September 21, 2026

In this part, we get familiar with numeric data types and learn how to use them.

Go's numbers are divided into the following three categories:

Integers (int)
Floating-point numbers (float)
Complex numbers (complex)

Integers

An integer is a number with no fractional part. Integers themselves are divided into two categories: signed and unsigned. The unsigned form can't store negative numbers.

Depending on how much memory is needed, Go offers 8, 16, 32, and 64-bit forms of integers. For example, with 8 bits we can store 2⁸ = 256 numbers, meaning the signed form can store from -128 to 127, and the unsigned form can store from 0 to 255.

package main

import "fmt"

func main() {
    // signed integers: int8 int16 int32 int64
    // unsigned integers: uint8 uint16 uint32 uint64
    var age int = 25
    var smallNumber int8 = -128
    var largeNumber uint64 = 18446744073709551615

    fmt.Println("Age:", age)
    fmt.Println("Small Number:", smallNumber)
    fmt.Println("Large Number:", largeNumber)
}

There are two other integer types, named int and uint, whose size depends on the architecture of the system the program runs on.

On 32-bit systems, the size of int and uint is 32 bits, and on 64-bit systems, their size is 64 bits.

The int type is used by default for integers in Go.

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a int = 42
    var b int32 = 42

    fmt.Println("Value of a:", a)
    fmt.Println("Size of a (int):", unsafe.Sizeof(a), "bytes") // size in bytes
    fmt.Println("Value of b:", b)
    fmt.Println("Size of b (int32):", unsafe.Sizeof(b), "bytes") // size in bytes
}

Here, we used the unsafe package to measure how much memory each variable uses.

If you run the program above on a 64-bit system, a's size will be 8 bytes (64 bits), while b's size is always 4 bytes (32 bits).
If you run the program above on a 32-bit system, a's size will be 4 bytes (32 bits), while b's size is still 4 bytes (32 bits).

This difference shows why, in some cases, you might want to be sure of the exact size, especially in applications that need consistent, predictable data sizes.

#golang #go

Latest

Most viewed

Latest

Most viewed

Comments

Numbers | Golang basics

Integers

Floating-Point Numbers

Complex Numbers

Arithmetic Operators

Summary