Un moteur de template (gére les sous-blocs à tous les niveaux)

Télécharger le projet
Commenter

Description

Voici un petit moteur de template. Je mets le code là, mais toutes les explications sont dans le zip ;)

Source / Exemple : 


<?php
class template
{
//definition des variables
var $template;
var $debug_mode;
var $fichier;
var $blocs;
var $chrono;
var $debut;
	
	/*constructeur : $mode permet de definir si les erreurs sont affichées,(pour $mode='debug'),
	$chrono permet à TRUE de renvoyer le temps d'execution de la page depuis  la definition de l'objet */
	function template($template, $mode=0, $chrono=FALSE)
	{
		//on vérifie que le fichier template existe
		if(is_file($template))
		{
			$this->template=file_get_contents($template);
			$this->fichier=$template;
		}
		else if($mode!='debug')
		{
			echo 'Template introuvable';		
		}
		else
		{
			echo 'Template - Erreur. L\'erreur retournée est  : 
			template <strong>'.$this->fichier.'</strong> introuvable';		
		}
		
		
		$this->debug_mode=$mode;
		$this->chrono=$chrono;
		
		//si $chrono est à TRUE, on enregistre le timestamp actuel
		if($chrono==TRUE)
		{
			
			$temps = microtime();
			$temps = explode(' ', $temps);
			$this->debut = $temps[1] + $temps[0];
		}	
	}
	
	/*Assignation d'une variable $variable est la variable qui sera utilisée sous la forme
	{variable} dans le fichier template, $valeur la valeur à laquelle elle correspond*/
	function variable($variable, $valeur)
	{
		//on vérifie que le fichier template contient bien la variable à traiter
		if(preg_match('!{'.$variable.'}!', $this->template))
		{
			//si oui, on la remplace par sa valeur
			$this->template=preg_replace('!{'.$variable.'}!', $valeur, $this->template);
		}
		else if ($this->debug_mode=='debug')
		{
			echo '<br/>Template - Erreur. L\'erreur retournée est  : 
			<strong>{'.$variable.'}</strong> est introuvable dans le fichier template 
			<strong>'.$this->fichier.'</strong>';
		}
	}
	
	/*Pour les blocs, cela devient plsu compliqué. $bloc est le nom du bloc tel qu'il sera utilisé sous la forme
		<!--BLOC-->
			{VARIABLE1}
			{VARIABLE2}
			...
			<!--SOUS-BLOC-->
				...
			<!--/SOUS-BLOC-->
		<!--/BLOC-->
	$array est un tableau contenant toutes les variables du bloc. La clef de $array correspond au nom de la variable
	et la valeur de $array correspond à la valeur de la variable	


    	
  • /

	function bloc($bloc, $array)
	{
		//On vérifie que le bloc existe dans le fichier template
		if(preg_match('<!--'.$bloc.'-->', $this->template) and preg_match('<!--/'.$bloc.'-->', $this->template))
		{
			//on définit $contenu_bloc comme le contenu du bloc
			ereg('<!--'.$bloc.'-->(.*)<!--/'.$bloc.'-->', $this->template, $contenu_bloc_tableau);
			$contenu_bloc=$contenu_bloc_tableau[0];
			
			
			$i=1;
			/*on traite toutes les clefs et les valeurs de $array pour les mettre dans 
			deux tableaux associatifs distincts*/
			while(list($key, $val) = each($array))
			{
				//on vérifie à chaque foi que la variable se trouve bien dans dans l'array
				if(preg_match('{'.$key.'}', $this->template))
				{
					$cle[$i]='{'.$key.'}';
					$valeur[$i]=$val;
					$i++;				
										
				}
				else if ($this->debug_mode=='debug')
				{
					echo '<br/>Template - Erreur. L\'erreur retournée est  :
					<strong>{'.$variable.'}</strong> est introuvable dans le fichier template 
					<strong>'.$this->fichier.'</strong> dans le bloc <strong>'.$bloc.'</strong>';
				}
				
			}
			
			//On remplace toutes les variables du bloc par leur contenu
			$bloc_final=str_replace($cle, $valeur, $contenu_bloc);
			
			if (isset($this->blocs[$bloc]))
			{
				//Si le bloc existe, on insère la partie qu'on vient de traiter
				$this->blocs[$bloc].=$bloc_final;
				
			}
			else
			{
				//Sinon, on en créé un nouveau
				$this->blocs[$bloc]=$bloc_final;
			}
						
		}
		else if ($this->debug_mode=='debug')
		{
			echo '<br/Template - Erreur. L\'erreur retournée est  : 
			le bloc <strong>'.$bloc.'</strong> est introuvable dans le fichier template 
			<strong>'.$this->fichier.'/</strong>';
		}
		
	
	}
	
	//Traitement final du template, sous_blocs permet à TRUE de trater les sous blocs
	function traitement($sous_blocs=FALSE)
	{
		//On met toutes les clefs de l'array blocs dans un tableau
		$fin_bloc=array_keys($this->blocs);
		
		$i=0;
		//La boucle est éxécutée tant qu'il reste des clees à trater dans l'array
		while(array_key_exists($i, $fin_bloc))
		{	
			$j=$i-1;
			//Si $sous_blocs est à true et qu'il existe un sous-bloc, on le traite
			if($j>-1 and $sous_blocs=TRUE)
			{
				$this->blocs[$fin_bloc[$i]]=
				preg_replace('!<\!--'.$fin_bloc[$j].'-->(.+)<\!--/'.$fin_bloc[$j].'-->!isU', 
								$this->blocs[$fin_bloc[$j]], $this->blocs[$fin_bloc[$i]]);
			}
			//On traite le bloc lui-même
			$this->template=
			preg_replace('!<\!--'.$fin_bloc[$i].'-->(.+)<\!--/'.$fin_bloc[$i].'-->!isU', 
							$this->blocs[$fin_bloc[$i]], $this->template); 
			$i++;
		}
		
		//On renvoi le template traité.
		return $this->template;
	
	}
	
	
	function temps_execution()
	{
		if($this->chrono==TRUE)
		{
			$temps = microtime();
			$temps = explode(' ', $temps);
			$fin = $temps[1] + $temps[0];
			$vitesse=round(($fin - $this->debut),6);
		
			return $vitesse;
		}
		else
		{
			return 'Template - Erreur. L\'erreur retournée est : la fonction temps_execution() a été
			utilisée alors que le paramètre chrono est égal à false';
		}
	
	}
	
}
?>

Conclusion :


Voilà. J'ai fais un petit manuel, qui est dans le zip, pour que tous puissent utiliser ce système de template.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (The_Template)