Bonjour à toutes et tous,

J'ai créé un système de cache simple, en POO, je penses qu'il peut servir...

<?php
/*
#################################################
#########Système de gestion du cache#############
#########Par Katagoto############################
###########Class : Kache#########################
#########Commencé le 04/07/2008##################
##########Finit le 05/07/2008####################
#################################################
*/

class Kache implements Iterator {

	// Variables

	private $chemin_cache="cache/"; // Chemin du répertoire des fichier caches

	private $extention=".kache"; // Extention des fichier caches

	private $nom; // nom du fichier cache

	public $cache; // Contenu du cache

	// Variables pour les fonctions itératrices
	private $clef=array();// Les clefs

	private $valeur=array();// Les valeurs

	private $index=0; // L'index


	// Fonctions

	public function __construct($nom=NULL, $chemin_cache="cache/", $extention=".kache") {
		if (!empty($nom)) {
			$this->nom=$nom;
		}
		else {
			// Pour simplifier la tâche, le cache aura le nom qui suit la dernière / dans l'url
			preg_match("#\/([a-zA-Z0-9_\-\.]+)$#", $_SERVER['REQUEST_URI'], $matches);
			$this->nom=$matches[1];
		}

		// J'ai tenté de ne faire marché les REGEX qu'une cas d'ewtrême necessité
		if (!empty($chemin_cache) && $chemin_cache!=$this->chemin_cache) {
			if (is_dir($chemin_cache) && preg_match("#\/$#", $chemin_cache)) {
				$this->chemin_cache=$chemin_cache;
			}
			else {
				die("Le chemin du cache (<b>".$chemin_cache."</b>) n'éxiste pas...");
			}
		}

		if (!empty($extention) && $extention!=$this->extention) {
			if (preg_match("#^\.#", $extention)) {
				$this->extention=$extention;
			}
			else {
				die("L'extention des fichier cache définie (<b>".$extention."</b>) est incorrecte, vous avez dût oublié un point au début");
			}
		}

	}

	// Génère/Ecrit le cache
	public function genere($contenu=NULL, $existe=true)
	{
		$existe=(bool) $existe;

		if (!$existe) {
			if(!empty($contenu)){
				$this->cache=$contenu;
			}
			else {
				die("Veuillez stipuler un contenu");
			}
		}
		else {
			if(!empty($contenu)){
				$this->cache=$contenu;
			}
			else {
				die("Veuillez stipuler un contenu");
			}
		}

		$this->test_tableau();

		// utilisation de serialize() pour transformer $this->cache en chaine de caractères
		$contenu_serialize = serialize($this->cache);

		// échappement les caractères spéciaux pour pouvoir mettre le tout entre quotes dans le futur fichier
		$contenu_serialize = str_replace(array('', "'", "0", '"'), array('\\', '\'', '0', '\"'), $contenu_serialize);

		// création du code php à stocker dans le fichier
		$contenu_serialize = "<?php" . "\n" . "\$cache = unserialize('" .  $contenu_serialize . "');" . "\n" . '?>';

		// écriture du code dans le fichier
		$fichier = fopen($this->chemin_cache.$this->nom.$this->extention, 'w');
		$resultat = fwrite($fichier, $contenu_serialize);
		fclose($fichier);

		// renvoie true si l'écriture du fichier a réussi
		return $resultat;
	}

	// Récupère/charge et retourne le cache contenu dans le fichier...
	public function charge()
	{
		if(!@include($this->chemin_cache.$this->nom.$this->extention)){
			return false;
		}
		else {
			$this->cache=$cache;
			$this->test_tableau();
			return $this->cache;
		}
	}

	// Detruit le cache || $vide : [True] -> Le tableau est vidé, ainsi que $this->cache, et l'index et remit à 0 - [False] -> Seul le fichier est détruit (une sécurité)
	public function detruit($vide=false){
		$vide=(bool)$vide;
		if ($vide) {
			$this->cache=NULL;
			$this->index=0;
			unset($this->clef);
			unset($this->valeur);

		}
		return @unlink($this->chemin_cache.$this->nom.$this->extention);
	}

	// Fonction qui détecte si $this->cache est un tableau, affin de le référencer si s'en est un
	private function test_tableau(){
		if(is_array($this->cache)){
			foreach ($this->cache as $clef => $valeur) {
				$this->clef[]=$clef;
				$this->valeur[]=$valeur;
			}
			return true;
		}
		return false;
	}

	// Les fonctions Itératrices (pour les boucles)
	public function current(){
		if ($this->valid()) return $this->valeur[$this->index]; else return null;
	}
	public function next(){
		$this->index++;
		if ($this->valid()) return true; else return false;
	}
	public function valid(){
		return ($this->index >= 0 && $this->index < count($this->clef));
	}
	public function previous(){
		$this->index--;
		if ($this->valid()) return true; else return false;
	}
	public function key(){
		if ($this->valid()) return $this->clef[$this->index];
	}
	public function rewind(){
		$this->index=0;
	}

}

?>

Voilà, il tient sur 169 en tout, il est très simple, pratique pour les système de template, ou la génération de fichier XML, dans le cas d'un système XML/XSLT...

C'est un système de cache de contenu.

Quelques exemples d'utilisations :

<?php
include("Kache.php");
$cache=new Kache("test");
if (!$cache->charge()) {
	// On pourrait remplacer cette ligne par un while qui liste les news ou qui cré un fichier XML, dans le casd'un système XML/XSLT
	$chaine="<html><head><title>Test du système Kache<title></head><body><p>le teste 1 un marche</p>";
	$cache->genere($chaine);
}

echo $cache->cache;

$tableau=array("ligne 1", "ligne 2", "ligne 3", "ligne 4", "ligne 5");
$cache->genere($tableau, false);

echo "<p><p><p>Test 2 :</p>";
foreach ($cache as $valeur) {
	echo "<p>".$valeur."</p>";
}
$cache->detruit(true);
$tableau2=array("clef 1" => "ligne 1", "clef 2" => "ligne 2", "clef 3" => "ligne 3", "clef 4" => "ligne 4", "clef 5" => "ligne 5");
$cache->genere($tableau, false);
echo "<p><p><p>Test 3 :</p>";
foreach ($cache as $clef => $valeur) {
	echo "<p><b>[".$clef."]</b> - ".$valeur."</p>";
}
?>

Voilà, il est très simple, si vous avez des suggestions, des remarques, des idées d'amélioration, ou si vous rencontrez des bugs, n'ésitez pas...

Je garde le meilleur pour la fin : un grand merci à Sékiltoyai et à sadeq pour leurs participations