Pour implémenter une fonction PHP avec la fonction de cache, la clé consiste à utiliser les fermetures pour enregistrer l'entrée et la sortie; Les étapes spécifiques sont les suivantes: 1. Définissez la fonction Memoize et encapsulez la fonction objectif et le tableau de cache avec les fermetures; 2. Utilisez la sérialisation pour générer des clés uniques des paramètres; 3. Vérifiez si le cache existe. S'il n'existe pas, exécutez la fonction et stockez le résultat; 4. Renvoie la valeur du cache. Les notes incluent la gestion des paramètres non sérialisés, le contr?le de l'utilisation de la mémoire et de la liaison de la portée; Les méthodes d'optimisation incluent l'utilisation de systèmes de cache externes tels que la fa?ade de cache de Laravel pour atteindre un stockage persistant.

Il n'est pas difficile d'écrire une fonction PHP avec une fonction de cache (c'est-à-dire la fonction de mémorisation communément appelée). La clé consiste à comprendre sa logique principale: enregistrer l'entrée et la sortie de la fonction et de renvoyer le résultat directement la prochaine fois que vous rencontrerez la même entrée. Jetons un ?il à la fa?on de l'implémenter étape par étape.

Qu'est-ce que la mémorisation?

En termes simples, la mémorisation est une méthode d'optimisation utilisée pour éviter les calculs répétés . Par exemple, vous avez une fonction qui prend du temps, comme le calcul d'une séquence Fibonacci ou l'analyse d'une cha?ne complexe. Tant que les paramètres sont les mêmes, les résultats seront certainement les mêmes. à l'heure actuelle, vous pouvez utiliser la mémorisation pour "rappeler" les résultats précédents.

Ce n'est pas un cache qui met en cache toute la page ou la requête de base de données, mais un petit cache granulaire pour un certain appel de fonction.

Comment faire un emballage de mémorisation de base en PHP?

PHP n'a pas de support de mémoires intégré, mais vous pouvez envelopper la fonction objectif par le biais de fermetures ou de classes. Ici, nous prenons la fermeture comme exemple:

 Fonction Memoize ($ func) {
    $ cache = [];

    Fonction de retour (... $ args) Utiliser ($ func, & $ cache) {
        $ key = serialize ($ args);

        if (! isset ($ cache [$ key])) {
            $ cache [$ key] = $ func (... $ args);
        }

        retourner $ cache [$ key];
    };
}

Ensuite, vous pouvez l'utiliser comme ceci:

 $ fibonacci = fonction ($ n) use (& $ fibonacci) {
    if ($ n <2) renvoyer $ n;
    retour $ fibonacci ($ n - 1) $ fibonacci ($ n - 2);
};

$ memozedfib = memoize ($ fibonacci);

echo $ memoozedfib (10); // c&#39;est beaucoup plus rapide

Note:

• Utiliser serialize() pour générer des paramètres uniques est une pratique courante, mais si les paramètres contiennent des objets, vous devez y faire face vous-même.
• Si vous vous inquiétez des conflits clés, vous pouvez également utiliser MD5 (sérialiser ($ args)) pour créer une clé de cha?ne.
• N'oubliez pas de transmettre $func et de référence $cache dans la fermeture.

Problèmes possibles et suggestions d'optimisation

Il peut y avoir plusieurs petits pièges dans une utilisation réelle:

• Limitation du type de paramètre : S'il existe des types tels que des ressources, des objets, etc. Dans les paramètres qui ne peuvent pas être sérialisés, une erreur se produira. La solution consiste à personnaliser la stratégie de génération de clés, comme ne prendre que certains champs ou hachages.
• Problèmes d'utilisation de la mémoire : le cache augmente en continu peut affecter les performances. Vous pouvez ajouter une limite de cache maximale et effacer la première partie une fois qu'elle le dépasse.
• Pollution de la portée : si vous utilisez des fonctions récursives (comme le Fibonacci ci-dessus), faites attention si la liaison de la portée de la fermeture est correcte.

Les méthodes d'optimisation courantes comprennent:

• Utilisez des tableaux de référence faibles (tels que FaibleMap) pour gérer le cache des paramètres de l'objet (PHP 8.0)
• Définition du mécanisme TTL (temps d'expiration)
• Insérer des caches dans un stockage externe, comme APCU ou Redis, adapté aux scénarios de partage multi-processus

Utilisez des fa?ons plus flexibles dans les cadres

Si vous vous développez dans un cadre comme Laravel ou Symfony, vous pouvez directement utiliser leurs systèmes de cache pour faire quelque chose de similaire. Par exemple, à Laravel, vous pouvez combiner la fa?ade de cache pour le faire:

 Utiliser illuminate \ support \ faades \ cache;

Fonction MemoisedCall ($ key, $ callback) {
    return Cache :: Remember ($ key, maintenant () -> addHour (), $ callback);
}

// utilise $ result = memozedcall ("fib_10", function () {
    retour fibonacci (10);
});

Cela implémente non seulement la mémorisation, mais utilise également automatiquement Redis ou d'autres pilotes pour le cache persistant.

Fondamentalement, c'est tout. La rédaction d'une fonction de mémorisation simple n'est pas trop difficile, mais pour le faire fonctionner de manière stable dans de vrais projets, vous devez prêter attention à des détails tels que le traitement des paramètres, le nettoyage du cache et le partage de la demande croisée. Mais une fois que vous l'avez ma?trisé, c'est un outil d'optimisation des performances très pratique.

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!