Performance optimization of memory function

Find the factorial

Generally, the method of finding factorial

function factorial(n) {
    
    if (n == 0 || n == 1) return 1;
    return n * factorial(n - 1)
}
console.time("factorial");
factorial(3000)
console.timeEnd("factorial");

You can see that the direct running time is about 0.3s about

adopt hash Table for caching

let cache = {
    };
function getCache(n) {
    
   if (cache[n]) return cache[n];
   if (n == 0 || n == 1) return (cache[n] = 1);
   return (cache[n] = n * getCache(n - 1));
}
   console.time("getCache-first");
   getCache(3000)
   console.timeEnd("getCache-first");


   console.time("getCache-second");
   getCache(2000)
   console.timeEnd("getCache-second");

You can find that the first time you call 0.9s The second call is 0.01s

Higher order memory function

Abstract the process into a function to make it universal

function memorize(fn) {
    
    let cache = {
    };
    return function () {
    
        let key = fn.name + '_' + [].join.call(arguments, ','); // Function names and parameters are spliced 
        // console.log(key, arguments);
        return (cache[key] = cache[key] || fn.apply(this, arguments));
    }
}

let memorizeFactory = memorize(factorial);

console.time("memorizeFactory-first");
memorizeFactory(3000)
console.timeEnd("memorizeFactory-first");


console.time("memorizeFactory-second");
memorizeFactory(3000)
console.timeEnd("memorizeFactory-second");

Implementing caching

import {
    api} form "./utils";
const cache  = {
    };
const request = async (url) => {
    
    if(cache[url]){
    
        return cache[url]
    }
    const response = await api(url);
    cache[url] = response;
    return response
}