Pdo php skript sa spustí 2-krát. PHP PDO - správna práca s databázami

príklad kľúčových slov metaznačiek (4)

Cieľ

Ako vidím, váš cieľ je v tomto prípade dvojaký:

vytvoriť a udržiavať jedno/opakovane použiteľné pripojenie pre každú databázu
skontrolujte, či je pripojenie správne nakonfigurované

Riešenie

$provider = function() ( $instance = new PDO("mysql:......;charset=utf8", "username", "password"); $instance->setAttribute(PDO::ATTR_ERRMODE, PDO: :ERRMODE_EXCEPTION); $instance->setAttribute(PDO::ATTR_EMULATE_PREPARES, false); return $instance; ); $factory = new StructureFactory($poskytovateľ);

Potom v inom súbore alebo nižšie v tom istom súbore:

$niečo = $továreň->vytvoriť("Niečo"); $foobar = $factory->create("Foobar");

Samotná továreň by mala vyzerať asi takto:

Class StructureFactory ( protected $provider = null; protected $connection = null; verejná funkcia __construct(volateľný $provider) ( $this->provider = $provider; ) verejná funkcia create($name) ( if ($this->connection = == null) ( $this->connection = call_user_func($this->provider); ) return new $name($this->connection); ) )

Týmto spôsobom môžete mať centralizovanú štruktúru, ktorá zaisťuje, že spojenie sa vytvorí iba v prípade potreby. To by tiež uľahčilo proces testovania a údržby jednotky.

Dodávateľa v tomto prípade nájdete niekde počas bootstrap fázy. Tento prístup tiež poskytne jasné miesto, kde môžete definovať konfiguráciu, ktorú používate na pripojenie k DB.

Majte na pamäti, že toto extrémne zjednodušený príklad. Môžete si tiež pozrieť nasledujúce dve videá:

Tiež vrelo odporúčam prečítať si riadny návod o používaní PDO (online je zlý návod).

Z času na čas vidím otázky týkajúce sa pripojenia k databáze.
Väčšina odpovedí nie je taká, ako to robím ja, alebo jednoducho neviem odpovedať správne. Každopádne; Nikdy som o tom nepremýšľal, pretože spôsob, akým to robím, mi funguje.

Ale tu je bláznivá myšlienka; Možno to všetko robím zle, a ak áno; Naozaj by som chcel vedieť, ako sa správne pripojiť k databáze údaje MySQL pomocou PHP a PDO a sprístupniť ich.

Robím to takto:

Po prvé, tu je moja štruktúra súborov (skrátené) :

Public_html/ * index.php * initialize/ -- load.initialize.php -- configure.php -- sessions.php

index.php
Úplne hore požadujem("initialize/load.initialize.php"); ,

load.initialize.php

# konfigurácie stránok vyžadujú("configure.php"); # pripojenie k databáze vyžaduje("root/somewhere/connect.php"); // tento súbor je kvôli lepšej bezpečnosti umiestnený mimo public_html. # include classs foreach (glob("assets/classes/*.class.php") ako $class_filename)( include($class_filename); ) # include functions foreach (glob("assets/functions/*.func.php") as $func_filename)( include($func_filename); ) # handle sessions required("sessions.php");

Viem, že existuje lepší alebo správnejší spôsob, ako zahrnúť triedy, ale nepamätám si, čo to bolo. Ešte som nemal čas sa na to pozrieť, ale myslím, že to bolo niečo s automatickým načítaním. niečo také...

configure.php
Tu v podstate len niektoré prebíjam php.ini-vlastnosti a robiť niektoré ďalšie globálne nastavenia pre stránku

pripojiť.php
Pripojenie k triede som nastavil tak, aby to ostatné triedy mohli expandovať toto...

Trieda connect_pdo ( chránené $dbh; verejná funkcia __construct() ( try ( $db_host = " "; // názov hostiteľa $ názov_db = " "; // názov databázy $db_user = " "; // používateľské meno $user_pw = " "; // heslo $con = new PDO("mysql:host=".$db_host."; dbname=".$db_name, $db_user, $user_pw); $con->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $con->exec("SET CHARACTER SET utf8"); // vráti všetky sql požiadavky ako UTF-8 ) catch (PDOException $err) ( echo "neškodné chybové hlásenie, ak spojenie zlyhá"; $err->getMessage() "
"; file_put_contents("PDOErrors.txt",$err, FILE_APPEND); // zapíšte niektoré podrobnosti do protokolu chýb mimo public_html die(); // ukončite pripojenie ) ) verejná funkcia dbh() ( return $this->dbh ;) ) # vložte obslužný program databázy do var pre jednoduchší prístup $con = new connect_pdo(); $con = $con->dbh(); //

Toto je miesto, kde skutočne verím, že existuje priestor na masívne zlepšenie, pretože som sa nedávno začal učiť OOP a namiesto mysql používam PDO.
Tak som len sledoval pár návodov pre začiatočníkov a vyskúšal som rôzne veci...

sessions.php
Okrem spracovania normálnych relácií tiež inicializujem niektoré triedy v relácii takto:

If (!isset($_SESSION["sqlQuery"]))( session_start(); $_SESSION["sqlQuery"] = new sqlQuery(); )

Takže táto trieda je dostupná všade. To nemusí byť veľmi dobre cvicenie (?) ...
V každom prípade mi tento prístup umožňuje robiť všade:

Echo $_SESSION["sqlQuery"]->getAreaName("kraj",9); // výstupy: Aust-Agder (názov okresu s týmto ID v databáze)

Vnútri môjho trieda sqlQuery, ktorý rozširuje môj Trieda connect_pdo , mám verejnú funkciu getAreaName, ktorá spracováva dotaz v mojej databáze.
Podľa mňa celkom slušné.

Funguje ako kúzlo
Takže v podstate to robím takto.
Tiež, kedykoľvek potrebujem získať niečo z mojej DB z triedy, urobím niečo podobné ako toto:

$id = 123; $sql = "VYBERTE čokoľvek Z MyTable WHERE id = :id"; $qry = $con->prepare($sql); $qry -> bindParam(":id", $id, PDO::PARAM_INT); $qry -> vykonat(); $get = $qry->fetch(PDO::FETCH_ASSOC);

Pretože vo vnútri vkladám spojenie do premennej connect_pdo.php, len to odkážem a môžem ísť. Funguje to. Dosahujem očakávané výsledky...

Ale bez ohľadu na to; Naozaj by som ocenil, keby ste mi povedali, či odtiaľto odídem. Namiesto toho by som musel zmeniť oblasti, ktoré by som mohol alebo mal zmeniť kvôli zlepšeniu atď.

Naozaj chcem študovať...

$dsn = "mysql:host=názov_vášho_hostiteľa;dbname=názov_vášho_db_tu"; // definujte názov hostiteľa a názov databázy $username = "vy"; // definujte používateľské meno $pwd="vaše_heslo"; // pokus o heslo ( $db = nový PDO($dsn, $username, $pwd); ) catch (PDOException $e) ( $error_message = $e->getMessage(); echo "zobrazuje sa, pretože sa našla chyba "; VÝCHOD(); )

Nedávno som sám od seba prišiel na podobnú odpoveď/otázku. Toto som urobil, ak by to niekoho zaujímalo:

args = func_get_args(); ) verejná funkcia __call($method, $args) ( if (empty($this->db)) ( $Ref = new \ReflectionClass("\PDO"); $this->db = $Ref->newInstanceArgs($ this->args); ) return call_user_func_array(pole($this->db, $method), $args); ) )

Ak ho chcete zavolať, stačí zmeniť tento riadok:

$DB = new \Library\PDO(/* normálne argumenty */);

A typ nápovedy, ak ju používate (\Library\PDO$DB).

Toto je skutočne podobné prijatej odpovedi a vašej; má však značnú výhodu. Zvážte tento kód:

$DB = new \Library\PDO(/* args */); $STH = $DB->prepare("SELECT * FROM users WHERE user = ?"); $STH->execute(pole(25)); $Pouzivatel = $STH->fetch();

Aj keď to môže vyzerať ako bežné PDO (je modifikované iba touto \Library\), v skutočnosti neinicializuje objekt, kým nezavoláte prvú metódu, podľa toho, ktorá to je. Vďaka tomu je viac optimalizovaný, pretože vytvorenie objektu PDO je trochu drahé. Toto je transparentná trieda, alebo to, čo sa nazýva Ghost, forma. Môžete zaobchádzať s $DB ako s bežnou inštanciou PDO, prenášať ju, robiť rovnaké operácie atď.

Navrhoval by som nepoužívať $_SESSION na globálny prístup k vášmu pripojeniu DB.

Môžete urobiť jednu z niekoľkých vecí (dobre najhoršie za najlepšie praktizujúci):

Prístup k $ dbh pomocou globálneho $ dbh vo vašich funkciách a triedach

Použite register singleton a pristupujte k nemu globálne, napríklad:

$registre = MyRegistry::getInstance(); $dbh = $registre->getDbh();

Pridajte obslužný program databázy do tried, ktoré potrebuje:

Trieda MyClass ( verejná funkcia __construct($dbh) ( /* ... */ ) )

Je však trochu pokročilejšia a vyžaduje si viac „káblovania“ bez rámu. Ak je teda pre vás injekcia závislostí príliš zložitá, namiesto kolekcie globálnych premenných použite singletonový register.

Poskytuje metódy na prípravu výrazov a prácu s objektmi, vďaka ktorým budete produktívnejší!

Úvod do CHOP

"PDO - PHP Data Objects je vrstva prístupu k databáze, ktorá poskytuje jednotné metódy na prístup k rôznym databázam."

Nespolieha sa na špecifickú syntax databázy a umožňuje vám jednoduchý prechod na iný typ databázy a platformu jednoduchou zmenou pripojovacieho reťazca vo väčšine prípadov.

Táto lekcia nie je popisom procesu práce s SQL. Je určený pre tých, ktorí používajú rozšírenia mysql alebo mysqli pomôcť im prejsť na výkonnejšie a prenosnejšie CHOP.

Podpora databázy

Rozšírenie podporuje akúkoľvek databázu, pre ktorú existuje ovládač PDO. V súčasnosti sú dostupné ovládače pre nasledujúce typy databáz:

PDO_DBLIB (FreeTDS / Microsoft SQL Server / Sybase)
PDO_FIREBIRD (Firebird/Interbase 6)
PDO_IBM (IBM DB2)
PDO_INFORMIX (IBM Informix Dynamic Server)
PDO_MYSQL (MySQL 3.x/4.x/5.x)
PDO_OCI (rozhranie volania Oracle)
PDO_ODBC (ODBC v3 (IBM DB2, unixODBC a win32 ODBC))
PDO_PGSQL (PostgreSQL)
PDO_SQLITE (SQLite 3 a SQLite 2)
PDO_4D (4D)

Aby systém fungoval, stačí nainštalovať len tie ovládače, ktoré sú skutočne potrebné. Zoznam ovládačov dostupných v systéme môžete získať takto:

Print_r(PDO::getAvailableDrivers());

Pripojenie

Rôzne databázy môžu mať mierne odlišné spôsoby pripojenia. Spôsoby pripojenia k niekoľkým populárnym databázam sú uvedené nižšie. Všimnete si, že prvé tri sú navzájom identické a iba SQLite má špecifickú syntax.

skúste ( # MS SQL Server a Sybase s PDO_DBLIB $DBH = nový PDO("mssql:host=$host;dbname=$dbname, $user, $pass"); $DBH = nový PDO("sybase:host=$hostiteľ ;dbname=$dbname, $user, $pass"); # MySQL s PDO_MYSQL $DBH = nový PDO("mysql:host=$host;dbname=$dbname", $user, $pass); # SQLite $DBH = new PDO("sqlite:my/database/path/database.db"); ) catch (PDOException $e) ( echo $e->getMessage(); )

Venujte pozornosť bloku Skús chytiť- operácie s CHOP by ste mali vždy zabaliť do bloku Skús chytiť a použite mechanizmus výnimiek. Zvyčajne sa vytvorí iba jedno pripojenie, náš príklad ukazuje viacero pripojení na zobrazenie syntaxe. $DBH obsahuje databázový popisovač a bude používaný v našom návode.

Každé spojenie môžete uzavrieť nastavením rukoväte na nulový.

# Zatvorte spojenie $DBH = null;

Viac o konkrétnych možnostiach a reťazcoch pripojenia pre rôzne databázy sa dozviete z dokumentov na PHP.net.

Výnimky a CHOP

PDO môže použiť výnimky na spracovanie chýb. To znamená, že všetky operácie s CHOP musia byť uzavreté v bloku Skús chytiť. PDO môže vyvolať tri úrovne chýb, úroveň kontroly chýb sa vyberá nastavením atribútu režimu kontroly chýb pre deskriptor databázy:

$DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT); $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING); $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

