5 الگوی ذخیره سازی برتر برای برنامه های کاربردی با کارایی بالا

Summarize this content to 400 words in Persian Lang
کش کردن یک تکنیک قدرتمند برای افزایش عملکرد و مقیاس پذیری برنامه ها است. با ذخیره داده‌هایی که به طور مکرر در دسترس هستند در لایه‌های ذخیره‌سازی سریع‌تر، می‌توانید تأخیر را کاهش دهید، بار پایگاه داده را کاهش دهید و تجربه کاربری روان‌تری ارائه دهید.

در این مقاله، ما پنج الگوی برتر ذخیره سازی را که هر توسعه دهنده ای باید بداند، بررسی خواهیم کرد. با استفاده از TypeScript و Node.js، نشان خواهیم داد که چگونه می توان این الگوها را برای بهینه سازی عملکرد برنامه پیاده سازی کرد.

1️⃣ کش درون حافظهیک کش درون حافظه داده ها را برای عملیات خواندن و نوشتن سریع در حافظه ذخیره می کند. این برای ذخیره داده های کوچک و اغلب قابل دسترسی مانند اطلاعات جلسه یا تنظیمات پیکربندی ایده آل است.

مثال: کش کردن با Node.js

class InMemoryCache<T> {
private cache: Map<string, T> = new Map();

set(key: string, value: T) {
this.cache.set(key, value);
}

get(key: string): T | undefined {
return this.cache.get(key);
}

delete(key: string) {
this.cache.delete(key);
}
}

// Usage
const cache = new InMemoryCache<number>();
cache.set(‘user:123’, 42);
console.log(cache.get(‘user:123’)); // Output: 42

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

2️⃣ نوشتن از طریق کش

در حافظه پنهان نوشتن از طریق کش، ابتدا نوشتن در حافظه پنهان انجام می شود و سپس بلافاصله در ذخیره سازی داده های زیرین نوشته می شود. این تضمین می کند که کش همیشه با پایگاه داده همگام باشد.

مثال: نوشتن از طریق کش

class WriteThroughCache<T> {
private cache: Map<string, T> = new Map();

async write(key: string, value: T, writeToDb: (key: string, value: T) => Promise<void>) {
this.cache.set(key, value);
await writeToDb(key, value); // Write to database
}

get(key: string): T | undefined {
return this.cache.get(key);
}
}

// Simulated database function
async function dbWrite(key: string, value: any) {
console.log(`Writing ${key}: ${value} to database`);
}

// Usage
const writeCache = new WriteThroughCache<string>();
writeCache.write(‘key1’, ‘value1’, dbWrite);
console.log(writeCache.get(‘key1’)); // Output: ‘value1’

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

3️⃣ الگوی حافظه پنهان

در الگوی cache-aside، برنامه ابتدا حافظه پنهان را بررسی می کند. اگر داده در دسترس نباشد، آن را از پایگاه داده بازیابی می کند و برای درخواست های بعدی در کش ذخیره می کند.

مثال: Cache-aside با Redis

import redis from ‘redis’;
import { promisify } from ‘util’;

const client = redis.createClient();
const getAsync = promisify(client.get).bind(client);
const setAsync = promisify(client.set).bind(client);

async function getData(key: string, fetchFromDb: () => Promise<string>): Promise<string> {
const cachedValue = await getAsync(key);

if (cachedValue) {
console.log(‘Cache hit’);
return cachedValue;
}

console.log(‘Cache miss’);
const value = await fetchFromDb();
await setAsync(key, value);
return value;
}

// Simulated database fetch
async function fetchFromDb() {
return ‘Database Value’;
}

// Usage
getData(‘user:123’, fetchFromDb).then(console.log);

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

4️⃣ کش خواندنی

در یک کش خواندنی، تمام درخواست‌های خواندن از طریق کش عبور می‌کنند. اگر داده وجود نداشته باشد، حافظه پنهان آن را از فروشگاه داده دریافت می کند و به طور خودکار به روز می شود.

مثال: کش خواندنی

class ReadThroughCache<T> {
private cache: Map<string, T> = new Map();

async get(key: string, fetchFromDb: () => Promise<T>): Promise<T> {
if (this.cache.has(key)) {
console.log(‘Cache hit’);
return this.cache.get(key)!;
}

console.log(‘Cache miss’);
const value = await fetchFromDb();
this.cache.set(key, value);
return value;
}
}

