Unatangazaje vigeu na ni aina zipi za msingi za Go?

Question

Accepted Answer

Go ina aina za tuli (statically typed) na ina njia kadhaa za kutangaza vigeu. Njia inayotumika zaidi ni **utangazaji mfupi** `:=`, ambao hutambua aina yenyewe. Aina za msingi za Go zinajumuisha namba, mistari ya maandishi (strings), boolean, na zaidi.

## Kutangaza vigeu

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

`:=` ndiyo njia ya kiidiomatiki ndani ya function — fupi pamoja na utambuzi wa aina. `var` hutumika katika kiwango cha package na pale unapotaka aina dhahiri au thamani sifuri tu.

## Aina za msingi

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

## Thamani sifuri — hakuna vigeu "visivyoanzishwa"

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

Kipengele muhimu cha Go: kila kigeu kilichotangazwa hupewa **thamani sifuri** yenye maana kiotomatiki — hakuna thamani zisizoeleweka/za takataka. Hii hufanya msimbo kuwa salama zaidi na inamaanisha mara nyingi unaweza kuruka uanzishaji dhahiri.

## Ubadilishaji wa aina ni dhahiri

```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 huhitaji ubadilishaji wa aina kuwa **dhahiri** — haichanganyi aina kwa siri kamwe, jambo linalozuia kundi la makosa ya hila.

## Kwa nini ni muhimu

Kuelewa utangazaji wa vigeu na aina za Go ni msingi wa kuandika Go yoyote.

Utangazaji mfupi wa kiidiomatiki `:=` pamoja na utambuzi hufanya msimbo kuwa mfupi, huku `var` na constants zikitekeleza majukumu yao.

**Dhamana ya thamani sifuri** (kila kigeu kinaanzishwa kwa usalama) ni kipengele bainifu na muhimu cha Go kinachoondoa makosa ya vigeu visivyoanzishwa na kinachounda mifumo ya kiidiomatiki (mfano, struct yenye thamani sifuri mara nyingi inatumika moja kwa moja).

Na msisitizo wa Go juu ya **ubadilishaji dhahiri wa aina** (hakuna ubadilishaji wa kisiri) ni chaguo la usalama la makusudi linalozuia aina za makosa ya namba ya kimya ambayo lugha nyingine huruhusu.

Kujua aina za msingi (hasa `rune` kwa Unicode, `byte`, na kwamba `int`/`float64` ndizo chaguo-msingi) ni maarifa muhimu ya kila siku.