Bez ohľadu na nastavenú úroveň riadenia, chyba pripojenia vždy vyvolá výnimku, a preto by mala byť vždy uzavretá v bloku Skús chytiť.

PDO::ERRMODE_SILENT

Úroveň kontroly chýb je predvolene nastavená. Na tejto úrovni sa chyby generujú podľa rovnakého princípu ako v rozšíreniach mysql alebo mysqli. Ďalšie dve úrovne kontroly chýb sú vhodnejšie pre štýl programovania DRY (Don't Repeat Youself).

PDO::ERRMODE_WARNING

Na tejto úrovni kontroly chýb sa vygenerujú štandardné varovania PHP a program môže pokračovať vo vykonávaní. Táto úroveň je vhodná na ladenie.

PDO::ERRMODE_EXCEPTION

Táto úroveň kontroly chýb by sa mala používať vo väčšine situácií. Výnimky sa generujú na starostlivé spracovanie chýb a skrytie údajov, ktoré by mohli niekomu pomôcť hacknúť váš systém. Nižšie je uvedený príklad demonštrujúci výhody výnimiek:

# Skúste sa pripojiť k databáze ( $DBH = nový PDO("mysql:host=$host;dbname=$dbname", $user, $pass); $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION) ; # Nesprávne zadanie DELECT namiesto SELECT! $DBH->prepare("DELECT name FROM people"); ) catch(PDOException $e) ( echo "Prepáčte, ale operáciu nebolo možné vykonať."; file_put_contents("PDOErrors. txt" , $e->getMessage(), FILE_APPEND); )

V príkaze SELECT je tu úmyselná chyba. Toto vyvolá výnimku. Výnimka odošle popis chyby do súboru denníka a zobrazí správu používateľovi.

Vkladanie a aktualizácia údajov

Vkladanie nových údajov alebo aktualizácia existujúcich údajov je jednou z najčastejšie používaných bežných databázových operácií. Pri použití CHOP sa rozkladá na dve etapy. Všetko popísané v tejto kapitole platí pre obe operácie. AKTUALIZOVAŤ A VLOŽIŤ.

Tu je príklad najpoužívanejšieho typu vkladania údajov:

# STH je "stavový popisovač" $STH = $DBH->prepare("INSERT INTO people (first_name) values ("Cathy")"); $STH->execute();

Samozrejme, môžete túto operáciu vykonať pomocou metódy exec() a počet hovorov bude o jeden menší. Na získanie výhod pripravených výrazov je však lepšie použiť dlhší spôsob. Aj keď ich zamýšľate použiť iba raz, pripravené výrazy vám pomôžu chrániť sa pred útokmi na váš systém.

Pripravené výrazy

Pripravené príkazy sú predkompilované príkazy SQL, ktoré možno vykonať mnohokrát odoslaním iba údajov na server. Ich výhodou je automatické vyplnenie šablóny údajmi v podobe ochrany pred útokmi prostredníctvom príloh SQL kódu.

Môžete použiť pripravené výrazy zahrnutím šablón do kódu SQL. Nižšie sú uvedené 3 príklady: jeden bez šablón, jeden s nepomenovanými šablónami, jeden s pomenovanými šablónami.

# žiadne šablóny - otvorené útokom SQL injection! $STH = $DBH->("INSERT INTO ľudových (meno, adresa, mesto) hodnoty ($meno, $addr, $mesto)"); # nepomenované šablóny $STH = $DBH->("VLOŽIŤ DO ľudí (meno, adresa, mesto) hodnoty (?, ?, ?); # pomenované šablóny $STH = $DBH->("INSERT DO ľudí (meno) , addr , city) value (:name, :addr, :city)");

Mali by ste sa vyhnúť použitiu prvej metódy. Výber pomenovaných alebo nepomenovaných vzorov ovplyvňuje spôsob nastavenia údajov pre tieto výrazy.

Nepomenované šablóny

# každej šablóne priraďte premenné, indexované od 1 do 3 $STH->bindParam(1, $name); $STH->bindParam(2, $addr); $STH->bindParam(3, $mesto); # Vložte jeden riadok $name = "Dima" $addr = "Lizyukova St."; $mesto = "Moskva"; $STH->execute(); # Vložte ďalší riadok $name = "Senya" $addr = "Komunistická slepá ulička"; $mesto = "Peter"; $STH->execute();

Operácia prebieha v dvoch etapách. V prvom kroku sa šablónam priradia premenné. Potom sa premenným priradia hodnoty a výraz sa vykoná. Ak chcete odoslať ďalšiu časť údajov, musíte zmeniť hodnoty premenných a znova spustiť výraz.

Vyzerá to trochu ťažkopádne pre výrazy s množstvom parametrov? určite. Ak sú však vaše údaje uložené v poli, všetko bude veľmi krátke:

# Údaje, ktoré sa majú vložiť $data = array("Monya", "Forget-Me-Not Avenue", "Zakutajsk"); $STH = $DBH->("VLOŽTE DO hodnôt ľudí (meno, adresa, mesto) (?, ?, ?)"); $STH->execute($data);

Údaje v poli sa nahradia do šablón v poradí, v akom sa zobrazujú. $data prejde do prvej šablóny, $data do druhej atď. Ak je však pole indexované v inom poradí, takáto operácia sa nevykoná správne. Musíte zabezpečiť, aby sa poradie vzorov zhodovalo s poradím údajov v poli.

Pomenované šablóny

Tu je príklad použitia pomenovanej šablóny:

# Prvý argument funkcie je názov pomenovanej šablóny # Pomenovaná šablóna vždy začína dvojbodkou $STH->bindParam(":name", $name);

Môžete použiť skratky, ale fungujú s priradenými poľami. Príklad:

# Údaje na vloženie $data = array("name" => "Michelle", "addr" => "Kuznechny Lane", "city" => "Cnjkbwf"); # Skratka $STH = $DBH->("INSERT INTO people (meno, addr, city) value (:name, :addr, :city)"); $STH->execute($data);

Kľúče vašej tabuľky nevyžadujú dvojbodku, ale musia sa zhodovať s názvami šablón. Ak používate pole polí, môžete ho iterovať a jednoducho zavolať vykonať pre každý súbor údajov.

Ďalšou príjemnou vlastnosťou pomenovaných šablón je možnosť vkladať objekty priamo do vašej databázy, keď sa vlastnosti a názvy polí zhodujú. Príklad:

# Osoba triedy jednoduchých objektov ( public $name; public $addr; public $mesto; funkcia __construct($n,$a,$c) ( $this->name = $n; $this->addr = $a; $ this->city = $c; ) # atď... ) $cathy = new person("Katya","Lenin Avenue","Mozhaisk"); # Vykonať: $STH = $DBH->("INSERT INTO people (meno, addr, city) value (:name, :addr, :city)"); $STH->execute((pole)$cathy);

Konverzia typu objektu na pole V vykonať spôsobí, že vlastnosti sa budú považovať za kľúče poľa.

Prijímanie údajov

Na získanie údajov sa používa metóda identifikátora štátu ->fetch(). Pred volaním metódy načítať () musíte PDO povedať, ako budete získavať údaje z databázy. Môžete vybrať nasledujúce možnosti:

PDO::FETCH_ASSOC: vráti pole indexované podľa názvov stĺpcov
PDO::FETCH_BOTH (predvolené): vráti pole indexované podľa názvov stĺpcov a čísel
PDO::FETCH_BOUND: Pomocou metódy priradí hodnoty vašich stĺpcov množine premenných ->bindColumn()
PDO::FETCH_CLASS: priradí hodnoty stĺpcov vlastnostiam pomenovanej triedy; ak zodpovedajúca vlastnosť neexistuje, vytvorí sa
PDO::FETCH_INTO: aktualizuje existujúcu inštanciu pomenovanej triedy
CHOP::FETCH_LAZY: kombinácia PDO::FETCH_BOTH/PDO::FETCH_OBJ, vytvára názvy premenných objektov tak, ako sa používajú
PDO::FETCH_NUM: vráti pole indexované podľa čísel stĺpcov
PDO::FETCH_OBJ: vráti anonymný objekt s názvami vlastností zodpovedajúcimi názvom stĺpcov

V skutočnosti sa základné situácie riešia pomocou troch možností: FETCH_ASSOC, FETCH_CLASS A FETCH_OBJ. Ak chcete nastaviť metódu extrakcie údajov:

$STH->setFetchMode(PDO::FETCH_ASSOC);

Priamo vo volaní metódy môžete nastaviť aj metódu získavania údajov ->fetch().

FETCH_ASSOC

Tento typ získavania údajov vytvára asociatívne pole indexované podľa názvov stĺpcov. Mal by byť pomerne dobre známy tým, ktorí používajú rozšírenia mysql/mysqli. Vzorová vzorka údajov:

$STH = $DBH->query("VYBRAŤ meno, adresa, mesto od ľudí"); # Nastavte režim získavania dát $STH->setFetchMode(PDO::FETCH_ASSOC); while($row = $STH->fetch()) ( echo $row["meno"] . "\n"; echo $row["addr"] . "\n"; echo $row["mesto"] . "\n" ;)

Cyklus zatiaľ čo pokračuje v iterácii výsledkov vzorky jeden riadok po druhom, až kým sa nedokončí.

FETCH_OBJ

Pri tomto type získavania údajov sa vytvorí objekt triedy std pre každý riadok prijatých údajov:

$STH = $DBH->query("VYBRAŤ meno, adresa, mesto od ľudí"); # Nastavte režim načítania dát $STH->setFetchMode(PDO::FETCH_OBJ); # zobraziť výsledok while($row = $STH->fetch()) ( echo $row->name . "\n"; echo $row->addr. "\n"; echo $row->mesto. " \ n" ;)

FETCH_CLASS

Pri tomto type extrakcie sa údaje umiestnia priamo do triedy, ktorú si vyberiete. Použitím FETCH_CLASS vlastnosti vášho objektu sú nastavené PRED volaním konštruktora. Je to veľmi dôležité. Ak vlastnosť zodpovedajúca názvu stĺpca neexistuje, takáto vlastnosť sa vytvorí (ako verejnosti) pre teba.

To znamená, že ak dáta potrebujú transformáciu po načítaní z databázy, môže to urobiť automaticky váš objekt hneď po vytvorení.

Predstavte si napríklad situáciu, že adresa musí byť čiastočne skrytá pre každý záznam. Úlohu môžeme splniť manipuláciou s vlastnosťou v konštruktore:

Tajná_osoba triedy ( public $name; public $addr; public $mesto; public $other_data; function __construct($other = "") ( $this->address = preg_replace("//", "x", $this-> adresa); $this->other_data = $other; ) )

Po extrahovaní údajov do triedy budú všetky malé písmená a-z v adrese nahradené znakom x. Teraz, pomocou triedy a získania údajov, transformácia prebieha úplne transparentne:

$STH = $DBH->query("VYBRAŤ meno, adresa, mesto od ľudí"); $STH->setFetchMode(PDO::FETCH_CLASS, "tajna_osoba"); while($obj = $STH->fetch()) ( echo $obj->addr; )

Ak bola adresa „Leninsky Prospekt 5“, uvidíte „Lxxxxxxxxxx xx-x 5“. Samozrejme, existujú situácie, keď chcete, aby bol konštruktor zavolaný pred priradením údajov. CHOP má prostriedky na implementáciu:

$STH->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, "tajna_osoba");

