أنماط التحفيظ (Memoization) في جافاسكريبت: استراتيجيات التخزين المؤقت ومكاسب الأداء

في عالم تطوير البرمجيات، يعتبر الأداء أمرًا بالغ الأهمية. تتطلب لغة جافاسكريبت، كونها لغة متعددة الاستخدامات في بيئات متنوعة، من تطوير الواجهات الأمامية للويب إلى تطبيقات الخادم باستخدام Node.js، غالبًا التحسين لضمان تنفيذ سلس وفعال. إحدى التقنيات القوية التي يمكن أن تحسن الأداء بشكل كبير في سيناريوهات محددة هي التحفيظ (memoization).

التحفيظ هو أسلوب تحسين يُستخدم أساسًا لتسريع برامج الكمبيوتر عن طريق تخزين نتائج استدعاءات الدوال المكلفة وإعادة النتيجة المخزنة مؤقتًا عند حدوث نفس المدخلات مرة أخرى. في جوهره، هو شكل من أشكال التخزين المؤقت يستهدف الدوال بشكل خاص. هذا النهج فعال بشكل خاص للدوال التي تكون:

• نقية (Pure): الدوال التي تعتمد قيمتها المُرجعة فقط على قيم مدخلاتها، دون أي آثار جانبية.
• محددة (Deterministic): لنفس المدخلات، تنتج الدالة دائمًا نفس المخرجات.
• مكلفة (Expensive): الدوال التي تكون حساباتها مكثفة حسابيًا أو تستغرق وقتًا طويلاً (مثل الدوال العودية، الحسابات المعقدة).

يستكشف هذا المقال مفهوم التحفيظ في جافاسكريبت، ويتعمق في مختلف الأنماط واستراتيجيات التخزين المؤقت ومكاسب الأداء التي يمكن تحقيقها من خلال تطبيقه. سندرس أمثلة عملية لتوضيح كيفية تطبيق التحفيظ بفعالية في سيناريوهات مختلفة.

فهم التحفيظ: المفهوم الأساسي

في جوهره، يستفيد التحفيظ من مبدأ التخزين المؤقت. عندما يتم استدعاء دالة مُحفّظة بمجموعة معينة من الوسائط، فإنها تتحقق أولاً مما إذا كانت نتيجة تلك الوسائط قد تم حسابها وتخزينها بالفعل في ذاكرة تخزين مؤقت (عادةً ما تكون كائن جافاسكريبت أو Map). إذا تم العثور على النتيجة في ذاكرة التخزين المؤقت، يتم إرجاعها على الفور. وإلا، تقوم الدالة بتنفيذ الحساب، وتخزين النتيجة في ذاكرة التخزين المؤقت، ثم إرجاعها.

تكمن الفائدة الرئيسية في تجنب الحسابات المتكررة. إذا تم استدعاء دالة عدة مرات بنفس المدخلات، فإن الإصدار المُحفّظ يقوم بالحساب مرة واحدة فقط. تسترد الاستدعاءات اللاحقة النتيجة مباشرة من ذاكرة التخزين المؤقت، مما يؤدي إلى تحسينات كبيرة في الأداء، خاصة للعمليات المكلفة حسابيًا.

أنماط التحفيظ في جافاسكريبت

يمكن استخدام عدة أنماط لتنفيذ التحفيظ في جافاسكريبت. دعنا نفحص بعضًا من أكثرها شيوعًا وفعالية:

1. التحفيظ الأساسي باستخدام الإغلاق (Closure)

هذا هو النهج الأساسي للتحفيظ. يستخدم الإغلاق (closure) للحفاظ على ذاكرة تخزين مؤقت ضمن نطاق الدالة. تكون ذاكرة التخزين المؤقت عادةً كائن جافاسكريبت بسيط حيث تمثل المفاتيح وسائط الدالة والقيم تمثل النتائج المقابلة.

function memoize(func) {
 const cache = {};
 return function(...args) {
 const key = JSON.stringify(args); // Create a unique key for the arguments
 if (cache[key]) {
 return cache[key]; // Return cached result
 } else {
 const result = func.apply(this, args); // Calculate the result
 cache[key] = result; // Store the result in the cache
 return result; // Return the result
 }
 };
}

