How do you declare variables and what are Go's basic types?

Question

Accepted Answer

Go is statically typed with several ways to declare variables. The most common is the **short declaration** `:=`, which infers the type. Go's basic types cover numbers, strings, booleans, and more.

## Declaring variables

```go
var x int = 42        // full form: explicit type and value
var y = 42            // type inferred → int
var z int             // declared, ZERO-valued (z = 0)

name := "Ann"         // short declaration (:=) — infers type, INSIDE functions only
count := 10

var a, b = 1, "two"   // multiple at once
const Pi = 3.14159     // constant (compile-time)
```

`:=` is the idiomatic in-function way — concise with type inference. `var` is used at package level and when you want an explicit type or just the zero value.

## The basic types

```go
// integers
int, int8, int16, int32, int64     // signed (int is platform-sized, usually 64-bit)
uint, uint8, ..., uint64           // unsigned
byte                                // alias for uint8
rune                                // alias for int32 — a Unicode code point

// floating point
float32, float64                    // float64 is the default for decimals

// others
string                              // immutable UTF-8 text
bool                               // true / false
complex64, complex128              // complex numbers
```

## Zero values — no "uninitialized" variables

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (empty)
var b bool      // false
var p *int      // nil
```

A crucial Go feature: every declared variable gets a sensible **zero value** automatically — there are no undefined/garbage values. This makes code safer and means you can often skip explicit initialization.

## Type conversions are explicit

```go
var i int = 42
var f float64 = float64(i)   // MUST convert explicitly — no implicit coercion
var u uint = uint(f)
// i + f  → ❌ compile error: mismatched types
```

Go requires **explicit** type conversions — it never implicitly mixes types, preventing a class of subtle bugs.

## Why it matters

Understanding Go's variable declarations and types is fundamental to writing any Go.

The idiomatic `:=` short declaration with inference keeps code concise, while `var` and constants serve their roles.

The **zero-value guarantee** (every variable is safely initialized) is a distinctive, important Go feature that eliminates uninitialized-variable bugs and shapes idiomatic patterns (e.g. a zero-valued struct is often usable).

And Go's insistence on **explicit type conversions** (no implicit coercion) is a deliberate safety choice that prevents the kinds of silent numeric bugs other languages allow.

Knowing the basic types (especially `rune` for Unicode, `byte`, and that `int`/`float64` are the defaults) is essential everyday knowledge.