> ## 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 uint16
`uint16` is a built-in unsigned integer type in Go that represents a 16-bit (2-byte) numerical value. Because it is unsigned, it lacks a sign bit, utilizing all 16 bits strictly to represent mathematical magnitude.
## Technical Specifications
* **Memory Size:** 16 bits (2 bytes)
* **Value Range:** `0` to `65535` ($2^{16} - 1$)
* **Zero Value:** `0`
* **Type Identity:** `uint16` is a distinct, non-aliased primitive type.
## Syntax and Initialization
Variables of type `uint16` can be declared using standard variable declaration, short variable declaration with explicit casting, or by referencing constants from the `math` package.
```go theme={"dark"}
package main
import (
"fmt"
"math"
)
func main() {
// Explicit declaration
var a uint16 = 32000
// Short declaration requiring explicit type conversion
b := uint16(1024)
// Zero value initialization (defaults to 0)
var c uint16
// Maximum possible value using the math package
max := uint16(math.MaxUint16) // 65535
// All declared variables must be used in Go
fmt.Printf("a: %d, b: %d, c: %d, max: %d\n", a, b, c, max)
}
```
## Type Strictness and Conversion
Go enforces strict static typing. A `uint16` cannot be implicitly combined with, compared to, or assigned to variables of other numeric types (such as `int`, `uint8`, or `uint32`). Explicit type conversion is mandatory to satisfy the compiler.
```go theme={"dark"}
package main
import "fmt"
func main() {
var val16 uint16 = 500
var val32 uint32 = 1000
// INVALID: Compiler error (mismatched types uint16 and uint32)
// sum := val16 + val32
// VALID: Explicit conversion aligns the types before the operation
sum := uint32(val16) + val32
fmt.Printf("Sum: %d\n", sum)
}
```
## Boundary Behavior (Overflow and Underflow)
At runtime, `uint16` operations that exceed the 16-bit boundary exhibit standard modular arithmetic (wraparound) behavior. Note that while runtime operations wrap around, constant expressions that overflow will be caught as compile-time errors.
```go theme={"dark"}
package main
import "fmt"
func main() {
var min uint16 = 0
var max uint16 = 65535
// Runtime underflow: wraps around to the maximum value
min--
fmt.Println(min) // Output: 65535
// Runtime overflow: wraps around to the minimum value (zero)
max++
fmt.Println(max) // Output: 0
}
```
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
