Go uint64

uint64 is a built-in primitive data type in Go representing an unsigned 64-bit integer. It allocates exactly 8 bytes of memory and strictly stores non-negative whole numbers.

Technical Specifications

Memory Size: 64 bits (8 bytes)
Minimum Value: 0
Maximum Value: 18,446,744,073,709,551,615 ( $2^{64} - 1$ )
Zero Value: 0
Constant Reference: math.MaxUint64 (from the math package)

Declaration and Initialization

You can declare a uint64 using standard variable declaration, short variable declaration with type casting, or the new keyword. Go strictly requires all declared local variables to be used.

package main

import "fmt"

func main() {
    // Explicit declaration
    var a uint64 = 1000000000000

    // Short declaration with type conversion
    b := uint64(2000000000000)

    // Pointer to a zero-valued uint64
    c := new(uint64) 

    fmt.Printf("%T: %d\n", a, a)
    fmt.Printf("%T: %d\n", b, b)
    fmt.Printf("%T: %d\n", c, *c)
}

Type Conversion

Go enforces strict static typing. A uint64 cannot be implicitly mixed with other numeric types (such as int, uint32, or float64) in operations. Explicit type conversion is mandatory.

package main

import "fmt"

func main() {
    var x int = 42
    var y uint32 = 100

    // Explicitly converting int and uint32 to uint64
    var result uint64 = uint64(x) + uint64(y)
    
    fmt.Printf("Result: %d\n", result)
}

Overflow and Underflow Behavior

Because uint64 is a fixed-size integer, exceeding its maximum or minimum boundaries results in wrap-around behavior (modulo

2^{64}

arithmetic) rather than a runtime panic.

package main

import (
    "fmt"
    "math"
)

func main() {
    // Overflow
    var max uint64 = math.MaxUint64
    max++ 
    fmt.Printf("Overflow result: %d\n", max) // Output: 0

    // Underflow
    var min uint64 = 0
    min-- 
    fmt.Printf("Underflow result: %d\n", min) // Output: 18446744073709551615
}

String Formatting

When using the fmt package, uint64 utilizes standard integer verbs for string interpolation and formatting.

package main

import "fmt"

func main() {
    var val uint64 = 255

    // Base 10
    fmt.Printf("%d\n", val) // Output: 255

    // Hexadecimal (lowercase/uppercase)
    fmt.Printf("%x\n", val) // Output: ff
    fmt.Printf("%X\n", val) // Output: FF

    // Binary
    fmt.Printf("%b\n", val) // Output: 11111111
}

Tired of Poor Go Skills? Fix That With Deep Grasping!Learn More

Functions

Concurrency

Methods

Interfaces

Structs

Generics

Error Handling

Variables & Constants

Pointers

Composite Types

Type Declarations

Packages

Imports

Control Flow

Loops

Basic Types

Comments

Arithmetic Operators

Assignment Operators

Comparison Operators

Logical Operators

Index & Slice Operators

Unary Operators

Pointer Operators

Bitwise Operators

Shift Operators

Technical Specifications

Declaration and Initialization

Type Conversion

Overflow and Underflow Behavior

String Formatting

​Technical Specifications

​Declaration and Initialization

​Type Conversion

​Overflow and Underflow Behavior

​String Formatting

Technical Specifications

Declaration and Initialization

Type Conversion

Overflow and Underflow Behavior

String Formatting