// Example: Memoizing a factorial function
function factorial(n) {
 if (n <= 1) {
 return 1;
 }
 return n * factorial(n - 1);
}

const memoizedFactorial = memoize(factorial);

console.time('First call');
console.log(memoizedFactorial(5)); // Calculates and caches
console.timeEnd('First call');

console.time('Second call');
console.log(memoizedFactorial(5)); // Retrieves from cache
console.timeEnd('Second call');

الشرح:

• تأخذ دالة `memoize` دالة `func` كمدخل.
• تنشئ كائن `cache` ضمن نطاقها (باستخدام الإغلاق).
• تعيد دالة جديدة تغلف الدالة الأصلية.
• تنشئ هذه الدالة المغلفة مفتاحًا فريدًا بناءً على وسائط الدالة باستخدام `JSON.stringify(args)`.
• تتحقق مما إذا كان `key` موجودًا في `cache`. إذا كان كذلك، فإنها تعيد القيمة المخزنة.
• إذا لم يكن `key` موجودًا، فإنها تستدعي الدالة الأصلية، وتخزن النتيجة في `cache`، وتعيد النتيجة.

القيود:

• يمكن أن يكون `JSON.stringify` بطيئًا للكائنات المعقدة.
• يمكن أن يكون إنشاء المفتاح إشكاليًا مع الدوال التي تقبل وسائط بترتيبات مختلفة أو التي تكون كائنات بنفس المفاتيح ولكن بترتيب مختلف.
• لا يتعامل مع `NaN` بشكل صحيح حيث أن `JSON.stringify(NaN)` يعيد `null`.

2. التحفيظ باستخدام مولد مفاتيح مخصص

لمعالجة قيود `JSON.stringify`، يمكنك إنشاء دالة مولد مفاتيح مخصصة تنتج مفتاحًا فريدًا بناءً على وسائط الدالة. يوفر هذا مزيدًا من التحكم في كيفية فهرسة ذاكرة التخزين المؤقت ويمكن أن يحسن الأداء في سيناريوهات معينة.

function memoizeWithKey(func, keyGenerator) {
 const cache = {};
 return function(...args) {
 const key = keyGenerator(...args);
 if (cache[key]) {
 return cache[key];
 } else {
 const result = func.apply(this, args);
 cache[key] = result;
 return result;
 }
 };
}

// Example: Memoizing a function that adds two numbers
function add(a, b) {
 console.log('Calculating...');
 return a + b;
}

// Custom key generator for the add function
function addKeyGenerator(a, b) {
 return `${a}-${b}`;
}

const memoizedAdd = memoizeWithKey(add, addKeyGenerator);

console.log(memoizedAdd(2, 3)); // Calculates and caches
console.log(memoizedAdd(2, 3)); // Retrieves from cache
console.log(memoizedAdd(3, 2)); // Calculates and caches (different key)

الشرح:

• هذا النمط مشابه للتحفيظ الأساسي، ولكنه يقبل وسيطًا إضافيًا: `keyGenerator`.
• `keyGenerator` هي دالة تأخذ نفس وسائط الدالة الأصلية وتعيد مفتاحًا فريدًا.
• يسمح هذا بإنشاء مفاتيح أكثر مرونة وكفاءة، خاصة للدوال التي تعمل مع هياكل بيانات معقدة.

3. التحفيظ باستخدام Map

يوفر كائن `Map` في جافاسكريبت طريقة أكثر قوة وتنوعًا لتخزين النتائج المخزنة مؤقتًا. على عكس كائنات جافاسكريبت العادية، يسمح `Map` باستخدام أي نوع بيانات كمفاتيح، بما في ذلك الكائنات والدوال. هذا يلغي الحاجة إلى تحويل الوسائط إلى سلاسل نصية ويبسط إنشاء المفاتيح.

