Hogyan deklarálsz változókat, és melyek a Go alapvető típusai?

Question

Accepted Answer

A Go statikusan típusított, és több módja van a változók deklarálásának. A leggyakoribb a **rövid deklaráció** `:=`, amely kikövetkezteti a típust. A Go alapvető típusai számokat, stringeket, logikai értékeket és még sok mást tartalmaznak.

## Változók deklarálása

```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)
```

A `:=` az idiomatikus módja a függvényen belüli deklarációnak — tömör típuskövetkeztetéssel. A `var` csomagszinten és akkor használatos, amikor explicit típust vagy csak a nulla értéket szeretnél.

## Az alapvető típusok

```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
```

## Nulla értékek — nincs "inicializálatlan" változó

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

A Go egyik lényeges jellemzője: minden deklarált változó automatikusan kap egy értelmes **nulla értéket** — nincsenek definiálatlan/hulladék értékek. Ez biztonságosabbá teszi a kódot, és azt jelenti, hogy gyakran kihagyhatod az explicit inicializálást.

## Típuskonverziók 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
```

A Go **explicit** típuskonverziókat igényel — soha nem kever implicit módon típusokat, ezzel megelőzve a finom hibák egy osztályát.

## Miért fontos

A Go változódeklarációinak és típusainak megértése alapvető bármelyik Go írásához.

Az idiomatikus rövid deklaráció `:=` a típuskövetkeztetéssel tömörnek tartja a kódot, míg a `var` és a konstansok megkapják a szerepüket.

A **nulla érték garancia** (minden változó biztonságosan inicializálódik) a Go különleges, fontos jellemzője, amely kiküszöböli az inicializálatlan változókhoz kapcsolódó hibákat, és alakítja az idiomatikus mintákat (például egy nulla értékű struktúra gyakran használható).

A Go **explicit típuskonverzióra** való ragaszkodása (nincs implicit típuskényszerítés) egy szándékos biztonsági választás, amely megelőzi azokat a csendes numerikus hibákat, amelyeket más nyelvek megengednek.

Az alapvető típusok ismerete (különösen az Unicode-hoz szükséges `rune`, `byte`, és hogy az `int`/`float64` az alapértelmezett) alapvető, napi tudás.