Share
Numeroase exemple de la roboți la biciclete au fost oferite ca explicații "ușoare" despre ceea ce este POR. Am ales să vă arăt cum funcționează OOP cu un exemplu din viața reală, pentru un programator. Creând o clasă MySQL CRUD puteți crea, citi, actualiza și șterge cu ușurință intrări în oricare dintre proiectele dvs., indiferent de modul în care este proiectată baza de date.
Configurarea scheletului clasei noastre este destul de simplă odată ce ne dăm seama exact de ce avem nevoie. Mai întâi trebuie să ne asigurăm că putem să ne facem funcțiile MySQL de bază. Pentru a face acest lucru, avem nevoie de următoarele funcții:
Acestea par destul de fundamentale, dar sunt sigur că, pe măsură ce vom trece prin noi, vom observa că mulți dintre ei folosesc câteva aspecte similare, așa că este posibil să fie nevoie să creăm mai multe clase. Iată ce ar trebui să arate definiția dvs. de clasă. Observați că m-am asigurat că metodele au fost create cu ajutorul cuvântului cheie public.
() public funcția de deconectare () funcția publică selectați () funcția publică inserați () funcția publică șterge () actualizarea funcției publice ()
Această funcție va fi destul de fundamentală, însă crearea acesteia va necesita crearea mai multor variabile. Deoarece vrem să ne asigurăm că nu pot fi accesați din afara clasei noastre, le vom stabili ca private. Aceste variabile vor fi utilizate pentru a stoca gazda, numele de utilizator, parola și baza de date pentru conexiune. Din moment ce acestea vor rămâne destul de constante pe tot parcursul anului, nu trebuie nici măcar să creăm metode de modificare sau de accesare a acestora. După aceea, ar trebui să creați o declarație simplă mysql pentru a vă conecta la baza de date. Desigur, deoarece, în calitate de programatori, trebuie să presupunem întotdeauna că utilizatorul (chiar dacă noi suntem) va face ceva stupid, vă permite să adăugați un strat suplimentar de precauție. Putem verifica dacă utilizatorul sa conectat la baza de date, iar dacă există, nu este nevoie de re-conectare. Dacă nu au atunci, putem folosi datele de conectare pentru a le conecta.
privat db_host = "; privat db_user ="; privat db_pass = "; privat db_name ="; funcția publică () if (! $ this-> con) $ myconn = @mysql_connect ($ this-> db_host, $ this-> db_user, $ this-> db_pass); dacă ($ myconn) $ seldb = @mysql_select_db ($ this-> db_name, $ myconn); dacă ($ seldb) $ this-> con = adevărat; return true; altfel return false; altfel return false; altceva return true;
După cum puteți vedea, acesta face uz de câteva funcții mysql de bază și un pic de eroare de verificare pentru a vă asigura că lucrurile se întâmplă în conformitate cu planul. Dacă se conectează cu succes la baza de date, aceasta va reveni la adevărat, iar dacă nu, va reveni fals. Ca bonus, acesta va seta, de asemenea, variabila de conexiune la true dacă conexiunea a fost finalizată cu succes.
Această funcție va verifica pur și simplu variabila de conectare pentru a vedea dacă este setată la true. Dacă este, înseamnă că este conectat la baza de date, iar scriptul nostru se va deconecta și va reveni la adevărat. Dacă nu, atunci într-adevăr nu este nevoie să faceți nimic deloc.
funcția publică deconectare () if ($ this-> con) if (@mysql_close ()) $ this-> con = false; return true; altfel return false;
Aceasta este prima funcție în care lucrurile încep să devină puțin complicate. Acum ne vom ocupa de argumentele utilizatorilor și vom întoarce rezultatele în mod corespunzător. Deoarece nu dorim neapărat să putem folosi rezultatele imediat, vom introduce, de asemenea, o nouă variabilă numită rezultat, care va stoca rezultatele în mod corespunzător. În afară de aceasta, vom crea, de asemenea, o nouă funcție care verifică dacă există o anumită tabelă în baza de date. Deoarece toate operațiile noastre CRUD vor necesita acest lucru, este mai logic să o creezi separat decât să o integrezi în funcție. În acest fel, vom economisi spațiu în codul nostru și, ca atare, vom putea optimiza mai bine lucrurile mai târziu. Înainte de a intra în instrucțiunea real select, aici este funcția tableExists și variabila privată de rezultate.
Accentsconagua
privat $ result = array (); tabelul funcțiilor privateExistă ($ table) $ tablesInDb = @mysql_query ('SHOW TABLES FROM'. $ this-> db_name 'LIKE' '. $ table.' ''); dacă ($ tablesInDb) if (mysql_num_rows ($ tablesInDb) == 1) return true; altfel return false; Această funcție verifică pur și simplu baza de date pentru a vedea dacă există deja tabelul necesar. În cazul în care se va întoarce adevărat și dacă nu, va reveni false.
funcția publică selectați ($ table, $ rows = '*', $ unde = null, $ order = null) $ q = 'SELECT'. Din tabelul $. dacă ($ unde! = null) $ q. = 'WHERE'. $ unde; dacă ($ ordine! = null) $ q. = 'ORDER BY'. comanda $; dacă ($ this-> tableExists ($ table)) $ query = @mysql_query ($ q); dacă ($ interogare) $ this-> numResults = mysql_num_rows ($ query); pentru ($ i = 0; $ i < $this->numResults; $ i + +) $ r = mysql_fetch_array ($ interogare); $ cheie = array_keys ($ r); pentru ($ x = 0; $ x < count($key); $x++) // Sanitizes keys so only alphavalues are allowed if(!is_int($key[$x])) if(mysql_num_rows($query) > 1) $ this-> rezultat [$ i] [$ cheie [$ x]] = $ r [$ cheie [$ x]]; altfel dacă (mysql_num_rows ($ query) < 1) $this->rezultat = null; altfel $ this-> rezultat [$ key [$ x]] = $ r [$ cheie [$ x]]; return true; altfel return false; returnează altfel;
În timp ce la prima vedere pare puțin cam înfricoșător, această funcție face într-adevăr o grămadă de lucruri. În primul rând, acceptă 4 argumente, dintre care unul este necesar. Numele tabelului este singurul lucru pe care trebuie să-l transmiteți funcției pentru a obține rezultate înapoi. Cu toate acestea, dacă doriți să o particularizați un pic mai mult, puteți face acest lucru adăugând care rânduri vor fi extrase din baza de date și puteți adăuga chiar și o clauză de locație și comandă. Desigur, atâta timp cât treceți prima valoare, rezultatul va fi în mod prestabilit la cele presetate, deci nu trebuie să vă faceți griji în ceea ce privește stabilirea tuturor acestora. Bitul de cod imediat după argumente servește doar pentru a compila toate argumentele noastre într-o instrucțiune select. După ce se face acest lucru, se face o verificare pentru a vedea dacă tabela există, folosind funcția noastră exterioară de tabelExiste. Dacă există, atunci funcția continuă și interogarea este efectuată. Dacă nu, va eșua.
Următoarea secțiune este magia reală a codului. Ceea ce face este să adune coloanele și datele solicitate din baza de date. Apoi îl atribuie variabilei noastre de rezultate. Cu toate acestea, pentru a face mai ușor pentru utilizatorul final, în loc de auto-incrementarea cheilor numerice, numele de coloane sunt utilizate. În cazul în care obțineți mai mult de un rezultat, fiecare rând care este returnat este stocat cu o matrice bidimensională, prima cheie fiind numerică și incrementare automată, iar a doua cheie este numele coloanei. Dacă se întoarce doar un rezultat, atunci se creează o matrice unidimensională, cu tastele fiind coloanele. Dacă niciun rezultat nu este transformat, variabila rezultat este setată la null. Așa cum am spus mai devreme, pare puțin cam confuz, dar odată ce spargeți lucrurile în secțiunile lor individuale, puteți vedea că acestea sunt destul de simple și simple.
Această funcție este mult mai simplă decât cea precedentă. Pur și simplu ne permite să inserăm informații în baza de date. Ca atare vom cere un argument suplimentar pentru numele tabelului. Vom cere o variabilă care să corespundă valorilor pe care dorim să le input. Putem separa pur și simplu fiecare valoare cu o virgulă. Apoi, tot ce trebuie să facem este să verificăm rapid pentru a vedea dacă tabela noastrăExistă, și apoi să construim instrucțiunea insert, manipulând argumentele noastre pentru a forma o instrucțiune insert. Atunci ne-am ruga interogarea.
($ table, $ values, $ rows = null) if ($ this-> tableExists ($ table)) $ insert = 'INSERT INTO'. dacă ($ rows! = null) $ insert. = '('. $ rws. ')'; pentru ($ i = 0; $ i < count($values); $i++) if(is_string($values[$i])) $values[$i] = '"'.$values[$i].'"'; $values = implode(',',$values); $insert .= ' VALUES ('.$values.')'; $ins = @mysql_query($insert); if($ins) return true; else return false; După cum puteți vedea, această funcție este mult mai simplă decât instrucțiunea selectată destul de complexă. Funcția noastră de ștergere va fi chiar mai simplă.
Această funcție șterge pur și simplu fie un tabel, fie un rând din baza noastră de date. Ca atare, trebuie să trecem numele tabelului și o clauză opțională unde. Clauza de unde ne va anunța dacă trebuie să ștergem un rând sau întregul tabel. În cazul în care clauza de loc este trecut, înseamnă că intrările care se potrivesc va trebui să fie șterse. După ce ne gândim la toate acestea, este doar o chestiune de compilare a instrucțiunii noastre de ștergere și de rulare a interogării.
funcția publică șterge ($ table, $ where = null) if ($ this-> tableExists ($ table)) if ($ unde == null) $ delete = 'DELETE'. altceva $ delete = 'DELETE FROM'. $ table. ' WHERE '. $ Unde; $ del = @mysql_query ($ delete); dacă ($ del) return true; altfel return false; altfel return false;
Și, în sfârșit, ajungem la ultima noastră funcție majoră. Această funcție servește pur și simplu la actualizarea unui rând din baza de date cu unele informații noi. Cu toate acestea, datorită naturii sale ceva mai complexe, se va desprinde ca un pic mai mare și infinit mai confuz. Nu vă temeți niciodată, urmează mult din același model al funcției noastre anterioare. Mai întâi vom folosi argumentele noastre pentru a crea o declarație de actualizare. Acesta va continua apoi să verifice baza de date pentru a vă asigura că tabelaExistă. Dacă există, va actualiza pur și simplu rândul corespunzător. Partea greu, desigur, vine atunci când încercăm să creăm declarația de actualizare. Întrucât instrucțiunea de actualizare conține reguli pentru actualizarea cu mai multe intrări (IE - coloane diferite în același rând prin folosirea virgulei de virgulă), va trebui să luăm acest lucru în considerare și să creăm o modalitate de a face față acestei situații. Am optat să trec clauza de locație ca o singură matrice. Primul element din matrice va fi numele coloanei care este actualizată, iar următoarea va fi valoarea coloanei. În acest fel, fiecare număr par (inclusiv 0) va fi numele coloanei, iar fiecare număr impar va fi noua valoare. Codul pentru efectuarea acestui lucru este foarte simplu și este prezentat mai jos în afara funcției:
pentru ($ i = 0; $ i < count($where); $i++) if($i%2 != 0) if(is_string($where[$i])) if(($i+1) != null) $where[$i] = '"'.$where[$i].'" AND '; else $where[$i] = '"'.$where[$i].'"'; else if(($i+1) != null) $where[$i] = $where[$i]. ' AND '; else $where[$i] = $where[$i];
Următoarea secțiune va crea partea din instrucțiunea de actualizare care se referă la setarea efectivă a variabilelor. Din moment ce puteți schimba orice număr de valori, am optat pentru a merge cu un tablou în care cheia este coloana și valoarea este noua valoare a coloanei. În acest fel putem face chiar și un cec pentru a vedea câte valori diferite au fost transmise pentru a fi actualizate și puteți adăuga în mod corespunzător virgulă.
$ chei = array_keys ($ rânduri); pentru ($ i = 0; $ i < count($rows); $i++) if(is_string($rows[$keys[$i]])) $update .= $keys[$i].'="'.$rows[$keys[$i]].'"'; else $update .= $keys[$i].'='.$rows[$keys[$i]]; // Parse to add commas if($i != count($rows)-1) $update .= ',';
Acum, când le-am scăpat de cele două bucăți de logică, restul instrucțiunii de actualizare este ușor. Aici este prezentat mai jos:
($ this-> tableExists ($ table)) // Parse unde valorile // valori even (inclusiv 0) conțin unde rândurile // valori ciudate conțin ($ table, $ rows, $ unde) clauzele pentru rândul pentru ($ i = 0; $ i < count($where); $i++) if($i%2 != 0) if(is_string($where[$i])) if(($i+1) != null) $where[$i] = '"'.$where[$i].'" AND '; else $where[$i] = '"'.$where[$i].'"'; $where = implode('=',$where); $update = 'UPDATE '.$table.' SET '; $keys = array_keys($rows); for($i = 0; $i < count($rows); $i++) if(is_string($rows[$keys[$i]])) $update .= $keys[$i].'="'.$rows[$keys[$i]].'"'; else $update .= $keys[$i].'='.$rows[$keys[$i]]; // Parse to add commas if($i != count($rows)-1) $update .= ','; $update .= ' WHERE '.$where; $query = @mysql_query($update); if($query) return true; else return false; else return false; Acum, că avem că am terminat ultima noastră funcție, interfața noastră simplă CRUD pentru MySQL este completă. Acum puteți crea intrări noi, citiți intrări specifice din baza de date, actualizați intrări și ștergeți lucrurile. De asemenea, creați și reutilizați această clasă veți descoperi că economisiți mult timp și codificați. Ah, frumusețea programării orientate obiect.
Deci ne-am făcut clasa noastră, dar cum o folosim? Această parte este simplă. Să începem prin crearea unei baze de date foarte simple de sistem care să fie utilizată în testarea noastră. Am creat o bază de date numită test, apoi am rulat statutul MySQL. Puteți să-l plasați în orice bază de date care vă place, doar asigurați-vă că schimbați variabilele de conectare din partea de sus a scriptului pentru a se potrivi:
Prima linie este comentată pur și simplu pentru că nu toată lumea va avea nevoie de ea. Dacă trebuie să rulați mai mult de o dată, va trebui să o dezarhivați a doua oară pentru a vă asigura că creează tabelul.
Acum, că tabelul nostru este creat și populat, este timpul să rulați câteva întrebări simple pe el.
conectați(); $ DB> selectați ( 'mysqlcrud'); $ res = $ db-> getResult (); print_r ($ res); ?>
Dacă ați făcut corect, ar trebui să vedeți următoarele:
De asemenea, putem merge mai departe și rulați o interogare de actualizare, apoi ieșiți rezultatele:
actualizare ( 'mysqlcrud', array ( 'name' => 'schimbată!'), array ( 'id', 1)); $ DB> actualizare ( 'mysqlcrud', array ( 'name' => 'Changed2!'), Array ( 'id', 2)); $ res = $ db-> getResult (); print_r ($ res); ?>
Ar trebui să vedem asta
Acum, pentru o declarație de inserare simplă:
;inserați ("mysqlcrud", array (3, "Nume 4", "[email protected]")); $ res = $ db-> getResult (); print_r ($ res); ?> 
