Foros del Web » Programando para Internet » PHP » Frameworks y PHP orientado a objetos »

problemas con instanciar una classe

Estas en el tema de problemas con instanciar una classe en el foro de Frameworks y PHP orientado a objetos en Foros del Web. Hola tengo un problema en mi proyecto resulta que al instanciar las class me da un error Strict Standards: Non-static method Core::getInstance() should not be ...
  #1 (permalink)  
Antiguo 04/08/2011, 07:49
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
problemas con instanciar una classe

Hola tengo un problema en mi proyecto resulta que al instanciar las class me da un error

Strict Standards: Non-static method Core::getInstance() should not be called statically in C:\xampp\htdocs\redsocial.com\header.php on line 118
  #2 (permalink)  
Antiguo 04/08/2011, 07:51
Avatar de abimaelrc
Colaborador
 
Fecha de Ingreso: mayo-2009
Ubicación: En el planeta de Puerto Rico
Mensajes: 14.734
Antigüedad: 10 años, 4 meses
Puntos: 1516
Respuesta: problemas con instanciar una classe

¿Qué haz hecho?
__________________
Verifica antes de preguntar.
Los verdaderos amigos se hieren con la verdad, para no perderlos con la mentira. - Eugenio Maria de Hostos
  #3 (permalink)  
Antiguo 04/08/2011, 07:51
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

las class las instanceo asi $tsdb =& tsDatabase::getInstance();
  #4 (permalink)  
Antiguo 04/08/2011, 07:53
Avatar de abimaelrc
Colaborador
 
Fecha de Ingreso: mayo-2009
Ubicación: En el planeta de Puerto Rico
Mensajes: 14.734
Antigüedad: 10 años, 4 meses
Puntos: 1516
Respuesta: problemas con instanciar una classe

¿Que tienes en la clase? ¿Cómo la declaraste? Acuérdate que para poder ayudarte necesitas brindarnos información. Otra cosa si estás usando PHP5 no debes usar referencia.
__________________
Verifica antes de preguntar.
Los verdaderos amigos se hieren con la verdad, para no perderlos con la mentira. - Eugenio Maria de Hostos
  #5 (permalink)  
Antiguo 04/08/2011, 08:23
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

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

mi class de la db como la declaro

asi $tsdb =& tsDatabase::getInstance();
  #6 (permalink)  
Antiguo 04/08/2011, 08:25
Avatar de abimaelrc
Colaborador
 
Fecha de Ingreso: mayo-2009
Ubicación: En el planeta de Puerto Rico
Mensajes: 14.734
Antigüedad: 10 años, 4 meses
Puntos: 1516
Respuesta: problemas con instanciar una classe

Ok, veo que estás usando PHP4, ¿por qué no tratas de cambiar a PHP5? Otra cosa, no sé si PHP4 usa static pero tsDatabase::getInstance() está tratando de llamar una clase que sea estática. Por lo que getInstance debes declararla como static.
__________________
Verifica antes de preguntar.
Los verdaderos amigos se hieren con la verdad, para no perderlos con la mentira. - Eugenio Maria de Hostos
  #7 (permalink)  
Antiguo 04/08/2011, 08:40
Avatar de GatorV
$this->role('moderador');
 
Fecha de Ingreso: mayo-2006
Ubicación: /home/ams/
Mensajes: 38.567
Antigüedad: 13 años, 4 meses
Puntos: 2135
Respuesta: problemas con instanciar una classe

Aparte que en PHP5 ya no debes de usar &= porque en PHP5 todos los objetos se devuelven por referencia, y el uso que tienes ahí de global y static son incorrectos, lo correcto en teoría debería de ser algo así:
Código PHP:
Ver original
  1. class Database
  2. {
  3.        private static $_link = null;
  4.  
  5.        public static getInstance()
  6.        {
  7.                if (!(self::$_link instanceof self)) {
  8.                         self::$_link = new self();
  9.                }
  10.  
  11.                return self::$_link;
  12.        }
  13. }

Aunque también usar singleton para conexiones de la BDD es des-aconsejado, busca en el foro, hay muchas discusiones al respecto.