Teraz, keď zopakujete predchádzajúci príklad s nastaveným režimom PDO::FETCH_PROPS_LATE adresa nebude skrytá, pretože bol zavolaný konštruktor a boli priradené vlastnosti.

Ak potrebujete, môžete pri extrakcii údajov do objektu odovzdať konštruktorovi argumenty:

$STH->setFetchMode(PDO::FETCH_CLASS, "tajna_osoba", pole("veci"));

Ak potrebujete pre každý objekt odovzdať konštruktorovi iné údaje, môžete v metóde nastaviť režim získavania údajov aport:

$i = 0; while($rowObj = $STH->fetch(PDO::FETCH_CLASS, "tajná_osoba", pole($i))) ( // robiť veci $i++ )

Niektoré ďalšie užitočné metódy

Keďže PDO nie je možné úplne opísať v krátkom článku, predstavíme si niekoľko užitočných metód na vykonávanie základných operácií.

$DBH->lastInsertId();

Metóda ->lastInsertId() je vždy volaná popisovačom databázy (nie popisovačom stavu) a vracia hodnotu automaticky inkrementovaného id posledného vloženého riadku pre dané pripojenie.

$DBH->exec("VYMAZAŤ Z ľudí, KDE 1"); $DBH->exec("SET time_zone = "-8:00"");

Metóda ->exec() používa sa na rôzne pomocné operácie.

$safe = $DBH->quote($unsafe);

Metóda ->citovať() kvóty reťazcov, aby ich bolo možné použiť v dotazoch. Toto je vaša rezerva v prípade, že sa nepoužijú pripravené výrazy.

$rows_affected = $STH->rowCount();

Metóda ->rowCount() vráti hodnotu celé číslo, označujúci počet riadkov, ktoré operácia spracuje. V najnovšej verzii PDO podľa správy o chybe (http://bugs.php.net/40822) táto metóda nefunguje s výrazmi VYBRAŤ. Ak máte problémy a nemôžete aktualizovať PHP, môžete získať počet riadkov nasledujúcim spôsobom:

$sql = "VYBERTE POČET (*) FROM ľudí"; if ($STH = $DBH->query($sql)) ( # Skontrolujte počet riadkov if ($STH->fetchColumn() > 0) ( # Tu by mal byť kód SELECT) else ( echo "Existujú žiadne riadky nezodpovedajú dopytu." ;) )

Dúfam, že sa vám lekcia páčila!

Nastavenie a používanie PDO - rozšírenie PHP Data Objects pre prácu s databázami

Vytvorenie testovacej databázy a tabuľky

Najprv vytvorte databázu pre tento tutoriál:

CREATE DATABASE solar_system; UDELTE VŠETKY PRIVILEGIÁ PRE solar_system.* „testuser“@“localhost“ IDENTIFIKOVATEĽNÝM PODĽA „testovacieho hesla“;

Používateľovi s prihlasovacím menom testuser a heslom testpassword boli udelené plné prístupové práva do databázy solar_system.

Teraz vytvorte tabuľku a vyplňte ju údajmi, ktorých astronomická presnosť nie je zahrnutá:

USE solar_system; CREATE TABLE planéty (id TINYINT(1) UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY(id), názov VARCHAR(10) NOT NULL, farba VARCHAR(10) NOT NULL); INSERT INTO planét(meno, farba) VALUES("zem", "modrá"), ("mars", "červená"), ("jupiter", "divný");

Popis pripojenia

Teraz, keď je databáza vytvorená, definujme DSN () - informácie pre pripojenie k databáze, prezentované ako reťazec. Syntax popisu sa líši v závislosti od použitého DBMS. V príklade pracujeme s MySQL/MariaDB, takže uvádzame:

názov hostiteľa, kde sa nachádza DBMS;
port (voliteľný, ak sa používa štandardný port 3306);
názov databázy;
kódovanie (voliteľné).

Linka DSN v tomto prípade vyzerá takto:

$dsn = "mysql:host=localhost;port=3306;dbname=solar_system;charset=utf8";

Predpona databázy je špecifikovaná ako prvá. V príklade - mysql. Predpona je oddelená od zvyšku riadku dvojbodkou a každý nasledujúci parameter je oddelený bodkočiarkou.

Vytvorenie objektu PDO

Teraz, keď je reťazec DSN pripravený, vytvorme objekt PDO. Konštruktor vstupu akceptuje nasledujúce parametre:

Reťazec DSN.
Meno používateľa, ktorý má prístup k databáze.
Heslo tohto používateľa.
Pole s ďalšími parametrami (voliteľné).

$options = [ PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC ]; $pdo = nové PDO($dsn, "testuser", "testpassword", $options);

Ďalšie parametre možno definovať aj po vytvorení objektu pomocou metódy SetAttribute:

$pdo->SetAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

Definovanie predvolenej metódy vzorkovania

PDO::DEFAULT_FETCH_MODE je dôležitý parameter, ktorý určuje predvolenú metódu načítania. Uvedená metóda sa používa pri získavaní výsledku požiadavky.

PDO::FETCH_BOTH

Predvolený režim. Výsledok výberu je indexovaný číslami (od 0) a názvami stĺpcov:

$stmt = $pdo->query("SELECT * FROM planet"); $vysledky = $stmt->fetch(PDO::FETCH_BOTH);

Po vykonaní dotazu v tomto režime proti testovacej tabuľke planét dostaneme nasledujúci výsledok:

Pole ( => 1 => 1 => zem => zem => modrá => modrá)

PDO::FETCH_ASSOC

Výsledok je uložený v asociatívnom poli, v ktorom je kľúčom názov stĺpca a hodnota je zodpovedajúca hodnota riadka:

$stmt = $pdo->query("SELECT * FROM planet"); $vysledky = $stmt->fetch(PDO::FETCH_ASSOC);

V dôsledku toho dostaneme:

Pole ( => 1 => zem => modrá)

PDO::FETCH_NUM

Pri použití tohto režimu je výsledok prezentovaný ako pole indexované podľa čísel stĺpcov (od 0):

Pole ( => 1 => zem => modrá)

PDO::FETCH_COLUMN

Táto možnosť je užitočná, ak potrebujete získať zoznam hodnôt pre jedno pole vo forme jednorozmerného poľa, ktorého číslovanie začína od 0. Napríklad:

$stmt = $pdo->query("VYBRAŤ meno FROM planét");

V dôsledku toho dostaneme:

Pole ( => zem => mars => jupiter)

PDO::FETCH_KEY_PAIR

Túto možnosť používame, ak potrebujeme získať zoznam hodnôt dvoch polí vo forme asociatívneho poľa. Kľúče poľa sú údaje v prvom stĺpci výberu, hodnoty poľa sú údaje v druhom stĺpci. Napríklad:

$stmt = $pdo->query("VYBRAŤ meno, farbu FROM planét"); $vysledok = $stmt->fetchAll(PDO::FETCH_KEY_PAIR);

V dôsledku toho dostaneme:

Pole ( => modrá => červená => zvláštne)

PDO::FETCH_OBJECT

Pri použití PDO::FETCH_OBJECT sa pre každý načítaný riadok vytvorí anonymný objekt. Jeho verejné vlastnosti sú názvy vzorových stĺpcov a ako ich hodnoty sa používajú výsledky dotazu:

$stmt = $pdo->query("VYBRAŤ meno, farbu FROM planét"); $vysledky = $stmt->fetch(PDO::FETCH_OBJ);

V dôsledku toho dostaneme:

Objekt StdClass ( => zem => modrá)

PDO::FETCH_CLASS

V tomto prípade, rovnako ako v predchádzajúcom, sa hodnoty stĺpca stanú vlastnosťami objektu. Musíte však zadať existujúcu triedu, ktorá sa použije na vytvorenie objektu. Pozrime sa na to na príklade. Najprv vytvoríme triedu:

Trieda Planet ( private $name; private $color; public function setName($planet_name) ( $this->name = $planet_name; ) public function setColor($planet_color) ( $this->color = $planet_color; ) public function getName () ( return $this->name; ) verejna funkcia getColor() ( return $this->color; ) )

Upozorňujeme, že trieda Planet má súkromné vlastnosti a nemá konštruktora. Teraz vykonáme požiadavku.

Ak používate metódu načítania s PDO::FETCH_CLASS, pred odoslaním požiadavky na načítanie údajov musíte použiť metódu setFetchMode:

$stmt = $pdo->query("VYBRAŤ meno, farbu FROM planét"); $stmt->setFetchMode(PDO::FETCH_CLASS, "Planet");

Prvý parameter, ktorý odovzdáme metóde setFetchMode, je konštanta PDO::FETCH_CLASS. Druhým parametrom je názov triedy, ktorá sa použije pri vytváraní objektu. Teraz urobme:

$planeta = $stmt->fetch(); var_dump($planeta);

Výsledkom je, že dostaneme objekt planéty:

Planétový objekt ( => zem => modrá)

Hodnoty vrátené dotazom sú priradené zodpovedajúcim vlastnostiam objektu, dokonca aj súkromným.

Definovanie vlastností po vykonaní konštruktora

Trieda Planet nemá explicitný konštruktor, takže nebudú žiadne problémy s priraďovaním vlastností. Ak má trieda konštruktor, v ktorom bola vlastnosť priradená alebo zmenená, budú prepísané.

Pri použití konštanty FETCH_PROPS_LATE budú hodnoty vlastností priradené po vykonaní konštruktora:

Trieda Planet ( private $name; private $color; public function __construct($name = mesiac, $color = sivá) ( $this->name = $name; $this->color = $color; ) verejná funkcia setName($ planet_name) ( $this->name = $planet_name; ) verejna funkcia setColor($planet_color) ( $this->color = $planet_color; ) verejna funkcia getName() ( return $this->name; ) verejna funkcia getColor() (vráťte $this->color; ) )

Upravili sme triedu Planet pridaním konštruktora, ktorý berie ako vstup dva argumenty: názov a farbu. Predvolené hodnoty pre tieto polia sú mesiac a sivá.

Ak nepoužijete FETCH_PROPS_LATE, vlastnosti sa pri vytvorení objektu prepíšu predvolenými hodnotami. Poďme sa na to pozrieť. Najprv spustíme dotaz:

$stmt = $pdo->query("SELECT meno, farba FROM solar_system WHERE name = "zem""); $stmt->setFetchMode(PDO::FETCH_CLASS, "Planet"); $planeta = $stmt->fetch(); var_dump($planeta);

V dôsledku toho dostaneme:

Object(Planet)#2 (2) ( ["name":"Planet":private]=> string(4) "mesiac" ["color":"Planet":private]=> string(4) "grey" )

Ako sa očakávalo, hodnoty získané z databázy sa prepíšu. Teraz sa pozrime na riešenie problému pomocou FETCH_PROPS_LATE (podobná požiadavka):

$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, "Planet"); $planeta = $stmt->fetch(); var_dump($planeta);

V dôsledku toho dostaneme to, čo potrebujeme:

Object(Planet)#4 (2) ( ["name":"Planet":private]=> string(5) "earth" ["color":"Planet":private]=> string(4) "modrá" )

Ak konštruktor triedy nemá predvolené hodnoty a sú potrebné, parametre konštruktora sa nastavia pri volaní metódy setFetchMode s tretím argumentom vo forme poľa. Napríklad:

Planéta triedy ( súkromné $meno; súkromné $farba; verejná funkcia __construct($meno, $farba) ( $this->name = $name; $this->color = $farba; ) [...] )

Argumenty konštruktora sú povinné, takže urobme:

$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, "Planéta", ["mesiac", "sivá"]);

Prichádzajúce parametre tiež fungujú ako predvolené hodnoty, ktoré sú potrebné na inicializáciu. V budúcnosti budú prepísané hodnotami z databázy.

Načítanie viacerých objektov

Viaceré výsledky sa načítajú ako objekty pomocou metódy načítania v rámci cyklu while:

Kým ($planet = $stmt->fetch()) ( // spracovanie výsledkov )

Alebo vzorkovaním všetkých výsledkov naraz. V druhom prípade sa používa metóda fetchAll a režim je špecifikovaný v čase volania:

$stmt->fetchAll(PDO::FETCH_CLASS|PDO_FETCH_PROPS_LATE, "Planéta", ["mesiac", "sivá"]);

PDO::FETCH_INTO

Keď vyberiete túto možnosť výberu, PDO nevytvorí nový objekt, ale aktualizuje vlastnosti existujúceho objektu. Toto je však možné len pre verejné vlastnosti alebo pri použití metódy __set magic na objekte.

Pripravené a priame požiadavky

Existujú dva spôsoby vykonávania dotazov v PDO:

rovný, ktorý pozostáva z jedného kroku;
pripravený, ktorý pozostáva z dvoch krokov.

Priame požiadavky

Existujú dva spôsoby vykonávania priamych dopytov:

dotaz sa používa pre príkazy, ktoré nevykonávajú zmeny, ako napríklad SELECT. Vráti objekt PDOStatemnt, z ktorého sa získavajú výsledky dotazu pomocou metód fetch alebo fetchAll;
exec sa používa pre príkazy ako INSERT, DELETE alebo UPDATE. Vráti počet riadkov spracovaných požiadavkou.

Priame operátory sa používajú iba vtedy, ak v dotaze nie sú žiadne premenné a ste si istí, že dotaz je bezpečný a správne escapovaný.

Pripravené otázky

PDO podporuje pripravené príkazy, ktoré sú užitočné na ochranu aplikácie pred: metóda príprav vykonáva potrebné escapovanie.

Pozrime sa na príklad. Chcete vložiť vlastnosti objektu Planéta do tabuľky Planéty. Najprv si pripravíme žiadosť:

$stmt = $pdo->prepare("INSERT INTO planet(name, color) VALUES(?, ?)");

Používame metódu Prepare, ktorá berie ako argument SQL dotaz s pseudopremennými (zástupnými symbolmi). Pseudové premenné môžu byť dvoch typov: nepomenované a pomenované.

Nepomenované pseudo premenné

Nepomenované pseudopremenné (pozičné zástupné symboly) sú označené ? . Výsledný dotaz je kompaktný, ale vyžaduje, aby boli hodnoty nahradené v rovnakom poradí. Odovzdávajú sa ako pole metódou vykonania:

$stmt->execute([$planet->name, $planet->color]);

Pomenované pseudopremenné

Pri použití pomenovaných zástupných symbolov nie je dôležité poradie, v ktorom sa hodnoty odovzdávajú na nahradenie, ale kód sa v tomto prípade stáva menej kompaktným. Údaje sú odovzdané metóde vykonania vo forme asociatívneho poľa, v ktorom každý kľúč zodpovedá názvu pseudopremennej a hodnota poľa zodpovedá hodnote, ktorú je potrebné dosadiť do požiadavky. Zopakujme predchádzajúci príklad:

$stmt = $pdo->prepare("INSERT INTO planet(name, color) VALUES(:name, :color)"); $stmt->execute(["meno" => $planéta->názov, "farba" => $planéta->farba]);

Metódy prípravy a spustenia sa používajú pri vykonávaní požiadaviek na zmenu aj pri načítavaní.

A informáciu o počte spracovaných riadkov v prípade potreby poskytne metóda rowCount.

Kontrola chybového správania PDO

Parameter výberu chybového režimu PDO::ATTR_ERRMODE sa používa na určenie toho, ako sa PDO správa v prípade chýb. K dispozícii sú tri možnosti: PDO::ERRMODE_SILENT , PDO::ERRMODE_EXCEPTION a PDO::ERRMODE_WARNING .

PDO::ERRMODE_SILENT

Predvolená možnosť. PDO jednoducho zaznamená informácie o chybe, ktoré vám pomôžu získať metódy errorCode a errorInfo.

PDO::ERRMODE_EXCEPTION

Toto je preferovaná možnosť, keď PDO vyvolá okrem informácií o chybe aj výnimku (PDOException). Výnimka preruší vykonávanie skriptu, čo je užitočné pri používaní transakcií PDO. Príklad je uvedený v popise transakcií.

PDO::ERRMODE_WARNING

V tomto prípade PDO zaznamenáva aj informácie o chybe. Tok skriptu nie je prerušený, ale sú vydávané varovania.

metódy bindValue a bindParam

Na nahradenie hodnôt v dotaze môžete použiť aj metódy bindValue a bindParam. Prvý spája hodnotu premennej s pseudopremennou, ktorá sa používa na prípravu požiadavky:

$stmt = $pdo->prepare("INSERT INTO planet(name, color) VALUES(:name, :color)"); $stmt->bindValue("name", $planet->name, PDO::PARAM_STR);

Prepojil hodnotu premennej $planet->name s pseudopremennou:name . Všimnite si, že pri použití metód bindValue a bindParam je typ premennej špecifikovaný ako tretí argument pomocou príslušných konštánt PDO. V príklade - PDO::PARAM_STR .

Metóda bindParam viaže premennú na pseudo premennú. V tomto prípade je premenná spojená s referenciou pseudopremennej a hodnota bude vložená do požiadavky až po zavolaní metódy spúšťania. Pozrime sa na príklad:

$stmt->bindParam("name", $planet->name, PDO::PARAM_STR);

Transakcie v CHOP

Predstavme si nezvyčajný príklad. Používateľ si musí vybrať zoznam planét a pri každom vykonaní požiadavky sa aktuálne údaje vymažú z databázy a potom sa vložia nové. Ak sa po vymazaní vyskytne chyba, ďalší používateľ dostane prázdny zoznam. Aby sme tomu zabránili, používame transakcie:

$pdo->beginTransaction(); skúste ( $stmt1 = $pdo->exec("DELETE FROM planet"); $stmt2 = $pdo->prepare("INSERT INTO planet(name, color) VALUES (?, ?)"); foreach ($planets as $planet) ( $stmt2->execute([$planet->getName(), $planet->getColor()]); ) $pdo->commit(); ) catch (PDOException $e) ( $pdo-> vrátiť späť (); )

Metóda beginTransaction zakáže automatické vykonávanie požiadaviek a vo vnútri konštrukcie try-catch sa požiadavky vykonávajú v požadovanom poradí. Ak nie sú vyvolané žiadne výnimky PDO, požiadavky budú dokončené pomocou metódy odovzdania. V opačnom prípade budú vrátené späť pomocou metódy rollback a automatické vykonávanie dopytov sa obnoví.

To vytvorilo konzistentnosť pri vykonávaní dotazu. Je zrejmé, že aby sa to stalo, PDO::ATTR_ERRMODE musí byť nastavené na PDO::ERRMODE_EXCEPTION .

Záver

Teraz, keď už bola popísaná práca s PDO, všimnime si jej hlavné výhody:

s PDO je ľahké preniesť aplikáciu do iných DBMS;
Podporované sú všetky populárne DBMS;
vstavaný systém správy chýb;
rôzne možnosti prezentácie výsledkov vzoriek;
sú podporované pripravené dotazy, ktoré skracujú kód a robia ho odolným voči SQL injekciám;
Podporované sú transakcie, ktoré pomáhajú udržiavať integritu údajov a konzistenciu dotazov, keď užívatelia pracujú paralelne.

3. júna 2018 Andrej Černyšov Návod na preklad 2025 0

PDO je skratka pre PHP Data Objects: je to rozšírenie PHP pre prácu s databázami pomocou objektov. Jedna z jeho výhod spočíva v tom, že nie je priamo viazaný na konkrétnu databázu: jeho rozhranie umožňuje prístup k niekoľkým rôznym prostrediam, vrátane: MySQL, SQLite, PostgreSQL, Microsoft SQL Server.

Cieľom tejto príručky je poskytnúť úplný prehľad o CHOP a previesť čitateľa krok za krokom od vytvorenia a pripojenia k databáze až po výber najvhodnejších metód vyhľadávania, demonštrovať, ako vytvoriť pripravené dotazy a popísať možné chybové režimy.

Vytvorenie testovacej databázy a tabuľky

Najprv si vytvoríme databázu:

CREATE DATABASE solar_system; UDELTE VŠETKY PRIVILEGIÁ PRE solar_system.* „testuser“@“localhost“ IDENTIFIKOVATEĽNÝM PODĽA „testovacieho hesla“;

Používateľovi testuser sme udelili všetky privilégiá v databáze solar_system pomocou testpassword pre heslo. Teraz vytvorte tabuľku a vyplňte ju niekoľkými informáciami:

Popis pripojenia DSN (Názov zdroja údajov).

Teraz, keď máme databázu, musíme nastaviť DSN. DSN je skratka pre názov zdroja údajov a je to súbor informácií potrebných na pripojenie k databáze, DSN je vo forme reťazca. Syntax sa líši v závislosti od databázy, ku ktorej sa potrebujete pripojiť, ale keďže používame MySQL/MariaDB, musíme nastaviť nasledovné:

Typ ovládača použitého na pripojenie;
Názov hostiteľského počítača, na ktorom beží databáza;
Port pripojenia (voliteľné);
Názov databázy;
Kódovanie (voliteľné).

Formát riadku v našom prípade bude takýto (uložíme ho do premennej $dsn):

$dsn = "mysql:host=localhost;port=3306;dbname=solar_system;charset=utf8";

V prvom rade nastavíme prefix databázy alebo prefix databázy. V tomto prípade, keďže sa pripájame k databáze typu MySQL/MariaDB, používame mysql. Predponu sme potom oddelili od zvyšku riadku dvojbodkou a každá nasledujúca časť bola oddelená od zvyšku bodkočiarkou.

V ďalších dvoch častiach sme špecifikovali názov hostiteľa, na ktorom databáza beží a port použitý na pripojenie. Ak nie je zadaný žiadny port, použije sa predvolený port, v tomto prípade 3306. Hneď za názvom databázy je charset .

Vytvorenie objektu PDO

Teraz, keď je naše DSN pripravené, začneme vytvárať objekt PDO. Konštruktor PDO používa reťazec DSN ako prvý parameter, užívateľské meno databázy ako druhý parameter, heslo ako tretí a voliteľné pole nastavení ako štvrtý.

$options = [ PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC ]; $pdo = nové PDO($dsn, "testuser", "testpassword", $options);

Nastavenia je možné nastaviť aj po vytvorení objektu pomocou metódy SetAttribute():

$pdo->SetAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

Konfigurácia PDO pre chyby zobrazenia

Pozrime sa na niektoré dostupné možnosti pre PDO::ATTR_ERRMODE. Tieto možnosti sú mimoriadne dôležité, pretože určujú, ako sa PDO správa, keď sa vyskytnú chyby. Možné možnosti:

PDO::ERRMODE_SILENT

Predvolená možnosť. PDO jednoducho vyhodí chybový kód a chybové hlásenie. Možno ich získať pomocou metód errorCode() a errorInfo().

PDO::ERRMODE_EXCEPTION

Túto možnosť sa podľa môjho názoru odporúča použiť. S jeho pomocou PDO okrem vydania chybového kódu a informácie vyhodí PDOException, ktorá preruší vykonávanie skriptu a hodí sa aj pri transakciách PDO (pozrieme sa na ne trochu neskôr).

PDO::ERRMODE_WARNING

Pri tejto voľbe PDO zobrazí chybový kód a hlásenie rovnako ako PDO::ERRMODE_SILENT, ale zobrazí aj VAROVANIE, ktoré nepreruší skript.

Nastavenie predvolenej metódy vzorkovania

Ďalšie dôležité nastavenie je regulované pomocou konštanty PDO::DEFAULT_FETCH_MODE. Umožňuje vám nakonfigurovať predvolenú operáciu metódy fetch(), ktorá sa použije na získanie výsledkov požiadavky. Tu sú najčastejšie používané možnosti:

PDO::FETCH_BOTH

Pri jeho použití budú získané výsledky indexované ako celé čísla, tak názvy stĺpcov. Jeho použitie v metóde na získanie riadku z tabuľky planét nám poskytne nasledujúce výsledky:

$stmt = $pdo->query("SELECT * FROM planet"); $vysledky = $stmt->fetch(PDO::FETCH_BOTH); Pole ( => 1 => 1 => zem => zem => modrá => modrá)

PDO::FETCH_ASSOC

S touto konštantou sa výsledky zapíšu do asociatívneho poľa, v ktorom bude každý kľúč názvom stĺpca a každá hodnota bude predstavovať konkrétnu hodnotu v riadku:

$stmt = $pdo->query("SELECT * FROM planet"); $vysledky = $stmt->fetch(PDO::FETCH_ASSOC); Pole ( => 1 => zem => modrá)

PDO::FETCH_NUM

Pomocou konštanty PDO::FETCH_NUM dostaneme pole indexované 0:

Pole ( => 1 => zem => modrá)

PDO::FETCH_COLUMN

Táto konštanta je užitočná na získanie iba hodnôt zo stĺpca a metóda vráti všetky výsledky v jednoduchom jednorozmernom poli. Napríklad tu je žiadosť:

$stmt = $pdo->query("VYBRAŤ meno FROM planét");

Ako výsledok:

Pole ( => zem => mars => jupiter)

PDO::FETCH_KEY_PAIR

Táto konštanta je užitočná, keď potrebujete získať hodnoty z dvoch stĺpcov. Metóda fetchAll() vráti výsledky ako asociatívne pole. V tomto poli budú údaje z prvého stĺpca špecifikované vo forme kľúčov a z druhého - ako hodnoty:

$stmt = $pdo->query("VYBRAŤ meno, farbu FROM planét"); $vysledok = $stmt->fetchAll(PDO::FETCH_KEY_PAIR);

Ako výsledok:

Pole ( => modrá => červená => zvláštne)

PDO::FETCH_OBJECT

Pri použití konštanty PDO::FETCH_OBJECT sa pre každý načítaný riadok vytvorí anonymný objekt. Jeho (verejné) vlastnosti budú pomenované rovnako ako stĺpce a ako hodnoty sa použijú výsledky dotazu. Použitím tejto metódy pre rovnaký dotaz ako vyššie sa získa nasledujúci výsledok:

$vysledky = $stmt->fetch(PDO::FETCH_OBJ); objekt stdClass ( => zem => modrá)

PDO::FETCH_CLASS

Rovnako ako predchádzajúca konštanta, táto priradí hodnoty stĺpcov vlastnostiam objektu, ale v tomto prípade musíme nakonfigurovať existujúcu triedu, ktorá sa použije na vytvorenie objektu. Pre demonštráciu najprv vytvoríme triedu:

Nevenujte pozornosť jednoduchosti kódu, pozrime sa radšej na triedu Planet, ktorú sme vytvorili: má vo svojich vlastnostiach súkromnú a trieda nemá konštruktor. Teraz sa pokúsme dosiahnuť výsledky.

Pri použití funkcie fetch() s PDO::FETCH_CLASS musíte použiť metódu setFetchMode() na objekte pred pokusom o načítanie údajov, napríklad:

$stmt = $pdo->query("VYBRAŤ meno, farbu FROM planét"); $stmt->setFetchMode(PDO::FETCH_CLASS, "Planet");

Konštantu PDO::FETCH_CLASS zadáme ako prvý argument metódy setFetchMode() a názov triedy použitej na vytvorenie objektu (v našom prípade „Planet“) ako druhý argument. Teraz spustíme kód:

$planeta = $stmt->fetch();

Výsledkom by mal byť objekt planéty:

Var_dump($planeta); Planétový objekt ( => zem => modrá)

Všimnite si, ako boli hodnoty vrátené z dotazu priradené k zodpovedajúcim charakteristikám objektu, aj keď sú súkromné.

Priradenie charakteristík po vytvorení objektu

Trieda „Planet“ nemala žiadny špecifický konštruktor, takže neboli žiadne problémy s priraďovaním charakteristík; ale čo ak má trieda konštruktor, v ktorom sa nastavujú a menia charakteristiky? Keďže hodnoty sú priradené pred spustením konštruktora, budú prepísané.

PDO pomáha poskytnúť konštantu FETCH_PROPS_LATE: pri použití sa hodnoty priradia po vytvorení objektu. Príklad:

Upravili sme našu triedu Planet, aby sme vytvorili konštruktor, ktorý bude mať dva argumenty: názov názov a farbu . Tieto argumenty majú základné hodnoty mesiac a sivá, čo znamená, že ak nie sú zadané žiadne iné hodnoty, nastavia sa tieto.

V tomto prípade, ak nepoužijeme FETCH_PROPS_LATE, potom bez ohľadu na to, aké hodnoty sa získajú z databázy, všetky charakteristiky zostanú základné, pretože počas procesu vytvárania objektu budú prepísané. Ak to chcete skontrolovať, spustite nasledujúci dotaz:

$stmt = $pdo->query("SELECT meno, farba FROM solar_system WHERE name = "zem""); $stmt->setFetchMode(PDO::FETCH_CLASS, "Planet"); $planeta = $stmt->fetch();

Teraz sa pozrime na objekt Planéta a skontrolujte, ktoré hodnoty zodpovedajú jeho charakteristikám:

Var_dump($planeta); object(Planet)#2 (2) ( ["name":"Planet":private]=> string(4) "mesiac" ["color":"Planet":private]=> string(4) "grey" )

Ako sa očakávalo, hodnoty získané z databázy boli prepísané predvolenými hodnotami. Teraz ukážeme riešenie problémov pomocou konštanty FETCH_PROPS_LATE (a rovnakého dotazu ako predchádzajúci):

$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, "Planet"); $planeta = $stmt->fetch(); var_dump($planeta); object(Planet)#4 (2) ( ["name":"Planet":private]=> string(5) "earth" ["color":"Planet":private]=> string(4) "blue" )

Nakoniec sa dosiahol požadovaný výsledok. Ale čo ak konštruktor triedy nemá žiadne základné hodnoty a musia byť špecifikované? Toto je už jednoduchšie: parametre konštruktora môžeme nastaviť vo forme poľa, ako tretí argument za názvom triedy, pomocou metódy setFetchMode(). Zmeňme napríklad konštruktor:

Planéta triedy ( súkromné $meno; súkromné $farba; verejná funkcia __construct($meno, $farba) ( $this->name = $name; $this->color = $farba; ) [...] )

Argumenty konštruktora sú teraz povinné, takže spustíme:

$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, "Planéta", ["mesiac", "sivá"]);

