Cad is oibreoir fógairt neamh-null (!) ann agus cathain a bhíonn sé oiriúnach?

Question

Accepted Answer

Insíonn an `!` postfix an tiomsaitheoir "Ráthaím go bhfuil an luach seo **nach** null nó undefined anseo" — ag baint `null`/`undefined` ó a chineál gan aon sheiceáil runtime.

```ts
function f(name?: string) {
  // name is string | undefined
  console.log(name!.toUpperCase()); // `!` asserts it's defined → string
}
```

Is fógairt ama-tiomsaithe amháin a thugtar air — cosúil le `as`, ní dhéanann sé **aon** fhíorú runtime. Má bhíonn tú mícheart, tuairteann sé:

```ts
const el = document.getElementById("app")!; // assert non-null
el.innerHTML = "hi"; // 💥 runtime error if #app doesn't actually exist
```

## Cathain is réasúnta a bheith ann

```ts
// 1. You've logically guaranteed it, but the compiler can't see it
if (map.has(key)) map.get(key)!.doThing(); // has() proves get() isn't undefined

// 2. Class fields initialized outside the constructor (DI, lifecycle hooks)
class C { value!: string; } // definite assignment assertion
```

## Rogha a thabhairt do roghanna níos sábháilte

```ts
name?.toUpperCase();           // optional chaining — no crash, yields undefined
const x = name ?? "default";    // provide a fallback
if (name) name.toUpperCase();   // narrow with a real check
```

Láimhseálann gach ceann acu an cás atá ar iarraidh in ionad a bheith ag fógairt air.

## Cén fáth a bhfuil tábhacht ann

Is uirlis gheal a thugtar ar `!`: cuireann sé ciúnas ar dhílseacht null an tiomsaitheoir agus sé a bheith ag iarraidh a dhéanamh.

Tá sé ócáideach a bheith réasúnta (tá eolas agat ar an tiomsaitheoir nach bhfuil), ach má úsáideann tú go hiomarcach é, tugann sé ar ais go díreach na fabhtanna null-chraiseanna a chosc `strictNullChecks`.

Bainfidh tú triail as `?.`, `??`, nó gardáil dhréachta ar dtús; úsáid `!` ach amháin nuair is féidir leat neamh-nullness a chruthú ar fhíor.