eigen framework / beheersysteem
Pagina: « vorige 1 2 3 4 ... 10 11 12 volgende »
Quote:
Als een registry ergens nuttig is, is het toch wel in de controller?
Zeker heb je gelijk in. Maar ik heb mijn registry niet in elke controller nodig en daarom is het naar mijn mening overboden dat je hem in de constructor als parameter opgeeft. Wil je bepaalde attributen vanuit het registry laden roep je gewoon de instantie aan en haal je de waarde op. Verder kan de registry natuurlijk het beste als een singleton. + wat lazy registreren van object is natuurlijk gewoon cool :)
@The Force
Zoals ik zei, ik zal hem eens downloaden voor verder onderzoek zodat ik de geruchten kan onderbouwen ja of nee :)
Over ZF:
ZF wordt leuk als je bezig bent met hele grote projecten, vandaar dat ik daar wel favorite van ben.
Quote:
Ipv magic methods dan get en set functie maken?
Wat bedoel je met ArrayAutoloader en PearAutoloader?
Wat bedoel je met ArrayAutoloader en PearAutoloader?
Ja, Of gebruik ze gewoon beiden. Maar ik raad je ook aan om het singleton pattern te gebruiken.
Over de ArrayAutoloader en PearAutoloader was even een snel hersenspinsel. Het idee hieronder uitgewerkt.
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
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
<?php
interface Autoloader
{
public function loader( $classname );
}
abstract class Loader
{
public function includeFile( $filename )
{
if( file_exists( $filename ) ) {
return include_once( $filename );
}
return false;
}
}
class ArrayAutoloader extends Loader implements Autoloader
{
public function loader( )
{
}
}
class PearAutoloader extends loader implements Autoloader
{
public function loader( )
{
}
}
?>
interface Autoloader
{
public function loader( $classname );
}
abstract class Loader
{
public function includeFile( $filename )
{
if( file_exists( $filename ) ) {
return include_once( $filename );
}
return false;
}
}
class ArrayAutoloader extends Loader implements Autoloader
{
public function loader( )
{
}
}
class PearAutoloader extends loader implements Autoloader
{
public function loader( )
{
}
}
?>
ArrayAutoloader is dus een array in de klasse pompen en die gaat op zoek naar de files en probeerd deze te importeren. Dat moet wel lukken geloof ik.
Met de PearAutoloader bedoel ik de op de zend framework manier. Dus bijvoorbeeld:
Code (php)
1
2
3
2
3
<?php
Framework_Registry::getInstance( );
?>
Framework_Registry::getInstance( );
?>
Wordt vertaald in Framework/Registry/Registry.php. Dan krijg je ongeveer het volgende:
Code (php)
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
<?php
public function loader( $classname )
{
$filename = str_replace( '_', '/', strtolower( $classname ) . '.php' );
if( file_exists( $filename ) ) {
return $this->includeFile( $filename );
}
return false;
}
?>
public function loader( $classname )
{
$filename = str_replace( '_', '/', strtolower( $classname ) . '.php' );
if( file_exists( $filename ) ) {
return $this->includeFile( $filename );
}
return false;
}
?>
Ik hoop dat je er wat aan hebt!
Gewijzigd op 01/01/2011 13:54:43 door Niels K
De beste wensen :)
Dankjewel voor de code... aangezien ik geen opleiding heb gehad op IT gebied en nooit eerder heb gewerkt met abstracte classes en ik "implements" ook niet ken, is het wat lastig te volgen, dus ik zal me er in moeten verdiepen wat je precies doet met die autoloader classes.
Verder schrijf je "lazy registreren van object is natuurlijk gewoon cool :)". Nou, dat klinkt heel leuk... maar wat bedoel je hiermee :)
Niels Kieviet op 01/01/2011 13:53:31:
Over ZF:
ZF wordt leuk als je bezig bent met hele grote projecten, vandaar dat ik daar wel favorite van ben.
ZF wordt leuk als je bezig bent met hele grote projecten, vandaar dat ik daar wel favorite van ben.
Dat lijkt me geen argument. Je moet het framework gebruiken die het beste past bij een project, niet andersom. Als de topicstarter van plan is met een team van programmeurs een groot overheidsproject aan te gaan pakken dan moet je je keuze nog maar eens overwegen. Het ziet er overigens wel erg 'stoer' uit met die bootstrap files en al die configuratie maar CI 'just works'. Het routing mechanisme is gewoon geniaal in eenvoud maar je kan er alles mee. Lees het volgende eens: http://www.inventis.be/blog/zend-framework-vs-codeigniter-the-good-the-bad/. CodeIgniter is een snel en weinig belastend RAD-framework. ZF is meer 'bloatware'. Goed geprogrammeerd, heel erg uitgebreid maar voor 99% van de projecten te lomp. Ik overdrijf miss. een beetje om mijn punt te maken maar je begrijpt me denk ik wel ;). Het argument in bovenstaande link dat functionaliteit als de ViewHelper ontbreekt vind ik overigens een beetje te kort door de bocht. Voor alles wat je wil zijn libraries te vinden.
Als de topic starter een framework wil die simpel is, volledig naar zijn hand te zetten is en waarmee snel goede applicaties gemaakt kunnen worden raad ik hem echt aan CI eens uit te proberen.
Edit: @Ozzie Kijk eens naar http://codeigniter.com/user_guide/database/active_record.html#insert, makkelijker kan toch bijna niet? :)
Gewijzigd op 01/01/2011 16:17:41 door The Force
Ozzie PHP op 01/01/2011 16:16:26:
Dank je voor je reactie... maar nogmaals, het zelf maken lijkt me ook wel wat, want dan heb je nooit overkill aan (te veel) code en je weet zelf precies hoe alles in elkaar steekt wat ook weer z'n voordelen heeft lijkt me zo. Alleen specifieke technieken als autoloaden e.d. tja dat zal even best lastig zijn om uit te vogelen hoe ik dat moet aanpakken.
Als je geen dingen als autoloading, method chaining etc. erin stopt dan is je framework miss. klein, maar krijg je wel een overkill aan code die je moet kloppen voor elke website. Het is wel leerzaam. Nah goed, kijk maar wat je er mee doet. Ik stop met zeuren ;).
Ik ga die dingen zeker er wel in stoppen... ik wil het mezelf zo makkelijk mogelijk maken...
Wat is method chaining dan weer...? Ik hoor telkens iets nieuws :)
Code (php)
1
2
3
2
3
<?php
$this->db->select('title')->from('mytable')->where('id', $id)->limit(10, 20);
?>
$this->db->select('title')->from('mytable')->where('id', $id)->limit(10, 20);
?>
i.p.v.
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$this->db->select('title');
$this->db->from('mytable');
$this->db->where('id', $id);
$this->db->limit(10, 20);
?>
$this->db->select('title');
$this->db->from('mytable');
$this->db->where('id', $id);
$this->db->limit(10, 20);
?>
kan doen.
Is dat lastig om zelf te bouwen? Of gewoon kwestie van een goede tutorial? Lijkt me in ieder geval wel een superhandige optie!
Ozzie PHP op 01/01/2011 17:38:18:
Aaaah... dat ziet er nice uit! :)
Is dat lastig om zelf te bouwen? Of gewoon kwestie van een goede tutorial? Lijkt me in ieder geval wel een superhandige optie!
Is dat lastig om zelf te bouwen? Of gewoon kwestie van een goede tutorial? Lijkt me in ieder geval wel een superhandige optie!
Gewoon CI gebruiken die hebben beiden opties aanwezig. ;)
Maar bovenstaande is natuurlijk allemaal mooi bedacht, maar hebben jullie er ook aan gedacht dat het soms helemaal niet handig is om met dit soort active records te werken?
Denk bijvoorbeeld aan complexe query's e.d...
Bart V B op 01/01/2011 17:49:15:
Gewoon CI gebruiken die hebben beiden opties aanwezig. ;)
Maar bovenstaande is natuurlijk allemaal mooi bedacht, maar hebben jullie er ook aan gedacht dat het soms helemaal niet handig is om met dit soort active records te werken?
Denk bijvoorbeeld aan complexe query's e.d...
Ozzie PHP op 01/01/2011 17:38:18:
Aaaah... dat ziet er nice uit! :)
Is dat lastig om zelf te bouwen? Of gewoon kwestie van een goede tutorial? Lijkt me in ieder geval wel een superhandige optie!
Is dat lastig om zelf te bouwen? Of gewoon kwestie van een goede tutorial? Lijkt me in ieder geval wel een superhandige optie!
Gewoon CI gebruiken die hebben beiden opties aanwezig. ;)
Maar bovenstaande is natuurlijk allemaal mooi bedacht, maar hebben jullie er ook aan gedacht dat het soms helemaal niet handig is om met dit soort active records te werken?
Denk bijvoorbeeld aan complexe query's e.d...
Het zal inderdaad eens voorkomen dat je de query niet kan genereren met Active Record. Maar leg mij eens uit waarom je in de andere gevallen het dan niet zou moeten gebruiken?
@Ozzie: method-chaining is makkelijk te maken, je functie moet een instantie van hemzelf teruggeven zodat daarop weer een functie aangeroepen kan worden. Dat kan met $this vanaf PHP5. Even zonder controle, maar dit hieronder zou moeten werken:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
class Testing {
public $voorbeeld = '';
//Test functie
function voegBlaatToe() {
//Doe wat...
$this->voorbeeld .= "Blaat";
//Return instantie.
return $this;
}
function getBlaats() {
return $this->voorbeeld;
}
}
$blaat = new Testing();
echo $blaat->voegBlaatToe()->voegBlaatToe()->voegBlaatToe()->getBlaats();
//Output "BlaatBlaatBlaat"...
?>
class Testing {
public $voorbeeld = '';
//Test functie
function voegBlaatToe() {
//Doe wat...
$this->voorbeeld .= "Blaat";
//Return instantie.
return $this;
}
function getBlaats() {
return $this->voorbeeld;
}
}
$blaat = new Testing();
echo $blaat->voegBlaatToe()->voegBlaatToe()->voegBlaatToe()->getBlaats();
//Output "BlaatBlaatBlaat"...
?>
Maar als ik je goed begrijp moet je dus bij iedere functie "return $this;" toevoegen? Kan dat bijvoorbeeld niet overkoepelend? Dat het voor alle functies in een bepaalde class geldt?
Ozzie PHP op 01/01/2011 19:59:15:
Ah oke, thanks...
Maar als ik je goed begrijp moet je dus bij iedere functie "return $this;" toevoegen? Kan dat bijvoorbeeld niet overkoepelend? Dat het voor alle functies in een bepaalde class geldt?
Maar als ik je goed begrijp moet je dus bij iedere functie "return $this;" toevoegen? Kan dat bijvoorbeeld niet overkoepelend? Dat het voor alle functies in een bepaalde class geldt?
Nope, elke functie moet zelf aangeven wat het terug geeft...
Kijk eens naar een abstracte methode:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
abstract class Loader
{
public function includeFile( $filename )
{
if( file_exists( $filename ) ) {
return include_once( $filename );
}
return false;
}
abstract public function load($className);
}
?>
abstract class Loader
{
public function includeFile( $filename )
{
if( file_exists( $filename ) ) {
return include_once( $filename );
}
return false;
}
abstract public function load($className);
}
?>
Dan heb je die interface helemaal niet nodig.
Een singleton registry is heel vervelend bij Unit-testen hoor...
Gewijzigd op 01/01/2011 21:33:41 door Pim -
Allereerst, pas op met het Active Record Pattern. Een aparte klasse (of zelfs meerdere) is/zijn NOOIT in staat om sneller of simpeler te zijn dan een query in een variabele. Sterker nog, wat is er nu makkelijker dan "SELECT x FROM y WHERE z = 1"? Elke (beginnende) developer snapt direct wat er gebeurd. Wel is het natuurlijk netjes om al je database verkeer in een aparte laag te regelen, zoals de M in MVC. Het Data Mapper Pattern is hiervan een voorbeeld, maar er zijn er nog een paar.
Ten tweede ben ik geen fan van CodeIgniter. Een framework dat in deze tijd nog compatibel met PHP4 probeert te zijn valt bij mij bij voorbaat al af. Vreemd genoeg heb ik in dit topic nog niets gelezen over Kohana. Dit framework werkt wel met PHP5, en is ook nog eens gebaseerd op CodeIgniter.
Daarnaast heb je natuurlijk nog Symfony, Yii, Zend Framework en ga zo maar door. Het aangekondigde Symfony Reloaded lijkt veelbelovend, vooral de ideeën achter de Kernel en Dependency Injection zijn indrukwekkend. Een nadeel is dat Symfony overal configuratie instellingen voor heeft. Qua modulariteit is dit super, maar van mij mag het wat minder. Yii werkt veel met statische klassen, dat is voor mij een grote min. Singleton is voor mij een anti pattern. Dan, het Zend Framework zit theoretisch prima in elkaar, maar praktisch werkt het niet altijd. Voor goede performance zul je ergens anders moeten zoeken.
Zelf heb ik al enkele ontwikkelcycli van mijn eigen framework doorlopen. Aangezien performance en modulariteit voor mij het belangrijkst zijn, richt ik me vooral hier op. Vooral het maken van een goede, werkende MVC structuur is een pittige, maar uitdagende, klus.
Aan de topicstarter zou ik verder willen adviseren dat het niet zo slim is om met geringe kennis meteen een framework te willen bouwen. Dat lijkt me wat ambitieus, zeker aangezien je geen achtergrondkennis in de webwereld (design patterns, OOP etc.) zegt te hebben. Kies er dan voor met een bestaand framework wat te bouwen, daar zal je op dit moment het meest van leren.
Just my two cents.
In dat tweede geval zou een basis MVC opzet prima werken. Er bestaat zelfs al een geinig framework welke in een tweet past (Twitto). Toch kan het MVC principe al vrij ingewikkeld worden. Ik stoei momenteel met de volgende dingen:
- Routing,
- Dependency Injection (meegeven van bijvoorbeeld database, log, cache klassen aan de verschillende controllers, op basis van een configuratiebestand),
- Layouts,
- Helpers (nemen een klein deel van de layout voor hun rekening, zodat deze cross-controller gebruikt kan worden),
- Plugins of widgets (niet perse nodig, maar wel leuk om te hebben).
Je kan het eigenlijk zo ingewikkeld maken als je het zelf wilt. Bovenstaande dingen zijn in mijn ogen echt onmisbaar. Maar alles (netjes!) met elkaar te verbinden is moeilijker dan het lijkt. Als je geen deadline hebt, zou ik hier zeker mee gaan stoeien. Een eigen framework (proberen te) maken leert je veel over OOP, Design Patterns en noem maar op.
Is dit eenmaal gelukt, dan kan je eens kijken naar HMVC, ingebouwde AJAX support en andere leuke dingetjes. Maar dat is voor later.
Gewijzigd op 01/01/2011 23:03:33 door Mark PHP
Mark PHP op 01/01/2011 23:01:20:
Ik weet niet precies wat je nu bedoeld. Een beheersysteem in de zin van CMS? Of een projectopzet, waarbij je direct begint met applicatiespecifieke code en de basis al bestaat?
Eigenlijk een combinatie van beide :)
Als ik een website moet maken dan wil ik mijn "framework" op de server zetten, en dan meteen al een goede basis hebben. Met basis bedoel ik een basis CMS systeem waarin je bijvoorbeeld routes kunt aanmaken en users kunt toevoegen. Daarnaast is de code dan volgens het MVC model opgezet en beschik ik al over bepaalde basis-functionaliteit (bijvoorbeeld database en caching). Dat is een beetje wat ik wil bereiken.Snap je wat ik bedoel?
Waarom kan je beter
$db->select("velden")->from("tabel")->where("naam", "piet")->limit(0, 1);
gebruiken ipv
$db->query("SELECT velden FROM tabel WHERE naam = 'piet' LIMIT 0,1);
Pagina: « vorige 1 2 3 4 ... 10 11 12 volgende »