Hoe parseer ik objectgegevens uit de MySQL-database met behulp van PHP PDO?

Het probleem met deze video-tutorials is dat hun auteurs geen idee hebben over het onderwerp, waardoor het resultaat VEEL SLECHTER is dan wanneer je hun mentale uitwerpselen helemaal niet zou gebruiken. De schade die ze aanrichten is zo erg dat ik zelfs een speciaal artikel moest schrijven waarin wordt uitgelegd waarom al deze hulpeloze "wrappers" totaal onbruikbaar zijn voor de echte toepassing, De kinderziektes van je eerste database-wrapper .

Neem bijvoorbeeld deze wrapper uit de video:

• Foutrapportage is volledig gebrekkig
• Een nutteloze functie voor SELECT's.
• Statigheid
• Beveiligde PDO-instantie

Dus in wezen zul je niet in staat zijn om uit deze "wrapper" zelfs zoiets dwaas als Insert Id te krijgen. En geen enkele foutrapportage kan u zelfs maar helpen om het probleem te realiseren.

Vanaf uw code, koop gewoon niet om uzelf te besparen door een SQL-sleutelwoord te typen. Het is dom. SQL is een kostbaar iets, verwerp het niet ten gunste van enkele wartaal-snelkoppelingen. Je moet PDO ook niet reduceren tot een toestand van een kreupele invalide, waarbij de meest briljante eigenschappen worden weggevaagd.

Uw wrapper moet alle PDO- en SQL-functies toegankelijk maken in plaats van ze weg te gooien. Zo gaat het:

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;
    }
}

deze wrapper is tien keer eenvoudiger en tegelijkertijd tien keer krachtiger dan die uit de video.

En nu jouw klas

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>';
    }
}

Het geheim hier is dat PDO u al objectgegevens kan geven, zonder een enkele extra regel codering.

Hoewel dit eenvoudige voorbeeld niet erg indrukwekkend is, is het geheim hier dat deze wikkel je ook zal dienen voor elk ander voorbeeld, wanneer dat van de video zal stikken. Probeer een ander voorbeeld te bedenken en ik zal je laten zien hoe eenvoudig maar krachtig deze verpakking is.