Saludos.
  #8 (permalink)  
Antiguo 04/08/2011, 08:41
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

como ??? noo entienddo getinstance debo declararla static ?
  #9 (permalink)  
Antiguo 04/08/2011, 08:49
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

ah ok gatorV veo que lo que echo esta mal cierto deberia de buscar algo o de hacer algo un poco mejor :)
  #10 (permalink)  
Antiguo 04/08/2011, 09:03
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

Cita:
Iniciado por abimaelrc Ver Mensaje
Ok, veo que estás usando PHP4, ¿por qué no tratas de cambiar a PHP5? Otra cosa, no sé si PHP4 usa static pero tsDatabase::getInstance() está tratando de llamar una clase que sea estática. Por lo que getInstance debes declararla como static.
Mi problema de migrar a php5 es que no estoy muy actualizado al php 5 y casi no se como empezar las cosas :(
  #11 (permalink)  
Antiguo 04/08/2011, 09:07
Avatar de abimaelrc
Colaborador
 
Fecha de Ingreso: mayo-2009
Ubicación: En el planeta de Puerto Rico
Mensajes: 14.734
Antigüedad: 10 años, 4 meses
Puntos: 1516
Respuesta: problemas con instanciar una classe

Pero si ya dominas la del 4, solo es cuestión de aprender lo nuevo en el 5.
__________________
Verifica antes de preguntar.
Los verdaderos amigos se hieren con la verdad, para no perderlos con la mentira. - Eugenio Maria de Hostos
  #12 (permalink)  
Antiguo 04/08/2011, 09:21
Avatar de GatorV
$this->role('moderador');
 
Fecha de Ingreso: mayo-2006
Ubicación: /home/ams/
Mensajes: 38.567
Antigüedad: 13 años, 4 meses
Puntos: 2135
Respuesta: problemas con instanciar una classe

En el Manual de PHP hay una sección de migración y te puede ayudar a identificar lo que cambio entre PHP4 y PHP5.

Saludos.
  #13 (permalink)  
Antiguo 05/08/2011, 11:42
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

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

Sigues usando el operador de referencia &= lo cual no es correcto, revisa más arriba el porque.
  #15 (permalink)  
Antiguo 05/08/2011, 16:44
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 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 :)
  #16 (permalink)  
Antiguo 06/08/2011, 14:09
Avatar de GatorV
$this->role('moderador');
 
Fecha de Ingreso: mayo-2006
Ubicación: /home/ams/
Mensajes: 38.567
Antigüedad: 13 años, 4 meses
Puntos: 2135
Respuesta: problemas con instanciar una classe

Declaras la propiedad $_dbLink, pero nunca la usas, y usas el operador static dentro de tu clase la cual no es necesaria, usa mejor la propiedad $_dbLink.

Saludos.
  #17 (permalink)  
Antiguo 06/08/2011, 15:13
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

bueno hice el cambio GatorV aquí lo dejo y lo revises estoy usando esto

Código PHP:
Ver original
  1. public static  function getInstance(){
  2.     if (!(self::$_dblink instanceof self)) {
  3.                         self::$_dblink = new self();
  4.                }
  5.  
  6.                return self::$_dblink;
  7.     }

utilizando la propiedad $_dblink. como lo indicaste alla arriba eliminando las variables static y globas que tenia

mi pregunta es yo lo hago asi no se si esta bien hago una class ejemplo

class mi_class extends class_db {

private static $_dblink = null;

public static function getInstance(){
if (!(self::$_dblink instanceof self)) {
self::$_dblink = new self();
}

return self::$_dblink;
}


public function mifuncion(){

$query = $this->select("configuracion","*","","",1);
// RETORNAMOS
return $this->fetch_assoc($query);

}

}


eso esta bien pregunto no ay problemas en como lo esto haciendo

Última edición por thehack; 06/08/2011 a las 15:32 Razón: edtado
  #18 (permalink)  
Antiguo 06/08/2011, 16:49
Avatar de skywolker  
Fecha de Ingreso: julio-2011
Ubicación: España
Mensajes: 195
Antigüedad: 8 años, 2 meses
Puntos: 8
Respuesta: problemas con instanciar una classe

