ObjetivoPHP

Paginador en PHP versión 3.0.0

por ObjetivoPHP el Ago.28, 2011 , en la categoria General

Aquí les dejo una actualización de la clase paginador, trae bastantes cambios con respecto a la anterior, igualmente sigue manteniendo la compatibilidad con la forma antigua de realizar la paginación, por lo cual se podría cambiar sin problemas con la anterior. Entre las novedades tenemos la capacidad de omitir enlaces (setOmitir) para realizar una paginacion anterior – siguiente solamente por ejemplo, permite deshabilitar enlaces que no son necesarios, generador de código html para los enlaces, propagación de variables útiles etc.

La siguiente imagen es ejemplo de las barras de navegación que podemos obtener:

Estilos para la barra de navegacion del paginador

Estilos para la barra de navegacion del paginador

Le dejo el archivo de descarga donde contiene una explicación paso por paso para la configuración del mismo.
Paginador 3.0.0

Los estilos fueron obtenidos de los siguientes sitios.
Mis Algoritmos
TimerSys

Permitir un Comentario mas...

Generador Fixture, torneo tipo Single Round Robin o de liguilla.

por ObjetivoPHP el Feb.23, 2011 , en la categoria Rutinas PHP

Esta clase genera un arreglo (tabla) conteniendo los cruces para una liga, donde todos los equipos se deben cruzar entre si. Ejemplo si tenemos 10 equipos se generara una matriz de 9 filas (Cantidad de Fechas necesarias) por 5 columnas (partidos por fechas), cada elemento contendrá una sub-matriz con los dos equipos que se enfrentaran, el siguiente cuadro muestra una representación de la matriz que se obtendrá.
Cerro
Peñarol
River Plate
Racing
Liverpool
Defensor SP.
Danubio
Wanderers
Nacional
Rampla Jrs
Rampla Jrs
Peñarol
Wanderers
Nacional
Defensor SP.
Danubio
Racing
Liverpool
Cerro
River Plate
River Plate
Peñarol
Liverpool
Cerro
Danubio
Racing
Nacional
Defensor SP.
Rampla Jrs
Wanderers
Wanderers
Peñarol
Defensor SP.
Rampla Jrs
Racing
Nacional
Cerro
Danubio
River Plate
Liverpool
Liverpool
Peñarol
Danubio
River Plate
Nacional
Cerro
Rampla Jrs
Racing
Wanderers
Defensor SP.
Defensor SP.
Peñarol
Racing
Wanderers
Cerro
Rampla Jrs
River Plate
Nacional
Liverpool
Danubio
Danubio
Peñarol
Nacional
Liverpool
Rampla Jrs
River Plate
Wanderers
Cerro
Defensor SP.
Racing
Racing
Peñarol
Cerro
Defensor SP.
River Plate
Wanderers
Liverpool
Rampla Jrs
Danubio
Nacional
Nacional
Peñarol
Rampla Jrs
Danubio
Wanderers
Liverpool
Defensor SP.
River Plate
Racing
Cerro

Código de la Clase:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
<?php
/**
 * Clase Fixture.
 * Genera una tabla de cruces para un torneo tipo Single Round Robin. o de
 * liguilla.
 *
 * @author      Marcelo Castro
 * @package     Fixture creado en el projecto opet
 * @copyright   2011 - ObjetivoPHP
 * @license     Gratuito (Free) http://www.opensource.org/licenses/gpl-license.html
 * @author      Marcelo Castro (ObjetivoPHP)
 * @link        objetivophp@******.*****
 * @link        http://objetivophp.com
 * @version     0.0.1 (19/02/2011 - 21/02/2011)
 */
class Fixture
{
    /**
     * Cantidad de equipos participantes en el torneo.
     * @var integer
     */
    private $_cantidadEquipos   = 10;
 
    /**
     * Cantidad de equipos utilizados para armar el fixture.
     * Puede haber uno mas en caso de ser impar el numero de equipos.
     * @var integer
     */
    private $_equiposFixture;
 
    /**
     * Cantidad de fechas que contendra el torneo.
     * @var integer
     */
    private $_fechas;
 
    /**
     * Cantidad de partidos que se jugaran por fecha.
     * @var integer
     */
    private $_partidosXFechas;
 
