ZetCode

Golang IntegerType

last modified May 8, 2025

This tutorial explains the IntegerType built-in type in Go. We'll cover all integer types with practical examples of their usage in Go programs.

The IntegerType in Go represents both signed and unsigned integer values. Go provides several integer types with different sizes and ranges. These include architecture-dependent and independent types.

Integer types in Go are used for whole number values. They differ in size, range, and whether they can represent negative numbers. Choosing the right type affects memory usage and program correctness.

Basic integer types

Go provides several built-in integer types with fixed sizes. This example demonstrates the basic integer types and their ranges.
Note: The actual size of int and uint depends on the platform.

basic_integers.go
package main

import (
    "fmt"
    "math"
    "unsafe"
)

func main() {

    var i8 int8 = math.MaxInt8
    var i16 int16 = math.MaxInt16
    var i32 int32 = math.MaxInt32
    var i64 int64 = math.MaxInt64
    
    fmt.Printf("int8:  %d (size: %d bytes)\n", i8, unsafe.Sizeof(i8))
    fmt.Printf("int16: %d (size: %d bytes)\n", i16, unsafe.Sizeof(i16))
    fmt.Printf("int32: %d (size: %d bytes)\n", i32, unsafe.Sizeof(i32))
    fmt.Printf("int64: %d (size: %d bytes)\n", i64, unsafe.Sizeof(i64))
    
    var u8 uint8 = math.MaxUint8
    var u16 uint16 = math.MaxUint16
    var u32 uint32 = math.MaxUint32
    var u64 uint64 = math.MaxUint64
    
    fmt.Printf("\nuint8:  %d (size: %d bytes)\n", u8, unsafe.Sizeof(u8))
    fmt.Printf("uint16: %d (size: %d bytes)\n", u16, unsafe.Sizeof(u16))
    fmt.Printf("uint32: %d (size: %d bytes)\n", u32, unsafe.Sizeof(u32))
    fmt.Printf("uint64: %d (size: %d bytes)\n", u64, unsafe.Sizeof(u64))
}

The example shows all fixed-size integer types with their maximum values. We use unsafe.Sizeof to demonstrate the memory size of each type.

Architecture-dependent integers

Go provides int and uint types whose size depends on the system architecture. This example demonstrates platform-dependent integer behavior.

arch_integers.go
package main

import (
    "fmt"
    "math"
    "runtime"
    "unsafe"
)

func main() {

    var i int = math.MaxInt
    var ui uint = math.MaxUint
    
    fmt.Printf("OS: %s, Arch: %s\n", runtime.GOOS, runtime.GOARCH)
    fmt.Printf("int:  %d (size: %d bytes)\n", i, unsafe.Sizeof(i))
    fmt.Printf("uint: %d (size: %d bytes)\n", ui, unsafe.Sizeof(ui))
    
    // Demonstrate overflow behavior
    var smallInt int8 = 127
    smallInt++ // Wraps around to -128
    fmt.Printf("\nint8 overflow: %d\n", smallInt)
}

The program shows the size of int and uint on the current platform. It also demonstrates integer overflow behavior which wraps around silently.

Integer type conversions

Go requires explicit conversion between different integer types. This example shows proper type conversion techniques and potential pitfalls.

type_conversions.go
package main

import "fmt"

func main() {

    var big int64 = 500
    var small int8
    
    // Explicit conversion required
    small = int8(big)
    fmt.Printf("Converted %d to %d\n", big, small)
    
    // Conversion with potential data loss
    big = 300
    small = int8(big)
    fmt.Printf("Converted %d to %d (data loss occurred)\n", big, small)
    
    // Safe conversion checking
    if big >= math.MinInt8 >> big <= math.MaxInt8 {
        small = int8(big)
        fmt.Println("Safe conversion performed")
    } else {
        fmt.Println("Conversion would cause overflow")
    }
}

The example demonstrates explicit type conversion syntax in Go. It shows how to check for potential overflow before performing conversions.

Integer arithmetic operations

Go supports standard arithmetic operations on integers. This example shows basic operations and their behavior with different integer types.

arithmetic_operations.go
package main

import "fmt"

func main() {

    a := 20
    b := 3
    
    // Basic arithmetic
    fmt.Println("Addition:", a + b)
    fmt.Println("Subtraction:", a - b)
    fmt.Println("Multiplication:", a * b)
    fmt.Println("Division:", a / b) // Integer division
    fmt.Println("Remainder:", a % b)
    
    // Bitwise operations
    fmt.Println("\nBitwise AND:", a & b)
    fmt.Println("Bitwise OR:", a | b)
    fmt.Println("Bitwise XOR:", a ^ b)
    fmt.Println("Left shift:", a << 2)
    fmt.Println("Right shift:", a >> 1)
    
    // Overflow example
    var maxInt8 int8 = 127
    fmt.Printf("\nMax int8 + 1 = %d (overflow)\n", maxInt8 + 1)
}

The program demonstrates standard arithmetic and bitwise operations. It also shows integer division behavior and overflow examples.

Integer literals and formatting

Go supports different formats for integer literals and output formatting. This example shows various ways to represent and display integers.

integer_literals.go
package main

import "fmt"

func main() {

    // Different base literals
    decimal := 42
    binary := 0b101010
    octal := 0o52
    hex := 0x2A
    
    fmt.Println("Decimal:", decimal)
    fmt.Println("Binary:", binary)
    fmt.Println("Octal:", octal)
    fmt.Println("Hexadecimal:", hex)
    
    // Formatted output
    fmt.Printf("\nFormatted output:\n")
    fmt.Printf("Decimal: %d\n", decimal)
    fmt.Printf("Binary: %b\n", decimal)
    fmt.Printf("Octal: %o\n", decimal)
    fmt.Printf("Hex (lower): %x\n", decimal)
    fmt.Printf("Hex (upper): %X\n", decimal)
    
    // Underscores in literals (Go 1.13+)
    bigNumber := 1_000_000
    fmt.Printf("\nFormatted with commas: %,d\n", bigNumber)
}

The example demonstrates different integer literal formats in Go. It shows how to use fmt.Printf for formatted output with various bases.

Source

Go language specification

This tutorial covered the IntegerType in Go with practical examples of declaration, conversion, arithmetic, and formatting.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Golang tutorials.