Foros del Web » Programando para Internet » PHP »

[SOLUCIONADO] PHP OO Corregir/mejorar mi código

Estas en el tema de Corregir/mejorar mi código en el foro de PHP en Foros del Web. Hola a todos, antes de nada quiero decirles que soy nuevo en este foro y agradezco de antemano, vuestra atención. Soy nuevo programando en PHP ...
  #1 (permalink)  
Antiguo 19/08/2015, 10:17
 
Fecha de Ingreso: febrero-2015
Mensajes: 6
Antigüedad: 9 años, 2 meses
Puntos: 0
Información Corregir/mejorar mi código

Hola a todos, antes de nada quiero decirles que soy nuevo en este foro y agradezco de antemano, vuestra atención.

Soy nuevo programando en PHP y aun mas programando con POO, por eso quiero mostrarles un sencillo código que he realizado para que me aconsejen en que punto se puede mejorar o como lo haríais vosotros. Realmente el código funciona, pero no quiere decir que lo pueda estar haciendo bien y por eso pido vuestra colaboracion:

1ª página:
conexion.php

Código PHP:
class Conectar{
private 
$host$user$pass$database$charset;

    public function 
__construct() {

    require_once(
'db.php');  // Contiene las constantes de la conf. de la base de datos

    
$this->host        SERVIDORLOCAL;
        
$this->user        USUARIO;
        
$this->pass        CONTRASEÑA;
        
$this->database BASEDATOS;
        
$this->charset    CHARSET;

    }

    public function 
conexion(){
        try{
            if(!
$mysqli = new mysqli($this->host$this->user$this->pass$this->database)) throw new Exception("No se ha podido conectar con la base de datos.");
            
// Codificacion de caracteres utf-8
            
$mysqli->set_charset("'" $this->charset "'");

        }catch(
Exception $e){
            echo 
"Mensaje de error: " $e->getMessage();
            exit;
        }
            return 
$mysqli;
    }


2ª página:
insertClass.php
Código PHP:
require_once 'conexion.php';

