eigen framework / beheersysteem
Pagina: « vorige 1 2 3 4 5 ... 10 11 12 volgende »
De tweede optie is beter. Niet de eerste. ;)
Lees de reply van Mark PHP 01/01/2011 21:49:03 nog maar eens..
Wel zoiets als sneller en in jouw ogen overzichtelijker.
Simpele queries zijn natuurlijk prima met een API te maken, ingewikkelder niet.
Wat voor jou het beste is, hangt alleen van jouzelf af...
Persoonlijk vind ik niet-select queries sowieso handiger met een api.
Het is erg eenvoudig. Wil je alsnog een bepaalde URL iets anders, kan je nog steeds een regel maken in htaccess. (rewriterule)
Iets anders wat ik je nog zou aanraden is het gebruik van PDO, werkt altijd netjes voor je queries. Klikje
Gewijzigd op 02/01/2011 17:58:00 door Write Down
Bart V B op 02/01/2011 17:10:13:
@Jaron,
De tweede optie is beter. Niet de eerste. ;)
Lees de reply van Mark PHP 01/01/2011 21:49:03 nog maar eens..
De tweede optie is beter. Niet de eerste. ;)
Lees de reply van Mark PHP 01/01/2011 21:49:03 nog maar eens..
Hoezo dat dan? Door niet zelf de queries te schrijven maak je je code abstracter. Je beschrijft meer wat je wil in plaats van hoe je dat wilt. Eén van de voordelen die dat biedt is dat je code onafhankelijk wordt van de achterliggende database. Als je later overstapt op een nieuwe versie die syntaxwijzigingen heeft (of je switcht van DB) dan hoef je alleen je config aan te passen. Het is dus meer de OO gedachte. Daarnaast dwingt Active Record automatisch veilige queries af door alles te escapen, door een XSS filter te halen enzovoorts. Er zijn inderdaad situaties waarin Active Record geen oplossing biedt.
Active Record stelt je in staat een generieke modellaag te creeëren. Hierdoor kan je sneller code ontwikkelen. Als ik afgestudeerd ben zal ik daar eens een tutorial over schrijven. Je code wordt overzichtelijker vooral als je queries genereert afhankelijk van user input. In een situatie waar je 0 of meer WHERE statements kan hebben moet je als je zelf de query samenstelt counters gaan bijhouden of een hack als 'WHERE 0=1 ' toepassen zodat je daarna 'OR kolom=waarde' kan doen. Met Active Record kan je gewoon een array meegeven ('$this->db->where($where)'). Zit er niks in dan krijg je geen WHERE. Je hoeft dus geen loopjes en if statements te maken.
Ander voorbeeld: inserten. $this->db->insert('tablename', $values). Kan het nog simpeler? Ander voorbeeld: foutafhandeling. Heel goed geregeld (nog specifiek of je read of write queries uitvoert). Als je zelf queries schrijft dan weet het framework niet wat er geschreven is en kan het daaromheen liggende proces ook niet geoptimaliseerd worden. Helaas is deze gedachte nog niet echt in de PHP wereld ingebakken, in tegenstelling tot bijvoorbeeld Microsoft met producten als Linq. Eén databaseachtige manier om met alle databronnen zoals tekstbestanden, excelbestanden, databases, xml bestanden te communiceren.
Veel bronnen op internet menen dat je de ene taal niet in de andere moet mappen.
Simpele inserts zijn natuurlijk veel handiger in zo'n DBAL, veel selects niet.
The Force op 02/01/2011 21:17:23:
Hoezo dat dan? Door niet zelf de queries te schrijven maak je je code abstracter. Je beschrijft meer wat je wil in plaats van hoe je dat wilt.
Wat is het verschil in $query = $this->select('x')->from('y')->where('z'); en $query = "SELECT x FROM y WHERE z"? Het eerste is omslachtiger. Het is een drogreden om te denken dat het eerste simpeler is omdat de developer dan geen SQL hoeft te kennen.
Daarbij aansluitend je tweede argument, dat Active Record je query aanpast naar standaard SQL. Dit wil je vaak niet, omdat je profijt wilt hebben van de trukjes, voordelen en functies die een specifieke database je biedt. Uiteraard zul je, als je ooit wil switchen naar een andere database, je queries hier en daar aan moeten passen. Maar zolang je alle SQL in een bepaalde applicatielaag hebt, is dit een peuleschil.
The Force op 02/01/2011 21:17:23:
In een situatie waar je 0 of meer WHERE statements kan hebben moet je als je zelf de query samenstelt counters gaan bijhouden of een hack als 'WHERE 0=1 ' toepassen zodat je daarna 'OR kolom=waarde' kan doen.
Ik kan me niet echt een situatie indenken waarbij je in PHP WHERE clausules aan elkaar gaat plakken.
The Force op 02/01/2011 21:17:23:
Daarnaast dwingt Active Record automatisch veilige queries af door alles te escapen, door een XSS filter te halen enzovoorts.
Dit kan je ook afdwingen door een eigen Database klasse te schrijven, en alleen Prepared Statements toe te staan. Bovendien kan je adapters schrijven voor MySQL, PostgreSQL, Oracle enzovoort. XSS filteren doe je overigens niet als je data de database in moet, maar pas als je het aan de gebruiker presenteert.
Gewijzigd op 02/01/2011 21:37:05 door Mark PHP
Mark PHP op 02/01/2011 21:35:47:
Wat is het verschil in $query = $this->select('x')->from('y')->where('z'); en $query = "SELECT x FROM y WHERE z"? Het eerste is omslachtiger. Het is een drogreden om te denken dat het eerste simpeler is omdat de developer dan geen SQL hoeft te kennen.
The Force op 02/01/2011 21:17:23:
Hoezo dat dan? Door niet zelf de queries te schrijven maak je je code abstracter. Je beschrijft meer wat je wil in plaats van hoe je dat wilt.
Wat is het verschil in $query = $this->select('x')->from('y')->where('z'); en $query = "SELECT x FROM y WHERE z"? Het eerste is omslachtiger. Het is een drogreden om te denken dat het eerste simpeler is omdat de developer dan geen SQL hoeft te kennen.
Er is een andere reden waarom die 1e manier wel de voorkeur heeft, namelijk het automatisch aanvullen van functies waardoor je sneller een query kan schrijven, maar dit is persoonlijk natuurlijk.
Kun je die method chaining eigenlijk ook intelligent maken vraag ik me af?
Want in theorie zou je kunnen zeggen $database->select('naam')->from('gebruikers')->select('leeftijd').
Let op, in bovengenoemd voorbeeld maak ik bewust een fout door 2x select() aan te roepen. Zou je het nu ook zo kunnen maken dat zodra je seelct hebt aangeroepen je niet nogmaals select kunt aanroepen? Of kan dat niet?
Gewijzigd op 02/01/2011 21:42:12 door Ozzie PHP
Toevoeging op 02/01/2011 22:04:05:
wat is overigens dat "lazy registreren van een object" waar Niels het eerder over had?
Gewijzigd op 02/01/2011 22:04:19 door Ozzie PHP
Dus als een registry, maar dan gebeurt er pas iets bij aanvraag en niet vooraf.
Kijk eens naar Pimple
Je kunt zeker niet een heeeeeeel simpel code voorbeeldje geven zodat ik in ieder geval het principe snap? (en hopelijk ook waar je het voor kunt gebruiken)
Ozzie PHP op 02/01/2011 22:15:52:
Hmmm... ik vrees dat ik hier niks van ga snappen :-/
Je kunt zeker niet een heeeeeeel simpel code voorbeeldje geven zodat ik in ieder geval het principe snap? (en hopelijk ook waar je het voor kunt gebruiken)
Je kunt zeker niet een heeeeeeel simpel code voorbeeldje geven zodat ik in ieder geval het principe snap? (en hopelijk ook waar je het voor kunt gebruiken)
Het is eigenlijk heel simpel. Je maakt een instantie van een object aan pas op het moment dat je hem nodig hebt. Zie http://dougalmatthews.com/articles/2008/apr/26/lazy-loading-in-php-with-__autoload/.
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
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
<?php
class Container
{
private $_database;
public function getDatabase()
{
if (!$this->_database)
$this->_loadDatabase();
return $this->_database;
}
private function _loadDatabase()
{
$this->_database = new PDO(...);
}
}
$x = new Container();
// geen verbinding gemaakt.
$pdo = $x->getDatabase();
// jeej, nu nodig, dus nu een verbinding
$pdo2 = $x->getDatabase();
// verbinding is al gemaakt, kunnen we hem best hergebruiken.
?>
class Container
{
private $_database;
public function getDatabase()
{
if (!$this->_database)
$this->_loadDatabase();
return $this->_database;
}
private function _loadDatabase()
{
$this->_database = new PDO(...);
}
}
$x = new Container();
// geen verbinding gemaakt.
$pdo = $x->getDatabase();
// jeej, nu nodig, dus nu een verbinding
$pdo2 = $x->getDatabase();
// verbinding is al gemaakt, kunnen we hem best hergebruiken.
?>
Maar omdat dat al snel heel veel dezelfde code wordt, is het wel prettig om iets flexibelers te hebben zoals Pimple. Of, eentje die erop lijkt en die ik zelf gebruik:
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
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
<?php
class DependencyContainer
{
private $_factories = array();
private $_instances = array();
public function add($name, $factory)
{
$this->_factories[$name] = $factory;
}
public function __get($name)
{
if (!isset($this->_instances[$name]))
$this->_instantiate($name);
return $this->_instances[$name];
}
private function _instantiate($name)
{
if (!isset($this->_factories[$name]))
throw new DependencyContainer_Exception("There is no factory for $name.");
$instance = $this->_factories[$name]($this);
if (is_null($instance))
throw new DependencyContainer_Exception("Factory for $name returned NULL.");
$this->_instances[$name] = $instance;
}
}
class DependencyContainer_Exception extends Exception
{}
$x = new DependencyContainer();
$x->add('pdo', function($container) {
return new PDO(...);
});
$x->add('users', function($container) {
return new User_Store($container->pdo);
});
// Nu wordt User_Store pas ingeladen en aangemaakt, en daarvoor wordt dan PDO aangemaakt.
$x->users->find();
?>
class DependencyContainer
{
private $_factories = array();
private $_instances = array();
public function add($name, $factory)
{
$this->_factories[$name] = $factory;
}
public function __get($name)
{
if (!isset($this->_instances[$name]))
$this->_instantiate($name);
return $this->_instances[$name];
}
private function _instantiate($name)
{
if (!isset($this->_factories[$name]))
throw new DependencyContainer_Exception("There is no factory for $name.");
$instance = $this->_factories[$name]($this);
if (is_null($instance))
throw new DependencyContainer_Exception("Factory for $name returned NULL.");
$this->_instances[$name] = $instance;
}
}
class DependencyContainer_Exception extends Exception
{}
$x = new DependencyContainer();
$x->add('pdo', function($container) {
return new PDO(...);
});
$x->add('users', function($container) {
return new User_Store($container->pdo);
});
// Nu wordt User_Store pas ingeladen en aangemaakt, en daarvoor wordt dan PDO aangemaakt.
$x->users->find();
?>
Waarom gebruik je een underscore voor je functie- en variabelenamen?
(misschien stomme vraag, maar wat is een factory?)
Pagina: « vorige 1 2 3 4 5 ... 10 11 12 volgende »