Share
Se han ofrecido numerosos ejemplos, desde robots a bicicletas, como explicaciones "fáciles" de lo que es OOP. He optado por mostrarte cómo funciona la OOP con un ejemplo de la vida real, para un programador. Al crear una clase MySQL CRUD, puede crear, leer, actualizar y eliminar fácilmente entradas en cualquiera de sus proyectos, independientemente de cómo esté diseñada la base de datos..
Configurar el esqueleto de nuestra clase es bastante simple una vez que descubrimos exactamente lo que necesitamos. Primero debemos asegurarnos de que podemos hacer nuestras funciones básicas de MySQL. Para hacer esto, necesitamos las siguientes funciones:
Esos parecen bastante básicos, pero estoy seguro de que a medida que avancemos, notaremos que muchos de ellos utilizan algunos aspectos similares, por lo que es posible que tengamos que crear más clases. Aquí es cómo debe verse la definición de su clase. Observe que me aseguré de que los métodos se crearon con la palabra clave pública.
clase Base de datos public function connect () public function disconnect () public function select () public function insert () public function delete () public function update ()
Esta función será bastante básica, pero su creación nos obligará a crear primero algunas variables. Ya que queremos asegurarnos de que no se pueda acceder a ellos desde fuera de nuestra clase, los estableceremos como privados. Estas variables se utilizarán para almacenar el host, el nombre de usuario, la contraseña y la base de datos para la conexión. Dado que prácticamente se mantendrán constantes durante todo el proceso, ni siquiera necesitamos crear métodos modificadores o de acceso. Después de eso, solo tendríamos que crear una declaración mysql simple para conectarnos a la base de datos. Por supuesto, ya que como programadores siempre tenemos que asumir que el usuario (incluso si somos nosotros) hará algo estúpido, permite agregar una capa adicional de precaución. Podemos verificar si el usuario se ha conectado realmente a la base de datos primero, y si lo han hecho, realmente no hay necesidad de volver a conectarse. Si no lo han hecho podemos usar sus credenciales para conectarse.
private db_host = "; private db_user ="; private db_pass = "; private db_name ="; función pública 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; devuelve verdadero else devolver falso; else return false; else return true;
Como puede ver, hace uso de algunas funciones básicas de mysql y un poco de comprobación de errores para asegurarse de que las cosas vayan según lo planeado. Si se conecta con la base de datos con éxito, devolverá verdadero, y si no, devolverá falso. Como bono adicional, también establecerá la variable de conexión en verdadero si la conexión se completó con éxito.
Esta función simplemente verificará nuestra variable de conexión para ver si está configurada como verdadera. Si lo está, eso significa que está conectado a la base de datos, y nuestro script se desconectará y devolverá verdadero. Si no es así, entonces realmente no hay necesidad de hacer nada en absoluto.
función pública disconnect () if ($ this-> con) if (@mysql_close ()) $ this-> con = false; devuelve verdadero else devolver falso;
Esta es la primera función donde las cosas comienzan a complicarse un poco. Ahora trataremos con los argumentos del usuario y devolveremos los resultados correctamente. Ya que no necesariamente queremos poder usar los resultados de inmediato, también vamos a introducir una nueva variable llamada resultado, que almacenará los resultados correctamente. Aparte de eso, también vamos a crear una nueva función que verifica si existe una tabla en particular en la base de datos. Dado que todas nuestras operaciones CRUD requerirán esto, tiene más sentido crearlo por separado en lugar de integrarlo en la función. De esta manera, ahorraremos espacio en nuestro código y, como tal, podremos optimizar mejor las cosas más adelante. Antes de entrar en la declaración de selección real, aquí está la función tableExists y la variable de resultados privados.
Accentsconagua
privado $ result = array (); private function tableExists ($ table) $ tablesInDb = @mysql_query ('SHOW TABLES FROM'. $ this-> db_name. 'LIKE "'. $ table. '"'); if ($ tablesInDb) if (mysql_num_rows ($ tablesInDb) == 1) return true; else devolver falso; Esta función simplemente verifica la base de datos para ver si la tabla requerida ya existe. Si lo hace, devolverá verdadero y si no, devolverá falso.
selección de función pública ($ table, $ rows = '*', $ where = null, $ order = null) $ q = 'SELECT'. $ rows. ' FROM '. $ 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); para ($ i = 0; $ i < $this->numResults; $ i ++) $ r = mysql_fetch_array ($ consulta); $ key = array_keys ($ r); para ($ 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 ($ consulta) < 1) $this->resultado = nulo; else $ this-> result [$ key [$ x]] = $ r [$ key [$ x]]; devolver verdadero; else devolver falso; de lo contrario devuelve falso;
Aunque a primera vista parece un poco de miedo, esta función realmente hace un montón de cosas. En primer lugar acepta 4 argumentos, 1 de los cuales es requerido. El nombre de la tabla es lo único que debe pasar a la función para obtener resultados. Sin embargo, si desea personalizarlo un poco más, puede hacerlo agregando las filas que se extraerán de la base de datos, e incluso puede agregar una cláusula de dónde y orden. Por supuesto, siempre que pase el primer valor, el resultado se establecerá de manera predeterminada en sus valores predeterminados, por lo que no tiene que preocuparse por configurarlos todos. El bit de código justo después de los argumentos solo sirve para compilar todos nuestros argumentos en una declaración de selección. Una vez hecho esto, se realiza una comprobación para ver si existe la tabla, utilizando nuestra función de tableExists anterior. Si existe, entonces la función continúa y se realiza la consulta. Si no, fallará.
La siguiente sección es la verdadera magia del código. Lo que hace es reunir las columnas y los datos que se solicitaron de la base de datos. Luego lo asigna a nuestra variable de resultado. Sin embargo, para que sea más fácil para el usuario final, en lugar de las claves numéricas de incremento automático, se utilizan los nombres de las columnas. En caso de que obtenga más de un resultado, cada fila que se devuelve se almacena con una matriz bidimensional, con la primera clave numérica y auto-incrementando, y la segunda clave es el nombre de la columna. Si solo se devuelve un resultado, entonces se crea una matriz unidimensional con las claves que son las columnas. Si no se activa ningún resultado, la variable de resultado se establece en nulo. Como dije antes, parece un poco confuso, pero una vez que divide las cosas en sus secciones individuales, puede ver que son bastante simples y directas..
Esta función es mucho más simple que la anterior. Simplemente nos permite insertar información en la base de datos. Como tal, necesitaremos un argumento adicional al nombre de la tabla. Requeriremos una variable que corresponda a los valores que deseamos ingresar. Simplemente podemos separar cada valor con una coma. Luego, todo lo que debemos hacer es verificar rápidamente si existe nuestra tabla, y luego compilar la declaración de inserción manipulando nuestros argumentos para formar una declaración de inserción. Entonces simplemente ejecutamos nuestra consulta.
función pública insert ($ table, $ valores, $ rows = null) if ($ this-> tableExists ($ table)) $ insert = 'INSERT INTO'. $ table; if ($ rows! = null) $ insert. = '('. $ rows. ')'; para ($ 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; Como puede ver, esta función es mucho más simple que nuestra declaración de selección bastante compleja. Nuestra función de borrado será incluso más simple.
Esta función simplemente elimina una tabla o una fila de nuestra base de datos. Como tal, debemos pasar el nombre de la tabla y una cláusula where opcional. La cláusula where nos permitirá saber si necesitamos eliminar una fila o toda la tabla. Si se pasa la cláusula where, eso significa que las entradas que coincidan deberán eliminarse. Después de que resolvamos todo eso, es solo una cuestión de compilar nuestra declaración de eliminación y ejecutar la consulta.
función pública delete ($ table, $ where = null) if ($ this-> tableExists ($ table)) if ($ where == null) $ delete = 'DELETE'. $ table; else $ delete = 'DELETE FROM'. $ table. ' DONDE '. $ Donde; $ del = @mysql_query ($ delete); if ($ del) return true; else devolver falso; else return false;
Y finalmente llegamos a nuestra última función importante. Esta función simplemente sirve para actualizar una fila en la base de datos con información nueva. Sin embargo, debido a su naturaleza un poco más compleja, resultará un poco más grande e infinitamente más confuso. Nunca temas, sigue gran parte del mismo patrón de nuestra función anterior. Primero usará nuestros argumentos para crear una declaración de actualización. Luego procederá a verificar la base de datos para asegurarse de que exista la tabla. Si existe, simplemente actualizará la fila correspondiente. La parte difícil, por supuesto, viene cuando intentamos crear la declaración de actualización. Dado que la declaración de actualización tiene reglas para la actualización de múltiples entradas (IE: diferentes columnas en la misma fila a través del uso astuto de coma), tendremos que tener eso en cuenta y crear una manera de lidiar con ella. He optado por pasar la cláusula where como una sola matriz. El primer elemento de la matriz será el nombre de la columna que se está actualizando, y el siguiente será el valor de la columna. De esta manera, cada número par (incluido 0) será el nombre de la columna, y cada número impar será el nuevo valor. El código para realizar esto es muy simple, y se presenta a continuación fuera de la función:
para ($ 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 siguiente sección creará la parte de la declaración de actualización que trata con la configuración real de las variables. Ya que puedes cambiar cualquier número de valores, opté por ir con una matriz donde la clave es la columna y el valor es el nuevo valor de la columna. De esta manera, incluso podemos hacer una verificación para ver cuántos valores diferentes se pasaron para ser actualizados y podemos agregarlos de manera apropiada.
$ keys = array_keys ($ rows); para ($ 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 .= ',';
Ahora que hemos eliminado esos dos bits de lógica, el resto de la declaración de actualización es fácil. Aquí se presenta a continuación:
actualización de funciones públicas ($ tabla, $ filas, $ donde) si ($ this-> tableExists ($ tabla)) // Analizar los valores donde // los valores pares (incluido 0) contienen el lugar donde las filas // valores impares las cláusulas de la fila para ($ 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; Ahora que hemos terminado nuestra última función, nuestra sencilla interfaz CRUD para MySQL está completa. Ahora puede crear nuevas entradas, leer entradas específicas de la base de datos, actualizar entradas y eliminar cosas. Además, al crear y reutilizar esta clase, descubrirá que se está ahorrando mucho tiempo y codificación. Ah, la belleza de la programación orientada a objetos..
Así que tenemos nuestra clase hecha, pero ¿cómo la usamos? Esta parte es simple. Comencemos por crear una base de datos del sistema muy simple para usar en nuestras pruebas. Creé una base de datos llamada prueba, y luego ejecuté la declaración de MySQL. Puede colocarlo en cualquier base de datos que desee, solo asegúrese de cambiar las variables de conexión en la parte superior del script para que coincidan:
La primera línea está comentada simplemente porque no todos la necesitarán. Si necesita ejecutarlo más de una vez, deberá descomentarlo la segunda vez para asegurarse de que crea la tabla..
Ahora que nuestra tabla está creada y llena, es hora de ejecutar algunas consultas simples en ella.
conectar(); $ db-> select ('mysqlcrud'); $ res = $ db-> getResult (); print_r ($ res); ?> Si se hace correctamente, debería ver lo siguiente:
Del mismo modo, podemos ir un paso más allá y ejecutar una consulta de actualización, y luego generar los resultados:
update ('mysqlcrud', array ('name' => 'Changed!'), array ('id', 1)); $ db-> update ('mysqlcrud', array ('name' => 'Changed2!'), array ('id', 2)); $ res = $ db-> getResult (); print_r ($ res); ?> Deberiamos ver esto
Ahora para una simple declaración de inserción:
;inserte ('mysqlcrud', array (3, "Name 4", "[email protected]")); $ res = $ db-> getResult (); print_r ($ res); ?> 