    /**
     * Guarda la matriz del fixture, incluye el equipo ficticio en caso de que
     * sea necesario.
     * @var array
     */
    private $_fixture           = array();
 
    /**
     * Contiene los nombres de los equipos o en su defecto los numeros, que se
     * le otorgaron a cada uno.
     * @var array
     */
    private $_equipos           = array();
 
    /**
     * Contiene si se seudo-aleatoriza la tabla de cruces o no.
     * @var boolean
     */
    private $_aleatorio         = true;
 
    /**
     * Contiene que debe de ponerse cuando un cuadro queda libre, caso
     * de cantidad de cuadros impares.
     * @var string
     */
    private $_libre             = 'libre';
 
    /**
     * Metodo __construct.
     * @param   mixed     $equipos    Cantidad de equipos o arreglo con los nombres.
     * @return  void
     */
    public function __construct($equipos = null)
    {
        if (is_array($equipos)) {
            $this->_cantidadEquipos = count($equipos);
            $this->_equipos         = $equipos;
        } else {
            $this->_cantidadEquipos =  is_int($equipos)? $equipos : 10;
            for ($f = 0; $f <= $this->_cantidadEquipos; $f++) {
                $this->_equipos[$f] = $f+1;
            }
        }
 
        $this->_partidosXFechas = ceil($this->_cantidadEquipos /2 );
        $this->_equiposFixture  = $this->_cantidadEquipos +  $this->_cantidadEquipos % 2;
        $this->_fechas          = $this->_partidosXFechas * 2 - 1 ;
    }
 
    /**
     * Configura si se aleatoriza la tabla de cruces.
     * @param   boolean     $aleatorio
     * @return  void
     */
    public function setAleatorio($aleatorio = true)
    {
        $this->_aleatorio   = ($aleatorio)? true : false;
    }
 
    /**
     * Asigna el comentario para fecha libre.
     * @param   string  $cometario
     * @return  void
     */
    public function setFechaLibre($comentario)
    {
        $this->_libre = $comentario;
    }
 
    /**
     * Metodo tablaDeCruces.
     * Genera una matriz con los cruces correspondientes entre los equipos.
     * @return void
     */
    public function tablaDeCruces()
    {
        $fixture   = array();
        if ($this->_aleatorio) {
            shuffle($this->_equipos);
        }
 
        if ($this->_cantidadEquipos % 2) {
            $this->_equipos[$this->_equiposFixture-1] = $this->_libre;
        }
 
        // Lleno el indice A de cada elemento con numeros del numero 1
        // hasta llegar al maximo de fechas y vuelvo a comenzar en 1.
        // El ultimo numero puesto debe ser el maximo de fechas.-
        $datos      = $this->_partidosXFechas * $this->_fechas;
        for ($f = 1; $f <= $datos; $f++) {
 
            $col        = $f % $this->_partidosXFechas;
            $col        = ($col != 0)? $col : $this->_partidosXFechas;
            $fila       = ceil ($f / $this->_partidosXFechas);
            $auxiliar   = $f % $this->_fechas;
            if ($auxiliar == 0) {
                $auxiliar = (int) $this->_fechas;
            }
            $fixture[$fila][$col]['A'] = $this->_equipos[$auxiliar-1];
        }
 
        // Lleno el primer elemento de cada fila con el ultimo equipo
        // o el equipo ficticio, si la cantidad de equipo es impar.
        for ($f = 1; $f<= $this->_fechas; $f++) {
            $fixture[$f][1]['B']    = $this->_equipos[$this->_equiposFixture-1];
        }
 
        // Lleno el indice B de cada elemento empezando del maximo de fechas
        // hasta 1 y vuelvo a empezar salteo la primer columna que ya fue completada
        // en el ciclo anterior
        $indice = $this->_fechas;
        for ($f = 1; $f <= $this->_fechas; $f++) {
            for ($c = 2; $c <= $this->_partidosXFechas; $c++) {
                $fixture[$f][$c]['B']   = $this->_equipos[$indice - 1];
                if (--$indice == 0) {
                    $indice = $this->_fechas;
                }
            }
        }
        $this->_fixture     = $fixture;
    }
 
