Cad iad na straitéisí taisce a fheabhsaíonn feidhmíochaint API Node?

Question

Accepted Answer

**Taiscéadh** stóraíonn sé torthaí oibríochtaí costasacha (fiosrúcháin DB, ríomhanna, glaoch API seachtrach) ionas gur féidir iarrataí arís agus arís eile a fhreastal ar bhealach gasta gan an obair a athdéanamh. Is ceann de na barrfheabhsúcháin feidhmíochaint is ardtionchair do API.

## Taiscéadh i-athroinnt (is tapa, aonuachtar)

```js
const cache = new Map();

async function getUser(id) {
  if (cache.has(id)) return cache.get(id); // cache HIT — instant
  const user = await db.findUser(id);       // cache MISS — do the work
  cache.set(id, user);
  return user;
}
```

Simplí agus an-tapa, ach tá an taisce **in-próiseas** (gan roinnt ar chases) agus caillte ar atosú. Maith do shonraí beaga, te — ach tá feidhm ag fágáil amach (úsáid taisce LRU cosúil le `lru-cache`) chun cuimhne a bhaint.

## Taiscéadh dáilte le Redis (roinnt, inscálaithe)

```js
import { createClient } from "redis";
const redis = createClient();

async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // hit

const user = await db.findUser(id);
  await redis.setEx(`user:${id}`, 3600, JSON.stringify(user)); // cache for 1h (TTL)
  return user;
}
```

Is é **Redis** an caighdeán do thaiscéadh ar fud iliomad cás freastalaí — stór roinnte, tapa atá fós ann tar éis atosú agus ag scála le do app. An **TTL** (am-chun-bheith-beo) fág an taisce in-infhillte ionas nach n-imíonn sonraí fadó choíche.

## Taiscéadh HTTP (lig do chliaint/CDN taisce)

```js
res.set("Cache-Control", "public, max-age=3600"); // browsers/CDN cache for 1h
res.set("ETag", hash);                            // conditional requests (304 Not Modified)
```

Do bharrach loighic HTTP fág an taisce ar bhrabhsairí agus CDN ar fad — an taisce is tapa is an t-iarratas nach sroichann do fhreastalaí riamh.

## An chuid dhian: neamhdhéantacht an taisce

```js
// when data changes, the cache must be updated or cleared, or users see stale data
async function updateUser(id, data) {
  await db.updateUser(id, data);
  await redis.del(`user:${id}`); // INVALIDATE — next read repopulates with fresh data
}
```

Is é an dúshlán taiscéadh is mó **neamhdhéantacht** — a chinntiú go soiléir agus gur glan/athnuachan iontrálacha taisce a théann i bhfeidhm ionas nach bhfaighidh úsáideoirí sonraí sean-aimseartha. Straitéisí: TTL (glacadh le sean-aimseartha gairid), scríobh-trí (taisce a thabhairt nuair a scríobhtar), nó scriosadhairis ar athrú.

## Cad atá le taisce (agus gan taisce)

```text
✓ Read-heavy, infrequently-changing data (config, product catalogs, user profiles)
✓ Expensive computations, external API responses
✗ Highly dynamic/personalized or rapidly-changing data (or use very short TTLs)
✗ Sensitive data without care for who can read the cache
```

## Cén fáth a bhíonn sé tábhachtach

Laghdaíonn taiscéadh an latency agus an ualach DB/seachtrach go mór, go minic an difríonn idir API mall agus ceann tapa, inscálaithe.

A thuiscint ar na sraithe — i-athroinnt (is tapa, in-próiseas, teoranta le LRU), Redis (roinnt ar chases), agus taiscéadh HTTP/CDN (fág ar fad) — a bhaint amach an ceart straitéis.

Agus a thuiscint ar dhúshlán lárnach taiscéadh, **neamhdhéantacht** (trí TTL nó glanáil ar scríobhtha), ar a bhíonn ort briseadh an fhaillí clasaiceach a sheachaint ar fhothairbhiú úsáideoirí sonraí sean-aimseartha.

Is ceann de na huirlisí is gealadaiche le haghaidh feidhmíochaint agus inscálaitheacht API an taiscéadh éifeachtach.