Dans le développement quotidien de PHP, Parse_url est une fonction très courante qui analyse l'URL et renvoie leurs composants. Bien que cette fonction elle-même soit rapide, dans certains scénarios d'appel à haute fréquence, comme lorsque le traitement par lots de grandes quantités d'URL, la répétition fréquente de la même URL entraînera des frais généraux de performances inutiles.
Pour éviter ce calcul en double, nous pouvons stocker les résultats de parse_url via un mécanisme de cache. Cet article introduira en détail comment mettre en cache les résultats de Parse_url de manière simple et efficace pour améliorer les performances des applications PHP.
Bien que PARSE_URL soit une fonction PHP intégrée et possède une efficacité d'exécution élevée, il effectuera toujours l'analyse de chaîne, la correspondance régulière et d'autres opérations. Si un système traite à plusieurs reprises la même URL à plusieurs endroits, appeler PARSE_URL à chaque fois est en fait un déchet. Par des résultats d'analyse en cache, vous pouvez:
Évitez l'analyse répétée;
Réduire les frais généraux du processeur;
Améliorez les performances globales, en particulier dans les environnements cycliques ou à haut niveau.
Ci-dessous, nous fournissons une encapsulation de fonction simple pour le traitement de cache au niveau de la mémoire des résultats de parse_url :
function cached_parse_url(string $url): array|false {
static $cache = [];
// Utilisez le hachage comme clé de cache,éviter URL Trop longue provoque des clés de tableau incohérentes
$key = md5($url);
if (isset($cache[$key])) {
return $cache[$key];
}
$parsed = parse_url($url);
if ($parsed !== false) {
$cache[$key] = $parsed;
}
return $parsed;
}
Le noyau de cette fonction est un cache $ variable statique, qui est partagé globalement dans le cadre de la fonction, donc même si la fonction est appelée plusieurs fois, le cache sera touché tant qu'il est de la même URL.
$urls = [
'https://gitbox.net/path?query=1',
'https://gitbox.net/path?query=1',
'https://gitbox.net/otherpath?query=2',
];
foreach ($urls as $url) {
$parts = cached_parse_url($url);
print_r($parts);
}
Dans l'exemple ci-dessus, bien qu'il y ait trois URL, l'une d'elles est en double, Cached_Parse_Url ne va qu'une seule fois, et la deuxième fois renverra directement le résultat mis en cache.
Pour les exigences de cache plus importantes ou croisées, APCU peut être utilisée:
function cached_parse_url_apcu(string $url): array|false {
$key = 'parsed_url_' . md5($url);
$cached = apcu_fetch($key);
if ($cached !== false) {
return $cached;
}
$parsed = parse_url($url);
if ($parsed !== false) {
apcu_store($key, $parsed);
}
return $parsed;
}
L'utilisation d'APCU permet aux caches de voyager dans plusieurs cycles de vie de demande, adaptés à l'optimisation des performances des applications Web ou des scripts CLI.
PARSE_URL reviendra False lorsque l'analyse des URL non valides sera analysée. Il est recommandé de juger les résultats avant de les mettre en cache.
Le mécanisme de mise en cache lui-même occupera également des ressources de mémoire, et il n'est pas recommandé de mettre en cache des URL uniques.
Dans des environnements multi-thread ou hautement simultanés, la sécurité des threads doit être assurée si l'APCU est utilisée.
Bien que Parse_Url soit une fonction triviale, sa consommation de performances ne peut pas être ignorée lorsqu'elle est appelée à haute fréquence. En introduisant un simple mécanisme de mise en cache, nous pouvons réduire considérablement les frais généraux des ressources du système tout en garantissant une précision d'analyse. La puissance du cache peut également montrer une grande valeur en détail. Pour les projets PHP avec des exigences d'optimisation des performances, cette optimisation est très digne de pratique.