Il problema con questi video tutorial sono i loro autori che non hanno idea sull'argomento, rendendo il risultato MOLTO MOLTO PEGGIO che se non stessi usando i loro escrementi mentali. Il danno che stanno infliggendo è così grave che ho persino dovuto scrivere un articolo dedicato che spiega perché tutti questi "involucri" indifesi sono totalmente inutilizzabili per qualsiasi applicazione reale, Le prime malattie infantili del tuo database wrapper .
Prendi questo wrapper dal video, ad esempio:
- La segnalazione degli errori è completamente imperfetta
- Una funzione inutile per SELECT.
- Statualità
- Istanza PDO protetta
Quindi, in sostanza, non sarai in grado di ottenere da questo "involucro" nemmeno una cosa così sciocca come Insert Id. E nessuna segnalazione di errore potrebbe aiutarti nemmeno a realizzare il problema.
A partire dal tuo codice, non contrattare per salvarti digitando una parola chiave SQL. È sciocco. SQL è una cosa preziosa, non scartarlo a favore di alcune scorciatoie senza senso. Né dovresti ridurre il PDO a uno stato di invalido paralizzato, spazzando via le sue caratteristiche più brillanti.
Il tuo wrapper dovrebbe rendere accessibili tutte le funzionalità PDO e SQL invece di scartarle. Così va:
class DB
{
protected static $instance;
protected $pdo;
protected function __construct() {
$opt = array(
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_OBJ,
PDO::ATTR_EMULATE_PREPARES => FALSE,
);
$dsn = 'mysql:host='.DB_HOST.';dbname='.DB_NAME.';charset='.DB_CHAR;
$this->pdo = new PDO($dsn, DB_USER, DB_PASS, $opt);
}
// a classical static method to make it universally available
public static function instance()
{
if (self::$instance === null)
{
self::$instance = new self;
}
return self::$instance;
}
// a proxy to native PDO methods
public function __call($method, $args)
{
return call_user_func_array(array($this->pdo, $method), $args);
}
// a helper function to run prepared statements smoothly
public function run($sql, $args = [])
{
$stmt = $this->pdo->prepare($sql);
$stmt->execute($args);
return $stmt;
}
}
questo wrapper è dieci volte più semplice e allo stesso tempo dieci volte più potente di quello del video.
E ora la tua classe
class Schedule
{
private $_db;
public function __construct()
{
$this->_db = DB::instance();
}
public function listGames()
{
$data = $this->_db->query('SELECT * FROM games')->fetchAll();
var_dump($data);
echo '<br>';
}
}
Il segreto qui è che PDO può già fornirti dati oggetto, senza una singola riga di codifica aggiuntiva.
Sebbene questo semplice esempio non sia molto impressionante, il segreto qui è che questo wrapper ti servirà anche per qualsiasi altro esempio, quando quello del video si strozzerà. Prova a pensare a qualsiasi altro esempio e ti mostrerò quanto sia semplice ma potente questo wrapper.