    class 
InsertDataDb {
        private  
$conectar;
        private  
$con;
        private  
$params = array();
        private  
$type;
        private  
$tableName;
        private  
$columnName;
        private  
$values;

        public function 
__construct() {
            
$this->conectar = new Conectar();
            
$this->con $this->conectar->conexion();
        }

        private function 
refValues($arr){
            if (
strnatcmp(phpversion(),'5.3') >= 0//Reference is required for PHP 5.3+
            
{
                
$refs = array();
                foreach(
$arr as $key => $value)
                    
$refs[$key] = &$arr[$key];
                return 
$refs;
            }
        return 
$arr;
        }

            
//Setters

            /* Bind parameters. Types: s = string, i = integer, d = double,  b = blob */
        
public function setType($type){
            
$this->type = (string) $type;
        }

        public function 
setTableName($tableName){
            
$this->tableName = (string) $tableName;
        }

        public function 
setParams($bind_params){
//Obtiene los nombre de la columna de la tabla de la bd
            
if(!isset($this->columnName)){
                
$this->columnName implode(" , "array_keys($bind_params));
            }
//Obtiene el número de datos que el cliente va a ingresar en la bd para convertirlo en una sentencia preparada ejem: (?,?,?)
            
if (!isset($this->values)) {
                
$c count($bind_params);
                
$v ='';
                for(
$i 0$i $c$i++){
                    
$v .= '?,';
                }
                
$this->values rtrim($v,',');
            }
//Crea la sql
            
if(!isset($this->sql)){
                
$this->sql "INSERT INTO " $this->tableName " (" $this->columnName ") VALUES (" $this->values ")";
            }
            
$params $bind_params;
            if (isset(
$params) && is_array($params)) {
                
/* Unimos los parametros */
                
array_unshift($params$this->type);
                
$bp array_values($params);
                
$this->params $bp;
            }
        }


            
//Insertar datos
        
public function insertData(){
            if(
$stmt $this->con->prepare($this->sql)){
                
call_user_func_array(array($stmt'bind_param'), $this->refValues($this->params));
            }else{
                throw new 
Exception("No se ha podido introducir los datos en la base de datos " $this->con->error);
            }

            if(!
$stmt->execute()) throw new Exception("Se ha producido un fallo en la ejecución de almacenamiento de datos en la base de datos." $this->con->error);
    
$this->close();    
        }

            
//Inserta el ultimo id registrado
        
public function insertId(){
            return 
$this->con->insert_id;
        }

        public function 
close(){
            return 
$this->con->close();
        }
    } 
/* EJECUTAR */
Código PHP:
try{
$data = array(    
'cliente'     => 'Manolito',
'email'       => '[email protected]',
'password' => '1234');

        
$insert = new InsertDataDb();
        
$insert->setTableName('usuario'); // Nombre de la tabla de la bd
        
$insert->setType('sss');                //   Types: s = string, i = integer ...
        
$insert->setParams($data);        
        
$insert->insertData();

    }catch(
Exception $e){
        echo 
"Mensaje de error: " $e->getMessage();
        exit();
    } 
Mi idea es mejorar/corregir mi código y aprender de vosotros. En Internet hay mil maneras de hacerlo pero cada uno lo hace de manera diferente!!!
  #2 (permalink)  
Antiguo 19/08/2015, 23:03
Avatar de NSD
NSD
Colaborador
 
Fecha de Ingreso: mayo-2012
Ubicación: Somewhere
Mensajes: 1.332
Antigüedad: 11 años, 11 meses
Puntos: 320
Respuesta: Corregir/mejorar mi código

Lo que intentas hacer es una DBAL, busca en google con ese termino y veras muchas soluciones.

Esta desactualizado, pero esta es una clase que hice hace bastante para tal fin.

Con respecto a tu código, yo lo haría así:
DbTable.php
Código PHP:
Ver original
  1. <?php
  2. class DbTable {
  3.    
  4.     const ERROR_CONNECTION = "No se pudo conectar a la base de datos.";
  5.     const ERROR_PREPARE_STMT = "Error %1\$n preparando la sentencia. %2\$s.";
  6.     const ERROR_BIND_PARAM = "Error al agregar los parametros a la sentencia.";
  7.     const ERROR_EXECUTE_STMT = "Error %1\$n ejecutando la sentencia. %2\$s.";
  8.    
  9.     private static $_instance;
  10.     private $_table;
  11.     private $_stmt;
  12.     public $props = [];
  13.    
  14.     public function __construct($table) {
  15.         if(is_null(self::$_instance)) {
  16.             self::$_instance = new mysqli("localhost", "root", "", "database");
  17.             if(self::$_instance->connect_errno)
  18.                 throw new Exception(self::ERROR_CONNECTION);
  19.             else
  20.                 self::$_instance->set_charset("utf8");
  21.         }
  22.        
  23.         $this->_table = $table;
  24.     }
  25.    
  26.     public function flush() {
  27.         if(!is_null($this->_stmt)) {
  28.             $this->_stmt->close();
  29.             $this->_stmt = null;
  30.         }
  31.         $this->props = [];
  32.        
  33.         return $this;
  34.     }
  35.    
  36.     public function insert() {
  37.         $this->exec("INSERT INTO ".$this->_table." (".implode(array_keys($this->props)).") VALUES (?".str_repeat(",?", count($this->props)-1).");", $this->props);
  38.        
  39.         return self::$_instance->insert_id;
  40.     }
  41.    
  42.     public function exec($query = "", $params = []) {
  43.         if(is_null($this->_stmt)) {
  44.             if(!($this->_stmt = self::$_instance->prepare($query)))
  45.                 throw new Exception(sprintf(self::ERROR_PREPARE_STMT, self::$_instance->errno, self::$_instance->error));
  46.             elseif($params) {
  47.                 $bind_params = array("");
  48.                 foreach($params as &$param) {
  49.                     switch(gettype($param)) {
  50.                         case "integer": case "boolean": $bind_params[0] .= "i"; break;
  51.                         case "double" : $bind_params[0] .= "d"; break;
  52.                         case "blob"   : $bind_params[0] .= "b"; break;
  53.                         default       : $bind_params[0] .= "s"; break;
  54.                     }
  55.                     $bind_params[] = &$param;
  56.                 }
  57.                 if(!call_user_func_array(array($this->_stmt, "bind_param"), $bind_params))
  58.                     throw new Exception(self::ERROR_BIND_PARAM);
  59.             }
  60.         }
  61.        
  62.         if(!$this->_stmt->execute())
  63.             throw new Exception(sprintf(self::ERROR_EXECUTE_STMT, self::$_instance->error, self::$_instance->errno));
  64.         else {
  65.             $result = [];
  66.             if($registros = $this->_stmt->get_result()) {
  67.                 while($registro = $registros->fetch_array(MYSQLI_ASSOC))
  68.                     $result[] = $registro;
  69.             }
  70.         }
  71.        
  72.         return $result;
  73.     }
  74. }

Uso:
Código PHP:
Ver original
  1. require("DbTable.php");
  2. try {
  3.     $usuarios = new DbTable("usuarios");
  4.     $usuarios->props["cliente"] = "Manolito";
  5.     $usuarios->props["email"] = "[email protected]";
  6.     $usuarios->props["password"] = "1234";
  7.     $usuarios->props["edad"] = 22;
  8.  
  9.     echo "Se inserto el registro: ".$insert->insert();
  10. } catch(Exception $e) {
  11.     echo "Error: " . $e->getMessage();
  12.     exit();
  13. }
__________________
Maratón de desafíos PHP Junio - Agosto 2015 en FDW | Reglamento - Desafios
  #3 (permalink)  
Antiguo 20/08/2015, 01:35
Avatar de dashtrash
Colaborador
 
Fecha de Ingreso: abril-2007
Ubicación: Ni en Sevilla,ni en Sanlúcar..qué más da..
Mensajes: 927
Antigüedad: 17 años
Puntos: 270
Respuesta: Corregir/mejorar mi código

Sólo una puntualización sobre los tipos de dato.
Tanto
Código PHP:
Ver original
  1. $insert->setType('sss')
como
Código PHP:
Ver original
  1. switch(gettype($param)) {
  2.                         case "integer": case "boolean": $bind_params[0] .= "i"; break;
  3.                         case "double" : $bind_params[0] .= "d"; break;
  4.                         case "blob"   : $bind_params[0] .= "b"; break;
  5.                         default       : $bind_params[0] .= "s"; break;
  6. }
sugieren que la gestión de los tipos de datos es algo que concierne a la base de datos, cuando en realidad, es un problema que va desde los sistemas de almacenamiento, al código javascript ejecutado en el cliente.
Yo haría lo siguiente:
Código PHP:
Ver original
  1. $metaData=array(
  2.    "cliente"=>array("type"=>"STRING","MIN"=>...,"MAX"=>.........),
  3.    "email"=>array("type"=>"STRING","MIN"=>...,"MAX"=>....,"REGEXP"=>....)
  4.    ....
  5. );
Mientras no crees modelos, que unan esa metadata con los datos en sí, la secuencia
Código PHP:
Ver original
  1. $insert->setType('sss');                //   Types: s = string, i = integer ...
  2.         $insert->setParams($data);
pasa a ser
Código PHP:
Ver original
  1. $insert->setParams($data,$metaData);
  #4 (permalink)  
Antiguo 20/08/2015, 09:16
Avatar de NSD
NSD
Colaborador
 
Fecha de Ingreso: mayo-2012
Ubicación: Somewhere
Mensajes: 1.332
Antigüedad: 11 años, 11 meses
Puntos: 320
Respuesta: Corregir/mejorar mi código

Hay dos escenarios posibles:
1- El desarrollador conoce la estructura completa de la base de datos y bindea en funcion de lo que la base de datos espera recibir.
2- El desarrollador no conoce (o no le interesa) la estructura completa de la base de datos y bindea en funcion de los datos que tiene.

La contra de la primer opción es que se produce un doble modelado, el primero es un modelado interno en la base de datos y el segundo el modelado de la metadata para hacer los bindeos, ambos modelos deben ser consistentes entre si y cualquier cambio en uno debe ser replicado en el otro.
Se puede usar ingeniería reversa, pero es una carga adicional.
Se puede hacer modificaciones automáticas de uno en base al otro pero es mas complicado todavía.

En el segundo caso, es la base de datos la que se encarga de saber si lo que le viene le sirve o no, y no es una carga adicional, en SQL se permite una sentencia de este tipo:
Código SQL:
Ver original
  1. INSERT INTO usuarios (edad) VALUES ('2015'), (2015), (NOW());
Siendo el campo edad entero, los 3 valores anteriores insertados seran un 2015 entero, por lo tanto como se menciona en el manual (de mysql en particular, pero aplica a otros motores también con algunas diferencias) es la base de datos la que se encarga de realizar una gestión de tipos de datos.
Cita:
sugieren que la gestión de los tipos de datos es algo que concierne a la base de datos, cuando en realidad, es un problema que va desde los sistemas de almacenamiento, al código javascript ejecutado en el cliente.
Yo lo afirmo, no lo sugiero. En particular, en el modelo relacional, la gestion de tipos de datos es algo que concierne explicitamente a las bases de datos desde la definicion teorica de las mismas y se denomina "Integridad de dominio", es uno de los 4 items principales de la integridad de datos y ningun motor puede considerarse estable o seguro si no implementa robustamente estas validaciones. (Ref1, Ref2, Ref3, Ref4, Ref5)

Supongamos que tienes en Mysql un campo del tipo "ENUM" donde los datos permitidos son el conjunto ("SI", "NO", "TAL VEZ", 1, 2, 2015) ¿Como se bindea un valor a insertar? Con el tipo que tenga el valor en ese momento, pues no se sabe de antemano.
Pero mysql es un mal ejemplo porque su soporte es muy precario, pensemos mejor en Firebird por ejemplo, en Firebird puedes crear dominios propios:
Código SQL:
Ver original
  1. CREATE DOMAIN db_enum
  2. AS VARCHAR(20) CHECK (VALUE IS NULL OR VALUE IN ('Firebird','MySQL','MSSQL', 1, 2, 3));
Como se puede ver, el dominio db_enum es un string, pero es la base de datos la que se encarga de gestionar su tipo y que su valor sea valido.
Validaciones de minimo, maximo, forma, etc son restricciones de dominio, son parte de SQL estándar y por ejemplo en firebird se implementan asi.

No confundamos limitaciones con responsabilidades, la gestion de tipos de datos e integridad de dominio (que son casi casi la misma cosa) es responsabilidad de la base de datos, que algunas implementaciones como mysql no lo hagan no quiere decir que no le concierna.

Solo aclarar tambien que javascript nada tiene que ver (salvo que uses node.js o similar para conectarte directamete) puesto que a php se lo puede usar desde la consola y es en general Apache o el servidor de turno el que modifica los tipos de datos al llegar la petición, por eso json es una buena herramienta para mitigar ese inconveniente.
__________________
Maratón de desafíos PHP Junio - Agosto 2015 en FDW | Reglamento - Desafios
  #5 (permalink)  
Antiguo 20/08/2015, 11:25
Avatar de dashtrash
Colaborador
 
Fecha de Ingreso: abril-2007
Ubicación: Ni en Sevilla,ni en Sanlúcar..qué más da..
Mensajes: 927
Antigüedad: 17 años
Puntos: 270
Respuesta: Corregir/mejorar mi código

Cita:
En particular, en el modelo relacional, la gestion de tipos de datos es algo que concierne explicitamente a las bases de datos desde la definicion teorica de las mismas y se denomina "Integridad de dominio",
Una aplicación no es una base de datos,ni es el modelo relacional.El modelo relacional es una cosa, una aplicación es otra.
Cita:
Como se puede ver, el dominio db_enum es un string, pero es la base de datos la que se encarga de gestionar su tipo y que su valor sea valido.
Asi que, dependiendo del motor de base de datos que uses, un cierto dato, tiene una representación ...variable, dependiendo de qué motor use.Lo lógico es que la aplicación normalice su representación, lo cual significa, normaliza el tipo de dato, independientemente del sistema de almacenamiento.

Cita:
la gestion de tipos de datos e integridad de dominio (que son casi casi la misma cosa) es responsabilidad de la base de datos
A nivel de aplicación,conceptualmente, un enum es una variable que puede tener un número restingido de valores.Si un cierto sistema de almacenamiento gestiona los enums como strings, otros como entero, otros como lo que sea, eso no es más que la proyección de ese tipo de dato, sobre ese sistema de almacenamiento concreto.Eso forma parte de la idea de serializacion.

Si la base de datos se encarga de gestionar tipos, y que el valor sea válido, supongo que cuando recibes datos de un formulario, *sin comprobar tipos, ni valores válidos*, haces un insert...y si falla, al usuario le devuelves el error devuelto por la base de datos, verdad?
La responsabilidad de comprobar tipos, valores válidos y la integridad de dominio, va desde el cliente, hasta varias (multiples) capas del backend.No creo que haya mucha gente que en su sano juicio le deje a la base de datos "comprobar tipos y la integridad de dominio".

Por otro lado....el código que tú propones, deja en manos de php(!!) la comprobación del tipo...sé consecuente...llama a la base de datos, obtén la metadata de las columnas que van a ser modificadas (buena suerte con los updates cruzados), y haz el binding según esa metadata, no según lo que diga php.

Cita:
No confundamos limitaciones con responsabilidades,[...] que algunas implementaciones como mysql no lo hagan no quiere decir que no le concierna.
A ver si consigo entender esto, entre tanta retórica...Quieres decir que le concierne, pero que no lo hace...Ah...Pues entonces, alguien tendrá que hacerlo, no?
Aparte...como que no lo hace? Puedes hacer casi de todo con triggers...Si quieres construir tu aplicación así, claro...Y, esa sería la única forma (a base de muchos..muchos..triggers) que coincidirían las reglas de dominio SQL con las reglas de dominio de una aplicación.
Claro, que también podría elegir guardar mis datos en XML, o en MongoDB, o en ficheros planos, o en json, incluso insert() podría efectuarse sobre un webservice, un interfaz REST, o a través de SOAP.
Tú confundes "debe" con "es el responsable de".Que una base de datos relacional "deba" cumplir con una serie de restricciones de dominio, no significa que "sea el responsable de" mantener esas restricciones de dominio, sobre todo, cuando es un fallo de diseño presuponer que tus datos van a estar almacenados en un soporte con ciertas características.Más aún, presuponer que ese soporte va a realizar comprobaciones extra del dominio (por ejemplo, comprobar un nombre de usuario sobre una tabla de nombres de usuario no permitidos).Puedes hacerlo con SQL? Claro, por supuesto, con triggers....y esperando que nunca vayas a cambiar de base de datos...

Que buenos tiempos los del 92, con los dbase4 y todo eso...las aplicaciones estaban DENTRO de la base de datos...Pero aplicar esos conceptos en el 2015...

El resto , de ingenierías inversas, etc, no sé con qué tiene que ver...demasiada retórica.

Última edición por dashtrash; 20/08/2015 a las 11:43
  #6 (permalink)  
Antiguo 20/08/2015, 14:59
Avatar de NSD
NSD
Colaborador
 
Fecha de Ingreso: mayo-2012
Ubicación: Somewhere
Mensajes: 1.332
Antigüedad: 11 años, 11 meses
Puntos: 320
Respuesta: Corregir/mejorar mi código

Cita:
Quieres decir que le concierne, pero que no lo hace...Ah...Pues entonces, alguien tendrá que hacerlo, no?
Si. Pero ese alguien definitivamente no es la aplicación.
Ese alguien es una Capa de Abstraccion de la Base de Datos (aka DBAL) que suple las falencias del motor de turno.
No hay sentido a reinventar la rueda, si el motor sabe hacerlo que lo haga, si no sabe se le emparcha, pero emparchar porque quizás mañana cambie el motor no es (a mi criterio) una opción valida.

Me remito a un principio del modelo de desarrollo incremental de agilismo:
Cita:
La definición de un ítem se puede postergar hasta en momento en el cual se decide abordar el ítem. Esto favorece la resistencia al cambio, pues no se necesita hacer inversión de esfuerzo con anticipación. Mientras más tiempo hay entre la definición y la ejecución de un ítem, más riesgo existe que dicha definición caduque o que el ítem pierda prioridad.
Traducido a este caso: Si la base de datos de turno puede chequear y validar integridad de tipo y dominio de la forma que sea, que lo haga. Si el dia de mañana cambia la base de datos, se emparcha y todo sigue funcionando.

Si la base actual soporta dominios y la nueva no, se tendra que implementar con triggers.
Si la base actual soporta triggers y la nueva base de datos no soporta triggers ni herramientas equivalentes, la dbal tendra que implementarlos por su cuenta.
La aplicación ni se entero, ella sigue dialogando con la dbal.
En la practica la base de datos se recarga con querys fallidas? La dbal tendra que empezar a validar antes para quitarle carga.
Soluciones concretas a problemas concretos.

Resumiendo y sin retoricas para que entiendas mi punto: Si hoy la base de datos puede validar ella, que lo haga. Si mañana no puede se buscara una solución mañana. Soluciones simples y rapidas a problemas cotidianos, soluciones complejas y lentas a problemas aislados.
__________________
Maratón de desafíos PHP Junio - Agosto 2015 en FDW | Reglamento - Desafios
  #7 (permalink)  
Antiguo 22/08/2015, 12:58
 
Fecha de Ingreso: febrero-2015
Mensajes: 6
Antigüedad: 9 años, 2 meses
Puntos: 0
Respuesta: Corregir/mejorar mi código

Bueno muchas gracias a NSD y a Dashtrash por vuestras respuestas.

NSD me ha gustado mucho tu código (DbTable.php) es simple y sencillo de entender, lo pienso adaptar a mi proyecto personal.

Solo una corrección:
En la linea 37:
Código PHP:
$this->exec("INSERT INTO ".$this->_table." (".implode(array_keys($this->props)).") VALUES (?".str_repeat(",?"count($this->props)-1).");"$this->props); 
falta separar las palabras del implode " , ":
Código PHP:
 ...implode(", "array_keys($this->props))... 
Hay una parte del código que no logro acabar de entender bien su función. Se trata del ampersand que se encuentra en el bucle foreach en la variable $param:
Código PHP:
          foreach($params as &$param) {
                    switch(
gettype($param)) {
                        case 
"integer": case "boolean"$bind_params[0] .= "i"; break;
                        case 
"double" $bind_params[0] .= "d"; break;
                        case 
"blob"   $bind_params[0] .= "b"; break;
                        default       : 
$bind_params[0] .= "s"; break;
                    }
                    
$bind_params[] = &$param;
                } 
Sobre el tema de a quien concierne la gestión de los tipos de datos, desconozco si sería suficiente con realizar validaciones de los datos provenientes de los formularios solo con PHP
  #8 (permalink)  
Antiguo 23/08/2015, 10:10
Avatar de NSD
NSD
Colaborador
 
Fecha de Ingreso: mayo-2012
Ubicación: Somewhere
Mensajes: 1.332
Antigüedad: 11 años, 11 meses
Puntos: 320
Respuesta: Corregir/mejorar mi código

El ampersand sirve para crear una referencia a una variable, no es exactamente lo mismo, pero se lo puede comparar con los llamados punteros en otros lenguajes, lo que que hace la referencia no es copiar el contenido de una variable sino hacer referencia al contenido de otra:
Código PHP:
Ver original
  1. foreach($params as &$param) {
En esta linea lo que dice es que en cada interacción del loop, $param va a ser una referencia de la posición, no una copia del valor de la posicion, sino una referencia a ese valor, por lo que cuando cambie el valor de esa posicion del array, tambien cambiara el valor de $param (solo para que se entienda la idea, en realidad $param no tiene valor propio)
Código PHP:
Ver original
  1. $bind_params[] = &$param;
En este caso, lo que se esta haciendo es crear una referencia a una referencia, porque $param ya es una referencia en si misma, el resultado es que $bind_params contiene en el primer lugar el string con los tipos y luego una serie de referencias a los elementos de $params.
¿Para que?
Imaginate que tienes que repetir varias veces la misma accion, tienes que insertar 10 clientes, la sentencia se prepara solo una vez y luego solo se modifican los parametros ej:
Código PHP:
Ver original
  1. require("DbTable.php");
  2. try {
  3.     $usuarios = new DbTable("usuarios");
  4.     $usuarios->props["cliente"] = "Manolito";
  5.     $usuarios->props["email"] = "[email protected]";
  6.     $usuarios->props["password"] = "1234";
  7.     $usuarios->props["edad"] = 22;
  8.  
  9.     echo "Se inserto el registro: ".$insert->insert();
  10.     $usuarios->props["cliente"] = "Alberto";
  11.     echo "Se inserto el registro: ".$insert->insert();
  12.     $usuarios->props["cliente"] = "Jose";
  13.     echo "Se inserto el registro: ".$insert->insert();
  14.     $usuarios->props["cliente"] = "Pedro";
  15.     echo "Se inserto el registro: ".$insert->insert();
  16.     $usuarios->props["cliente"] = "Martin";
  17.     echo "Se inserto el registro: ".$insert->insert();
  18. } catch(Exception $e) {
  19.     echo "Error: " . $e->getMessage();
  20.     exit();
  21. }

Ese codigo reutiliza la sentencia preparada solo cambiando los valores, eso es posible porque los parametros vinculados a la sentencia son referencias a la propiedad $props, por lo que cuando esta propiedad se modifica, tambien lo hacen los valores de la sentencia (nuevamente, es a modo de ejemplo, la sentencia en realidad no tiene valores)
__________________
Maratón de desafíos PHP Junio - Agosto 2015 en FDW | Reglamento - Desafios
  #9 (permalink)  
Antiguo 02/09/2015, 09:40
 
Fecha de Ingreso: febrero-2015
Mensajes: 6
Antigüedad: 9 años, 2 meses
Puntos: 0
Respuesta: Corregir/mejorar mi código

Entendido, creo que ya he pillado el concepto sobre el ampersand , muchísimas gracias por tu aporte, rapidez y sencillez para explicar los temas. Gracias nuevamente.

Etiquetas: mysql, sql, tabla
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta




La zona horaria es GMT -6. Ahora son las 02:18.