Templates, wel of niet in PHP?

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

SilverWolf NL

SilverWolf NL

20/08/2010 23:25:13
Quote Anchor link
Beste PHP'ers,

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...
Gewijzigd op 20/08/2010 23:30:12 door SilverWolf NL
 
PHP hulp

PHP hulp

11/05/2021 15:27:56
 
Danny Roelofs

Danny Roelofs

20/08/2010 23:39:13
Quote Anchor link
Ja persoonlijk ben ik wel er op gewezen dat Smarty nou niet de betere template parser te zijn, er zijn ook andere die je ook voorzien, welke nu beter is dat kan ik je niet vertellen.

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.
 
Martijn Wieringa

Martijn Wieringa

21/08/2010 09:39:25
Quote Anchor link
In mijn visie is (ruwe)data en opmaak lang niet zo onafhankelijk van elkaar als men soms wil laten geloven. Het is daarom noodzakelijk dat templates zo flexibel mogelijk zijn om de data (onbeperkt?) te kunnen 'kneden' tot wenselijk formaat (HTML output?).

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.
 
Ruben Frijns

Ruben Frijns

21/08/2010 11:40:18
Quote Anchor link
Je kunt je ook afvragen hoe vaak een designer een template met code gaat zitten aanpassen. Meestal wordt de HTML aangeleverd die wordt omgezet in templates.
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.
 
SilverWolf NL

SilverWolf NL

22/08/2010 01:36:26
Quote Anchor link
Ik kan mij wel vinden in de onderste twee reacties, omdat ik zelf ook altijd de templates maak uit HTML, aangeleverd via een designer. Ik wil echter wel weten of iemand nou wel een goed voorbeeld kan geven wanneer een templateparser dan wel nodig is, en waarom dat niet in native-php kan.

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)
PHP script in nieuw venster Selecteer het PHP script
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
<?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);
        }
    }
}

?>


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
 



Overzicht Reageren

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.