Creo que deberian estar todas asi : public static function(){

}

y llamar
tsDatabase::myfunction();

o si no

$var="tsDatabase";
$var::myfunction();

si estas ejecutando variables privadas fuera de la function te dara fatal error
solo pueden ser llamadas dentro de la function

si deseas llamarla puedes meterla dentro la function con la explicacion que te di de static

Tambien vi que usas var eso en cualquier momento no seguira functionando son interpretadas como public asi que me jor usa public

suerte .
  #19 (permalink)  
Antiguo 06/08/2011, 17:56
Avatar de GatorV
$this->role('moderador');
 
Fecha de Ingreso: mayo-2006
Ubicación: /home/ams/
Mensajes: 38.567
Antigüedad: 13 años, 4 meses
Puntos: 2135
Respuesta: problemas con instanciar una classe

Ojo con heredar tus clases solamente por heredar, el heredar se debe de hacer cuando tienes una relación de uso. Si tu clase solamente va a usar tu clase DB, debes de solamente guardar la instancia en una variable y usarla, o mejor inyectarla en tiempo de ejecución:
Código PHP:
Ver original
  1. $db = MyDB::getInstance();
  2. $class = new OtherClass();
  3. $class->setDb($db);

Así desacoplas la independencia. Es lo que se conoce como inyección de dependencias.

Saludos.
  #20 (permalink)  
Antiguo 07/08/2011, 10:40
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

no entendi la parte de no heredar solo por heredar, osea lo de abajo esta mal herencia de la base de datos esta mal no entiendo deberas me enrede y disculpa es q apenas comienzo en php 5 y esto se me hace un poco complicado GatorV dices que mejor es hacer el paso 2
Código PHP:
Ver original
  1. class mi_class extends class_db {
  2.  
  3. private static $_dblink = null;
  4.  
  5. public static function getInstance(){
  6. if (!(self::$_dblink instanceof self)) {
  7. self::$_dblink = new self();
  8. }
  9.  
  10. return self::$_dblink;
  11. }
  12.  
  13.  
  14. public function mifuncion(){
  15.  
  16. $query = $this->select("configuracion","*","","",1);
  17. // RETORNAMOS
  18. return $this->fetch_assoc($query);
  19.  
  20. }
  21.  
  22. }

Paso 2:

Código PHP:
Ver original
  1. class miclase{
  2.  
  3. function mifuncion(){
  4.  $db = new tsDatabase();
  5.             // CONSULTA
  6.         $query = $db->select("w_configuracion","*","","",1);
  7.         // RETORNAMOS
  8.         return $db->fetch_assoc($query);
  9.  
  10.  
  11.  
  12. }
  13. }

No hace falta hacer esto


Código PHP:
Ver original
  1. class clase extends classDB{
  2. private static $_dblink = null;
  3.  
  4.         public static  function getInstance(){
  5.     if (!(self::$_dblink instanceof self)) {
  6.                         self::$_dblink = new self();
  7.                }
  8.  
  9.                return self::$_dblink;
  10.     }
  11.  
  12. function mifuncion(){
  13.  
  14.             // CONSULTA
  15.         $query = $this->select("w_configuracion","*","","",1);
  16.         // RETORNAMOS
  17.         return $this->fetch_assoc($query);
  18.  
  19.  
  20.  
  21. }
  22.  
  23. }
  #21 (permalink)  
Antiguo 07/08/2011, 11:40
Avatar de skywolker  
Fecha de Ingreso: julio-2011
Ubicación: España
Mensajes: 195
Antigüedad: 8 años, 2 meses
Puntos: 8
Respuesta: problemas con instanciar una classe

primera vez que veo este metodo :

