რა არის memoization და როგორ ახორციელებთ მას?

Question

Accepted Answer

**Memoization** აკეშინებს ფუნქციის შედეგებს მისი არგუმენტებით გასაღებული, ამიტომ განმეორებული ზარები ერთი და იგივე შეყვანილობით დაბრუნებენ დაკეშინებულ შედეგს დაუყოვნებლივ ხელახალი გამოთვლის ნაცვლად. ის ვაჭრობას **მეხსიერება სიჩქარის გამოცხადებაზე** და მხოლოდ **чисти** ფუნქციებისთვის მუშაობს (ერთი შეყვანილობა → ერთი შედეგი, გვერდითი ეფექტების გარეშე).

## განზოგადებული memoize wrapper

```js
function memoize(fn) {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args); // build a cache key from the arguments
    if (cache.has(key)) {
      return cache.get(key);          // cache hit — skip the work
    }
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

const slowSquare = n => { /* expensive */ return n * n; };
const fastSquare = memoize(slowSquare);
fastSquare(4); // computes → 16
fastSquare(4); // cached → 16 instantly
```

## კლასიკური მოგება: რეკურსიული Fibonacci

```js
const fib = memoize(n => (n < 2 ? n : fib(n - 1) + fib(n - 2)));
// turns exponential O(2^n) into roughly O(n) by caching subproblems
```

## კომპრომისები და გაფრთხოვებები

- **Cache გასაღების სტრატეგია**: `JSON.stringify` ვერ ხერხდება ფუნქციებისთვის, და გასაღების თანმიმდევრობა მნიშვნელოვანია ობიექტებისთვის. ობიექტის არგუმენტებისთვის, `WeakMap` (წარმოდგენილი მითითებით) თავიდან აიცილებს მეხსიერების გაჟონვას.
- **შეუზღუდავი ზრდა**: cache არასოდეს მცირდება — გამოიყენეთ **LRU** cache ხანგრძლივი პროცესებისთვის.
- მხოლოდ memoize, როდესაც ხელახალი გამოთვლა ნამდვილად ძვირი და შეყვანილობა ხშირად ბრუნდება.

## რატომ არის მნიშვნელოვანი

Memoization ყველგან გვხვდება: React-ის `useMemo`/`React.memo`, Reselect selectors, დინამიური პროგრამირება.

კონცეფცია (cache pure შედეგები შეყვანილობის მიხედვით) ერთი და იგივეა; ხელოვნება გასაღების არჩევა და cache-ის შეზღუდვაა.