V tomto prípade parametre, ktoré špecifikujeme, slúžia len ako základné hodnoty potrebné na to, aby objekt fungoval bez chýb: budú prepísané hodnotami z databázy.

Načítanie viacerých objektov

Je samozrejme možné získať viacero výsledkov naraz vo forme objektov, buď pomocou metódy fetch() alebo pomocou cyklu:

Kým ($planet = $stmt->fetch()) ( // Niečo spoločné s výsledkami )

Alebo získať všetky výsledky naraz. V tomto prípade, ako už bolo spomenuté vyššie, pri použití metódy fetchAll() budete musieť zadať režim načítania nie pred spustením metódy, ale v momente, keď sa spustí:

$stmt->fetchAll(PDO::FETCH_CLASS|PDO_FETCH_PROPS_LATE, "Planéta", ["mesiac", "sivá"]);

PDO::FETCH_INTO

Pri použití tejto konštanty PDO nevytvorí nový objekt, namiesto toho aktualizuje charakteristiky existujúceho objektu, ale iba ak je verejný alebo ak sa v objekte použije metóda __set().

Pripravené na základe priamych žiadostí

PDO má dva spôsoby práce s dopytmi: pomocou priamych a spoľahlivejšieho – pripraveného.

Priame požiadavky

Existujú dve hlavné metódy na používanie priamych dotazov: query() a exec() . Prvý vytvorí objekt PDOStatemnt, ku ktorému je možné pristupovať pomocou metód fetch() alebo fetchAll(): ak ich použijete v prípadoch, keď sa tabuľka nemení, ako napríklad SELECT .

Druhá metóda namiesto toho vracia číslo riadku, ktorý bol zmenený dotazom: používame ho v prípadoch, ktoré nahrádzajú riadky, ako napríklad INSERT, DELETE alebo UPDATE. Priame dotazy by sa mali používať iba v prípadoch, keď v dotazoch nie sú žiadne premenné a nie je pochýb o bezpečnosti metódy.

Pripravené otázky

PDO podporuje aj dvojkrokové pripravené dotazy: sú užitočné, keď majú dotazy premenné, a sú vo všeobecnosti bezpečnejšie, pretože všetku potrebnú prácu urobí za nás metóda Prepare(). Pozrime sa, ako sa používajú premenné. Predstavte si, že chceme vložiť charakteristiky planéty do tabuľky Planét. Najprv si pripravíme žiadosť:

$stmt = $pdo->prepare("INSERT INTO planet(name, color) VALUES(?, ?)");

Ako už bolo spomenuté, používame metódu Prepare(), ktorá berie ako argument dotaz SQL pomocou dočasných hodnôt premenných. Dočasné hodnoty môžu byť dvoch typov: polohové a nominálne.

Pozičné

Použitím? pozičné dočasné hodnoty, kód je stručnejší, ale musíme zadať údaje, ktoré sa majú vložiť v rovnakom poradí, ako sú názvy stĺpcov v poli poskytnutom ako argument metódy execute():

$stmt->execute([$planet->name, $planet->color]);

Personalizované

Použitím pomenovaných zástupných symbolov nepotrebujeme konkrétne poradie, ale vo výsledku získame viac kódu. Keď spustíme metódu execute(), musíme dodať údaje vo forme asociatívneho poľa, kde každý kľúč je názov použitej dočasnej hodnoty a pridružená hodnota je to, čo sa prenáša do dotazu. Napríklad predchádzajúca žiadosť by bola:

$stmt = $pdo->prepare("INSERT INTO planet(name, color) VALUES(:name, :color)"); $stmt->execute(["meno" => $planéta->názov, "farba" => $planéta->farba]);

Metódy pripraviť() a spustiť() je možné použiť pre dotazy, ktoré upravujú alebo jednoducho získavajú informácie z databázy. V prvom prípade používame na získanie informácií metódy fetch uvedené vyššie a v druhom prípade metódu rowCount().

metódy bindValue() a bindParam().

Metódy bindValue() a bindParam() možno použiť aj na poskytnutie hodnôt, ktoré budú vložené do požiadavky. Prvý viaže hodnotu danej premennej na pozičnú alebo pomenovanú dočasnú hodnotu použitú pri príprave požiadavky. Ak vezmeme ako príklad predchádzajúci prípad, urobíme:

$stmt->bindValue("name", $planet->name, PDO::PARAM_STR);

Hodnotu $planet->name viažeme na dočasnú hodnotu:name . Všimnite si, že pomocou metód bindValue() aj bindParam() môžeme tiež špecifikovať typ premennej ako tretí argument pomocou vhodnej konštanty PDO, v tomto prípade PDO::PARAM_STR .

Použitím bindParam() namiesto toho môžeme naviazať premennú na vhodnú dočasnú hodnotu použitú pri príprave dotazu. Všimnite si, že v tomto prípade je premenná viazaná na odkaz a jej hodnota sa zmení na dočasnú len vtedy, keď sa spustí metóda execute(). Syntax je rovnaká ako naposledy:

$stmt->bindParam("name", $planet->name, PDO::PARAM_STR)

Premennú, nie jej hodnotu, $planet->name sme naviazali na:meno ! Ako bolo uvedené vyššie, k nahradeniu dôjde iba vtedy, keď je spustená metóda execute(), takže dočasná hodnota bude v danom momente nahradená hodnotou premennej.

Transakcie s CHOP

Transakcie vám umožňujú zachovať konzistenciu pri spustení viacerých dotazov. Všetky dotazy sa vykonávajú v dávkach a aplikujú sa na databázu iba vtedy, ak sú všetky úspešné. Transakcie nebudú fungovať so všetkými databázami a nie so všetkými konštrukciami SQL, pretože niektoré z nich spôsobujú problémy.

Ako extrémny a zvláštny príklad si predstavte, že používateľ musel vybrať zoznam planét a zakaždým, keď urobil nový výber, pred vložením novej by ste museli predchádzajúcu z databázy vymazať. Čo ak k vymazaniu dôjde, ale k vloženiu nie? Získame používateľa bez planét! V zásade sa transakcie používajú takto:

V prvom rade metóda beginTransaction() na objekte PDO zakáže automatické potvrdenie požiadavky, potom sa požiadavky spúšťajú v požadovanom poradí. V tomto bode, pokiaľ sa nevyskytne výnimka PDO, požiadavky sa automaticky prenesú cez metódu commit(), inak sa transakcie zrušia pomocou metódy rollBack() a obnoví sa autocommit.

Týmto spôsobom pri viacerých požiadavkách bude vždy konzistentnosť. To je celkom zrejmé, ale transakcie PDO môže používať iba PDO::ATTR_ERRMODE nastavené na PDO::ERRMODE_EXCEPTION .

Bootstrap framework: rýchle adaptívne rozloženie

Video kurz krok za krokom o základoch adaptívneho rozloženia v rámci Bootstrap.

Naučte sa sádzať jednoducho, rýchlo a efektívne pomocou výkonného a praktického nástroja.

Rozloženie na objednávku a zaplatenie.

Bezplatný kurz „Stránka na WordPress“

Chcete ovládať WordPress CMS?

Získajte lekcie dizajnu a rozloženia webových stránok na WordPress.

Naučte sa pracovať s témami a strihať rozloženia.

Bezplatný video kurz o kreslení návrhu webu, rozložení a inštalácii na CMS WordPress!

* Ak chcete pozastaviť posúvanie, prejdite myšou.

Späť dopredu

Základy práce s rozšírením PDO

Dnes si rozoberieme veľmi zaujímavú tému – základy práce s rozšírením. CHOP pre PHP.

PDO (údajové objekty PHP)- toto je jednoducho rozhranie, ktoré vám umožňuje pracovať s rôznymi databázami bez zohľadnenia ich špecifík. Pomocou PDO môžeme jednoducho prepínať medzi rôznymi databázami a spravovať ich. Aby to bolo jasnejšie, pozrime sa na príklad.

Ako sme sa mali predtým pripojiť k databáze MySQL?

Mysql_connect($hostiteľ, $používateľ, $heslo); mysql_select_db($db);

Na pripojenie k SQLite mali sme to napísať takto:

Sqlite_open($db);

Ak potrebujeme databázu PostgreSQL, potom to musíte napísať takto:

Pg_connect("hostiteľ=$hostiteľ, názov databázy=$db, používateľ=$používateľ, heslo=$heslo");

Nie veľmi pohodlné, však? Ukazuje sa, že ak chceme zmeniť databázu, budeme musieť prerobiť veľa kódu. A tak, aby sa to vyriešilo, objavilo sa špeciálne rozšírenie PHP - CHOP.

Pozrime sa, ako sa teraz môžeme pripojiť k databáze:

$db = nové PDO("mysql:hostiteľ=$hostiteľ;dbname=$db", $user, $heslo);

$db = nove PDO("sqlite:$db);

PostgreSQL:

$db = nove PDO("pgsql:host=$host;dbname=$db", $user, $heslo);

Ako vidíte, všetko je po starom, až na spojovaciu linku. To je jediný rozdiel.

Teraz sa pozrime na to, ako sme museli vykonávať dotazy:

$sql = "INSERT INTO(meno, email) VALUES($meno, $email)"; // MySQL mysql_query($sql); // SQLite sqlite_query($sql); // PostgreSQL pg_query($sql);

Teraz môžeme abstrahovať z tohto:

// PDO $vysledok = $db->exec($sql);

Všetky! náš požiadavka bude vykonaná bez ohľadu na to, akú databázu používame a do premennej výsledok zobrazí počet ovplyvnených riadkov.

Takto však z databázy niečo nevyberieme. Na odber vzoriek musíme použiť nie exec, A dopyt.

$sql = "VYBRAŤ meno FROM užívateľov"; $vysledok = $db->dotaz($sql);

Teraz poďme Pamätajme na bezpečnosť, pretože je potrebné skontrolovať všetky údaje. Ako sme to robili predtým?

$sql = "VYBERTE * Z používateľov WHERE meno = $meno"; $name = $_POST["meno"]; // MySQL $name = mysql_real_escape_string($name); // SQLite $name = sqlite_escape_string($name); // PostgreSQL $name = pg_escape_string($name);

Teraz to už nemusíme robiť. CHOP urobí všetko za nás.

$meno = $db->quote($meno); $vysledok = $db->dotaz($sql);

Samotné PDO všetko skontroluje a spracuje prenášané údaje. Super? :) Ešte chladnejšie príde! Pokračujme.

Ako sme predtým previedli výsledok do poľa? Pozrime sa ako príklad na databázu MySQL.

$vysledok = mysql_query($sql); // Takže $riadok = mysql_fetch_assoc($vysledok); // Alebo takto... $row = mysql_fetch_array($result, FETCH_ASSOC);

Rovnako ako pri asociatívnom, môžeme získať aj očíslované pole. Teraz sa pozrime, ako sa to robí v CHOP:

$stmt = $db->query($sql); //Asociatívne $vysledok = $stmt->FETCH(PDO::FETCH_ASSOC); // Číslované $vysledok = $stmt->FETCH(PDO::FETCH_NUM); // Oba typy polí súčasne $vysledok = $stmt->FETCH(PDO::FETCH_BOTH); // Objekt $vysledok = $stmt->FETCH(PDO::FETCH_OBJ);

Je tiež veľmi jednoduché používať:

// Asociatívne echo $result["meno"]; // Číslované echo $vysledok; // Echo objektu $result->name;

Pre „lenivých“ je tu toto:

$stmt = $db->query($sql); $vysledok = $stmt->FETCH(PDO::FETCH_LAZY);

Vráti všetky 3 typy naraz. Tie. Toto FETCH_BOTH A FETCH_OBJ spolu. Ako ste možno uhádli, potom je možné k údajom pristupovať niektorým z troch spôsobov:

Echo $vysledok->meno; echo $vysledok["meno"]; echo $vysledok;

Avšak Načítať vráti iba jeden záznam, takže ak chceme získať všetky záznamy, musíme použiť FetchAll.

$stmt = $db->query("SELECT * FROM users"); $vysledok = $stmt->FetchAll(PDO::FETCH_ASSOC); foreach($result as $user) ( echo $user["meno"]."
"; }

S tým však súvisí aj ďalšia skvelá vec Načítať. S jeho pomocou môžeme naplniť našu triedu údajmi z databázy automaticky.

Class User ( verejné $ prihlásenie; verejné $ id; verejná funkcia showInfo() ( echo " ".$this->id.""." : ".$this->login."
"; ) ) $db = new PDO("mysql:host=localhost;dbname=test", "root", ""); $stmt = $db->query("SELECT * FROM `users`"); $ vysledok = $stmt->fetchAll(PDO::FETCH_CLASS, "Pouzivatel"); foreach($vysledok ako $user) ( $user->showInfo(); )

Ako vidíte, všetko je veľmi jednoduché. Potrebujeme len špecifikovať konštantu FETCH_CLASS a oddelené čiarkou v úvodzovkách, názov triedy, do ktorej budú vložené údaje.

Potom prechádzame objektom a zobrazujeme informácie, ktoré potrebujeme.
Pozor! Názvy vlastností v triede sa musia zhodovať s názvami polí v databáze.

Okrem iného môžeme vytvárať tzv pripravené otázky. Aké sú ich výhody?

1. Požiadavku môžeme pripraviť raz a potom ju spustiť toľkokrát, koľkokrát potrebujeme. A to s rovnakými aj inými parametrami.

Keď je dotaz pripravený, DBMS ho analyzuje, skompiluje a optimalizuje plán vykonávania. V prípade zložitých dotazov bude čas vykonania viditeľný, ak ho spustíme s inými parametrami. V prípade pripravených dopytov sa to robí raz, a preto sa stráca menej času.

2. Pripravené parametre dopytu nie je potrebné uvádzať v úvodzovkách, ovládač to robí automaticky. Ak aplikácia používa iba pripravené dotazy, potom sú injekcie SQL takmer nemožné.

PDO dokáže napodobniť pripravené dotazy, ak nie sú podporované ovládačom. Teraz sa pozrime na to, ako ich používať?

$stmt = $db->prepare("INSERT INTO users (meno, login) VALUES (:name, :login)"); $stmt->bindParam(":meno", $meno); $stmt->bindParam(":login", $login); // Vložte jeden riadok s týmito hodnotami $name = "vasya"; $login = "vasya123"; $stmt->execute(); // Teraz ďalší riadok s rôznymi hodnotami $name = "petya"; $login = "petya123"; $stmt->execute();

Metóda bindParam nám umožňuje nastaviť parametre. Myslím, že tu je všetko jasné. Najprv tam, kde chceme vložiť údaje, napíšeme nasledujúci riadok " :Názov". A potom označíme, odkiaľ budú pochádzať. V tomto prípade budú prevzaté z premenných názov A Prihlásiť sa.

Teraz môžeme túto požiadavku použiť s rôznymi parametrami toľkokrát, koľkokrát chceme, a na jej vykonanie musíme zavolať metódu vykonať. Títo boli pomenovaný možnosti. Je tu tiež nepomenovaný.

$stmt = $db->prepare("INSERT INTO users (meno, login) VALUES (?, ?)"); // Namiesto prvého otáznika $stmt->bindParam(1, $name) budú vložené údaje z premennej name; // Namiesto druhého otáznika budú vložené údaje z premennej login $stmt->bindParam(2, $login); // Vložte jeden riadok s týmito hodnotami $name = "vasya"; $login = "vasya123"; $stmt->execute(); // Teraz ďalší riadok s rôznymi hodnotami $name = "petya"; $login = "petya123"; $stmt->execute();

Ďalší bod - Ako zachytávame chyby?

Na to existuje trieda Výnimka PDO. Všetky požiadavky odporúčam písať do bloku Skús chytiť.

Skúste ( $db = nové PDO("myql:host=localhost;dbname=test", "root", ""); $stmt = $db->query("SELECT * FROM users"); $result = $stmt ->fetch(PDO::FETCH_ASSOC); echo $result["login"]; ) catch(PDOException $e) ( echo "Chyba: ".$e->getMessage()."
"; echo "Na riadku: ".$e->getLine(); )

Tu sme urobili chybu a napísali myql namiesto mysql. A trieda Výnimka PDO nám o tom napíše.

Má viacero metód, no najčastejšie používané sú getMessage() ktorý nám vráti chybový text a getLine(), ktorý vráti číslo riadku, kde sa vyskytla chyba.

A nakoniec, poďme si niečo povedať transakcií. Najprv dám kód.

Skúste ( $db = new PDO("mysql:host=localhost;dbname=test", "root", ""); $db->beginTransaction(); $stmt = $db->exec("INSERT INTO `users `(`login`) VALUES("login1")"); $stmt = $db->exec("INSERT INTO `users`(`login`) VALUES("login2")"); $stmt = $db- >exec("INSERT INTO `users`(`login`) VALUES("login3")"); $db->commit(); ) catch(PDOException $e) ( $db->rollBack(); )

Tu začneme transakciu pomocou metódy beginTransaction(). Ďalej prichádza nejaký kód dotazu. Potom zavoláme metódu zaviazať() na potvrdenie našich zmien. Ak sa niečo pokazí, tak v bloku chytiť nazývame metódu vrátiť späť (), ktorý vráti všetky naše údaje do predchádzajúceho stavu.

"Prečo sú tieto transakcie vlastne potrebné?" - pýtaš sa. Ak chcete odpovedať na túto otázku, zvážte príklad, ktorý som uviedol vyššie. Tam vložíte hodnotu do poľa "login". login1, login2, login3.

Predstavme si to po vložení prihlásenie1 A prihlásenie 2, vyskytla sa nejaká chyba. Ukazuje sa, že tieto údaje sú vložené a prihlásenie 3- Nie. V mnohých prípadoch je to neprijateľné a v budúcnosti to preruší aplikáciu.

Práve na predchádzanie takýmto situáciám sú potrebné transakcie. Ak zlyhá náš skript, potom metóda vrátiť späť () vráti všetko do pôvodnej podoby. Tie. prihlásenie1 A prihlásenie 2 tiež nebudú vložené. Poďme napodobniť túto chybu.

Skúste ( $db = new PDO("mysql:host=localhost;dbname=test", "root", ""); $db->beginTransaction(); $stmt = $db->exec("INSERT INTO `users `(`login`) VALUES("login1")"); $stmt = $db->exec("INSERT INTO `users`(`login`) VALUES("login2")"); exit("error") ; $stmt = $db->exec("INSERT INTO `users`(`login`) VALUES("login3")"); $db->commit(); ) catch(PDOException $e) ( $db-> vrátiť späť (); )

Po vložení prihlásenie1 A prihlásenie 2 pomocou funkcie ukončíme skript VÝCHOD(). Vyhodíme výnimku, skončíme v bloku chytiť a potom všetko vrátime do pôvodnej podoby. Teraz, keď sa pozrieme do databázy, tam už neuvidíme prihlásenie1 A prihlásenie 2.

V tomto bode skončíme. Je zrejmé, že tu sme nepokryli všetko, čo nám PDO poskytuje, ale naučili sme sa základy práce s ním. Podrobnejšie informácie o tomto rozšírení vždy nájdete na oficiálnej stránke PHP.

Materiál špeciálne pre web pripravil Vladislav Andreev

P.S. Chcete sa posunúť ďalej v ovládaní PHP a OOP? Venujte pozornosť prémiovým lekciám o rôznych aspektoch tvorby webových stránok, vrátane programovania v PHP, ako aj bezplatnému kurzu vytvárania vlastného CMS systému v PHP od nuly pomocou OOP:

Páčil sa vám materiál a chcete sa mi poďakovať?
Stačí zdieľať so svojimi priateľmi a kolegami!