Código PHP:
if (!(self::$_dblink instanceof self)) {
                        
self::$_dblink = new self();//  y aqui? 
Si self es la clase caul es new self?
  #22 (permalink)  
Antiguo 07/08/2011, 15:05
 
Fecha de Ingreso: abril-2010
Mensajes: 151
Antigüedad: 9 años, 6 meses
Puntos: 1
Respuesta: problemas con instanciar una classe

jejejeje bueno eh terminado algunas cosas hasta los momento e echo consultas y no me ha dado error no se si estare empezando por buen pie les coloco mi codigo

1: config.inc.php
Código PHP:
Ver original
  1. define('db_host', "localhost");  // SERVIDOR
  2. define('db_name', "nombre de la db");  // NOMBRE DE LA BASE DE DATOS
  3. define('db_user', "usuario");  // USUARIO DE LA BASE DE DATOS
  4. define('db_pass', "contraseña");  // CONTRASEÑA
  5. define('db_persist', 0);

2:config.class.php
Código PHP:
Ver original
  1. <?php
  2. Class Conf{
  3.     private  $_dbhost;
  4.     private  $_dbname;
  5.     private  $_dbuser;
  6.     private  $_dbpass;
  7.     private  $_db_persist;
  8.     static $_instance;
  9.  
  10.    private function __construct(){
  11.       require TS_ROOT.'/config.inc.php';
  12.                 $this->_dbhost = db_host;
  13.         $this->_dbname = db_name;
  14.         $this->_dbuser = db_user;
  15.         $this->_dbpass = db_pass;
  16.         $this->_db_persist = db_persist;
  17.    }
  18.  
  19.    private function __clone(){ }
  20.  
  21.    public static function getInstance(){
  22.       if (!(self::$_instance instanceof self)){
  23.          self::$_instance=new self();
  24.       }
  25.       return self::$_instance;
  26.    }
  27.  
  28.    public function getUserDB(){
  29.       $var = $this->_dbuser;
  30.       return $var;
  31.    }
  32.  
  33.    public function getHostDB(){
  34.       $var=$this->_dbhost;
  35.       return $var;
  36.    }
  37.  
  38.    public function getPassDB(){
  39.       $var=$this->_dbpass;
  40.       return $var;
  41.    }
  42.  
  43.    public function getDB(){
  44.       $var=$this->_dbname;
  45.       return $var;
  46.    }
  47.  
  48. }

3:db.php

Código PHP:
Ver original
  1. /*
  2.  
  3.     CLASE PARA TRABAJAR CON LA BASE DE DATOS
  4.    
  5.     METODOS DE LA CLASE DB:
  6.    
  7.     tsdatabase()
  8.     connect()
  9.     query()
  10.     select()
  11.     update()
  12.     replace()
  13.     insert()
  14.     delete()
  15.     data()
  16.     fetch_objects()
  17.     fetch_assoc()
  18.     num_rows()
  19.     free()
  20.     insert_id()
  21.     error()
  22. */
  23.  
  24. /* Clase encargada de gestionar las conexiones a la base de datos */
  25. Class tsDatabase{
  26.  
  27.    private $servidor;
  28.    private $usuario;
  29.    private $password;
  30.    private $base_datos;
  31.    private $link;
  32.    private $_querys;
  33.    static $_instance;
  34.  
  35.    /*La función construct es privada para evitar que el objeto pueda ser creado mediante new*/
  36.    private function __construct(){
  37.       $this->setConexion();
  38.       $this->conectar();
  39.    }
  40.  
  41.    /*Método para establecer los parámetros de la conexión*/
  42.    private function setConexion(){
  43.       $conf = Conf::getInstance();
  44.       $this->servidor=$conf->getHostDB();
  45.       $this->base_datos=$conf->getDB();
  46.       $this->usuario=$conf->getUserDB();
  47.       $this->password=$conf->getPassDB();
  48.    }
  49.  
  50.    /*Evitamos el clonaje del objeto. Patrón Singleton*/
  51.    private function __clone(){ }
  52.  
  53.    /*Función encargada de crear, si es necesario, el objeto. Esta es la función que debemos llamar desde fuera de la clase para instanciar el objeto, y así, poder utilizar sus métodos*/
  54.    public static function getInstance(){
  55.       if (!(self::$_instance instanceof self)){
  56.          self::$_instance=new self();
  57.       }
  58.          return self::$_instance;
  59.    }
  60.  
  61.    /*Realiza la conexión a la base de datos.*/
  62.    private function conectar(){
  63.       $this->link=mysql_connect($this->servidor, $this->usuario, $this->password);
  64.       mysql_select_db($this->base_datos,$this->link);
  65.       mysql_query("set names 'utf8'");
  66.       mysql_query("set character set utf8");
  67.    }
  68.  
  69.  
  70.    // METODO PARA HACER UNA CONSULTA
  71.     // INPUT: $query
  72.     // OUTPUT: $result
  73.     function query($q){
  74.     $this->_querys++;
  75.         // HACIENDO CONSULTA Y RETORNANDO
  76.         return mysql_query($q);
  77.     }
  78.     // METODO PARA HACER UN SELECT
  79.     // INPUT:
  80.     //      $table | NOMBRE DE LA TABLA
  81.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  82.     //      $where | CONDICION DE LA CONSULTA
  83.     //      $order | ORDEN DE LOS RESULTADOS
  84.     //      $limit | LIMITE DE RESULTADOS
  85.     // OUTPUT: $result
  86.     function select($table, $fields, $where = NULL, $order = NULL, $limit = NULL){
  87.  
  88.          $this->_querys++;
  89.  
  90.         // CREANDO LA CONSULTA
  91.         $q = 'SELECT '.$fields.' FROM '.$table;
  92.         if($where) $q .= ' WHERE '.$where;
  93.         if($order) $q .= ' ORDER BY '.$order;
  94.         if($limit) $q .= ' LIMIT '.$limit;
  95.         // HACIENDO CONSULTA Y RETORNANDO
  96.         return mysql_query($q);
  97.     }
  98.     // METODO PARA HACER UN UPDATE
  99.     // INPUT:
  100.     //      $table | NOMBRE DE LA TABLA
  101.     //      $pairs | CAMPOS Y VALORES A ACTUALIZAR
  102.     //      $where | CONDICION DE LA CONSULTA
  103.     // OUTPUT: status
  104.     function update($table, $pairs, $where){
  105.  
  106.         $this->_querys++;
  107.         // DESCOMPONER CAMPOS DE UN ARRAY
  108.         if(is_array($pairs)) $fields = implode(", ", $pairs);
  109.         else $fields = $pairs;
  110.         // ARMANDO CONSULTA
  111.         $q = 'UPDATE '.$table.' SET '.$fields.' WHERE '.$where;
  112.         // REALIZANDO CONSULTA
  113.         $result = mysql_query($q);
  114.         // RETORNANDO ESTADO
  115.         if($result) return true;
  116.         else return false;
  117.     }
  118.     // METODO PARA HACER UN REPLACE
  119.     // INPUT:
  120.     //      $table | NOMBRE DE LA TABLA
  121.     //      $fields | CAMPOS A REEMPLAZAR
  122.     //      $values | VALORES A REEMPLAZAR
  123.     // OUTPUT: status
  124.     function replace($table, $fields, $values){
  125.  
  126.         $this->_querys++;
  127.         // ARMANDO CONSULTA
  128.         $q = "REPLACE INTO $table ($fields) VALUES ($values)";
  129.         // REALIZANDO CONSULTA
  130.         $result = mysql_query($q);
  131.         // RETORNANDO ESTADO
  132.         if($result) return true;
  133.         else return false;
  134.     }
  135.     // METODO PARA HACER UN INSERT
  136.     // INPUT:
  137.     //      $table | NOMBRE DE LA TABLA
  138.     //      $fields | CAMPOS
  139.     //      $values | VALORES
  140.     // OUTPUT: status
  141.     function insert($table, $fields, $values){
  142.  
  143.         $this->_querys++;
  144.         // ARMANDO CONSULTA
  145.         $q = 'INSERT INTO '.$table.' ('.$fields.') VALUES ('.$values.')';
  146.         // REALIZANDO CONSULTA
  147.         $result = mysql_query($q);
  148.         // RETORNANDO ESTADO
  149.         if($result) return true;
  150.         else return false;
  151.     }
  152.     // METODO PARA HACER UN DELETE
  153.     // INPUT:
  154.     //      $table | NOMBRE DE LA TABLA
  155.     //      $where | CONDICION
  156.     // OUTPUT: status
  157.     function delete($table, $where){
  158.  
  159.         $this->_querys++;
  160.         // ARMANDO CONSULTA
  161.         $q = 'DELETE FROM '.$table.' WHERE '.$where;
  162.         // REALIZANDO CONSULTA
  163.         $result = mysql_query($q);
  164.         // RETORNANDO ESTADO
  165.         if($result) return true;
  166.         else return false;
  167.     }
  168.     // METODO PARA HACER UNA CONSULTA Y OBTENER OBJETOS
  169.     // INPUT:
  170.     //      $table | NOMBRE DE LA TABLA
  171.     //      $fields | CAMPOS A SELECCIONAR DE LA TABLA
  172.     //      $where | CONDICION DE LA CONSULTA
  173.     //      $order | ORDEN DE LOS RESULTADOS
  174.     //      $limit | LIMITE DE RESULTADOS
  175.     // OUTPUT: $result
  176.     function data($table, $fields, $where =NULL, $order = NULL, $limit = NULL){
  177.  
  178.         $this->_querys++;
  179.         // CREANDO LA CONSULTA
  180.         $q = 'SELECT '.$fields.' FROM '.$table;
  181.         if($where) $q .= ' WHERE '.$where;
  182.         if($order) $q .= ' ORDER BY '.$order;
  183.         if($limit) $q .= ' LIMIT '.$limit;
  184.         // HACIENDO CONSULTA
  185.         $result = mysql_query($q);
  186.         // CREANDO Y RETORNANDO OBJETOS
  187.         if($result) return mysql_fetch_object($result);
  188.         else return false;
  189.     }
  190.     // METODO PARA CREAR OBJETOS DESDE UNA CONSULTA
  191.     // INPUT: $result
  192.     // OUTPUT: $objs
  193.     function fetch_objects($result){
  194.         if(!is_resource($result)) return false;
  195.         while($obj = mysql_fetch_object($result)) $objs[] = $obj;
  196.         return $objs;
  197.     }
  198.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  199.     // INPUT: $result
  200.     // OUTPUT: array
  201.     function fetch_assoc($result){
  202.         if(!is_resource($result)) return false;
  203.         return mysql_fetch_assoc($result);
  204.     }
  205.     // METODO PARA CREAR ARRAY DESDE UNA CONSULTA
  206.     // INPUT: $result
  207.     // OUTPUT: array
  208.     function fetch_array($result,$array = NULL){
  209.         if(!is_resource($result)) return false;
  210.         while($row = mysql_fetch_assoc($result)) $array[] = $row;
  211.         return $array;
  212.     }
  213.     // METODO PARA OBTENER EL VALOR DE UNA ROW
  214.     // INPUT: $result
  215.     // OUTPUT: array
  216.     function fetch_row($result){
  217.         return mysql_fetch_row($result);
  218.     }
  219.     // METODO PARA CONTAR EL NUMERO DE RESULTADOS
  220.     // INPUT: $result
  221.     // OUTPUT: num_rows
  222.     function num_rows($result){
  223.         if(!is_resource($result)) return false;
  224.         return mysql_num_rows($result);
  225.     }
  226.     // METODO PARA LIBERAR MEMORIA
  227.     // INPUT: $result
  228.     // OUTPUT: void
  229.     function free($result = 0){
  230.         return mysql_free_result($result);
  231.     }
  232.     // METODO PARA RETORNAR EL ULTIMO ID DE UN INSERT
  233.     // INPUT: void
  234.     // OUTPUT: status
  235.     function insert_id(){
  236.  
  237.       $this->_querys++;
  238.       return mysql_insert_id($this->_dblink);
  239.     }
  240.     // METODO PARA RETORNAR LOS ERRORES
  241.     // INPUT: void
  242.     // OUTPUT: status
  243.     function error(){
  244.       return mysql_error($this->_dblink);
  245.     }
  246.  
  247. }


ese es mi codigo a la db como lo utilizo

Código PHP:
Ver original
  1. include TS_CLASS."Conf.class.php";
  2. include TS_CLASS."c.db.php";        // FUNCIONES PARA LA DB
  3.  
  4. $db = tsDatabase::getInstance();


ejemplo de una clase donde hago consultas a la DB

Código PHP:
Ver original
  1. class Portal  {
  2.  
  3.     // INSTANCIA DE LA CLASE
  4.        static $_instance;
  5.     // INSTANCIA DE LA CLASE
  6.        public static function getInstance(){
  7.       if (!(self::$_instance instanceof self)){
  8.          self::$_instance = new Portal();
  9.       }
  10.          return self::$_instance;
  11.    }
  12.  
  13. /** getFavorites()
  14.      * @access public
  15.      * @param
  16.      * @return array
  17.      */
  18.      public function getFavorites(){
  19.      
  20. $db =  tsDatabase::getInstance();
  21. $tsCore = tsCore::getInstance();
  22. $tsUser = tsUser::getInstance();
  23.         //
  24.         $query = $db->select("p_favoritos","COUNT(fav_id) AS total","fav_user = {$tsUser->uid}");
  25.         $total = $db->fetch_assoc($query);
  26.         $db->free($query);
  27.         if($total['total'] > 0)
  28.             $pages = $tsCore->getPagination($total['total'], 20);
  29.         else return false;
  30.         //
  31.         $query = $db->query("SELECT f.fav_id, p.post_id, p.post_category, p.post_title, p.post_date, p.post_comments, p.post_puntos, p.post_private, u.user_name, c.c_nombre, c.c_seo, c.c_img FROM p_favoritos AS f LEFT JOIN p_posts AS p ON f.fav_post_id = p.post_id LEFT JOIN u_miembros AS u ON p.post_user = u.user_id LEFT JOIN p_categorias AS c ON c.cid = p.post_category WHERE p.post_status = 0 AND f.fav_user = {$tsUser->uid} ORDER BY f.fav_date DESC LIMIT {$pages['limit']}");
  32.         $data['data'] = $db->fetch_array($query);
  33.         $db->free($query);
  34.         //
  35.         $data['pages'] = $pages;
  36.         //
  37.         return $data;
  38.      }
  39.  
  40. }


esta bien los pasos que hasta el momento e realizado consultas a la db

Última edición por thehack; 07/08/2011 a las 15:07 Razón: Edit algo mal escrito
  #23 (permalink)  
Antiguo 07/08/2011, 17:03
Avatar de skywolker  
Fecha de Ingreso: julio-2011
Ubicación: España
Mensajes: 195
Antigüedad: 8 años, 2 meses
Puntos: 8
Respuesta: problemas con instanciar una classe

este metodo que usas sirve para evitar usar utf8_encode? es la primera vez que lo veo
Cita:
mysql_query("set names 'utf8'");
mysql_query("set character set utf8");

Bueno lo que as hecho es impresionante pero sinseramente no para mi gusto me temo que estaras revisando el config classs. inc todo el rato asta que te acuerdes de tus funciones realizadas

podras usar :

get_class_methods('miclase');

asi sabras las funciones que tienes.


// si se tratara de seguridad ok estoy de acuerdo .

Creo que no isiste caso de php 5 myclase::myfuncion eso es lo que deberias cambiar para menos esfuerzo.

//creo que podias metes una funcion dentro de otra pero tambien no importa lo haces de fuera mi_fun(fun_2("ejecuta.."));


Tambien tienes la oportunidad de meterle una clase a esas misma clase cuando quieras una clase en especifico para ese archivo en concreto no para todos asi no estas metiendo un archivo.php con cada clase ni ir a la misma clase a meter otra funcion

algo como:

static class clase{

private $va;


public function my_fun( classe_2 $clase2){

//ejecuta

public $clase2->$va="hola";


}

}
$clase= new clase;
$clase::$va;


$clase::my_fun(classe_2 new myclass() );


es como si mysql_query no fuera suficiente para ti

Mi recomendacion es que dejes las clases para cosas mas importantes saludos

Última edición por skywolker; 07/08/2011 a las 17:35

Etiquetas: classe, instanciar, php, php+archivos
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 22:51.