    /**
     * Retorna el arreglo de todos los cruces.
     * @return array 
     */
    public function getCruces()
    {
        return $this->_fixture;
    }
 
    /**
     * Metodo verCuadro.
     * Muestra la tabla de cruces en una tabla HTML, es solo a efectos demostrativos
     * @return  HTML
     */
    public function verCuadro()
    {
        echo "<table border=1>\n";
        for ($f = 1; $f <= $this->_fechas; $f++) {
            echo "<tr>\n";
            for ($c = 1; $c <= $this->_partidosXFechas; $c++) {
                echo "<td>";
                echo utf8_decode($this->_fixture[$f][$c]['A']);
                echo '</br>' . utf8_decode($this->_fixture[$f][$c]['B']);
                echo "</td>\n";
            }
            echo "</tr>\n";
        }
        echo "</table>";
    }
}

Método de Uso:
Como siempre por tratarse de una clase lo primero que debemos hacer es instanciarla,

$objFix     = new Fixture($equipos);
La variable $equipos, puede tomar dos tipos de datos, o puede ser un entero o puede ser un arreglo, si es un entero este sera tomado como la cantidad de equipos que participaran en el torneo. Si es un arreglo cada elemento del mismo debe ser el nombre de un equipo participante en el torneo y se tomara el tamaño del arreglo como la cantidad de equipos participantes.
// Primera forma pasamos un entero.
$equipos    = 10;
// Segunda forma pasamos un arreglo con los datos
$equipos    = array('Peñarol',
                    'Nacional',
                    'Liverpool',
                    'River Plate',
                    'Defensor SP.',
                    'Rampla Jrs',
                    'Wanderers',
                    'Cerro',
                    'Racing',
                    'Danubio');
// La definicion de la variable $equipos debe ser realizada antes de la instancia.

Configuraciones:

Solo tenemos dos métodos de configuración, setAleatorio y setFechaLibre.
setAleatorio solo recibe un parámetro de tipo boolean, donde si este es true generara la tabla en una forma seudo-aleatoria en realidad lo que realiza es un mezclado de los equipos pero no de la solución de cruces que siempre sera la misma. Por defecto se asume true
$objFix->setAleatorio(true);
// No es necesario para true pero es a modo de ejemplo.

setFechaLibre recibe un string (cadena de caracteres), que representa el comentario que se pondrá cuando un equipo tenga fecha libre.

$objFix->setFechaLibre('Libre');

Eso es lo único que podemos configurar.
Luego de realizar o no dicha configuración ejecutamos el método que genera la matriz de cruces.

$objFix->tablaDeCruces();

Por ultimo tenemos el método de captura de los resultados, para ello contamos con getCruces(), que nos retornara el arreglo o matriz con los emparejamientos de cuadros.

$cruces     = $objFix->getCruces();

Por ultimo mencionare el método tablaDeCruces() que en realidad esta puesto solo para ver en formato HTML la tabla de cruces, pero no debería formar parte de la clase.

Espero a alguien le sea de utilidad.

Permitir un Comentario :, , , , mas...

Generador de Números Aleatorios

por ObjetivoPHP el Feb.02, 2011 , en la categoria Rutinas PHP

Esta clase la realice no se con que fin y no se que utilidad pueda tener todavia, mas allá de jugar un rato con ella y programar otro poco. Se encarga de generar números aleatorios en un entorno dado, pudiendo elegir incluso la cantidad de decimales, la clase nos retorna como salida un arreglo con la cantidad de elementos seleccionados.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
<?php
/**
 * Clase Aleatorio.
 * Genera un numero aleatorio entre dos numeros dados.
 *
 * @package     matematica creado en el projecto ipusa
 * @copyright   2010 - ObjetivoPHP
 * @license     Gratuito (Free) http://www.opensource.org/licenses/gpl-license.html
 * @author      Marcelo Castro (ObjetivoPHP)
 * @link        objetivophp@*****.***
 * @version     1.0.0 (17/09/2010 - 17/09/2010)
 */
class Aleatorio
{
    /**
     * Es el extremo inferior del entorno de los numero aleatorios.
     * @var float
     */
    private $_extremoInferior = 0;
 