function memoizeWithMap(func) {
 const cache = new Map();
 return function(...args) {
 const key = args.join('|'); // Create a simple key (can be more sophisticated)
 if (cache.has(key)) {
 return cache.get(key);
 } else {
 const result = func.apply(this, args);
 cache.set(key, result);
 return result;
 }
 };
}

// Example: Memoizing a function that concatenates strings
function concatenate(str1, str2) {
 console.log('Concatenating...');
 return str1 + str2;
}

const memoizedConcatenate = memoizeWithMap(concatenate);

console.log(memoizedConcatenate('hello', 'world')); // Calculates and caches
console.log(memoizedConcatenate('hello', 'world')); // Retrieves from cache

الشرح:

• يستخدم هذا النمط كائن `Map` لتخزين ذاكرة التخزين المؤقت.
• يسمح `Map` باستخدام أي نوع بيانات كمفاتيح، بما في ذلك الكائنات والدوال، مما يوفر مرونة أكبر مقارنة بكائنات جافاسكريبت العادية.
• تُستخدم طرق `has` و `get` لكائن `Map` للتحقق من القيم المخزنة واستردادها، على التوالي.

4. التحفيظ العودي (Recursive Memoization)

يعتبر التحفيظ فعالاً بشكل خاص لتحسين الدوال العودية. من خلال تخزين نتائج الحسابات الوسيطة مؤقتًا، يمكنك تجنب العمليات الحسابية المتكررة وتقليل وقت التنفيذ بشكل كبير.

function memoizeRecursive(func) {
 const cache = {};
 function memoized(...args) {
 const key = String(args);
 if (cache[key]) {
 return cache[key];
 } else {
 cache[key] = func(memoized, ...args);
 return cache[key];
 }
 }
 return memoized;
}

// Example: Memoizing a Fibonacci sequence function
function fibonacci(memoized, n) {
 if (n <= 1) {
 return n;
 }
 return memoized(n - 1) + memoized(n - 2);
}

const memoizedFibonacci = memoizeRecursive(fibonacci);

console.time('First call');
console.log(memoizedFibonacci(10)); // Calculates and caches
console.timeEnd('First call');

console.time('Second call');
console.log(memoizedFibonacci(10)); // Retrieves from cache
console.timeEnd('Second call');

الشرح:

• تأخذ دالة `memoizeRecursive` دالة `func` كمدخل.
• تنشئ كائن `cache` ضمن نطاقها.
• تعيد دالة جديدة `memoized` تغلف الدالة الأصلية.
• تتحقق دالة `memoized` مما إذا كانت نتيجة الوسائط المحددة موجودة بالفعل في ذاكرة التخزين المؤقت. إذا كانت كذلك، فإنها تعيد القيمة المخزنة.
• إذا لم تكن النتيجة في ذاكرة التخزين المؤقت، فإنها تستدعي الدالة الأصلية مع الدالة `memoized` نفسها كوسيط أول. هذا يسمح للدالة الأصلية باستدعاء النسخة المُحفّظة من نفسها بشكل عودي.
• ثم يتم تخزين النتيجة في ذاكرة التخزين المؤقت وإعادتها.

5. التحفيظ القائم على الفئات (Class-Based)

بالنسبة للبرمجة كائنية التوجه، يمكن تنفيذ التحفيظ داخل فئة لتخزين نتائج الطرق مؤقتًا. يمكن أن يكون هذا مفيدًا للطرق المكلفة حسابيًا والتي يتم استدعاؤها بشكل متكرر بنفس الوسائط.

class MemoizedClass {
 constructor() {
 this.cache = {};
 }

 memoizeMethod(func) {
 return (...args) => {
 const key = JSON.stringify(args);
 if (this.cache[key]) {
 return this.cache[key];
 } else {
 const result = func.apply(this, args);
 this.cache[key] = result;
 return result;
 }
 };
 }

 // Example: Memoizing a method that calculates the power of a number
 power(base, exponent) {
 console.log('Calculating power...');
 return Math.pow(base, exponent);
 }
}

const memoizedInstance = new MemoizedClass();
const memoizedPower = memoizedInstance.memoizeMethod(memoizedInstance.power);

