Conas a dhéanann tú athróga a dhearbhú agus cad iad na bunphrionsabail a théann i bhfeidhm i Go?

Question

Accepted Answer

Is rud é Go a bhíonn tipiciúil seasmhach agus roinnt bealach ann chun athróga a dhearbhú. Is é an ceann is coitianta ná an **gearrdhéaradh** `:=`, a leagtar amach an cineál. Cuimsíonn na bunphrionsabail de Go líon, teaghrainn, booleanúla, agus níos mó.

## Athróga a dhearbhú

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

Is é `:=` an bealach idiomatúil i bhfeidhm — gearr le fothabhair cineáil. Úsáidtear `var` ag leibhéal an phaicéad agus nuair a bhíonn cineál soiléir uait nó go simplí an luach nialais.

## Na bunphrionsabail

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

## Luachanna nialais — gan athróga "neamhthosainithe"

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

Gné ríthábhachtach Go: faigheann gach athróg dhearbhaithe luach nialais **ciallmhar** go huathoibríoch — níl luachanna neamhshainithe/brúidiúla ann. Déanann sé seo an cód níos sábháilte agus ciallaíonn sé go leor ama agus is féidir leat tús an leagan soiléir a bhaint a bhaint go minic.

## Tiontú cineáil atá soiléir

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

Exigíonn Go tiontuithe cineáil **soiléir** — ní chuireann sé cineálacha le chéile go intuigthe, agus cuireann sé cosc ar aicme de bhuganna foluain.

## Cad atá tábhachtach

Tá tuiscint ar dhéaradh athróga agus cineálacha Go bunúsach chun aon Go a scríobh.

Coimeádann an gearrdhéaradh idiomatúil `:=` leis an bhfothabhair cineáil an cód gearr, agus freastalaíonn `var` agus tairgead a gcuid ról.

Is gné dhílis agus thábhachtach de Go an **barantúis luach nialais** (tá gach athróg thosainithe go sábháilte) agus cuireann sé an tsaintréithe athróganna neamhthosainithe ar ceal agus moilíonn sé patrúin idiomatúla (mar shampla, is féidir struct le luach nialais a úsáid go minic).

Agus is rogha sábháilteachta intinn é insistenceacht Go ar **tiontuithe cineáil soiléir** (gan comhchur intuigthe) a bhacann ar chineálacha de bhuganna uimhriúla i bhfolach a nglacann teangacha eile leo.

Tá eolas ar na bunphrionsabail (go háirithe `rune` do Unicode, `byte`, agus gur iad `int`/`float64` na rogha réamhshocraithe) bunúsach do gach lá.