    /**
     * Es el extremo superior del entorno superior de los numeros aleatorios.
     * @var float
     */
    private $_extremoSuperior = 1;
 
    /**
     * Cantidad de decimales, 0 para entero, max 10.
     * @var integer
     */
    private $_decimales = 0;
 
    /**
     * Cantidad de numeros aleatorios a Generar.
     * @var integer
     */
    private $_cantidad = 1;
 
    /**
     * Configura si seran aleatorios unicos false, o true para que se puedan repetir.
     * @var boolean
     */
    private $_permitirRepetidos = true;
 
    /**
     * Guarda los numeros aleatorios generados.
     * @var array
     */
    private $_aleatorios = array();
 
    /**
     * Metodo __construct.
     * @param   double  $extInferior    Numero minimo que se puede generar.
     * @param   double  $extSuperior    Numero maximo que se puede generar.
     * @return  void
     */
    public function  __construct($extInferior, $extSuperior)
    {
        if ($extSuperior > $extInferior) {
            $this->_extremoInferior = $extInferior;
            $this->_extremoSuperior = $extSuperior;
        }
    }
 
    /**
     * Metodo setDecimales.
     * Configura cuantos decimales despues de la coma deber tener el numero
     * aleatorio generado.
     * @param   integer $decimales  cantidad de decimales despues de la coma.
     * @return  void
     */
    public function setDecimales($decimales)
    {
        if ($decimales >=0 && $decimales <=10) {
            $this->_decimales = (int) $decimales;
        }
    }
 
    /**
     * Metodo setCantidad.
     * Configura la cantidad de numeros aleatorios que deberan generarse.
     * @param   integer $cantidad   Cantidad de numeros a generarse.
     * @return  void
     */
    public function setCantidad($cantidad)
    {
        $this->_cantidad = ($cantidad > 0)? (int) $cantidad : 1;
    }
 
    /**
     * Metodo setPermitirRepetidos.
     * Configuramos si se pueden repetir numeros o no.
     * @param   boolean $repetir true se pueden repetir los numeros
     *                           false no se puede repetir
     * @return  void
     */
    public function setPermitirRepetidos($repetir = true)
    {
        $this->_permitirRepetidos = ($repetir)? true : false;
    }
 
    /**
     * Metodo generar.
     * Genera los numeros aleatorios.
     * @return array
     */
    public function generar()
    {
        if (!$this->_controlarBucle()) {
            trigger_error('No se permite generar mas del 75% de los numeros unicos.', E_USER_ERROR);
            return;
        }
        mt_srand();
        $maxAleatorio   = mt_getrandmax();
        $amplitud       = $this->_extremoSuperior - $this->_extremoInferior;
 
        for ($i = 0; $i < $this->_cantidad; $i++) {
            do {
                $aleatorio  = mt_rand() / $maxAleatorio;
                $numero     = ($amplitud * $aleatorio) + $this->_extremoInferior;
                $numero     = number_format($numero, $this->_decimales);
            } while (!$this->_permitirRepetidos && in_array($numero, $this->_aleatorios));
            $this->_aleatorios[$i] = $numero;
        }
        return $this->_aleatorios;
    }
 
    /**
     * Metodo getAleatorios.
     * Retorna los numeros aleatorios que fueron generados.
     * @param   integer $orden 1 = Ascendente, 2 = descendente, otro sin ordenar.
     * @return  array
     */
    public function getAleatorios($orden = null)
    {
        $numeros    = $this->_aleatorios;
        switch ($orden) {
            case 1:
                sort($numeros);
                break;
            case 2:
                rsort($numeros);
                break;
            default:
        }
        return $numeros;
    }
 
