𝗹𝗼𝗱𝗮𝘀𝗵.𝗺𝗲𝗺𝗼𝗶𝘇𝗲-ஐக் குறித்து எச்சரிக்கையாக இருங்கள்

Lodash memoize இலவசமான செயல்திறன் (performance) போலத் தோன்றுகிறது. நீங்கள் ஒரு function-ஐ wrap செய்வதன் மூலம் ஒரு cache-ஐப் பெறலாம்.

ஆனால் அதன் இயல்பான செயல்பாட்டில் (default behavior) ஒரு சிக்கல் உள்ளது. இது முதல் argument-ஐக் கொண்டு மட்டுமே cache key-ஐ உருவாக்குகிறது. மற்ற அனைத்து argument-களையும் இது புறக்கணித்துவிடுகிறது.

நீங்கள் ஒரு argument-ஐ மட்டும் பயன்படுத்தினால், நீங்கள் பாதுகாப்பாக இருக்கிறீர்கள். ஆனால் இரண்டு அல்லது அதற்கு மேற்பட்டவற்றை பயன்படுத்தினால், பிழைகள் (bugs) உருவாகும்.

இந்த உதாரணத்தைப் பாருங்கள்:

const add = memoize((a, b) => a + b);

add(1, 2); // 3-ஐத் திருப்பித் தருகிறது. இது 1 என்ற key-ன் கீழ் முடிவை cache செய்கிறது.
add(1, 9); // 3-ஐத் திருப்பித் தருகிறது. இது தவறு. இது 10 ஆக இருக்க வேண்டும்.

Lodash மீண்டும் 1-ஐப் பார்க்கிறது. cache-ல் 1 இருப்பதை அது கண்டறிகிறது. எனவே பழைய முடிவையே திருப்பித் தருகிறது. அது 9-ஐப் பார்ப்பதே இல்லை.

Currency formatting என்பது ஒரு பொதுவான சிக்கல்.

const formatPrice = memoize((amount, currency) =>
  new Intl.NumberFormat('en', { style: 'currency', currency }).format(amount)
);

formatPrice(100, 'USD'); // "$100.00"-ஐத் திருப்பித் தருகிறது. Key என்பது 100.
formatPrice(100, 'EUR'); // "$100.00"-ஐத் திருப்பித் தருகிறது. இது தவறு.

இரண்டாவது அழைப்பு (call) 'EUR'-ஐப் புறக்கணித்துவிடுகிறது. cache-ல் 100 இருப்பதை அது பார்த்து, யூரோக்களுக்குப் பதிலாக டாலர்களைத் திருப்பித் தருகிறது. இதில் எந்தத் தவறும் (error) காட்டப்படுவதில்லை, எந்த எச்சரிக்கையும் (warning) வருவதில்லை. நீங்கள் உங்கள் பயனர்களுக்குத் தவறான பண மதிப்பைக் காட்டுகிறீர்கள்.

cache key-ஐ வரையறுக்க நீங்கள் இரண்டாவது argument-ஐ வழங்க வேண்டும். இந்த key அனைத்து input-களையும் உள்ளடக்கியிருக்க வேண்டும்.

const formatPrice = memoize(
  (amount, currency) =>
    new Intl.NumberFormat('en', { style: 'currency', currency }).format(amount),
  (amount, currency) => `${amount}|${currency}`
);

formatPrice(100, 'USD'); // "$100.00"
formatPrice(100, 'EUR'); // "€100.00"

வெளியீட்டை (output) மாற்றும் அனைத்து விஷயங்களையும் அந்த key பிடித்து வைத்திருக்க வேண்டும்.

ஒரு இறுதிச் சிந்தனை: memoization அபாயத்தை அதிகரிக்கிறது. ஒரு function அதிகச் செலவுமிக்கதாக (expensive) இருந்து, ஒரே மாதிரியான input-களுடன் அடிக்கடி இயங்கும்போது மட்டும் இதைப் பயன்படுத்தவும். எளிமையான functions-க்கு, அவற்றை நேரடியாக அழைப்பதே சிறந்தது. நீங்கள் பெறும் வேகத்தை விட, பிழை (bug) ஏற்படும் அபாயம் அதிகமாகவே இருக்கும்.

முக்கியக் குறிப்புகள்:

மூலம்: https://dev.to/figsify/beware-of-lodashmemoize-it-only-remembers-the-first-argument-4cjl