Basic Data Types in Go

Go programs are built from data. Every variable, every field, every expression result carries a value, and that value belongs to a specific type. The type determines what you can do with the data, how much memory it uses, and what happens when you combine it with other values.

The basic data types covered here are the foundation for everything else: slices, maps, structs, and interfaces are built on top of them. Understanding these types — how they behave, how they interact, and where beginners get tripped up — makes the rest of the language easier to learn.

What a Data Type Tells the Compiler

A data type is a classification that answers three questions:

• What kind of value is stored — a truth value, a whole number, a decimal number, a sequence of characters.
• How much memory the value occupies — an 8-bit integer uses one byte, a 64-bit floating-point number uses eight bytes.
• What operations are valid — you can add two integers, but you cannot add an integer and a boolean.

Go is statically typed, meaning every variable has a fixed type at compile time. The compiler refuses to build a program where you try to store a string in an int variable, or add a bool to a float64. This strictness catches entire categories of bugs before the program ever runs.

The Four Categories of Basic Types

Go's basic data types fall into four groups, each described in more detail in its own dedicated section:

• Boolean — the bool type, representing true or false
• Numeric — signed and unsigned integers of various sizes, floating-point numbers, and complex numbers
• String — the string type, a sequence of bytes that holds text
• Architecture-Dependent — int, uint, and uintptr, whose size changes with the platform

The following overview introduces each group with enough depth to start using them confidently. The separate pages under this section explore edge cases, internal representation, and advanced operations.

Boolean Type

A bool holds one of two values: true or false. It is the simplest data type and the backbone of all conditional logic and comparisons.

var isReady bool = true
completed := false
fmt.Println(isReady)  // true

Boolean values result from comparison operators (==, !=, \u003c, \u003e, \u003c=, \u003e=) and work with logical operators (&&, ||, !). The expression 5 > 3 evaluates to the boolean true, and you can combine such results: (age > 18) && (country == "IN").

A common pitfall in languages that treat true as 1 and false as 0 does not exist in Go. A bool is not a number, and there is no implicit conversion between the two. This prevents a whole class of subtle bugs where a truth value accidentally participates in arithmetic.

Numeric Types

Go provides a rich set of numeric types that cover whole numbers, fractional numbers, and even complex numbers. The variety gives you precise control over memory and value range, but it also means you must choose the right type for the job.

Integers

Integers come in two families: signed (can represent negative values) and unsigned (only zero and positive). Each family offers four sizes: 8, 16, 32, and 64 bits, plus the architecture-dependent int and uint.

Two integer aliases appear frequently:

• byte is uint8 — used for raw byte data
• rune is int32 — used for Unicode code points

Most of the time, you should reach for plain int. It adapts to the word size of the machine (32 or 64 bits) and works for the overwhelming majority of everyday values like counters, indices, and small arithmetic. Choose a specific size only when dealing with binary protocols, file formats, or tight memory constraints.

var count int = 142
var small int8 = 100
fmt.Printf("count type: %T, small type: %T\n", count, small)
// Output: count type: int, small type: int8

The Printf format verb %T prints the type — a handy tool when you are unsure what the compiler inferred.

Floating-Point Numbers

float32 and float64 follow the IEEE 754 standard. float64 is the default type for floating-point literals and the safe choice unless you have a specific reason to save memory.

pi := 3.14159
var radius float32 = 2.5
fmt.Printf("pi type: %T, radius type: %T\n", pi, radius)
// Output: pi type: float64, radius type: float32

Floating-point arithmetic is an approximation. Values like 0.1 cannot be represented exactly in binary, so 0.1 + 0.2 may not equal exactly 0.3. Use floating-point for measurements, graphics, and scientific computation — not for money. For exact decimal representation, turn to integer pennies or the math/big package.

Complex Numbers

Go has built-in support for complex64 (float32 real and imaginary parts) and complex128 (float64 parts). They are useful for signal processing, physics simulations, and certain mathematical domains.

c1 := complex(2, 3)   // 2 + 3i, type complex128
c2 := 5 + 1i
sum := c1 + c2
fmt.Println("Sum:", sum) // (7+4i)

The built-in functions real() and imag() extract the components. For most beginner programs, you will not need complex numbers, but their presence in the language means you can write numeric code across all standard numeric types without third-party libraries.

String Type

A string is a read-only sequence of bytes. It can contain any byte value — UTF-8 encoded text, binary data, or even null bytes. Go source code treats string literals as UTF-8, so you can write and print emoji, accented characters, and symbols directly.

greeting := "Hello, 世界"
raw := `A raw string
spanning multiple lines.
No escape sequences needed.`
fmt.Println(greeting)
fmt.Println(len(greeting)) // 13 bytes (not 9 characters)

Strings are immutable: once created, you cannot change individual bytes. Operations like greeting[0] = 'h' will not compile. Instead, you build new strings using concatenation (+), fmt.Sprintf, or the strings package.

The len function returns the number of bytes, not the number of characters. A single Unicode character (rune) can occupy multiple bytes in UTF-8, so iterating over a string byte-by-byte gives a different picture than iterating rune-by-rune using for range.

Architecture-Dependent Types

int, uint, and uintptr are sized to the native word size of the CPU the code is compiled for. On a 64-bit machine, they are 64 bits (8 bytes); on a 32-bit machine, they are 32 bits (4 bytes).

This design ties Go's most common integer type to the hardware, which generally gives the best performance for arithmetic and loop counters. But it also means the same code can behave differently on different machines if you make assumptions about the range of int.

var x int = 1\u003c\u003c62  // Safe on 64-bit; overflows on 32-bit
fmt.Println(x)

The general advice from the Go team: use int unless you have a documented reason for a sized type (binary protocol, cross-platform file format, tight memory control). This keeps your code idiomatic and portable across the architectures Go supports.

uintptr in Practice

uintptr is an unsigned integer large enough to hold a memory address. You will rarely use it directly unless interacting with the unsafe package or low-level system calls. Most pointer manipulation stays safely within Go's type-safe pointer rules.

Common Mistakes That Compile But Misbehave

• Mixing int and uint without conversion — Go requires explicit conversion. The compiler stops you outright, which is a safety feature. Still, programmers new to the language often write var u uint = -1 and wonder why it fails: unsigned types cannot represent negative values.
• Assuming len("hello") returns character count — it returns bytes. For the number of runes, use utf8.RuneCountInString.
• Comparing floating-point values with == — due to approximation, a == b may fail for values that are mathematically equal. Compare within a small tolerance instead.
• Relying on int being 64 bits — code that shifts or stores values beyond 2^31-1 must use int64 if 32-bit compatibility matters.