    /**
     * Metodo _controlarBucle.
     * Ofrece seguridad de no caer en un bucle infinito.
     * @return boolean
     */
    private function _controlarBucle()
    {
        $posible    = true;
        if ($this->_permitirRepetidos === false) {
            $intervalo      = 1 / pow(10, $this->_decimales);
            $amplitud       = $this->_extremoSuperior - $this->_extremoInferior + $intervalo;
            $maxCantidad    = $amplitud / $intervalo;
            if (($maxCantidad * 0.75) <= $this->_cantidad) {
                $posible    = false;
            }
        }
        return $posible;
    }
}
Bueno la utilización es sencilla. Como siempre primero instanciamos la clase, dándole los parámetros inferiores y superiores. Luego si queremos alguna opción más se la damos y por ultimo enviamos a generar.

Ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Instanciamos la clase y le decimos que genere en el entorno 15,99
$obj = new Aleatorio(15, 99);
//Podemos Congiguramos la cantidad de numeros que queremos si no ponemos nada es 1.
$obj->setCantidad(5);
// Cantidad de números después de la coma, 0 (cero) para enteros.
$obj->setDecimales(0);
// Configuramos si queremos que se repitan o no los numeros aleatorios.
$obj->setPermitirRepetidos(false);
// Generamos los numeros una vez seleccionadas las opciones que queremos.
// generar retorna un arreglo pero si no lo capturamos lo podremos hacer luego 
// con getAleatorios
$obj->generar();
// Capturamos los numeros generados.
// 1> ascendente - 2> Descendente - nullo como salieron
$numeros    = $obj->getAleatorios(1);
// Imprimimos los resultados
var_dump($numeros);

Bueno espero que a alguna persona le sea de utilidad.

1 Comentario :, , mas...

Buscador FullText MySQL con Paginador en PHP

por ObjetivoPHP el Nov.21, 2010 , en la categoria Rutinas PHP

En los artículos anteriores había presentado un paginador y un buscador genérico para mysql, tipo full text, y quedado pendiente la utilización de los mismos en conjunto. Bueno llego el momento de hacerlos trabajar juntos. Como verán no integrare todo en uno es decir no combinare dichas clases, si no que cada clase seguirá manteniendo su única responsabilidad para dejar intacta la re-utilización de las mismas.

El mismo código esta bastante explicado por lo cual se los dejo aqui y al finalizar el mismo un enlace de descarga para bajar el ejemplo completo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
<?php
// iniciamos session para no propagar por url variables que nos van a ayudar
// a mejorar la rapidez y la presentacion.
session_start();
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>BUSCADOR FULLTEXT + PAGINADOR</title>
</head>
 
