Ver Mensaje Individual
  #15 (permalink)  
Antiguo 05/08/2011, 16:44
thehack
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 14 años, 8 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

hola bueno de tanto lidear con el ejemplo de gatorv no se si este empezando por un buen camino el cambio de las referencias & y eliminando variables globales aqui les dejo lo que echo hasta ahora si alguno puede responderme a mi ejemplo se los agradeceria saludos y gracias por la paciencia y ayuda hasta ahora

Código PHP:
Ver original
  1. class tsDatabase {
  2.     private  $_dbhost;
  3.     private  $_dbname;
  4.     private  $_dbuser;
  5.     private  $_dbpass;
  6.     private  $_dbpersist;
  7.     private $_querys = 0;
  8.     private static $_dblink = null;
  9.  
  10.     // ESTE ES EL CONSTRUCTOR
  11.     // CONECTA Y SELECCIONA UNA BASE DE DATOS
  12.     // INPUT: VOID
  13.     // OUTPUT: $dblink
  14.     function tsDatabase(){
  15.         // DEFINICION DE VARIABLES
  16.         $this->_dbhost = db_host;
  17.         $this->_dbname = db_name;
  18.         $this->_dbuser = db_user;
  19.         $this->_dbpass = db_pass;
  20.         $this->_db_persist = db_persist;
  21.         // CONECTAR
  22.         $this->_dblink = $this->connect();
  23.         return $this->_dblink;
  24.        
  25.     }
  26.     // METODO PARA SELECCIONAR Y CONECTAR A LA BASE DE DATOS
  27.     // INPUT:
  28.     // OUTPUT: instancia de la clase
  29.         public static  function getInstance(){
  30.     static $database;
  31.        
  32.         if( !is_a($database, 'tsDatabase') ){
  33.             // Backwards compatibility
  34.             if( is_a($tsdb, 'tsDatabase') ){
  35.                 $database = $tsdb;
  36.             }
  37.             // Instantiate
  38.             else{
  39.                 $database = new tsDatabase();
  40.                 $tsdb = $database;
  41.             }
  42.         }
  43.         return $database;
  44.     }
  45.  
  46.     // METODO PARA CONECTAR A LA BASE DE DATOS
  47.     // INPUT: void
  48.     // OUTPUT: $db_link
  49.     function connect() {
  50.         // CONEXION PERSISTENTE?
  51.         if($this->_db_persist) $db_link = mysql_pconnect($this->_dbhost, $this->_dbuser, $this->_dbpass);
  52.         else $db_link = mysql_connect($this->_dbhost, $this->_dbuser, $this->_dbpass);
  53.         // NO SE PUDO CONECTAR?
  54.         if(empty($db_link)) die(N_ACCESS);
  55.         // SELECCIONAR BASE DE DATOS
  56.         mysql_select_db($this->_dbname);
  57.         // ASIGNAR CONDIFICACION
  58.         mysql_query("set names 'utf8'");
  59.         mysql_query("set character set utf8");
  60.         // REGRESAR LA CONEXCION
  61.         return $db_link;
  62.     }
  63.     // METODO PARA HACER UNA CONSULTA
  64.     // INPUT: $query
  65.     // OUTPUT: $result
  66.     function query($q){
  67.     $this->_querys++;
  68.         // HACIENDO CONSULTA Y RETORNANDO
  69.         return mysql_query($q);
  70.     }
  71.     // METODO PARA HACER UN SELECT
  72.     // INPUT:
  73.     //      $table | NOMBRE DE LA TABLA
  74.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  75.     //      $where | CONDICION DE LA CONSULTA
  76.     //      $order | ORDEN DE LOS RESULTADOS
  77.     //      $limit | LIMITE DE RESULTADOS
  78.     // OUTPUT: $result
  79.     function select($table, $fields, $where = NULL, $order = NULL, $limit = NULL){
  80.        
  81.          $this->querys++;
  82.  
  83.         // CREANDO LA CONSULTA
  84.         $q = 'SELECT '.$fields.' FROM '.$table;
  85.         if($where) $q .= ' WHERE '.$where;
  86.         if($order) $q .= ' ORDER BY '.$order;
  87.         if($limit) $q .= ' LIMIT '.$limit;
  88.         // HACIENDO CONSULTA Y RETORNANDO
  89.         return mysql_query($q);
  90.     }
  91.     // METODO PARA HACER UN UPDATE
  92.     // INPUT:
  93.     //      $table | NOMBRE DE LA TABLA
  94.     //      $pairs | CAMPOS Y VALORES A ACTUALIZAR
  95.     //      $where | CONDICION DE LA CONSULTA
  96.     // OUTPUT: status
  97.     function update($table, $pairs, $where){
  98.        
  99.         $this->querys++;
  100.         // DESCOMPONER CAMPOS DE UN ARRAY
  101.         if(is_array($pairs)) $fields = implode(", ", $pairs);
  102.         else $fields = $pairs;
  103.         // ARMANDO CONSULTA
  104.         $q = 'UPDATE '.$table.' SET '.$fields.' WHERE '.$where;
  105.         // REALIZANDO CONSULTA
  106.         $result = mysql_query($q);
  107.         // RETORNANDO ESTADO
  108.         if($result) return true;
  109.         else return false;
  110.     }
  111.     // METODO PARA HACER UN REPLACE
  112.     // INPUT:
  113.     //      $table | NOMBRE DE LA TABLA
  114.     //      $fields | CAMPOS A REEMPLAZAR
  115.     //      $values | VALORES A REEMPLAZAR
  116.     // OUTPUT: status
  117.     function replace($table, $fields, $values){
  118.        
  119.         $this->querys++;
  120.         // ARMANDO CONSULTA
  121.         $q = "REPLACE INTO $table ($fields) VALUES ($values)";
  122.         // REALIZANDO CONSULTA
  123.         $result = mysql_query($q);
  124.         // RETORNANDO ESTADO
  125.         if($result) return true;
  126.         else return false;
  127.     }
  128.     // METODO PARA HACER UN INSERT
  129.     // INPUT:
  130.     //      $table | NOMBRE DE LA TABLA
  131.     //      $fields | CAMPOS
  132.     //      $values | VALORES
  133.     // OUTPUT: status
  134.     function insert($table, $fields, $values){
  135.        
  136.         $this->querys++;
  137.         // ARMANDO CONSULTA
  138.         $q = 'INSERT INTO '.$table.' ('.$fields.') VALUES ('.$values.')';
  139.         // REALIZANDO CONSULTA
  140.         $result = mysql_query($q);
  141.         // RETORNANDO ESTADO
  142.         if($result) return true;
  143.         else return false;
  144.     }
  145.     // METODO PARA HACER UN DELETE
  146.     // INPUT:
  147.     //      $table | NOMBRE DE LA TABLA
  148.     //      $where | CONDICION
  149.     // OUTPUT: status
  150.     function delete($table, $where){
  151.        
  152.         $this->querys++;
  153.         // ARMANDO CONSULTA
  154.         $q = 'DELETE FROM '.$table.' WHERE '.$where;
  155.         // REALIZANDO CONSULTA
  156.         $result = mysql_query($q);
  157.         // RETORNANDO ESTADO
  158.         if($result) return true;
  159.         else return false;
  160.     }
  161.     // METODO PARA HACER UNA CONSULTA Y OBTENER OBJETOS
  162.     // INPUT:
  163.     //      $table | NOMBRE DE LA TABLA
  164.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  165.     //      $where | CONDICION DE LA CONSULTA
  166.     //      $order | ORDEN DE LOS RESULTADOS
  167.     //      $limit | LIMITE DE RESULTADOS
  168.     // OUTPUT: $result
  169.     function data($table, $fields, $where =NULL, $order = NULL, $limit = NULL){
  170.        
  171.         $this->querys++;
  172.         // CREANDO LA CONSULTA
  173.         $q = 'SELECT '.$fields.' FROM '.$table;
  174.         if($where) $q .= ' WHERE '.$where;
  175.         if($order) $q .= ' ORDER BY '.$order;
  176.         if($limit) $q .= ' LIMIT '.$limit;
  177.         // HACIENDO CONSULTA
  178.         $result = mysql_query($q);
  179.         // CREANDO Y RETORNANDO OBJETOS
  180.         if($result) return mysql_fetch_object($result);
  181.         else return false;
  182.     }
  183.     // METODO PARA CREAR OBJETOS DESDE UNA CONSULTA
  184.     // INPUT: $result
  185.     // OUTPUT: $objs
  186.     function fetch_objects($result){
  187.         if(!is_resource($result)) return false;
  188.         while($obj = mysql_fetch_object($result)) $objs[] = $obj;
  189.         return $objs;
  190.     }
  191.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  192.     // INPUT: $result
  193.     // OUTPUT: array
  194.     function fetch_assoc($result){
  195.         if(!is_resource($result)) return false;
  196.         return mysql_fetch_assoc($result);
  197.     }
  198.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  199.     // INPUT: $result
  200.     // OUTPUT: array
  201.     function fetch_array($result,$array = NULL){
  202.         if(!is_resource($result)) return false;
  203.         while($row = mysql_fetch_assoc($result)) $array[] = $row;
  204.         return $array;
  205.     }
  206.     // METODO PARA OBTENER EL VALOR DE UNA ROW
  207.     // INPUT: $result
  208.     // OUTPUT: array
  209.     function fetch_row($result){
  210.         return mysql_fetch_row($result);
  211.     }
  212.     // METODO PARA CONTAR EL NUMERO DE RESULTADOS
  213.     // INPUT: $result
  214.     // OUTPUT: num_rows
  215.     function num_rows($result){
  216.         if(!is_resource($result)) return false;
  217.         return mysql_num_rows($result);
  218.     }
  219.     // METODO PARA LIBERAR MEMORIA
  220.     // INPUT: $result
  221.     // OUTPUT: void
  222.     function free($result = 0){
  223.         return mysql_free_result($result);
  224.     }
  225.     // METODO PARA RETORNAR EL ULTIMO ID DE UN INSERT
  226.     // INPUT: void
  227.     // OUTPUT: status
  228.     function insert_id(){
  229.      
  230.       $this->querys++;
  231.       return mysql_insert_id($this->_dblink);
  232.     }
  233.     // METODO PARA RETORNAR LOS ERRORES
  234.     // INPUT: void
  235.     // OUTPUT: status
  236.     function error(){
  237.       return mysql_error($this->_dblink);
  238.     }
  239.    
  240.    
  241.    
  242. }

espero vaya bien :)