Si e deklaroni variablat dhe cilat janë llojet bazike të Go?

Question

Accepted Answer

Go është statikisht tipizuar me disa mënyra për të deklaruar variablat. Më e zakonshme është **deklarimi i shkurtër** `:=`, i cili nxjerr në pah llojin. Llojet bazike të Go mbulojnë numrat, vargjet, vlerat boolean, dhe më shumë.

## Deklarimi i variablave

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

`:=` është mënyra idiomatike në funksion — koncize me nxjerrje të llojit. `var` përdoret në nivelin e paketës dhe kur dëshironi një lloj të qartë ose thjesht vlerën zero.

## Llojet bazike

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

## Vlerat zero — nuk ka variabla "të neinicializuar"

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

Një veçori vendimtare e Go: çdo variabël i deklaruar merr një vlerë zero të arsyeshme automatikisht — nuk ka vlera të papërcaktuara/të rastit. Kjo e bën kodin më të sigurt dhe do të thotë se shpesh mund ta kaloni inicializimin e qartë.

## Konvertimet e tipit janë të qarta

```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 kërkon konvertim **të qartë** të tipit — nuk përzien kurrë në mënyrë implicite llojet, duke parandaluar një klasë të gabimeve delikate.

## Pse ka rëndësi

Kuptimi i deklarimeve dhe tipeve të variablave të Go është themelor për të shkruar ndonjë Go.

Deklarimi i shkurtër idiomatik `:=` me nxjerrje e mban kodin konciz, ndërsa `var` dhe konstantet shërbejnë rolet e tyre.

**Garantia e vlerës zero** (çdo variabël është inicializuar në mënyrë të sigurt) është një veçori e dallueshme dhe e rëndësishme e Go që eliminon gabimet e variablave të neinicializuar dhe formon modele idiomatike (p.sh. një strukturë me vlerë zero është shpesh e përdorshme).

Dhe insistenca e Go në **konvertimet eksplicite të tipit** (pa koercion implicite) është një zgjedhje deliberate sigurie që parandalon llojet e gabimeve të qeta numerike që lejojnë gjuhëj të tjera.

Dija e llojeve bazike (në veçanti `rune` për Unicode, `byte`, dhe se `int`/`float64` janë parazgjedhjet) është njohuri esenciale e përditshme.