<body>
	<?php
	// Parametros a ser usados por el Paginador y el Buscador
	$cantidadRegistrosPorPagina	= 1;
    $cantidadEnlaces            = 5; // Cantidad de enlaces que tendra el paginador.
    $totalRegistros             = 0;
 
    // Vemos si viene por el paginador o por el form del buscador
    if (isset($_POST['buscar'])) { // Viene por el buscador
        $pagina                 = 0;
        $inicioLimit            = 0;
        $_SESSION['BUSCAR']     = $_POST['buscar'];
        // Configuro el paginador
        require_once 'BuscadorFullText.php';
        $objBuscador				= new BuscadorFullText($_POST['buscar'], 'buscador');
        // Agregamos los campos donde se buscara las palabras o criterios de busqueda
        $objBuscador->addCamposFullText('titulo, desarrollo');
 
        // Campos que se obtendran como resultado
        $objBuscador->addCamposResultado(array('idNoticia', 'titulo', 'desarrollo', 'categoria'));
 
        // Parametros que pueden variar en este caso debe coincidir el nombre del campo en el form html
        // con el nombre en la tabla MySQL
        if (isset($_POST['categoria']) && $_POST['categoria'] ) {
            $objBuscador->addParametrosVariables('categoria' , '=');
        }
        // añade a la consulta una condicion fija
        $objBuscador->addParametrosFijos("estado LIKE 'aprobada'");
 
        // Para limitar la cantidad de caracteres en la salida de algun campo
        $objBuscador->limitarLargo('titulo', 100);
        $objBuscador->limitarLargo('desarrollo', 250);
        // Capturamos la consulta que se debe realizar y agregamos el limit
        $consulta                = $objBuscador->getConsultaMysql();
        $_SESSION['CONSULTA']    = $consulta;
 
    } else { // Viene por el paginador
        $pagina					= isset($_GET['pagina'])? $_GET['pagina'] : 0;
        $inicioLimit			= $cantidadRegistrosPorPagina * $pagina;
        $consulta               = isset($_SESSION['CONSULTA'])?$_SESSION['CONSULTA'] : '';
        $_SESSION['BUSCAR']     = isset($_SESSION['BUSCAR'])? $_SESSION['BUSCAR'] : '';
    }
 
	// incluimos e instanciamos la clase buscadorFullText, pasando como parametros
    // el valor del campo de busqueda y la tabla a buscar.
	?>
    <div align="center">
	<form id="form1" name="form1" method="post" action="">
		<input type="text" name="buscar" id="buscar" value="<?php echo $_SESSION['BUSCAR']; ?>" />
			<select name="categoria" id="categoria">
		  		<option value="0">Todo el Sitio</option>
                <option value="Noticias">Noticias</option>
		  		<option value="Reportes">Reportes</option>
		  		<option value="Revisiones">Revisiones</option>
	    	</select>
	  	<input type="submit" name="enviar" id="enviar" value="Enviar" />
    </form>
    <?php
	echo 'Consulta Generada: <br />' .$consultaLimit      = sprintf($consulta, $inicioLimit, $cantidadRegistrosPorPagina);
    echo '</div><br /><br />';
 
    if ($consultaLimit) {
        // CONEXION MYSQL
        // Bueno ahora lo hacemos con la clasica mysql_connect.
        $conexion           = mysql_connect('localhost', 'root', '');
        mysql_select_db('buscadorfulltext', $conexion);
        $resultados         = mysql_query($consultaLimit, $conexion);
        $resultadosCantidad = mysql_fetch_row(mysql_query("SELECT FOUND_ROWS();", $conexion));
        $totalRegistros     = $resultadosCantidad[0];   // Se usara en el Paginador
        // Mostramos los resultados de la forma clasica
        echo '<table>';
        while($fila = mysql_fetch_array($resultados)) {
            echo '<tr >';
                echo '<td style="border:1px; border-style:solid;">' . $fila['idNoticia'] . '</td>';
                echo '<td style="border:1px; border-style:solid;">' . $fila['titulo'] . '</td>';
                echo '<td style="border:1px; border-style:solid;">' . $fila['desarrollo'] . '</td>';
                echo '<td style="border:1px; border-style:solid;">' . $fila['categoria'] . '</td>';
            echo '</tr>';
        }
        echo '</table>';
    } else { // Muestro Propiedades del Buscador
    ?>
     <div align="center">
  <center>
  <table border="0" cellpadding="0" cellspacing="0" width="450" id="AutoNumber1" height="312">
    <tr>
      <td height="17" colspan="2">Propiedades del Buscador FULLTEXT</td>
      </tr>
    <tr>
      <td width="11%" height="17"><b>Operador</b></td>
      <td width="89%" height="17">
      <p align="center"><b>Significado</b></td>
    </tr>
    <tr>
      <td width="11%" align="center" height="13"></td>
      <td width="89%" height="13"> </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="36" style="border-bottom: 1px dotted #000000">&nbsp;</td>
      <td width="89%" height="36" align="justify" style="border-bottom: 1px dotted #000000">Por defecto no se especifica nada, las palabras son
      optativas pero tendran mayor importancia los registros con mas palabras
      coincidentes. </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="23" style="border-bottom: 1px dotted #000000">+</td>
      <td width="89%" height="23" align="justify" style="border-bottom: 1px dotted #000000">Indica que la palabra debe estar presente en los&nbsp;
      registro buscados. </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="23" style="border-bottom: 1px dotted #000000">-</td>
      <td width="89%" height="23" align="justify" style="border-bottom: 1px dotted #000000">Indica que la palabra no debe estar presente en los
      registros buscados.</td>
    </tr>
    <tr>
      <td width="11%" align="center" height="54" style="border-bottom: 1px dotted #000000">&lt;&gt;</td>
      <td width="89%" height="54" align="justify" style="border-bottom: 1px dotted #000000">Estos dos operadores se acostumbran a usar para cambiar la
      importancia de una palabra en la b&uacute;squeda. El signo &lt; disminuye la
      contribuci&oacute;n y el signo &gt;&nbsp; la aumenta. </td>
    </tr>
    <tr>
      <td width="11%" align="center" height="90" style="border-bottom: 1px dotted #000000">~</td>
      <td width="89%" height="90" align="justify" style="border-bottom: 1px dotted #000000">El tilde opera como negaci&oacute;n, causando una importancia negativa de la
      palabra en la b&uacute;squeda. Es &uacute;til para marcar las palabras de ruido. Una
      fila que contiene dicha palabra se le dara una importancia mas baja que
      otras, pero no se excluir&aacute; de los resultados, como si ocurrir&iacute;a si se
      usara el operador menos.</td>
    </tr>
    <tr>
      <td width="11%" align="center" height="36" style="border-bottom: 1px dotted #000000">&quot;</td>
      <td width="89%" height="36" align="justify" style="border-bottom: 1px dotted #000000">Las comillas dobles al principio y final de una frase,
      buscara s&oacute;lo registros que contienen la frase completa , tal como se
      tecle&oacute;.</td>
    </tr>
    </table>
  </center>
</div>
 
    <?php
    }
    // Comenzamos con el paginador.
    require_once 'Paginador.php';
    // Instanciamos la clase Paginador
    $paginador          = new Paginador();
 
    // Configuramos cuanto registros por pagina que debe ser igual a el limit de la consulta mysql
    $paginador->setCantidadRegistros($cantidadRegistrosPorPagina);
    $paginador->setCantidadEnlaces($cantidadEnlaces);
 
    // Y mandamos a paginar desde la pagina actual y le pasamos tambien el total
    // de registros de la consulta mysql.
    $datos              = $paginador->paginar($pagina, $totalRegistros);
 
 
    // Preguntamos si retorno algo, si retorno paginamos con los datos que nos da el
    // paginador que es un arreglo.
    if ($datos) {
        echo '<div align="center">';
        echo 'Pagina: ' . ($pagina + 1) . ' de ' . $paginador->getCantidadPaginas() . '<br />';
        echo 'Registros encontrados: ' . $totalRegistros . '<br />';
        foreach ($datos as $enlace) {
        ?>
            <a href="?pagina=<?php echo $enlace['numero']; ?>" title="<?php echo $enlace['title']; ?>" style="text-decoration:none;"><?php echo $enlace['vista']; ?></a>
        <?php
        }
        echo "</div>";
    }
    ?>
    <br />
