Introduction à l'utilisation de la mémoisation en JavaScript (code)

Cet article vous apporte une introduction à l'utilisation de la mémorisation en JavaScript (code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

La mémorandum vient du latin memorandum (« se souvenir »), à ne pas confondre avec la mémorisation.

Tout d'abord, jetons un coup d'œil à la description de Wikipédia :

En informatique, la mémoïsation ou mémoïsation est une technique d'optimisation utilisée principalement pour accélérer les programmes informatiques en stockant les résultats d'appels de fonctions coûteux et en renvoyant les résultats mis en cache. résultat lorsque les mêmes entrées se reproduisent.

En termes simples, la mémorisation est une technique d'optimisation principalement utilisée pour accélérer les programmes informatiques en stockant les résultats d'appels de fonctions coûteux et en renvoyant les résultats mis en cache lorsque les mêmes entrées se reproduisent.

Cet article présente d'abord un exemple simple d'utilisation de la technologie d'optimisation de la mémorisation, puis interprète le code source de l'utilisation de la mémorisation dans les bibliothèques de soulignement et de resélection pour approfondir la compréhension.

Factorial

Sans mémoïsation

Sans arrière-pensée, on écrirait immédiatement le code suivant :

const factorial = n => {
    if (n === 1) {
        return 1
    } else {
        return factorial(n - 1) * n
    }
};

Utiliser la mémoïsation

const cache = []
const factorial = n => {
    if (n === 1) {
        return 1
    } else if (cache[n - 1]) {
        return cache[n - 1]
    } else {
        let result = factorial(n - 1) * n
        cache[n - 1] = result
        return result
    }
};

Utiliser les fermetures et la mémoïsation

Une méthode courante consiste à utiliser les fermetures et la mémoïsation ensemble :

const factorialMemo = () => {
    const cache = []
    const factorial = n => {
        if (n === 1) {
            return 1
        } else if (cache[n - 1]) {
            console.log(`get factorial(${n}) from cache...`)
            return cache[n - 1]
        } else {
            let result = factorial(n - 1) * n
            cache[n - 1] = result
            return result
        }
    }
    return factorial
};
const factorial = factorialMemo();

Continuez à transformer, la méthode d'écriture suivante est la forme la plus courante.

const factorialMemo = func => {
    const cache = []
    return function(n) {
        if (cache[n - 1]) {
            console.log(`get factorial(${n}) from cache...`)
            return cache[n - 1]
        } else {
            const result = func.apply(null, arguments)
            cache[n - 1] = result
            return result
        }
    }
}

const factorial = factorialMemo(function(n) {
    return n === 1 ? 1 : factorial(n - 1) * n
});

À partir de cet exemple de factorielle, nous pouvons savoir que la mémorisation est une méthode espace-temps qui stocke les résultats de l'exécution la prochaine fois que la même entrée se produira, les résultats seront directement sortis. , ce qui améliore la vitesse d'exécution.

souligner la mémorisation dans le code source

// Memoize an expensive function by storing its results.
_.memoize = function(func, hasher) {
    var memoize = function(key) {
        var cache = memoize.cache;
        var address = '' + (hasher ? hasher.apply(this, arguments) : key);
        if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
        return cache[address];
    };
    memoize.cache = {};
    return memoize;
};

Le code est clair en un coup d'œil Utilisez _.memoize pour implémenter factorielle comme suit :

const factorial = _.memoize(function(n) {
    return n === 1 ? 1 : factorial(n - 1) * n
});

Référez-vous à ce code source, la factorielle ci-dessus peut continuer à être transformée comme suit :

const factorialMemo = func => {
    const memoize = function(n) {
        const cache = memoize.cache
        if (cache[n - 1]) {
            console.log(`get factorial(${n}) from cache...`)
            return cache[n - 1]
        } else {
            const result = func.apply(null, arguments)
            cache[n - 1] = result
            return result
        }
    }
    memoize.cache = []
    return memoize
}

const factorial = factorialMemo(function(n) {
    return n === 1 ? 1 : factorial(n - 1) * n
});

resélectionnez la mémorisation dans le code source

export function defaultMemoize(func, equalityCheck = defaultEqualityCheck) {
    let lastArgs = null
    let lastResult = null
    // we reference arguments instead of spreading them for performance reasons
    return function () {
        if (!areArgumentsShallowlyEqual(equalityCheck, lastArgs, arguments)) {
            // apply arguments instead of spreading for performance.
            lastResult = func.apply(null, arguments)
        }

        lastArgs = arguments
        return lastResult
    }
};

À partir du code source, nous pouvons savoir que lorsque lastArgs est identique aux arguments, func ne sera plus exécuté.

Résumé

La mémorisation est une technologie d'optimisation qui évite les calculs répétés inutiles et peut améliorer la vitesse de calcul.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!