Share
Talloze voorbeelden van robots tot fietsen zijn aangeboden als "eenvoudige" uitleg over wat OOP is. Ik heb ervoor gekozen om u te laten zien hoe OOP werkt met een realistisch voorbeeld, voor een programmeur. Door een MySQL CRUD-klasse te maken, kunt u gemakkelijk ingangen in een van uw projecten maken, lezen, bijwerken en verwijderen, ongeacht hoe de database is ontworpen.
Het skelet van onze klas opzetten is vrij eenvoudig als we erachter komen wat we precies nodig hebben. Eerst moeten we ervoor zorgen dat we onze basis MySQL-functies kunnen uitvoeren. Om dit te doen, hebben we de volgende functies nodig:
Die lijken vrij eenvoudig, maar ik ben er zeker van dat als we doorgaan, we zullen merken dat veel van hen een aantal soortgelijke aspecten gebruiken, dus we moeten misschien meer klassen maken. Hier is hoe uw klassendefinitie eruit zou moeten zien. Merk op dat ik ervoor zorgde dat de methoden werden gemaakt met het openbare sleutelwoord.
class Database public function connect () public function disconnect () openbare functie selecteren () public function insert () public function delete () public function update ()
Deze functie is vrij eenvoudig, maar voor het maken hiervan moeten we eerst een paar variabelen maken. Omdat we ervoor willen zorgen dat ze niet van buiten onze klas toegankelijk zijn, zullen we ze als privé plaatsen. Deze variabelen worden gebruikt om de host, gebruikersnaam, wachtwoord en database voor de verbinding op te slaan. Omdat ze vrijwel constant blijven, hoeven we daarvoor zelfs geen modifier- of accessor-methoden te maken. Daarna zouden we gewoon een eenvoudige mysql-instructie moeten maken om verbinding te maken met de database. Natuurlijk, omdat we als programmeurs altijd moeten aannemen dat de gebruiker (zelfs als wij het zijn) iets stoms doet, laten we een extra laagje voorzorg toevoegen. We kunnen eerst controleren of de gebruiker daadwerkelijk verbinding met de database heeft gemaakt en als dat het geval is, is er echt geen behoefte om opnieuw verbinding te maken. Als dat niet het geval is, kunnen we hun inloggegevens gebruiken om verbinding te maken.
private db_host = "; private db_user ="; private db_pass = "; private db_name ="; public function connect () if (! $ this-> con) $ myconn = @mysql_connect ($ this-> db_host, $ this-> db_user, $ this-> db_pass); if ($ myconn) $ seldb = @ mysql_select_db ($ this-> db_name, $ myconn); if ($ seldb) $ this-> con = true; geef waar terug; else return false; else return false; else return true;
Zoals je kunt zien, maakt het gebruik van enkele basis mysql-functies en een beetje foutcontrole om er zeker van te zijn dat alles volgens plan verloopt. Als het een verbinding met de database tot stand brengt, wordt true geretourneerd en als dit niet het geval is, wordt false geretourneerd. Als een toegevoegde bonus wordt ook de verbindingsvariabele ingesteld op true als de verbinding met succes is voltooid.
Deze functie controleert eenvoudig onze verbindingsvariabele om te zien of deze op true is ingesteld. Als dat het geval is, betekent dit dat het verbonden is met de database en ons script zal de verbinding verbreken en waar retourneren. Zo niet, dan is er helemaal geen behoefte om iets te doen.
public function disconnect () if ($ this-> con) if (@mysql_close ()) $ this-> con = false; geef waar terug; else return false;
Dit is de eerste functie waar dingen een beetje ingewikkeld beginnen te worden. Nu zullen we te maken krijgen met gebruikersargumenten en de resultaten op de juiste manier retourneren. Omdat we niet per se meteen de resultaten willen kunnen gebruiken, introduceren we ook een nieuwe variabele met de naam resultaat, die de resultaten op de juiste manier opslaat. Afgezien daarvan gaan we ook een nieuwe functie maken die controleert of een bepaalde tabel in de database bestaat. Omdat al onze CRUD-bewerkingen dit vereisen, is het logischer om deze afzonderlijk te maken in plaats van deze in de functie te integreren. Op deze manier besparen we ruimte in onze code en kunnen we de dingen later beter optimaliseren. Voordat we ingaan op de werkelijke select-instructie, is hier de functie tableExists en de variabele privéresultaten.
Accentsconagua
privé $ resultaat = array (); private function tableExists ($ table) $ tablesInDb = @ mysql_query ('TOON TABELLEN VAN'. $ this-> db_name. 'LIKE "'. $ table. '"'); if ($ tablesInDb) if (mysql_num_rows ($ tablesInDb) == 1) return true; else return false; Deze functie controleert eenvoudig de database om te zien of de vereiste tabel al bestaat. Als dit het doet, zal het waar teruggeven en zo niet, dan zal het false opleveren.
openbare functie selecteren ($ table, $ rows = '*', $ where = null, $ order = null) $ q = 'SELECT'. $ rows. ' FROM '. $ Tabel; if ($ where! = null) $ q. = 'WHERE'. $ where; if ($ order! = null) $ q. = 'ORDER BY'. $ order; if ($ this-> tableExists ($ table)) $ query = @ mysql_query ($ q); if ($ query) $ this-> numResults = mysql_num_rows ($ query); voor ($ i = 0; $ i < $this->numResults; $ i ++) $ r = mysql_fetch_array ($ query); $ key = array_keys ($ r); voor ($ 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-> result [$ i] [$ key [$ x]] = $ r [$ key [$ x]]; else if (mysql_num_rows ($ query) < 1) $this->resultaat = null; anders $ this-> result [$ key [$ x]] = $ r [$ key [$ x]]; return true; else return false; else return false;
Hoewel het op het eerste gezicht een beetje eng lijkt, doet deze functie echt heel veel dingen. Ten eerste accepteert het 4 argumenten, waarvan er 1 is vereist. De tabelnaam is het enige dat u moet doorgeven aan de functie om resultaten terug te krijgen. Als u het echter wat meer wilt aanpassen, kunt u dit doen door toe te voegen welke rijen uit de database worden getrokken en u kunt zelfs een Where & Order-clausule toevoegen. Natuurlijk, zolang u de eerste waarde doorgeeft, zal het resultaat standaard de standaardwaarden zijn, dus u hoeft zich geen zorgen te maken over het instellen van alle waarden. Het stukje code direct na de argumenten dient alleen om al onze argumenten in een select statement samen te vatten. Zodra dat is gebeurd, wordt er een controle uitgevoerd om te zien of de tabel bestaat, met behulp van onze vorige tableExists-functie. Als het bestaat, gaat de functie verder en wordt de query uitgevoerd. Zo niet, dan mislukt het.
Het volgende gedeelte is de echte magie van de code. Wat het doet is de kolommen en gegevens verzamelen die uit de database zijn opgevraagd. Vervolgens wordt deze toegewezen aan onze resultaatvariabele. Om het echter gemakkelijker te maken voor de eindgebruiker, worden in plaats van de numerieke toetsen automatisch verhoogd, de namen van de kolommen gebruikt. Als u meer dan één resultaat krijgt, wordt elke rij die wordt geretourneerd, opgeslagen met een tweedimensionale array, waarbij de eerste sleutel numeriek en automatisch incrementeel is en de tweede sleutel de naam van de kolom is. Als slechts één resultaat wordt geretourneerd, wordt een eendimensionale array gemaakt met de sleutels als de kolommen. Als er geen resultaten worden omgezet, wordt de resultaatvariabele ingesteld op nul. Zoals ik al eerder zei, lijkt het een beetje verwarrend, maar als je eenmaal de dingen hebt opgedeeld in hun afzonderlijke secties, zie je dat ze vrij eenvoudig en duidelijk zijn.
Deze functie is een stuk eenvoudiger dan onze vorige. Het stelt ons eenvoudig in staat om informatie in de database in te voegen. Als zodanig hebben we een extra argument nodig voor de naam van de tabel. We hebben een variabele nodig die overeenkomt met de waarden die we willen invoeren. We kunnen eenvoudig elke waarde scheiden met een komma. Vervolgens is alles wat we moeten doen snel te controleren om te zien of onze tableExists, en vervolgens de insert-instructie te bouwen door onze argumenten te manipuleren om een invoeginstructie te vormen. Vervolgens voeren we onze vraag uit.
public function insert ($ table, $ values, $ rows = null) if ($ this-> tableExists ($ table)) $ insert = 'INSERT INTO'. $ table; if ($ rows! = null) $ insert. = '('. $ rows. ')'; voor ($ 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; Zoals u kunt zien, is deze functie een stuk eenvoudiger dan onze vrij complexe select-instructie. Onze verwijderfunctie zal zelfs nog eenvoudiger zijn.
Deze functie verwijdert eenvoudig een tabel of een rij uit onze database. Als zodanig moeten we de tabelnaam en een optionele Where-component doorgeven. De where-component laat het ons weten als we een rij of de hele tabel moeten verwijderen. Als de Where-component wordt gepasseerd, betekent dit dat items die overeenkomen, moeten worden verwijderd. Nadat we dat allemaal hebben ontdekt, is het gewoon een kwestie van het samenstellen van onze verwijderinstructie en het uitvoeren van de query.
openbare functie verwijderen ($ table, $ where = null) if ($ this-> tableExists ($ table)) if ($ where == null) $ delete = 'DELETE'. $ table; else $ delete = 'DELETE FROM'. $ table. ' WAAR '. $ Waar; $ del = @mysql_query ($ delete); if ($ del) return true; else return false; else return false;
En uiteindelijk komen we bij onze laatste belangrijke functie. Deze functie dient eenvoudig om een rij in de database bij te werken met wat nieuwe informatie. Vanwege de iets complexere aard ervan, zal het echter iets groter en oneindig veel verwarrender worden. Nooit vrezen, het volgt veel van hetzelfde patroon van onze vorige functie. Eerst worden onze argumenten gebruikt om een updateverklaring te maken. Vervolgens wordt de database gecontroleerd om er zeker van te zijn dat de tabel bestaat. Als het bestaat, zal het gewoon de juiste rij bijwerken. Het harde deel komt natuurlijk als we proberen de update-instructie te maken. Omdat de update-instructie regels bevat voor het bijwerken van meerdere items (IE - verschillende kolommen in dezelfde rij via het sluwe gebruik van komma's), moeten we hiermee rekening houden en een manier creëren om ermee om te gaan. Ik heb ervoor gekozen de Where-component als een enkele array door te geven. Het eerste element in de array is de naam van de kolom die wordt bijgewerkt en de volgende kolom is de waarde van de kolom. Op deze manier is elk even getal (inclusief 0) de kolomnaam en elk oneven getal de nieuwe waarde. De code om dit uit te voeren is heel eenvoudig en wordt hieronder gepresenteerd buiten de functie:
voor ($ 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];
In de volgende sectie wordt het gedeelte van de update-instructie gemaakt dat handelt over het feitelijk instellen van de variabelen. Aangezien u elk aantal waarden kunt wijzigen, heb ik ervoor gekozen om te gaan met een array waarbij de sleutel de kolom is en de waarde de nieuwe waarde van de kolom is. Op deze manier kunnen we zelfs een controle uitvoeren om te zien hoeveel verschillende waarden zijn doorgegeven om te worden bijgewerkt en kunnen komma's op de juiste manier worden toegevoegd.
$ keys = array_keys ($ rijen); voor ($ 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 .= ',';
Nu we die twee stukjes logica uit de weg hebben geruimd, is de rest van de updateverklaring eenvoudig. Hier wordt het hieronder gepresenteerd:
update van openbare functies ($ tabel, $ rijen, $ waar) if ($ this-> tableExists ($ tabel)) // De waar-waarden parseren // even waarden (inclusief 0) bevatten de where-rijen // oneven waarden bevatten de clausules voor de rij voor ($ 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; Nu we hebben dat we onze laatste functie hebben voltooid, is onze eenvoudige CRUD-interface voor MySQL compleet. U kunt nu nieuwe items maken, specifieke vermeldingen uit de database lezen, items bijwerken en items verwijderen. Als je deze les maakt en opnieuw gebruikt, zul je merken dat je jezelf veel tijd en codering bespaart. Ah, de schoonheid van objectgeoriënteerd programmeren.
Dus we hebben onze les helemaal gemaakt, maar hoe gebruiken we die? Dit deel is eenvoudig. Laten we beginnen met het creëren van een zeer eenvoudige systeemdatabase om te gebruiken in onze testen. Ik heb een database gemaakt met de naam test en heb vervolgens de MySQL-codering uitgevoerd. U kunt het in elke gewenste database plaatsen, zorg er alleen voor dat u de verbindingsvariabelen bovenaan het script aanpast:
De eerste regel is becommentarieerd omdat niet iedereen het nodig heeft. Als u dat meer dan eens moet uitvoeren, moet u het de tweede keer uncommenteren om ervoor te zorgen dat het de tabel maakt.
Nu onze tabel is gemaakt en gevuld, is het tijd om een paar eenvoudige query's uit te voeren.
aansluiten(); $ Db-> selecteer ( 'mysqlcrud'); $ res = $ db-> getResult (); print_r ($ res); ?>
Als het goed is gedaan, ziet u het volgende:
Op dezelfde manier kunnen we een stap verder gaan en een update-query uitvoeren en vervolgens de resultaten weergeven:
Update ( 'mysqlcrud', array ( 'name' => 'Changed!'), array ( 'id', 1)); $ Db->-update ( 'mysqlcrud', array ( 'name' => 'Changed2!'), Array ( 'id', 2)); $ res = $ db-> getResult (); print_r ($ res); ?>
We zouden dit moeten zien
Nu voor een eenvoudige invoeginstructie:
;insert ('mysqlcrud', array (3, "Name 4", "[email protected]")); $ res = $ db-> getResult (); print_r ($ res); ?> 
