Share
Numerosi esempi dai robot alle biciclette sono stati offerti come spiegazioni "facili" di ciò che è OOP. Ho scelto di mostrarti come funziona OOP con un esempio di vita reale, per un programmatore. Creando una classe CRUD MySQL puoi facilmente creare, leggere, aggiornare e cancellare le voci in qualsiasi progetto, indipendentemente da come è progettato il database.
Impostare lo scheletro della nostra classe è abbastanza semplice una volta che abbiamo capito esattamente di cosa abbiamo bisogno. Per prima cosa dobbiamo assicurarci di poter eseguire le nostre funzioni di base di MySQL. Per fare questo, abbiamo bisogno delle seguenti funzioni:
Sembrano piuttosto semplici, ma sono sicuro che mentre passiamo, noteremo che molti di loro utilizzano aspetti simili, quindi potremmo dover creare più classi. Ecco come dovrebbe apparire la tua definizione di classe. Si noti che mi sono assicurato che i metodi fossero creati con la parola chiave pubblica.
class Database public function connect () public function disconnect () public function select () public function insert () public function delete () public function update ()
Questa funzione sarà abbastanza semplice, ma la sua creazione ci richiederà di creare prima alcune variabili. Dal momento che vogliamo assicurarci che non possano essere consultati da fuori della nostra classe, li imposteranno come privati. Queste variabili verranno utilizzate per memorizzare l'host, il nome utente, la password e il database per la connessione. Dal momento che rimarranno praticamente costanti dappertutto, non abbiamo nemmeno bisogno di creare metodi di modifica o di accesso per questo. Dopodiché, dovremmo semplicemente creare una semplice istruzione mysql per connettersi al database. Naturalmente, dato che come programmatori dobbiamo sempre presumere che l'utente (anche se siamo noi) farà qualcosa di stupido, aggiungiamo un ulteriore livello di precauzione. Possiamo verificare se l'utente è effettivamente connesso al database e, in caso affermativo, non è necessario riconnettersi. Se non lo sono, possiamo usare le loro credenziali per connettersi.
private db_host = "; private db_user ="; private db_pass = "; private db_name ="; funzione pubblica 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; ritorna vero; else return false; else return false; else return true;
Come puoi vedere, fa uso di alcune funzioni base di mysql e un po 'di controllo degli errori per assicurarsi che le cose stiano andando secondo i piani. Se si collega correttamente al database, restituirà true e, in caso contrario, restituirà false. Come bonus aggiuntivo, imposta la variabile di connessione su true se la connessione è stata completata con successo.
Questa funzione controllerà semplicemente la nostra variabile di connessione per vedere se è impostata su true. Se lo è, significa che è connesso al database e il nostro script si disconnetterà e restituirà true. Se no, allora non c'è davvero bisogno di fare nulla.
public function disconnect () if ($ this-> con) if (@mysql_close ()) $ this-> con = false; ritorna vero; else return false;
Questa è la prima funzione in cui le cose cominciano a diventare un po 'complicate. Ora tratteremo argomenti utente e restituiremo i risultati correttamente. Dato che non vogliamo necessariamente essere in grado di utilizzare immediatamente i risultati, introdurremo anche una nuova variabile chiamata result, che memorizzerà i risultati correttamente. Oltre a questo, creeremo anche una nuova funzione che controlla se esiste una tabella particolare nel database. Dal momento che tutte le nostre operazioni CRUD richiedono questo, ha più senso crearlo separatamente piuttosto che integrarlo nella funzione. In questo modo, risparmieremo spazio nel nostro codice e in tal modo saremo in grado di ottimizzare meglio le cose in seguito. Prima di passare all'istruzione select effettiva, ecco la funzione tableExists e la variabile dei risultati privata.
Accentsconagua
private $ result = array (); tabella delle funzioni privateEsiste ($ table) $ tablesInDb = @mysql_query ('SHOW TABLES FROM'. $ this-> db_name. 'LIKE' '. $ table.' "''); if ($ tablesInDb) if (mysql_num_rows ($ tablesInDb) == 1) return true; else return false; Questa funzione controlla semplicemente il database per vedere se la tabella richiesta esiste già. Se lo fa, restituirà true e in caso contrario restituirà false.
funzione pubblica select ($ table, $ rows = '*', $ where = null, $ order = null) $ q = 'SELECT'. $ rows. ' DA '. $ Table; 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); per ($ i = 0; $ i < $this->numResults; $ i ++) $ r = mysql_fetch_array ($ query); $ key = array_keys ($ r); for ($ 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]]; altrimenti se (mysql_num_rows ($ query) < 1) $this->risultato = null; altrimenti $ this-> result [$ key [$ x]] = $ r [$ key [$ x]]; restituisce true; else return false; else return false;
Mentre a prima vista sembra un po 'spaventoso, questa funzione fa davvero un sacco di cose. Innanzitutto accetta 4 argomenti, 1 dei quali è richiesto. Il nome della tabella è l'unica cosa che devi passare alla funzione per ottenere i risultati. Tuttavia, se si desidera personalizzarlo un po 'di più, è possibile farlo aggiungendo quali righe verranno estratte dal database e si può anche aggiungere una clausola where and order. Ovviamente, finché si passa il primo valore, il risultato verrà automaticamente impostato su quelli preimpostati, quindi non dovrai preoccuparti di impostarli tutti. Il bit di codice subito dopo gli argomenti serve solo a compilare tutti i nostri argomenti in un'istruzione select. Fatto ciò, viene eseguito un controllo per verificare se la tabella esiste, utilizzando la nostra funzione tabellaExisters precedente. Se esiste, la funzione continua in avanti e la query viene eseguita. In caso contrario, fallirà.
La prossima sezione è la vera magia del codice. Quello che fa è raccogliere le colonne e i dati richiesti dal database. Quindi lo assegna alla nostra variabile di risultato. Tuttavia, per facilitare l'utente finale, anziché utilizzare i tasti numerici con incremento automatico, vengono utilizzati i nomi delle colonne. Nel caso in cui si ottenga più di un risultato, ogni riga restituita viene archiviata con un array bidimensionale, con la prima chiave numerata e autoincrementata e la seconda chiave con il nome della colonna. Se viene restituito un solo risultato, viene creato un array monodimensionale con le chiavi come colonne. Se non viene eseguito alcun risultato, la variabile risultato viene impostata su null. Come ho detto prima, sembra un po 'confuso, ma una volta che si suddividono le singole sezioni, si può vedere che sono abbastanza semplici e dirette.
Questa funzione è molto più semplice della nostra precedente. Semplicemente ci consente di inserire informazioni nel database. Come tale richiederemo un argomento addizionale al nome della tabella. Richiederà una variabile che corrisponde ai valori che desideriamo inserire. Possiamo semplicemente separare ogni valore con una virgola. Quindi, tutto ciò che dobbiamo fare è controllare rapidamente se il nostro tableExists, e quindi compilare l'istruzione insert manipolando i nostri argomenti per formare un'istruzione insert. Quindi eseguiamo la nostra query.
inserimento di funzione pubblica ($ table, $ values, $ rows = null) if ($ this-> tableExists ($ table)) $ insert = 'INSERT INTO'. $ table; if ($ rows! = null) $ insert. = '('. $ rows. ')'; for ($ 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; Come puoi vedere, questa funzione è molto più semplice della nostra istruzione di selezione piuttosto complessa. La nostra funzione di cancellazione sarà in realtà ancora più semplice.
Questa funzione elimina semplicemente una tabella o una riga dal nostro database. Come tale dobbiamo passare il nome della tabella e una clausola where opzionale. La clausola where ci farà sapere se è necessario eliminare una riga o l'intera tabella. Se viene passata la clausola where, ciò significa che le voci corrispondenti devono essere eliminate. Dopo aver capito tutto, si tratta solo di compilare la nostra istruzione delete e di eseguire la query.
funzione pubblica delete ($ table, $ where = null) if ($ this-> tableExists ($ table)) if ($ where == null) $ delete = 'DELETE'. $ table; else $ delete = 'CANCELLA DA'. $ table. ' DOVE '. $ Dove; $ del = @mysql_query ($ delete); if ($ del) return true; else return false; else return false;
E finalmente arriviamo alla nostra ultima importante funzione. Questa funzione serve semplicemente per aggiornare una riga nel database con alcune nuove informazioni. Tuttavia, a causa della sua natura leggermente più complessa, si rivelerà un po 'più grande e infinitamente più confuso. Non temere mai, segue molto dello stesso schema della nostra funzione precedente. In primo luogo userà i nostri argomenti per creare una dichiarazione di aggiornamento. Quindi procederà a controllare il database per assicurarsi che la tabellaExists. Se esiste, aggiornerà semplicemente la riga appropriata. La parte difficile, ovviamente, arriva quando proviamo a creare la dichiarazione di aggiornamento. Poiché la dichiarazione di aggiornamento contiene regole per l'aggiornamento di più voci (IE - colonne diverse nella stessa riga tramite l'uso astuto delle virgole), dovremo tenerne conto e creare un modo per affrontarle. Ho deciso di passare la clausola where come singolo array. Il primo elemento dell'array sarà il nome della colonna che viene aggiornata e il prossimo sarà il valore della colonna. In questo modo, ogni numero pari (incluso 0) sarà il nome della colonna e ogni numero dispari sarà il nuovo valore. Il codice per eseguire ciò è molto semplice e viene presentato di seguito al di fuori della funzione:
per ($ 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];
La prossima sezione creerà la parte dell'istruzione di aggiornamento che si occupa dell'effettiva impostazione delle variabili. Poiché è possibile modificare qualsiasi numero di valori, ho optato per andare con un array in cui la chiave è la colonna e il valore è il nuovo valore della colonna. In questo modo possiamo anche fare un controllo per vedere quanti valori diversi sono stati passati per essere aggiornati e aggiungere virgole in modo appropriato.
$ keys = array_keys ($ rows); per ($ 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 .= ',';
Ora che abbiamo tolto questi due bit di logica, il resto della dichiarazione di aggiornamento è semplice. Qui è presentato di seguito:
aggiornamento della funzione pubblica ($ table, $ rows, $ where) if ($ this-> tableExists ($ table)) // Analizza dove valori // anche i valori (incluso 0) contengono le righe dove // valori dispari contengono le clausole per la riga per ($ 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; Ora che abbiamo terminato la nostra ultima funzione, la nostra semplice interfaccia CRUD per MySQL è completa. Ora puoi creare nuove voci, leggere voci specifiche dal database, aggiornare voci ed eliminare cose. Inoltre, stai creando e riusando questa lezione scoprirai che ti stai risparmiando un sacco di tempo e codice. Ah, la bellezza della programmazione orientata agli oggetti.
Quindi abbiamo fatto tutto il nostro corso, ma come lo usiamo? Questa parte è semplice. Iniziamo creando un database di sistema molto semplice da utilizzare nei nostri test. Ho creato un database chiamato test, quindi ho eseguito la statistica MySQL. Puoi posizionarlo in qualsiasi database che ti piace, ma assicurati di modificare le variabili di connessione nella parte superiore dello script in modo che corrispondano:
La prima riga è commentata semplicemente perché non tutti ne avranno bisogno. Se è necessario eseguirlo più di una volta, sarà necessario decommentarlo la seconda volta per assicurarsi di creare la tabella.
Ora che la nostra tabella è stata creata e popolata, è ora di eseguire alcune semplici query su di essa.
Collegare(); $ Db-> selezionare ( 'mysqlcrud'); $ res = $ db-> getResult (); print_r ($ res); ?>
Se fatto correttamente, dovresti vedere quanto segue:
Allo stesso modo possiamo fare un passo avanti ed eseguire una query di aggiornamento, e quindi produrre i risultati:
aggiornamento ( 'mysqlcrud', array ( 'nome' => 'cambiato!'), array ( 'id', 1)); $ Db-> update ( 'mysqlcrud', array ( 'name' => 'changed2!'), Array ( 'id', 2)); $ res = $ db-> getResult (); print_r ($ res); ?>
Dovremmo vedere questo
Ora per una semplice istruzione di inserimento:
;insert ('mysqlcrud', array (3, "Name 4", "[email protected]")); $ res = $ db-> getResult (); print_r ($ res); ?> 
