Comment déclarez-vous les variables et quels sont les types de base de Go ?

Question

Accepted Answer

Go est typé statiquement avec plusieurs façons de déclarer des variables. La plus courante est la **déclaration courte** `:=`, qui déduit le type. Les types de base de Go couvrent les nombres, les chaînes de caractères, les booléens, et bien d'autres.

## Déclarer des 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)
```

`:=` est la manière idiomatique dans une fonction — concise avec déduction de type. `var` est utilisé au niveau du package et quand vous voulez un type explicite ou simplement la valeur zéro.

## Les types de base

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

## Valeurs zéro — pas de variables « non initialisées »

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

Une caractéristique cruciale de Go : chaque variable déclarée obtient automatiquement une **valeur zéro** sensée — il n'y a pas de valeurs indéfinies/garbage. Cela rend le code plus sûr et signifie que vous pouvez souvent ignorer l'initialisation explicite.

## Les conversions de types sont explicites

```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 exige des conversions de types **explicites** — il ne mélange jamais implicitement les types, prévenant une classe de bugs subtils.

## Pourquoi c'est important

Comprendre les déclarations de variables et les types de Go est fondamental pour écrire du code Go.

La déclaration courte idiomatique `:=` avec déduction garde le code concis, tandis que `var` et les constantes servent leurs rôles.

La **garantie de valeur zéro** (chaque variable est initialisée de manière sûre) est une caractéristique distinctive et importante de Go qui élimine les bugs de variable non initialisée et façonne les patterns idiomatiques (par exemple, une struct avec valeur zéro est souvent utilisable).

Et l'insistance de Go sur les **conversions de types explicites** (pas de coercition implicite) est un choix de sécurité délibéré qui prévient les sortes de bugs numériques silencieux que d'autres langues permettent.

Connaître les types de base (particulièrement `rune` pour Unicode, `byte`, et que `int`/`float64` sont les défauts) est une connaissance essentielle au quotidien.