php, simuler inclure? Système de cache

Question

J'essaie de créer un petit système de gabarit et d'avoir une fonction qui boucle sur un tableau d'éléments. Actuellement j'utilise les fonctions de mise en mémoire tampon de sortie et je peux donc charger le fichier de gabarit alors qu'il a une portée pour la classe.

function loadTemplate($name, $vars) { 
    $buf = ''; 
    $path = $name . '.html'; 
    if (file_exists($path)) { 
     $this->vars = $vars; 
     ob_start(); 
     include($path); 
     $buf = ob_get_clean(); 
    } 
    return $buf; 
} 

Je me demandais si je pouvais stocker le modèle initial dans un tableau alors fonctionner (comme si elle était incluse) tout en gardant la portée, comme.

function loadTemplate($name, $vars) { 
    $buf = $template = ''; 
    if (isset($this->cache[$name])) 
     $template = $this->cache[$name]; 
    else { 
     $path = $name . '.html'; 
     $template = file_get_contents($path); 
     $this->cache[$name] = $template; 
    } 
    //Exec template here with scope. 
} 

Ou suis-je juste être pédant et essayer de micro optimize :)

Answer 1

va se pencher sur CakePHP selon le commentaire de NullUserException :)

Answer 2

Je ne pense pas que cela fasse une grande différence si vous incluez un modèle encore une fois, comme vous l'avez dit ... il serait micro-optimisation. Mais, ce que vous pouvez faire est de sauvegarder la source des modèles déjà inclus dans un tableau et d'utiliser le nom du modèle comme clé pour le tableau. Lorsque vous exécutez votre fonction loadTemplate, vous pouvez simplement faire un array_key_exists pour voir s'il est déjà inclus. Mais si je peux, je recommanderais le smarty template engine. Je l'ai utilisé dans mes projets et je le trouve simplement parfait. Je l'ai un peu adapté pour être plus fluide avec mon code, mais maintenant c'est vraiment parfait pour moi.

Answer 3

Continuez à l'inclure. La seule alternative serait de lire le contenu puis de les évaluer, et ça va être pire. Le surcoût de la seconde inclusion devrait être significativement moindre puisque la page est déjà analysée dans l'opcode ...

Answer 4

Si j'étais vous et que vous aviez des opérations complexes dans les fichiers modèles, je les sauvegarderais dans le système de fichiers. J'ai modifié votre fonction, je pense que vous comprendrez ce qui s'y passe:

<?php 

function template($name, $vars = array()) 
{ 
    $cache = 'cache/'; // Path to cache folder, must be writeable 
    $expire = 3600 * 3; // Cache lifetime, 3 hours 
    $path = $name . '.html'; 
    $cache_file = $cache . sha1($path) . '.txt'; // Generate cache file path and hash-name 

    // If cache file exists and it hasn't expired yet we must get cached data 
    if (file_exists($cache_file) && filemtime($cache_file) > (time() - $expire)) 
    { 
     return unserialize(file_get_contents($cache_file)); 
    } 

    // Return NULL if template file doesn't exist 
    if (!file_exists($path)) 
    { 
     return null; 
    } 

    $this->vars = $vars; 

    ob_start(); 
    include_once $path; 
    $output = ob_get_clean(); 

    // Save output to the cache file 
    file_put_contents($cache_file, serialize($output)); 

    return $output; 
} 

?> 

P.S. N'a pas testé la fonction.

Answer 5

C'est le cache le plus inutile que vous pouvez implémenter. Vous feriez mieux de penser à l'implémentation get conditionnelle HTTP qui n'aura pas besoin d'appeler temlpate du tout. Et puis allez pour cache d'opcode qui mettra en cache vos inclusions automatiquement.

Mais sapins que vous avez à profiler votre application/templater pour voir si vous avez besoin de cache du tout