[php] efficiënt includen

[ieperlingetje]

Ik zit met een structuurprobleem in mijn website: enerzijds werk ik met templates zodat telkens dezelfde layout gebruikt, maar ook zijn er soms spcifieke pagina's, bijv. met eerst een verwerking serverside, daarna een deel dat in de head geplaatst wordt en een deel in de body.

stel, ik heb een pagina met veel javascript en serverside verwerking(bijvoorbeeld een embedded google maps)
dan los ik dat op deze manier op:

ik heb een php bestand die altijd geinclude wordt: pagina.php

via pagina.php?pagina=blabla roep ik dan een specifieke pagina op.

in dat bestand dat ik dan include wordt gecheckt of de layout voor die pagina al geladen is, dat doe door te checken of een bepaalde variabele leeg is.

dit gebeurt via deze code

code:

if(strlen($layoutinclude) > 0)
 {
  if($type == "serverpart")
   {
   }
  if($type == "head")
   {
   }
  if($type == "body")
   {
   }
 }
else
 {
 $layoutinclude = "eenofanderepagina.php";
 include("layout.hfi.php");
 }

indien de layout dus niet geladen is, wordt eerst de layout geladen, waarna de layoutpagina dan deze pagina include, en dat dus 3 keer doet, één keer voor wat serverside gebeurd, een txeede keer voor de head, een derde keer voor de body.
dus schematisch gebeurt dit:
pagina.php include> eenpagina.php include> layout include> eenpagina.php (3x)

nu weet ik ook dat dit verre van efficiënt is, daarom is mijn vraag, hoe zorgen jullie ervoor dat een pagina telkens zijn eigen serverside verwerking heeft, zijn eigen head gedeelte, eigen body gedeelte maar toch een layout heeft die op elke pagina terugkomt?

(overigens, load is niet echt een probleem (0,01 seconde) maar ik denk dat het nogal omslachtig is om steeds te includen)

[AndriesLouw]

functions gebruiken voor head/body/overig, en als noodoplossing misschien include_once();

[Icekiller2k6]

ik zou kijken naar object georiënteerd te programmeren in PHP .. effiecienter dan dat is moeilijk..
maar makkelijk is in het begin niet..

[CH4OS]

Sowieso zal de PHP altijd eerst geparsed worden, zoals je weet en op de manier waarop je het nu schrijft, het een functioneel script is. Dat wil zeggen dat het script van boven naar beneden uitgevoerd word.

Wellicht kan het dus een boel schelen, als je een functie maakt, die de te includen bestanden bepaald of gelijk include? Overigens, weet niet of je er gebruik van maakt, maar include_once(); of require_once(); zorgen er voor dat de bestanden maximaal 1 malig geladen worden tijdens de uitvoering van het script.

[.oisyn]

Icekiller2k6 schreef op maandag 04 mei 2009 @ 17:59:
ik zou kijken naar object georiënteerd te programmeren in PHP .. effiecienter dan dat is moeilijk..
maar makkelijk is in het begin niet..

Alsof efficientie inherent is aan OO

[Icekiller2k6]

.oisyn schreef op maandag 04 mei 2009 @ 18:40:
[...]

Alsof efficientie inherent is aan OO

heb ik ook niet gezegd... maar als je correct kunt werken met OO is het wel efficienter..

[CoolGamer]

Icekiller2k6 schreef op maandag 04 mei 2009 @ 18:45:
[...]

heb ik ook niet gezegd... maar als je correct kunt werken met OO is het wel efficienter..

Alsof code ineens 10x efficiënter wordt als het in OO geschreven is, je kan ook heel goed efficiënte code schrijven zonder gebruik te maken van OO. In veel gevallen kan die code zelfs efficiënter zijn dan met OO, al zal goed geschreven code met of zonder OO niet al te veel schelen kwa performance.

[.oisyn]

Icekiller2k6 schreef op maandag 04 mei 2009 @ 18:45:
[...]


heb ik ook niet gezegd...

Nou, noem het maar "niet gezegd hebben", maar ik kan de volgende zin toch echt moeilijk anders interpreteren:

ik zou kijken naar object georiënteerd te programmeren in PHP .. effiecienter dan dat is moeilijk..

Dat laatste deel impliceert toch echt dat een (goed) OO ontwerp altijd efficient is - immers, efficienter dan dat is lastig te verkrijgen.

maar als je correct kunt werken met OO is het wel efficienter..

Sorry, maar complete onzin. Overigens hebben we nog niet vastgesteld over welke efficientie we het hier hebben - performance van de code en hoeveel werk je ervoor nodig hebt om de code te schrijven. Maar voor beide definities gaat het niet op. Sowieso is OO nooit het toonbeeld geweest van maximale performance - het concentreert zich meer op het daadwerkelijk ontwerp van de applicatie, en dus de maintainability van de code. Zo zijn abstractie en datahiding belangrijke eigenschappen van een goed OO ontwerp, maar dat zijn beide elementen die haaks staan op goede performance.

Maar zelfs voor design is OO geen heilige graal, er zijn tal van paradigima's die voor bepaalde probleemgebieden veel beter van toepassing zijn.

[ Voor 40% gewijzigd door .oisyn op 04-05-2009 19:04 ]

[ieperlingetje]

Met efficiëntie bedoel ik hier dat het later waarschijnlijk moeilijker wordt te onderhouden of te controleren op fouten, daarom ben ik op zoek naar andere manieren om hetzelfde te bereiken, maar die eenvoudiger zijn voor foutopsporing.

[Mei]

Layout, body, head, whatever moeten allemaal niks met je data te maken hebben. Voor je body en je head kan je een template engine gebruiken (of maken) en voor je layout heb je CSS.