Cad iad dearbhuithe cineáil agus laistí cineáil?

Question

Accepted Answer

Baineann **dearbhú cineáil** an chineál nó-theanga ó luach comhéadáin, agus déanann **lasta cineáil** brainseáil ar chineál bunúsach comhéadáin. Seo an dóigh a dhéanann tú faisnéis chineáil shonraigthe a bhaint ar ais ó chomhéadáin (go háirithe an comhéadáin fholamh / `any`).

## Dearbhú cineáil — cineál nó-theanga a bhaint

```go
var i interface{} = "hello"     // an interface holding a string

s := i.(string)                  // assert it's a string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i is not an int (wrong assertion)
```

Baineann an chomhréir `i.(Type)` é a dhearbhú go bhfuil luach den `Type` ag comhéadáin `i` agus baintear é. Ach **cuireann** dearbhú mícheart **scéimh** ar siúl — mar sin is gnách go mbíonn an fhoirm dhíoghluine comma-ok á úsáid agat.

## An fhoirm dhíoghluine comma-ok

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = the value
} else {
    fmt.Println("not a string")         // ok = false, s = zero value, NO panic
}
```

Tuairimíonn an dá-luach-fhoirm an luach agus boole — is falsa atá `ok` (in ionad páinc a chur ar siúl) mura n-éiríonn an dearbhú. **I gcónaí is fearr seo a roghnú** mura bhfuil tú cinnte faoin chineál.

## Lasta cineáil — brainseáil ar shaghasanna éagsúla

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // the special .(type) form, only in a switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

Seiceálann an fhoirm `switch v := i.(type)` an chineál bunúsach agus ceanglaíonn sé `v` (go cuí clóscríofa i ngach cás). Is an dóigh gheal a bhíonn ann chun comhéadáin a láimhseáil ar féidir go mbeadh saghasanna éagsúla ann.

## Dearbhuithe ar chineálacha comhéadáin a dhéanamh freisin

```go
// assert that a value implements a specific interface
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // use it as an io.Writer if it satisfies that interface
}
```

## Nuair a bhíonn na nithe seo de dhíth ort

```text
✓ Processing values of unknown type (interface{}/any) — JSON, generic handlers
✓ Checking if a value implements an optional interface (e.g. io.Closer)
✓ Handling heterogeneous data
⚠️ Often a sign you could use generics or better-typed interfaces instead — don't overuse
```

## Cén fáth a bhíonn tábhacht ann

Is uirlisí riachtanacha iad dearbhuithe cineáil agus laistí cineáil do obair le luachanna comhéadáin — faisnéis chineáil nó-theanga a bhaint ar ais ó `interface{}`/`any` nó seiceáil an gcomhlíonn luach comhéadáin ar leith (cosúil le "an ndéanann sé io.Closer a chur i bhfeidhm?").

Tá siad de dhíth nuair a bhíonn tú ag láimhseáil sonraí de chineál anaithnid nó athraitheach (JSON dinimiciúil a pharsáil, próiseáil ghéarchéimí, seiceálacha comhéadáin roghnach).

Tá an tuiscint ar an **idirdhealú idir páinc agus slán** an-chriticiúil: cuireann dearbhú geal `i.(T)` páinc ar siúl ar mhíréiteach, agus tuairimíonn an **fhoirm comma-ok** `v, ok := i.(T)` an dhroch-thorthaí go sábháilte — is cleachtas príomhúil í an fhoirm dhíoghluine a úsáid chun chun tuairiscí fadálaithe a sheachaint.

Láimhseálann an lasta cineáil saghasanna éagsúla go solúbtha.

Tá sé tábhachtach a bheith i bhfios againn na nithe seo (agus go gcosúlann an t-úsáid throm go bhfuil tú ag súil go mbéarfaidh tú ar ghéiniúlacht nó dearadh níos fearr a úsáid ina ionad sin) chun Go sábháilte, idioimeach a dhéanamh, agus is ábhar comhghairdeas coitianta é seo, ó tharla go bhfuil comhéadáin agus an comhéadáin fholamh chomh lárnach don teanga.