Ich habe gerade dieses interessante kleine Konzept des Auswendiglernens entdeckt.

Ich habe angefangen, den Artikel darüber zu lesen, und habe aufgehört, sobald ich den Kern der Idee verstanden habe.

Dann habe ich beschlossen, die einfache Lösung selbst und so zu finden, wie ich sie verstehe.

Wenn Sie noch nie davon gehört haben: Beim Memoisieren werden die Ergebnisse der Funktionsausführung gespeichert, sodass Sie sie aus einem kleinen (oder nicht so großen) Cache abrufen können, wenn Sie die Funktion das nächste Mal mit denselben Argumenten ausführen.

In Wirklichkeit kann dies für eine Funktion mit hohem Ressourcenverbrauch nützlich sein. Die Nutzung von zusätzlichem Speicherplatz als Cache ist mit Kosten verbunden. Aber es kann die Geschwindigkeit Ihres Codes und die Erfahrung der Benutzer, die ihn verwenden, verbessern.

Ich habe ein bisschen mit JS-Code herumgespielt und bin auf diese Lösung gekommen:

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
    if(!cache[fnKey]) {
      cache[fnKey] = fn(...args);
    }

    return cache[fnKey]
  };
}

Dann können Sie es so ausführen:

function _add(x, y) {
  console.log("function runs", x, y);
  return x   y;
}

const add = memoize(_add)

add(42, 69)
add(10, 15)
add(10, 15)

Das führt dazu, dass die Funktion zweimal ausgeführt wird ('Add'-Aufrufe Nr. 1 und Nr. 2). Der dritte „Add“-Aufruf verwendet den Cache, da er mit dem zweiten Aufruf identisch ist.

'function runs' 42 69
'function runs' 10 15

Sie können sehen, dass „Funktion läuft“ 10 15 nur einmal aufgerufen wird. Dies liegt daran, dass beim zweiten Aufruf der Cache verwendet wird.

Lassen Sie uns nun kurz zusammenfassen, was hier vor sich geht.

In diesem Beispiel verwenden wir den Verschlussmechanismus, um den Cache zu speichern.

const memoize = fn => {
  const cache = {}
  return () => {

  };
}

Dies ermöglicht es uns, das „fn“-Argument, das der König der Partei ist, da dies genau die Funktion ist, mit der wir operieren möchten, durch die Gültigkeitsbereiche zu werfen und jede seiner Ausführung zu „lauschen“.

Ich habe es wirklich auf die einfachste, naivste Art geschrieben. Wir werden also den Funktionsnamen mit Argumenten als Schlüssel des Caches und die Ergebnisse seiner Ausführung als Werte verwenden.

Das bedeutet, dass Folgendes ausgeführt wird:

add(2, 2)

Ergebnisse in

// Our cache
{
  'add(2, 2)': 4
}

Cache-Wert.

Ich weiß, dass dies möglicherweise nicht genau die Art und Weise ist, wie es „richtig“ gemacht werden sollte. Bei der Idee dieser Übung und des Artikels geht es jedoch nicht um die gut getestete sichere und randfallfreie Lösung.

Es geht um das Lernen und die einfache Umsetzung. Über das Konzept. Daher konzentriere ich mich im Moment nicht auf Details der Implementierung.

Jetzt finden wir zunächst den Schlüssel für den Funktionsaufruf heraus:

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
  };
}

Wir werden es verwenden, um Ergebnisse der Funktionsausführung im Cache zu speichern.

Dann prüfen wir, ob dieser Schlüssel (fnKey) bereits existiert. Wenn nicht, setzen wir den Schlüssel mit seinem Wert als Ergebnis der übergebenen Funktionsausführung.

Am Ende geben wir immer das Ergebnis aus dem Cache zurück. Die Ausführung der an die Methode memoize übergebenen Funktion endet also eigentlich immer mit dem Abschluss (im „Cache“-Objekt).

Wir arbeiten jetzt nur noch mit diesem Objekt:

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
    if(!cache[fnKey]) {
      cache[fnKey] = fn(...args);
    }

    return cache[fnKey]
  };
}

Und das ist es.

Jetzt werde ich mal schauen, wie es „richtig“ gemacht werden sollte. Aber wenn Sie das interessant finden, lassen Sie es mich wissen. Wenn bei diesem Ansatz etwas unklar oder falsch ist (für Ihren Geschmack), hinterlassen Sie einfach den Kommentar und lassen Sie uns darüber reden.

Danke, wir sehen uns!