ik ben een beetje bezig met het OOP programmeren. Nu ben ik een static function aan het maken voor de querys, zodat ik ze makkelijk kan aanroepen en uitvoeren, enkel weet ik niet precies wat ik aan het doen ben, of hoe ik het goed kan krijgen.
Hieronder zie je wat ik voor class heb gemaakt:
class query{
public $query;
public static function select($select, $from, $where){
$query = mysql_query("SELECT ".$select."FROM ".$from."WHERE ".$where);
return $query;
}
}
Onderstaande code is een test van me, nog niet echt gebasseerd op een loginscript,
Zo roep ik mijn code aan:
Statische functies, dat betekent:
- dat je functies hebt binnen een class ( dus methodes )
- die functies spreken geen $this-> variabelen ( dus properties ) aan.
- Je spreekt die aan met classnaam::methodenaam()
Elke keer je statische functies boven haalt, overtreed je de besisbegrippen van OOP. Elke keer.
Dat is net het ding aan statische functies.
De idee is: er zijn functies waarbij je geen nood hebt aan de eigenschappen van een object ( de instance van een class ). Je doet niets met enig object.
Dat zijn dus functie die informatie verwerken. Er komt iets binnen (via de parameters); dat wordt verwerkt; iets wordt teruggegeven.
Dat dus in tegenstelling tot methodes waarbij je resultaten gaat opslaan in $this-> eigenschappen. Deze resultaten zijn enkel beschikbaar binnen dat ene object waarmee je bezig bent.
----
En toch zal je elke tutorial over statische functies tergvinden onder de categorie OOP.
(er zullen wel uitzonderingen zijn)
Je gebruikt geen $this, maar mogelijk wel parent:: en self::. Dat is OOP, want je gebruikt én hergebruikt daarmee de klasse of ouderklassen in plaats van een object.
Voor het uitvoeren van een userExists() heb je geen User-object nodig. En voor de vormovereenkomst: je gaat dan ook geen SELECT met data uitvoeren, maar slechts tellen met een SELECT COUNT(*). In de volgende opzet kom je dan op twee statische methoden uit:
<?php
class Database extends mysqli
{
const DATABASE_HOST = 'localhost';
const DATABASE_USERNAME = 'root';
const DATABASE_PASSWD = '';
const DATABASE_DBNAME = 'test';
public function __construct()
{
parent::__construct(
self::DATABASE_HOST,
self::DATABASE_USERNAME,
self::DATABASE_PASSWD,
self::DATABASE_DBNAME
);
if (mysqli_connect_error()) {
throw new Exception('Could not connect to the database.');
}
if (!$this->set_charset('utf8')) {
throw new Exception('The database character set could not be set to UTF-8.');
}
}
}
class Query { }
class SelectQuery extends Query { }
class SelectCountQuery extends SelectQuery
{
public static function count($table_references, $where_condition = null)
{
$query = 'SELECT COUNT(*) FROM ' . $table_references;
if (isset($where_condition)) {
$query .= ' WHERE ' . $where_condition;
}
$dbh = new Database();
if ($result = $dbh->query($query)) {
$row = $result->fetch_row();
return $row[0];
}
}
}
class User
{
const USER_TABLE_NAME = 'users';
public static function userExists($username)
{
$counter = SelectCountQuery::count(
self::USER_TABLE_NAME,
"username = '" . $username . "'"
);
if ($counter >= 1) {
return true;
} else {
return false;
}
}
}
// Voor tests
$test = User::userExists('Admin');
var_dump($test);
?>
Static functies kunnen best en voor een query builder kunnen ze best werken. Je krijgt dan het facade pattern, iets waar Laravel groot mee geworden is...
door het werk kon ik deze dag niet reageren, enkel ben ik wel heel erg blij dat ik nu tot een oplossing ben gekomen. Bedankt voor al jullie reacties (buiten sommige bottere reacties), ik ben erg blij dat ik zo geholpen ben!