// Usage
const readCache = new ReadThroughCache<string>();
readCache.get(‘user:123’, async () => ‘Fetched from DB’).then(console.log);

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

5️⃣ حافظه پنهان توزیع شده

حافظه پنهان توزیع شده داده ها را در چندین گره ذخیره می کند و مقیاس پذیری و تحمل خطا را تضمین می کند. معمولاً در سیستم‌های مقیاس بزرگ برای مدیریت کارآمد ترافیک بالا استفاده می‌شود.

مثال: استفاده از Redis به عنوان کش توزیع شده

import { createClient } from ‘redis’;

const client = createClient();

async function setCache(key: string, value: string) {
await client.connect();
await client.set(key, value);
console.log(`Set ${key}: ${value}`);
await client.disconnect();
}

async function getCache(key: string) {
await client.connect();
const value = await client.get(key);
console.log(`Get ${key}: ${value}`);
await client.disconnect();
return value;
}

// Usage
setCache(‘session:abc’, ‘active’);
getCache(‘session:abc’);

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

الگوهای ذخیره سازی برای ساخت برنامه های کاربردی با کارایی بالا و مقیاس پذیر ضروری هستند. چه از کش های ساده در حافظه استفاده کنید یا از راه حل های ذخیره سازی توزیع شده پیچیده، انتخاب الگوی مناسب برای مورد استفاده شما می تواند به طور قابل توجهی سرعت و قابلیت اطمینان برنامه شما را بهبود بخشد.

با پیاده سازی این الگوها در Node.js با TypeScript، می توانید عملکرد سیستم خود را بهینه کنید و تجربه کاربری را افزایش دهید. با توسعه نیازهای برنامه خود، با اصول اولیه و مقیاس شروع کنید.

کد نویسی مبارک ❤️

class InMemoryCache<T> {
  private cache: Map<string, T> = new Map();

  set(key: string, value: T) {
    this.cache.set(key, value);
  }

  get(key: string): T | undefined {
    return this.cache.get(key);
  }

  delete(key: string) {
    this.cache.delete(key);
  }
}

// Usage
const cache = new InMemoryCache<number>();
cache.set('user:123', 42);
console.log(cache.get('user:123')); // Output: 42

class WriteThroughCache<T> {
  private cache: Map<string, T> = new Map();

  async write(key: string, value: T, writeToDb: (key: string, value: T) => Promise<void>) {
    this.cache.set(key, value);
    await writeToDb(key, value); // Write to database
  }

  get(key: string): T | undefined {
    return this.cache.get(key);
  }
}

// Simulated database function
async function dbWrite(key: string, value: any) {
  console.log(`Writing ${key}: ${value} to database`);
}

// Usage
const writeCache = new WriteThroughCache<string>();
writeCache.write('key1', 'value1', dbWrite);
console.log(writeCache.get('key1')); // Output: 'value1'

import redis from 'redis';
import { promisify } from 'util';

const client = redis.createClient();
const getAsync = promisify(client.get).bind(client);
const setAsync = promisify(client.set).bind(client);

async function getData(key: string, fetchFromDb: () => Promise<string>): Promise<string> {
  const cachedValue = await getAsync(key);

  if (cachedValue) {
    console.log('Cache hit');
    return cachedValue;
  }

  console.log('Cache miss');
  const value = await fetchFromDb();
  await setAsync(key, value);
  return value;
}

// Simulated database fetch
async function fetchFromDb() {
  return 'Database Value';
}

// Usage
getData('user:123', fetchFromDb).then(console.log);

class ReadThroughCache<T> {
  private cache: Map<string, T> = new Map();

  async get(key: string, fetchFromDb: () => Promise<T>): Promise<T> {
    if (this.cache.has(key)) {
      console.log('Cache hit');
      return this.cache.get(key)!;
    }

    console.log('Cache miss');
    const value = await fetchFromDb();
    this.cache.set(key, value);
    return value;
  }
}

// Usage
const readCache = new ReadThroughCache<string>();
readCache.get('user:123', async () => 'Fetched from DB').then(console.log);

import { createClient } from 'redis';

const client = createClient();

async function setCache(key: string, value: string) {
  await client.connect();
  await client.set(key, value);
  console.log(`Set ${key}: ${value}`);
  await client.disconnect();
}

async function getCache(key: string) {
  await client.connect();
  const value = await client.get(key);
  console.log(`Get ${key}: ${value}`);
  await client.disconnect();
  return value;
}

// Usage
setCache('session:abc', 'active');
getCache('session:abc');