Cum declari variabile și care sunt tipurile de bază din Go?

Question

Accepted Answer

Go este static tipizat cu mai multe moduri de a declara variabile. Cea mai comună este **declarația scurtă** `:=`, care deduce tipul. Tipurile de bază din Go acoperă numere, stringuri, booleani și alte tipuri.

## Declararea variabilelor

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

`:=` este modul idiomatic în funcții — concis cu deducerea tipului. `var` este folosit la nivelul pachetului și când dorești un tip explicit sau doar valoarea zero.

## Tipurile de bază

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

## Valorile zero — nu există variabile „neinițializate"

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

O caracteristică crucială a Go: fiecare variabilă declarată primește automat o **valoare zero** sensibilă — nu există valori nedefinite/neiniţializate. Acest lucru face codul mai sigur și înseamnă că adesea poți sări peste inițializarea explicită.

## Conversiile de tip sunt explicite

```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 cere conversii de tip **explicite** — nu amestecă niciodată tipuri în mod implicit, prevenind o clasă de erori subtile.

## De ce conteaza

Înțelegerea declarațiilor de variabile și a tipurilor din Go este fundamentală pentru a scrie orice cod Go.

Declarația scurtă idiomatic `:=` cu deducere păstrează codul concis, în timp ce `var` și constantele îndeplinesc rolurile lor.

Garanția **valorii zero** (fiecare variabilă este inițializată în siguranță) este o caracteristică distinctivă și importantă a Go care elimină erorile de variabile neinițializate și modelează modele idiomatice (de ex., o structură cu valoare zero este adesea utilizabilă).

Și insistența Go pe **conversii de tip explicite** (fără coerciție implicită) este o alegere deliberată de siguranță care previne genurile de erori numerice silențioase pe care alte limbaje le permit.

Cunoașterea tipurilor de bază (în special `rune` pentru Unicode, `byte`, și că `int`/`float64` sunt implicite) este cunoaștere esențială din viața de zi cu zi.