console.log(memoizedPower(2, 3)); // Calculates and caches
console.log(memoizedPower(2, 3)); // Retrieves from cache

الشرح:

• تُعرّف `MemoizedClass` خاصية `cache` في منشئها.
• تأخذ `memoizeMethod` دالة كمدخل وتعيد نسخة مُحفّظة من تلك الدالة، وتخزن النتائج في `cache` الخاص بالفئة.
• يسمح لك هذا بتحفيظ طرق معينة من فئة بشكل انتقائي.

استراتيجيات التخزين المؤقت

بالإضافة إلى أنماط التحفيظ الأساسية، يمكن استخدام استراتيجيات تخزين مؤقت مختلفة لتحسين سلوك ذاكرة التخزين المؤقت وإدارة حجمها. تساعد هذه الاستراتيجيات على ضمان بقاء ذاكرة التخزين المؤقت فعالة وعدم استهلاكها لذاكرة مفرطة.

1. ذاكرة التخزين المؤقت الأقل استخدامًا مؤخرًا (LRU)

تقوم ذاكرة التخزين المؤقت LRU بإخراج العناصر الأقل استخدامًا مؤخرًا عندما تصل ذاكرة التخزين المؤقت إلى حجمها الأقصى. تضمن هذه الاستراتيجية بقاء البيانات الأكثر وصولًا في ذاكرة التخزين المؤقت، بينما يتم التخلص من البيانات الأقل استخدامًا.

class LRUCache {
 constructor(capacity) {
 this.capacity = capacity;
 this.cache = new Map();
 }

 get(key) {
 if (this.cache.has(key)) {
 const value = this.cache.get(key);
 this.cache.delete(key); // Re-insert to mark as recently used
 this.cache.set(key, value);
 return value;
 } else {
 return undefined;
 }
 }

 put(key, value) {
 if (this.cache.has(key)) {
 this.cache.delete(key);
 }
 this.cache.set(key, value);
 if (this.cache.size > this.capacity) {
 // Remove the least recently used item
 const firstKey = this.cache.keys().next().value;
 this.cache.delete(firstKey);
 }
 }
}

// Example usage:
const lruCache = new LRUCache(3); // Capacity of 3

lruCache.put('a', 1);
lruCache.put('b', 2);
lruCache.put('c', 3);

console.log(lruCache.get('a')); // 1 (moves 'a' to the end)

lruCache.put('d', 4); // 'b' is evicted

console.log(lruCache.get('b')); // undefined
console.log(lruCache.get('a')); // 1
console.log(lruCache.get('c')); // 3
console.log(lruCache.get('d')); // 4

الشرح:

• تستخدم `Map` لتخزين ذاكرة التخزين المؤقت، والتي تحافظ على ترتيب الإدراج.
• تسترد `get(key)` القيمة وتعيد إدخال زوج المفتاح والقيمة لتمييزه كعنصر مستخدم مؤخرًا.
• تدرج `put(key, value)` زوج المفتاح والقيمة. إذا كانت ذاكرة التخزين المؤقت ممتلئة، يتم إزالة العنصر الأقل استخدامًا مؤخرًا (أول عنصر في `Map`).

2. ذاكرة التخزين المؤقت الأقل استخدامًا تكرارًا (LFU)

تقوم ذاكرة التخزين المؤقت LFU بإخراج العناصر الأقل استخدامًا تكرارًا عندما تكون ذاكرة التخزين المؤقت ممتلئة. تعطي هذه الاستراتيجية الأولوية للبيانات التي يتم الوصول إليها بشكل متكرر، مما يضمن بقاءها في ذاكرة التخزين المؤقت.

class LFUCache {
 constructor(capacity) {
 this.capacity = capacity;
 this.cache = new Map();
 this.frequencies = new Map();
 this.minFrequency = 0;
 }

 get(key) {
 if (!this.cache.has(key)) {
 return undefined;
 }

 const frequency = this.frequencies.get(key);
 this.frequencies.set(key, frequency + 1);
 return this.cache.get(key);
 }

