Share
Många exempel från robotar till cyklar har erbjudits som "enkla" förklaringar på vad OOP är. Jag har valt att visa dig hur OOP fungerar med ett verkligt exempel, för en programmerare. Genom att skapa en MySQL CRUD-klass kan du enkelt skapa, läsa, uppdatera och radera poster i något av dina projekt, oavsett hur databasen är utformad.
Att skapa skelett i vår klass är ganska enkelt när vi räknar ut exakt vad vi behöver. Först måste vi se till att vi kan göra våra grundläggande MySQL-funktioner. För att kunna göra detta behöver vi följande funktioner:
De verkar ganska grundläggande, men jag är säker på att när vi går igenom märker vi att många använder vissa liknande aspekter, så vi kanske måste skapa fler klasser. Här är vad din klassdefinition ska se ut. Observera att jag såg till att metoderna skapades med det offentliga sökordet.
klassen databas public function connect () public function disconnect () allmän funktion välj () public function insert () offentlig funktion radera () public function update ()
Denna funktion kommer att vara ganska grundläggande, men skapa det kommer att kräva att vi först skapar några variabler. Eftersom vi vill se till att de inte kan nås utanför vår klass, kommer vi att ställa dem som privata. Dessa variabler kommer att användas för att lagra värd, användarnamn, lösenord och databas för anslutningen. Eftersom de ganska mycket kommer att vara konstanta hela, behöver vi inte ens skapa modifierings- eller accessor-metoder för den. Därefter behöver vi bara skapa ett enkelt mysql-uttalande för att ansluta till databasen. Naturligtvis, eftersom vi som programmerare alltid måste anta att användaren (även om det är oss) kommer att göra någonting dumt, kan vi lägga till ett extra försiktighetsslag. Vi kan kontrollera om användaren faktiskt har anslutit sig till databasen först, och om de har det finns det verkligen inget behov av att återansluta. Om de inte har det kan vi använda deras referenser för att ansluta.
privat db_host = "; privat db_user ="; privat db_pass = "; privat db_name ="; public function connect () if (! $ this-> con) $ myconn = @mysql_connect ($ this-> db_host, $ this-> db_user, $ this-> db_pass); om ($ myconn) $ seldb = @mysql_select_db ($ this-> db_name, $ myconn); om ($ seldb) $ this-> con = true; återvänd sant; annars return false; annars return false; annars return true;
Som du kan se använder den några grundläggande mysql-funktioner och lite felkontroll för att se till att sakerna går enligt planen. Om den ansluts till databasen med framgång kommer den att returneras sant, och om inte, kommer den att returnera false. Som en tilläggsbonus kommer även inställningsvariabeln att vara sann om anslutningen slutfördes.
Denna funktion kommer helt enkelt att kontrollera vår anslutningsvariabel för att se om den är satt till true. Om det är, betyder det att det är anslutet till databasen, och vårt skript kommer att koppla från och returnera sant. Om inte, då är det verkligen inget behov av att göra någonting alls.
public function disconnect () if ($ this-> con) if (@mysql_close ()) $ this-> con = false; återvänd sant; annars return false;
Det här är den första funktionen där saker börjar bli lite komplicerade. Nu kommer vi att hantera användarargument och returnera resultaten korrekt. Eftersom vi inte nödvändigtvis vill kunna använda resultaten direkt kommer vi också att introducera en ny variabel som kallas resultat, vilket kommer att lagra resultaten korrekt. Bortsett från det kommer vi också att skapa en ny funktion som kontrollerar för att se om ett visst bord finns i databasen. Eftersom alla våra CRUD-operationer kräver detta, är det mer meningsfullt att skapa det separat än att integrera det i funktionen. På det sättet sparar vi plats i vår kod och vi kan sålunda bättre optimera saker senare. Innan vi går in i själva valda uttalandet, här är tabellenExists-funktionen och den privata resultatvariabeln.
Accentsconagua
privat $ result = array (); privatfunktionstabellenExister ($ tabell) $ tablesInDb = @mysql_query ('SHOW TABLES FROM'. $ this-> db_name. 'LIKE' '. $ tabell.' ''); om ($ tablesInDb) if (mysql_num_rows ($ tablesInDb) == 1) return true; annars return false; Den här funktionen kontrollerar bara databasen för att se om den önskade tabellen redan finns. Om det gör det kommer det tillbaka sant och om inte, kommer det att returnera falskt.
public function select ($ tabell, $ rader = '*', $ where = null, $ order = null) $ q = 'SELECT'. $ rader. ' FRÅN '. $ Tabell; om ($ var! = null) $ q. = 'VAR'. $ where; om ($ order! = null) $ q. = 'ORDER BY'. $ order; om ($ this-> tableExists ($ table)) $ query = @mysql_query ($ q); om ($ query) $ this-> numResults = mysql_num_rows ($ query); för ($ i = 0; $ i < $this->numResults; $ i ++) $ r = mysql_fetch_array ($ query); $ key = array_keys ($ r); för ($ 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]]; annars om (mysql_num_rows ($ query) < 1) $this->resultat = null; annars $ this-> result [$ key [$ x]] = $ r [$ key [$ x]]; returnera sant; annars return false; returnera annars falskt;
Även om det verkar lite läskigt vid första anblicken, gör den här funktionen verkligen en hel massa saker. Först accepterar det 4 argument, varav 1 krävs. Tabellnamnet är det enda som du måste överföra till funktionen för att få resultat tillbaka. Men om du vill anpassa det lite mer kan du göra det genom att lägga till vilka rader som ska dras från databasen, och du kan till och med lägga till en var och en orderklausul. Självklart, så länge du passerar det första värdet, kommer resultatet som standard till de förinställda, så du behöver inte oroa dig för att ställa in dem alla. Biten av kod direkt efter argumenten tjänar bara till att kompilera alla våra argument till ett valt uttalande. När det är klart görs en kontroll för att se om tabellen existerar, med vår tidigare tableExists-funktion. Om den existerar fortsätter funktionen och frågan utförs. Om inte, kommer det att misslyckas.
Nästa avsnitt är den riktiga magiken i koden. Vad det gör är att samla de kolumner och data som begärdes från databasen. Det tilldelar sedan det till vår resultatvariabel. För att göra det enklare för slutanvändaren, istället för att automatiskt öka inkommande numeriska nycklar, används namnen på kolumnerna. Om du får mer än ett resultat sparas varje rad som returneras lagras med en tvådimensionell matris, med den första nyckeln numerisk och automatisk inkrementerande och den andra nyckeln är namnet på kolumnen. Om bara ett resultat returneras, skapas en endimensionell grupp med nycklarna som är kolumnerna. Om inga resultat väntas är resultatvariabeln inställd på null. Som jag sa tidigare verkar det lite förvirrande, men när du bryter saker ner i sina enskilda sektioner kan du se att de är ganska enkla och raka.
Denna funktion är mycket enklare än vår tidigare. Det tillåter oss helt enkelt att infoga information i databasen. Som sådan kommer vi att kräva ytterligare ett argument till namnet på bordet. Vi kommer att kräva en variabel som motsvarar de värden vi vill skriva in. Vi kan helt enkelt skilja varje värde med ett kommatecken. Då är allt vi behöver göra snabbt att kontrollera om vårt bordExisterar, och sedan bygga in satsen uttalandet genom att manipulera våra argument för att bilda en insats uttalande. Då kör vi bara vår fråga.
public function insert ($ table, $ värden, $ rader = null) if ($ this-> tableExists ($ table)) $ insert = 'INSERT INTO'. om ($ rader! = null) $ insert. = '('. $ rader. ')'; för ($ 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; Som du kan se är den här funktionen mycket enklare än vårt ganska komplicerade valda uttalande. Vår raderingsfunktion blir faktiskt ännu enklare.
Den här funktionen raderar helt enkelt antingen en tabell eller en rad från vår databas. Som sådan måste vi skicka tabellnamnet och en valfri varuklausul. Var-klausulen kommer att meddela om vi behöver radera en rad eller hela tabellen. Om var klausulen är godkänd betyder det att poster som matchar måste raderas. När vi har redogjort för allt det här handlar det bara om att sammanställa vårt raderingsförklaring och köra frågan.
public function delete ($ table, $ where = null) if ($ this-> tableExists ($ table)) if ($ where == null) $ delete = 'DELETE' else $ delete = 'DELETE FROM'. $ tabell. ' Var ". $ Var; $ del = @mysql_query ($ delete); om ($ del) return true; annars return false; annars return false;
Och äntligen kommer vi till vår senaste stora funktion. Den här funktionen tjänar bara för att uppdatera en rad i databasen med ny information. Men på grund av den något mer komplexa naturen kommer den att komma ut som lite större och oändligt mer förvirrande. Frykt aldrig, det följer mycket av samma mönster av vår tidigare funktion. Först kommer det att använda våra argument för att skapa en uppdatering. Det fortsätter sedan för att kontrollera databasen för att försäkra sig om att tableExists. Om det existerar kommer det helt enkelt att uppdatera den rätta raden. Den svåra delen kommer givetvis när vi försöker skapa uppdateringsuppsättningen. Eftersom uppdateringsutlåtandet innehåller regler för uppdatering av flera poster (IE - olika kolumner i samma rad via listig användning av komma), måste vi ta hänsyn till detta och skapa ett sätt att hantera det. Jag har valt att passera var-klausulen som en enda grupp. Det första elementet i matrisen kommer att vara namnet på kolumnen som uppdateras, och nästa blir värdet av kolumnen. På så sätt blir varje jämnt tal (inklusive 0) kolonnnamnet, och varje udda nummer blir det nya värdet. Koden för att utföra detta är mycket enkelt och presenteras nedanför utanför funktionen:
för ($ 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];
Nästa avsnitt kommer att skapa den del av uppdateringsuppsättningen som handlar om att faktiskt ställa in variablerna. Eftersom du kan ändra ett antal värden valde jag att gå med en array där nyckeln är kolumnen och värdet är det nya värdet av kolumnen. På så sätt kan vi till och med göra en check för att se hur många olika värden som har gått för att uppdateras och kan lägga till kommatecken på lämpligt sätt.
$ keys = array_keys ($ rader); för ($ 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 när vi har dessa två bitar av logik ur vägen, är resten av uppdateringsutlåtandet lätt. Här presenteras det nedan:
Uppdatering av offentliga funktioner ($ tabell, $ rader, $ var) if ($ this-> tableExists ($ table)) // Parsa var värdena // jämnvärden (inklusive 0) innehåller var raden // udda värden innehåller klausulerna för raden för ($ 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 när vi har det vi har slutfört vår senaste funktion är vårt enkla CRUD-gränssnitt för MySQL komplett. Nu kan du skapa nya poster, läsa specifika poster från databasen, uppdatera poster och radera saker. Också, skapa och återanvända den här klassen hittar du att du sparar dig mycket tid och kodning. Åh, skönheten i objektorienterad programmering.
Så vi har gjort vår klass alla, men hur använder vi den? Den här delen är enkel. Låt oss börja med att skapa en mycket enkel systemdatabas att använda i våra test. Jag skapade en databas som heter test, och körde sedan MySQL-kontot. Du kan placera den i en databas som du vill, bara se till att du ändrar anslutningsvariablerna längst upp i manuset för att matcha:
Den första raden kommenteras helt enkelt för att inte alla kommer att behöva det. Om du behöver springa det mer än en gång måste du komma undan det för andra gången för att säkerställa att det skapar bordet.
Nu när vårt bord är skapat och befolket, är det dags att springa några enkla frågor på den.
ansluta(); $ DB> välj (mysqlcrud '); $ res = $ db-> getResult (); print_r ($ res); ?>
Om det görs korrekt bör du se följande:
På samma sätt kan vi gå ett steg längre och köra en uppdateringsfråga och sedan utföra resultaten:
uppdatering ( 'mysqlcrud', array ( 'name' => 'Ändrad!'), array ( 'id', 1)); $ DB> uppdatering ( 'mysqlcrud', array ( 'name' => 'Changed2!'), Array ( 'id', 2)); $ res = $ db-> getResult (); print_r ($ res); ?>
Vi borde se detta
Nu för ett enkelt inläggsförklaring:
;infoga ('mysqlcrud', array (3, "Name 4", "[email protected]")); $ res = $ db-> getResult (); print_r ($ res); ?> 
