Kuinka julistet muuttujia ja mitkä ovat Go:n perustyyppi?

Question

Accepted Answer

Go on staattisesti tyypitetty kieli, jolla on useita tapoja muuttujien julistamiseen. Yleisin on **lyhyt julistus** `:=`, joka päättelee tyypin. Go:n perustyyppit kattavat numerot, stringit, boolen arvot ja muuta.

## Muuttujien julistus

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

`:=` on idiomatinen tapa funktioiden sisällä — ytimekäs tyyppipäättelyllä. `var` käytetään pakettitasolla ja kun haluat eksplisiittisen tyypin tai vain nolla-arvon.

## Perustyyppi

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

## Nolla-arvot — ei "alustamattomia" muuttujia

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

Go:n kriittinen ominaisuus: jokainen julistettu muuttuja saa automaattisesti järkevän **nolla-arvon** — ei ole määrittelemättömiä/roskaarvoisia arvoja. Tämä tekee koodista turvallisempaa ja tarkoittaa, että voit usein ohittaa eksplisiittisen alustamisen.

## Tyypin muunnokset ovat eksplisiittiset

```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 vaatii **eksplisiittiset** tyypin muunnokset — se ei koskaan sekoita tyyppejä implisiittisesti, mikä estää hienovaraisten virheiden luokan.

## Miksi se on tärkeää

Go:n muuttujien julistamisen ja tyyppien ymmärtäminen on perustavanlaatuista minkä tahansa Go-koodin kirjoittamiselle.

Idiomatinen `:=` lyhyt julistus tyyppipäättelyllä pitää koodin ytimekkäänä, kun taas `var` ja vakiot palvelevat roolejaan.

**Nolla-arvotakuu** (jokainen muuttuja alustetaan turvallisesti) on Go:n erityinen ja tärkeä ominaisuus, joka eliminoi alustamattomien muuttujien virheet ja muokkaa idiomatisia malleja (esim. nolla-arvon rakenne on usein käyttökelpoinen).

Ja Go:n vaatimus **eksplisiiteistä tyypin muunnoksista** (ei implisiittisiä pakotuksia) on tarkoituksellinen turvallisuusvalinta, joka estää hiljaisten numeeristen virheiden tyypin, joita muut kielet sallivat.

Perustyyppien tunteminen (etenkin `rune` Unicode-merkeille, `byte` ja että `int`/`float64` ovat oletukset) on olennaista jokapäiväistä tietämystä.