Kaip jūs deklaruojate kintamuosius ir kokie yra Go pagrindiniai tipai?

Question

Accepted Answer

Go yra statiškai tipizuota su keliais būdais deklaruoti kintamuosius. Labiausiai paplitęs yra **trumpa deklaracija** `:=`, kuri nustato tipą. Go pagrindiniai tipai apima skaičius, eilutes, loginius kintamuosius ir daugiau.

## Kintamųjų deklaravimas

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

`:=` yra idiomatinis būdas funkcijos viduje — glaustai su tipu išvedimu. `var` naudojamas paketo lygiu ir kai norite aiškaus tipo arba tik nulinės reikšmės.

## Pagrindiniai tipai

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

## Nulinės reikšmės — nėra „neininicijuotų" kintamųjų

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

Kritinė Go ypatybė: kiekvienas deklaruotas kintamasis automatiškai gauna tikslią **nulinę reikšmę** — nėra neapibrėžtų/šiukšlių reikšmių. Tai padarytina kodą saugesniu ir reiškia, kad galite dažnai praleisti aiškią inicijalizaciją.

## Tipo konversijos yra aiškios

```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 reikalingas **aiškias** tipo konversijas — jis niekada nesumaišo tipų neaiškiai, todėl išvengiama subtilių klaidų klasės.

## Kodėl tai svarbu

Go kintamųjų deklaracijų ir tipų supratimas yra pagrindinis bet kokiam Go kodui rašyti.

Idiomatinė `:=` trumpa deklaracija su išvedimu daro kodą glaustą, o `var` ir konstantos atlieka savo vaidmenį.

**Nulinės reikšmės garantija** (kiekvienas kintamasis yra saugiai inicijuojamas) yra išskirtinė ir svarbi Go ypatybė, kuri pašalina neininicijuotų kintamųjų klaidas ir formuoja idiomatinę praktiką (pvz., nulinė struktūra dažnai gali būti naudojama).

Ir Go įžanga į **aiškias tipo konversijas** (jokios numantos priespaudos) yra sąmoninga saugumo pasirinkimas, kuri išvengia tų tylos skaitinių klaidų, kurias leidžia kitos kalbos.

Į pagrindinius tipus (ypač `rune` dėl Unicode, `byte` ir kad `int`/`float64` yra numatyti) žinojimas yra esminės kasdieninės žinios.