Yaya za ka bayyana Variables kuma menene Na Ainihi Go's basic types?

Question

Accepted Answer

Go yana da jeri tsaye da daban-dabanin hanyoyin bayyana Variables. The mafi yada shine **short declaration** `:=`, wanda ke bayyana nau'i. Ainihin nau'ikan Go suna hari lambobi, Strings, booleans, da ari.

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

`:=` shi ne hanyar hiya a ciki aikin — kaifin da nau'i fuska. `var` ana amfani a matsayin Paketi kuma lokacin da kake so bayyanannen nau'i ko kawai ƙimar ƙider.

## Ainihin nau'ikan

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

## Ƙimar ƙider — ba "wanda bai jadawa" Variables ba

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

Maɓuɓɓun muhimmancin Go: kowannen Variable da aka bayyana tana samun ƙimar ƙider **kyau** ta atomatik — babu ƙimar rashin jadawa/ƙasa. Wannan yana sanya lambar amfani ligomar kuma yana nufin kuna iya locaci da yawa sakewa bayyanannen aiki.

## Type conversions suna da bayyane

```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 yana buƙatar **bayyane** type conversions — ba tayi haɗa jerin nau'i a takaici, hana nau'i da dama.

## Menene Mahaɗa

Janwa sanannen Variable declarations kuma nau'ikan Go shine asashe zuwa rubutu kowane Go.

Idiomatic short declaration `:=` da buƙatun nau'i yana ajiye lambar jiya, yayin da `var` da maɓuɓɓun aiki.

**Zero-value guarantee** (kowannen Variable yana karɓa amfani ta ligomar) shine muhimmancin ilhami, mahimmancin muhimmancin Go wanda ke sharewa Variable ba-jadawa bugs kuma yana shaɓa idiomatic patterns (misali, zero-valued struct shine kauran lokaci).

Kuma Go de' kan **bayyane type conversions** (ba tayi kasua a takaici) shine buƙatun tsaro niyya da ke hana dabi'o'i na lambobi keɓewa da sauran harsununa ke bayyana.

Sananne ainihin nau'ikan (musamman `rune` don Unicode, `byte`, kuma cewa `int`/`float64` sune ainihi) shine mahimmanci kowane rana sanannu.