> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# 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.
```go theme={"dark"}
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.
```go theme={"dark"}
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.
```go theme={"dark"}
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.
```go theme={"dark"}
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