 put(key, value) {
 if (this.capacity <= 0) {
 return;
 }

 if (this.cache.has(key)) {
 this.cache.set(key, value);
 this.get(key);
 return;
 }

 if (this.cache.size >= this.capacity) {
 this.evict();
 }

 this.cache.set(key, value);
 this.frequencies.set(key, 1);
 this.minFrequency = 1;
 }

 evict() {
 let minFreq = Infinity;
 for (const frequency of this.frequencies.values()) {
 minFreq = Math.min(minFreq, frequency);
 }

 const keysToRemove = [];
 this.frequencies.forEach((freq, key) => {
 if (freq === minFreq) {
 keysToRemove.push(key);
 }
 });

 const keyToRemove = keysToRemove[0];
 this.cache.delete(keyToRemove);
 this.frequencies.delete(keyToRemove);
 }
}

// Example usage:
const lfuCache = new LFUCache(2);

lfuCache.put('a', 1);
lfuCache.put('b', 2);
console.log(lfuCache.get('a')); // 1, frequency(a) = 2
lfuCache.put('c', 3); // evicts 'b' because frequency(b) = 1
console.log(lfuCache.get('b')); // undefined
console.log(lfuCache.get('a')); // 1, frequency(a) = 3
console.log(lfuCache.get('c')); // 3, frequency(c) = 2

الشرح:

• تستخدم كائنين `Map`: `cache` لتخزين أزواج المفاتيح والقيم و `frequencies` لتخزين تكرار الوصول لكل مفتاح.
• تسترد `get(key)` القيمة وتزيد عدد التكرار.
• تدرج `put(key, value)` زوج المفتاح والقيمة. إذا كانت ذاكرة التخزين المؤقت ممتلئة، فإنها تخرج العنصر الأقل استخدامًا تكرارًا.
• تجد `evict()` أقل عدد تكرار وتزيل زوج المفتاح والقيمة المقابل من كل من `cache` و `frequencies`.

3. انتهاء الصلاحية المعتمد على الوقت

تقوم هذه الاستراتيجية بإبطال صلاحية العناصر المخزنة مؤقتًا بعد فترة زمنية معينة. هذا مفيد للبيانات التي تصبح قديمة مع مرور الوقت. على سبيل المثال، تخزين استجابات API التي تكون صالحة لبضع دقائق فقط.

function memoizeWithExpiration(func, ttl) {
 const cache = new Map();
 return function(...args) {
 const key = JSON.stringify(args);
 const cached = cache.get(key);

 if (cached && cached.expiry > Date.now()) {
 return cached.value;
 } else {
 const result = func.apply(this, args);
 cache.set(key, { value: result, expiry: Date.now() + ttl });
 return result;
 }
 };
}

// Example: Memoizing a function with a 5-second expiration time
function getDataFromAPI(endpoint) {
 console.log(`Fetching data from ${endpoint}...`);
 // Simulate an API call with a delay
 return new Promise(resolve => {
 setTimeout(() => {
 resolve(`Data from ${endpoint}`);
 }, 1000);
 });
}

const memoizedGetData = memoizeWithExpiration(getDataFromAPI, 5000); // TTL: 5 seconds

async function testExpiration() {
 console.log(await memoizedGetData('/users')); // Fetches and caches
 console.log(await memoizedGetData('/users')); // Retrieves from cache

 setTimeout(async () => {
 console.log(await memoizedGetData('/users')); // Fetches again after 5 seconds
 }, 6000);
}

testExpiration();

الشرح:

• تأخذ دالة `memoizeWithExpiration` دالة `func` وقيمة وقت البقاء (TTL) بالمللي ثانية كمدخلات.
• تخزن القيمة المخزنة مؤقتًا مع طابع زمني لانتهاء الصلاحية.
• قبل إرجاع قيمة مخزنة، تتحقق مما إذا كان طابع انتهاء الصلاحية لا يزال في المستقبل. إذا لم يكن كذلك، فإنها تبطل صلاحية ذاكرة التخزين المؤقت وتعيد جلب البيانات.

مكاسب الأداء والاعتبارات

