Templates, wel of niet in PHP?
Ik ben de laatste tijd (sinds ik begonnen ben met OOP) ook bezig met templates. Echter, op internet zijn de meningen verdeelt over wat het beste is, (native-)PHP of een templateparser zoals Smarty.
Aan de ene kant heeft Smarty zo zijn voordelen, omdat het gemaakt écht alleen gemaakt is voor templates, maar aan de andere kant is PHP gebruiken om files te parsen nou niet de snelste oplossing. Ik wou graag even deze twee links met jullie delen, en vooral jullie mening horen over het bovenstaande (en onderstaande).
Waarom je niet PHP moet gebruiken
Waarom je het wel moet gebruiken
Edit:
Oja, als je zelf nog links met info hebt, post ze dan a.u.b. even...
Oja, als je zelf nog links met info hebt, post ze dan a.u.b. even...
Gewijzigd op 20/08/2010 23:30:12 door SilverWolf NL
Op dit moment gebruik ik dan ook Smarty en hij is eigenlijk op sommige punten net niet goed, maar voor mij zelf iets te veel van het goede, omdat ik eigenlijk maar een aantal zaken ervan gebruik, en dat zijn meer de if else foreach statements om in de template mijn data weer te geven.
Uiteindelijk gebruik ik een template parser puur om php code en html van elkaar te scheiden zodat ik wat overzichtelijker kan werken. En tot nu toe zijn is mijn grootste routine in combinatie met templates verantwoordelijk voor een gebruik van 1mb geheugen verbruik en een laad tijd van 1/5ste seconde, en ik moet de code nog opschonen.
Maar ik ben er van overtuigd dat Smarty niet de betere is, het is een bekendere maar ik had er al een paar gezien onlangs waar ik zekers nog eens naar ga kijken.
Communicatie tussen de 'Model' en de 'View' zou beide kanten op moeten kunnen omdat er binnen website doorgaans te veel afhankelijkheden zijn waarop de 'View' moet kunnen inspelen. Dit betekend dat men dus (tot aan het extreme aan toe) moet kunnen script'en in de template.
Je kunt hiervoor een systeem als Smarty gebruiken; maar dergelijke systemen zijn al bijna een programmeertaal opzich; dus echt designer vriendelijk is het al lang niet meer. En waarom zou een programmeur die in PHP praat en droomt zichzelf een extra syntax aanleren die trager en beperkter is.
Mijn Conclusie:
- Designer vriendelijke template systemen zijn doorgaans véééél te beperkt.
- Geavanceerde template systemen zijn al snel te traag, en worden te complex voor designers; gebruik dan gewoon weer PHP.
Als er dan aanpassingen zijn, krijg je gewoon de aangepaste HTML met documentatie aangeleverd, en mag de ontwikkelaar dat weer aanpassen in de template.
In dat geval kun je net zo goed gewoon PHP blijven gebruiken.
Het argument dat je PHP van HTML wil scheiden gaat mijns inziens niet op, omdat je altijd een extra taal nodig hebt buiten HTML (als het niet PHP is, is het wel de parsing-taal). Als PHP dan begrijpelijker, sneler en handiger/uitgebreider is, dan gebruik ik dat natuurlijk.
Ik heb een opzet gemaakt van een simpele parser, die met native-php werkt:
Parser:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
<?PHP
class PHParser{
public $template_dir="./";
private $vars;
public function __construct(){
$this->vars=array();
}
public function assign($key,$value){
$this->vars[$key]=$value;
}
public function assign_array($array){
if(!is_array($array)){
throw new Exception("Data given to PHParser::assign_array() is not an array.");
}else{
foreach($array as $key=>$value){
$this->vars[$key]=$value;
}
}
}
public function get_assinged_vars(){
return $this->vars;
}
public function get_assigned_var($key){
if(!isset($this->vars[$key])){
return false;
}else{
return $this->vars[$key];
}
}
public function display($template){
$template=$this->template_dir.$template;
if(!file_exists($template)){
throw new Exception("Template {".$template."} does not exist!");
return false;
}else{
$container=new PHParser_container($this->vars);
$container->__display($template);
return true;
}
}
}
class PHParser_container{
private $vars;
public function __construct($array){
if((!is_array($array))||empty($array)){
$this->vars=array();
}else{
$this->vars=$array;
}
}
public function __set($var,$value){
$this->vars[$var]=$value;
}
public function __get($var){
return $this->vars[$var];
}
public function __display($template){
if(!file_exists($template)){
throw new Exception("Template {".$template."} does not exist!");
}else{
include($template);
}
}
}
?>
class PHParser{
public $template_dir="./";
private $vars;
public function __construct(){
$this->vars=array();
}
public function assign($key,$value){
$this->vars[$key]=$value;
}
public function assign_array($array){
if(!is_array($array)){
throw new Exception("Data given to PHParser::assign_array() is not an array.");
}else{
foreach($array as $key=>$value){
$this->vars[$key]=$value;
}
}
}
public function get_assinged_vars(){
return $this->vars;
}
public function get_assigned_var($key){
if(!isset($this->vars[$key])){
return false;
}else{
return $this->vars[$key];
}
}
public function display($template){
$template=$this->template_dir.$template;
if(!file_exists($template)){
throw new Exception("Template {".$template."} does not exist!");
return false;
}else{
$container=new PHParser_container($this->vars);
$container->__display($template);
return true;
}
}
}
class PHParser_container{
private $vars;
public function __construct($array){
if((!is_array($array))||empty($array)){
$this->vars=array();
}else{
$this->vars=$array;
}
}
public function __set($var,$value){
$this->vars[$var]=$value;
}
public function __get($var){
return $this->vars[$var];
}
public function __display($template){
if(!file_exists($template)){
throw new Exception("Template {".$template."} does not exist!");
}else{
include($template);
}
}
}
?>
De rede dat ik hier een aparte class maak om de data weer te geven is simpel: dit object kan uitgebreid worden met eigen functies. Je zou het ook in een class kunnen stoppen, maar dan zijn bepaalde functies al gedefinieerd, en niet zelf in te vullen.
Ook blijft het hiermee makkelijk om objecten te gebruiken in je templates, waardoor je je data ook zo kunt ophalen/tonen.
(Opbouwende) kritiek altijd welkom ;)
Gewijzigd op 22/08/2010 01:40:49 door SilverWolf NL