TypeScript में कैशिंग: Redis, Memcached और अंतर्निहित समाधान

परिचय: TypeScript अनुप्रयोगों के लिए कैशिंग क्यों महत्वपूर्ण है

TypeScript पर आधुनिक वेब अनुप्रयोग बढ़ते लोड और प्रतिक्रिया गति की आवश्यकताओं का सामना कर रहे हैं। कैशिंग किसी भी production-grade एप्लिकेशन के लिए केवल एक विकल्प नहीं, बल्कि एक आवश्यकता है। इसके बिना, डेटाबेस या बाहरी API से प्रत्येक अनुरोध एक महंगा ऑपरेशन बन जाता है, जो प्रतिक्रिया समय को 10-100 गुना बढ़ा देता है।

इस लेख में, हम TypeScript में कैशिंग के तीन मुख्य दृष्टिकोणों पर चर्चा करेंगे: Redis — वितरित कैश, Memcached — हल्का विकल्प और अंतर्निहित समाधान (in-memory cache)। आप सीखेंगे कि सही उपकरण कैसे चुनें और कोड उदाहरणों के साथ इसे कैसे लागू करें।

1. अंतर्निहित कैशिंग: TypeScript में In-Memory Cache

सबसे सरल और तेज़ तरीका है डेटा को सीधे प्रक्रिया की RAM में संग्रहीत करना। TypeScript/Node.js के लिए, यह मोनोलिथिक एप्लिकेशन या एक इंस्टेंस वाले माइक्रोसर्विसेज के लिए आदर्श है।

सरल in-memory कैश का कार्यान्वयन

आइए TTL (जीवनकाल) के समर्थन के साथ एक SimpleCache क्लास बनाएं:

interface CacheEntry<T> {  value: T;  expiresAt: number;}

class SimpleCache<T> {  private store = new Map<string, CacheEntry<T>>();  private defaultTTL: number; // मिलीसेकंड में

  constructor(defaultTTL: number = 60000) {    this.defaultTTL = defaultTTL;  }

  set(key: string, value: T, ttl?: number): void {    const expiresAt = Date.now() + (ttl ?? this.defaultTTL);    this.store.set(key, { value, expiresAt });  }

  get(key: string): T | null {    const entry = this.store.get(key);    if (!entry) return null;    if (Date.now() > entry.expiresAt) {      this.store.delete(key);      return null;    }    return entry.value;  }

  has(key: string): boolean {    return this.get(key) !== null;  }

  delete(key: string): void {    this.store.delete(key);  }

  clear(): void {    this.store.clear();  }}

// उपयोग का उदाहरणconst userCache = new SimpleCache<User>(30000); // TTL 30 सेकंडuserCache.set('user:123', { id: 123, name: 'अन्ना' });const cachedUser = userCache.get('user:123');

in-memory कैश के फायदे और नुकसान

• फायदे: अधिकतम गति (नैनोसेकंड), कोई नेटवर्क विलंब नहीं, कार्यान्वयन में सरलता।
• नुकसान: एप्लिकेशन पुनरारंभ होने पर डेटा खो जाता है, एक प्रक्रिया की RAM की मात्रा तक सीमित, क्षैतिज स्केलिंग पर काम नहीं करता।

कब उपयोग करें: भारी गणनाओं के परिणामों, कॉन्फ़िगरेशन, शायद ही कभी बदलने वाले स्थिर डेटा को कैश करने के लिए।

2. Redis: TypeScript के लिए वितरित कैशिंग

Redis सबसे लोकप्रिय in-memory data store है, जिसका उपयोग कैश, मैसेज ब्रोकर और डेटाबेस के रूप में किया जाता है। TypeScript के लिए हम ioredis लाइब्रेरी का उपयोग करते हैं।

स्थापना और बुनियादी सेटअप

npm install ioredisnpm install @types/ioredis -D

Redis के साथ काम करने के लिए एक सेवा बनाएं:

import Redis from 'ioredis';

class RedisCacheService {  private client: Redis;  private defaultTTL: number;

  constructor(ttlSeconds: number = 3600) {    this.client = new Redis({      host: process.env.REDIS_HOST || 'localhost',      port: Number(process.env.REDIS_PORT) || 6379,      retryStrategy: (times) => Math.min(times * 50, 2000),    });    this.defaultTTL = ttlSeconds;  }

  async set<T>(key: string, value: T, ttl?: number): Promise<void> {    const serialized = JSON.stringify(value);    const ttlToUse = ttl ?? this.defaultTTL;    await this.client.setex(key, ttlToUse, serialized);  }

  async get<T>(key: string): Promise<T | null> {    const data = await this.client.get(key);    if (!data) return null;    try {      return
```