يمكن للتحفيظ أن يحسن الأداء بشكل كبير، خاصة للدوال المكلفة حسابيًا التي يتم استدعاؤها بشكل متكرر بنفس المدخلات. تكون مكاسب الأداء أكثر وضوحًا في السيناريوهات التالية:

• الدوال العودية: يمكن للتحفيظ أن يقلل بشكل كبير من عدد الاستدعاءات العودية، مما يؤدي إلى تحسينات أداء أسية.
• الدوال ذات المشكلات الفرعية المتداخلة: يمكن للتحفيظ تجنب الحسابات المتكررة عن طريق تخزين نتائج المشكلات الفرعية وإعادة استخدامها عند الحاجة.
• الدوال ذات المدخلات المتطابقة المتكررة: يضمن التحفيظ أن الدالة تُنفذ مرة واحدة فقط لكل مجموعة فريدة من المدخلات.

ومع ذلك، من المهم مراعاة المقايضات التالية عند استخدام التحفيظ:

• استهلاك الذاكرة: يزيد التحفيظ من استخدام الذاكرة لأنه يخزن نتائج استدعاءات الدوال. يمكن أن يكون هذا مصدر قلق للدوال التي لديها عدد كبير من المدخلات المحتملة أو للتطبيقات ذات موارد الذاكرة المحدودة.
• إبطال صلاحية ذاكرة التخزين المؤقت: إذا تغيرت البيانات الأساسية، فقد تصبح النتائج المخزنة قديمة. من الضروري تنفيذ استراتيجية لإبطال صلاحية ذاكرة التخزين المؤقت لضمان بقاء ذاكرة التخزين المؤقت متسقة مع البيانات.
• التعقيد: يمكن أن يضيف تنفيذ التحفيظ تعقيدًا إلى الكود، خاصة لاستراتيجيات التخزين المؤقت المعقدة. من المهم التفكير بعناية في تعقيد الكود وقابليته للصيانة قبل استخدام التحفيظ.

أمثلة عملية وحالات استخدام

يمكن تطبيق التحفيظ في مجموعة واسعة من السيناريوهات لتحسين الأداء. إليك بعض الأمثلة العملية:

• تطوير واجهات الويب الأمامية: يمكن لتحفيظ الحسابات المكلفة في جافاسكريبت تحسين استجابة تطبيقات الويب. على سبيل المثال، يمكنك تحفيظ الدوال التي تقوم بمعالجة DOM معقدة أو التي تحسب خصائص التخطيط.
• تطبيقات الخادم: يمكن استخدام التحفيظ لتخزين نتائج استعلامات قاعدة البيانات أو استدعاءات API، مما يقلل من الحمل على الخادم ويحسن أوقات الاستجابة.
• تحليل البيانات: يمكن للتحفيظ تسريع مهام تحليل البيانات عن طريق تخزين نتائج الحسابات الوسيطة. على سبيل المثال، يمكنك تحفيظ الدوال التي تقوم بالتحليل الإحصائي أو خوارزميات تعلم الآلة.
• تطوير الألعاب: يمكن استخدام التحفيظ لتحسين أداء الألعاب عن طريق تخزين نتائج الحسابات المستخدمة بشكل متكرر، مثل اكتشاف الاصطدام أو تحديد المسار.

الخاتمة

التحفيظ هو أسلوب تحسين قوي يمكن أن يحسن أداء تطبيقات جافاسكريبت بشكل كبير. من خلال تخزين نتائج استدعاءات الدوال المكلفة، يمكنك تجنب الحسابات المتكررة وتقليل وقت التنفيذ. ومع ذلك، من المهم التفكير بعناية في المقايضات بين مكاسب الأداء واستهلاك الذاكرة، وإبطال صلاحية ذاكرة التخزين المؤقت، وتعقيد الكود. من خلال فهم أنماط التحفيظ المختلفة واستراتيجيات التخزين المؤقت، يمكنك تطبيق التحفيظ بفعالية لتحسين كود جافاسكريبت الخاص بك وبناء تطبيقات عالية الأداء.