Node API ના પ્રદર્શનમાં સુધાર કરતી કેશીંગ વ્યૂહરચનાઓ કયાં છે?

Question

Accepted Answer

**કેશીંગ** મોંઘા ક્રિયાઓ (DB પ્રશ્નો, ગણતરીઓ, બાહ્ય API કૉલ્સ) ના પરિણામોને સંગ્રહ કરે છે જેથી પુનરાવર્તિત વિનંતીઓ ઝડપથી પરીવહન કરી શકાય કાર્ય ફરીથી કર્યા વિના. તે API માટે સૌથી વધુ પ્રભાવ ધરાવતી કર્મક્ષમતા ઑપ્ટિમાઇઝેશન છે.

## ઇન-મેમરી કેશીંગ (સૌથી ઝડપી, એકલ-ઇન્સ્ટન્સ)

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

સરળ અને અત્યંત ઝડપી, પરંતુ કેશ **પ્રોસેસ દીઠ** છે (ઇન્સ્ટન્સ વચ્ચે શેર કરવામાં આવતું નથી) અને પુનઃશરૂઆત પર હારી જાય છે. નાના, ગરમ ડેટા માટે સારું — પરંતુ મેમરી બાંધવા માટે ઇવિક્શન (જેમ કે `lru-cache` જેવી LRU કેશ વાપરો) ની જરૂર છે.

## Redis સાથે વિતરિત કેશીંગ (શેર, માપી શકાય તેવું)

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

**Redis** બહુવિધ સર્વર ઇન્સ્ટન્સ વચ્ચે કેશીંગ માટે ધોરણ છે — એક શેર, ઝડપી સંગ્રહ જે પુનઃશરૂઆતો સર્વાઇવ કરે છે અને તમારી એપ્લિકેશન સાથે માપવામાં આવે છે. **TTL** (સમય-જીવનકાળ) પ્રવેશોને આપમેળે સમાપ્ત કરે છે જેથી ડેટા કાયમ જૂનો ન થાય.

## HTTP કેશીંગ (ક્લાયન્ટ્સ/CDN્સ કેશ કરવા દો)

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

HTTP કેશ હેડર્સ કેશીંગને બ્રાઉઝર અને CDN્સ માટે સંપૂર્ણપણે ઑફલોડ કરે છે — સૌથી ઝડપી કેશ એ વિનંતી છે જે ક્યારેય તમારા સર્વર સુધી પહોંચતી નથી.

## મુશ્કેલ ભાગ: કેશ અમાન્યતા

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

સૌથી મોટી કેશીંગ પડકાર **અમાન્યતા** છે — અપડેટ સ્પષ્ટ/તાજી કરવાની ખાતરી કરવી અસર કરેલ કેશ પ્રવેશો જેથી વપરાશકર્તાઓ જૂનો ડેટા ન જોય. વ્યૂહરચનાઓ: TTL (સંક્ષિપ્ત પુરાણત્વ સ્વીકાર), રાઇટ-થ્રુ (લખા પર કેશ અપડેટ કરો), અથવા મ્યુટેશન પર સ્પષ્ટ કાઢવું.

## શું કેશ કરવું (અને નહીં)

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

## તે શા માટે મહત્વપૂર્ણ છે

કેશીંગ નાટકીય રીતે લેટન્સી અને ડેટાબેસ/બાહ્ય લોડ ઘટાડે છે, ઘણીવાર ધીમી API અને ઝડપી, માપી શકાય તેવી એક વચ્ચે તફાવત છે.

સ્તરોને જાણવું — ઇન-મેમરી (સૌથી ઝડપી, પ્રતિ-ઇન્સ્ટન્સ, LRU સાથે બંધાયેલું), Redis (ઇન્સ્ટન્સ વચ્ચે શેર), અને HTTP/CDN કેશીંગ (સંપૂર્ણ ઑફલોડ) — તમને યોગ્ય વ્યૂહરચના પસંદ કરવા દે છે.

અને કેશીંગની કેન્દ્રીય મુશ્કેલીને સમજવું, **અમાન્યતા** (TTL અથવા લખા પર સ્પષ્ટ સફાઇ દ્વારા), તે શું વપરાશકર્તાઓને જૂનો ડેટા પરીવહન કરવાની ક્લાસિક ટ્રેડ-ઑફ નિષ્ફળતા અટકાવે છે.

प્રભાવી કેશીંગ API કર્મક્ષમતા અને માપযોગ્યતા માટે સૌથી પ્રભાવશાળી સાધનોમાંનું એક છે.