</body>
</html>
Espero que sea de su utilidad y cualquier duda para implementarlo, pueden dejar un mensaje con los obstáculos que encontraron para su utilización.

Ver características del Buscador.
Ver características del Paginador.
buscadorFullText

Nota: se recomienda bajar el ejemplo completo, pues tanto el buscador como el paginador tienen unos pequeños retoques.

Permitir un Comentario :, , , , mas...

Actualización DEAME3P V.5.2.0

por ObjetivoPHP el Oct.30, 2010 , en la categoria Breves

Actualización DEAME3P V.5.2.0

Se incorporan patrones de exportación. Con esta funcionalidad se podrá exportar intervalos de filas de la hoja de calculo, con una patrón similar al seleccionar hojas para imprimir de cualquier suite ofimática.
Se actualizo la librería PHPExcel de la versión 1.7.0 a la 1.7.4. (Si existe algún error por favor enviármelo… Gracias).
Mejoras en el formulario de Administrar Plantillas (Ahora pasa a utilizar la clase Directorio).
Descargar DEAME3P 5.2.0

Actualización DEAME3P V.5.1.0

Es la actualización mas importante de la versión 5, incluye arreglos en errores de tipo E_NOTICE que impedían una correcta generación de archivos tanto xls como xlsx. Así mismo se a agregado un administrador de los errores a mostrar por parte de la rutina que esta pensado para las próximas versiones.
Se modifico el código para soportar nombres de campos MySQL que contengan espacios.

En la parte del ABMTablas que esta en versión alfa se mejoro problemas con la librería iconv que se producían con letras ñ o tildes, al igual que mejora en errores DE TIPO E_NOTICE.

Cualquier error que encuentren por favor comunicármelo.

Descargar

Permitir un Comentario :, , , , , mas...

Busca algo

Use el formulario debajo para buscar en el sitio:

Todavía no a encontrado lo que usted busca? Deje un comentario, o póngase en contacto con nosotros así podremos ayudarlo.