
Ordenar listas de objetos, arrays asociativas y multidimensionales en PHP nunca fue más fácil. Desde PHP 5.3 se introdujo el concepto de closures o funciones anónimas. Estas permiten la creación de funciones sin nombre y en PHP se suelen usar como parámetro de callback.

\*Nota: Si has programado en Ruby, estas funciones son algo parecido a lo que se conoce como **blocks**. Esta metodología también se suele usar bastante en Javascript.

Veamos un ejemplo:

Si tenemos un listado de arrays

```php
$coleccion = array(
  array(
    "color" => "rojo"
  ),
  array(
    "color" => "blanco"
  ),
  array(
    "color" => "negro"
  ),
);
```

Lo ordenamos por la clave color alfabéticamente y de forma ascendente.

```php
usort($coleccion, function($a, $b)
 {
  return strcmp($a["color"], $b["color"]);
});
```

El array ordenado quedará así:

```php
print_r($coleccion);
```

```
Array
([0] => Array([color] => blanco)
    [1] => Array(
      [color] => negro
    )
    [2] => Array(
      [color] => rojo
    )
)
```

Como vemos la función permite pasarle como parámetro otra función.

## Visibilidad de variables

Una de las cosas a tener en cuenta al usar funciones anónimas es que se crea un ámbito único para ejecutar el código de la función, es decir, las variables que se definan fuera de esta función no son accesibles. Para utilizar una variable externa podemos usar la instrucción **use**, por ejemplo:

```php
$otra_variable = 1;

usort($coleccion, function($a, $b) use($otra_variable) {
  if($otra_variable == 1) {
    return strcmp($a["color"], $b["color"]);
  } elseif($otravariable == 2) {
    // ...
  }
});
```


Cómo ordenar arrays multidimensionales en PHP con usort y funciones anónimas

Ordenar arrays en PHP

ordenar-arrays-en-php


Para poder realizar peticiones de tipo POST en PHP hay que usar la librería CURL. Esta librería simplifica en gran medida el código necesario para realizar peticiones de tipo GET y sobretodo de tipo POST, ofreciendo además varias posibilidades adicionales sobre la misma conexión.

Una de las mayores diferencias entre una petición GET y POST es que la primera se le pueden pasar los parámetros en la misma dirección URL, mientras que en una petición de tipo POST los parámetros se pasan a parte.

Veamos un ejemplo completo. Primero definimos la url y los parámetros que pasaremos en la petición:

```php
$url =  "http://url-de-la-peticion.com";
$valor1 = "hola";
$valor2 = "adiós";
```

A continuación hay que codificar estos parámetros para que sean válidos con la función urlencode

$parametros_post = 'parametro1='.urlencode($valor1).'&parametro2='.urlencode($valor2);

_\* Atención: Con este tipo de petición sólo podremos pasar parámetros de tipo texto, las imágenes o archivos al usar codificación de tipo MULTIPART, se deben pasar como archivos binarios. Esto no lo veremos en este artículo._

Inicio de la sesión **CURL**, así como su configuración para esta petición:

```php
$sesion = curl_init($url);
// definir tipo de petición a realizar: POST
curl_setopt ($sesion, CURLOPT_POST, true);
// Le pasamos los parámetros definidos anteriormente
curl_setopt ($sesion, CURLOPT_POSTFIELDS, $parametros_post);
// sólo queremos que nos devuelva la respuesta
curl_setopt($sesion, CURLOPT_HEADER, false);
curl_setopt($sesion, CURLOPT_RETURNTRANSFER, true);
// ejecutamos la petición
$respuesta = curl_exec($sesion);
// cerramos conexión
curl_close($sesion);
```

Finalmente la variable $respuesta contiene la información que haya devuelto la petición y que trataremos según nos convenga.


Cómo generar una petición POST con curl en PHP, muy útil para conectar con servicios web

Petición vía POST con CURL en PHP

peticion-via-post-con-curl-en-php


PHPSH es una consola interactiva, también conocida como Shell, para PHP. Está escrita en Python por los desarrolladores de Facebook. Es Open Source y entre sus características destacan un rápido acceso a la documentación de PHP y la autocompletación de instrucciones con la tecla TAB.

Si habéis trabajado con otras consolas como la de Django, o la de Ruby on Rails estaréis de acuerdo en lo valiosas que son este tipo de herramientas para desarrollar aplicaciones rápidamente.

En este artículo veremos cómo instalar esta consola.

## Instalación PHPSH en Linux

Debemos tener instalado Python previamente a instalar PHPSH.

Descargamos la última versión de PHPSH y la descomprimimos:

```bash
wget http://www.phpsh.org/phpsh-latest.tgz
tar zxf phpsh-latest.tgz
```

Ahora debemos dar permisos de ejecución al archivo phpsh

```bash
cd phpsh/
chmod +x phpsh
```

Finalmente podemos ejecutar la consola PHP manualmente:

```bash
./phpsh
```

En futuras versiones tal y como comentan en su web es posible que añadan la posibilidad de utilizar breakpoints para depurar las aplicaciones PHP en tiempo real.


PHPSH es una consola interactiva para PHP

Consola PHP

consola-php


En un entorno de producción siempre será necesario capturar los errores en algun tipo de log. PHP nos lo permite hacer de una forma muy sencilla.

Hay que tener en cuenta que en nuestro entorno de desarrollo nos es más útil que los errores que aparecen al ejecutar una aplicación PHP se muestren por pantalla, sin embargo, esto es peligroso en un entorno real de producción, puesto que estos registros suelen dar información detallada sobre datos de nuestro sistema.

## Capturar todos los registros de errores PHP en un archivo

Para configurar los logs de error de PHP podemos modificar el archivo php.ini que se encarga de configurar opciones de PHP. Normalmente suele estar en /etc/php.ini

```bash
nano /etc/php.ini
```

Podemos usar cualquier editor que nos apetezca (vi, o si estás en entorno gráfico gedit, etc..)

Debemos buscar la línea donde aparezca la variable error_log descomentarla y añadir la ruta donde guardaremos el log. Por ejemplo:

```
error_log = "/var/log/php_errors.log"
```

También hay que asegurarse que la variable log_errors está a On para que registre errores

```
log_errors = On
```

Y finalmente la variable display_errors a Off para que no se muestren los errores por pantalla

```
display_errors = Off
```

Para que apache puedea escribir en ese fichero tiene que tener permisos. Podemos cambiar el owner del fichero /var/log/php_errors.log al usuario apache que suele ser el nombre de usuario que usa el servidor httpd

```bash
chown apache /var/log/php_errors.log
```

O sino, también podemos cambiar los permisos para que se pueda escribir

```bash
chmod 777 /var/log/php_errors.log
```

\* Atención: Hay que ir con cuidado al asignar este último permiso, ya que en un servidor con múltiples usuarios podrían tener acceso.


Configurar PHP para que muestre los errores en un log

Registrar errores PHP en un log

registrar-errores-php-en-un-log


Para iterar sobre arrays (estructuras de datos de tipo tabla o vector) en PHP podemos usar la instrucción **foreach**

Su uso es muy simple y nos permite recorrer estas estructuras de datos de una forma alternativa a la forma clásica de declarar una variable como contador e ir incrementándola a medida que recorremos los índices.

Existen dos tipos de sintaxis para la instrucción foreach:

```php
foreach (array as $valor){
    instruccion;
}

foreach (array as $clave => $valor){
    instruccion;
}
```

La primera se utiliza cuando solo nos interesa el contenido de una posición concreta de vector.

La segunda se usa si también deseamos usar el valor de $clave, por ejemplo si los índices no son numéricos.

## Ejemplo funcional de foreach en PHP

```php
$datos = array("69878754-E" => "Julián", "32684574-F" => "Paula", "44580546-P" => "Marta");
foreach ($datos as $clave => $valor) {
    echo "dni: $clave Nombre: $valor";
}
```

En este ejemplo tenemos un conjunto de personas en una tabla cuya identificación es su DNI.


Método foreach() para recorrer estructuras de tipo vector o tabla en PHP

Foreach PHP

foreach-php


En este tutorial mostraremos cómo acceder a un archivo remoto en formato CSV extraer los datos y ponerlos en un array para manejarlos como nos convenga.

Los archivos CSV son un tipo de archivo utilizado para guardar información de una forma estructurada de una base de datos en un archivo. Principalmente se utiliza Microsoft Excel para generar estos archivos y es común que nos pasen datos en este tipo de archivo y tengamos que extraerlos.

Para ello PHP tiene funciones que nos facilitarán el trabajo.

## Función fgetcsv()

Lo que haremos será cargar el archivo y luego leer línea a línea para obtener la información.

```php
$archivo = fopen("archivo.csv");
while($linea = fgetcsv($archivo,0,",")){
  $columna1 = $linea[0];
  $columna2 = $linea[1];
  $columna3 = $linea[2];
  $columna4 = $linea[3];
}
fclose($archivo);
```

Es importante que en la función **fgetcsv()** además de pasarle el archivo CSV, le pasemos la cadena de texto que hace de delimitador. En este caso una coma.


Código para extraer información de un archivo CSV en PHP

Cargar archivo CSV con PHP

cargar-archivo-csv-con-php


## Generar el abecedario en PHP

El siguiente código genera las letras del abecedario en PHP.

```php
for ($i=65; $i <= 90; $i++) {
  echo chr($i);
}
```

El ejemplo es muy sencillo. Lo único que se hace es recorrer los caracteres utilizando el código ASCII de cada letra. Teniendo en cuenta que el número 65 corresponde a la A mayúscula y el 90 a la Z.

## Intercambiar de mayúsculas a minúsculas un caracter

Si se desea modificar el caracter de mayúsculas a minúsculas, se puede utilizar también la numeración de los caracteres ASCII, utilizando la función ord() que devuelve el número entero que identifica el caracter:

```php
$distancia = abs(ord('a')-ord('A'));
for ($i=65;$i<=90;$i++) {
  echo chr($i)." ".chr(abs($i+$distancia))."  ";
}
```

En la variable $distancia guardamos la distancia que hay entre la A mayúscula y minúscula y utilizamos el valor abs para obtener el valor absoluto (sin signo negativo). Tanto la distancia como el orden se pueden consultar en la tabla ascii y poner los números directamente, pero así demostramos que se puede hacer sin tablas.


Ejemplo para generar el abecedario en PHP utilizando el código ASCII

Generar las letras del abecedario en PHP

generar-las-letras-del-abecedario-en-php


En este tutorial veremos cómo crear un formulario de contacto en PHP. Al finalizar, los usuarios podrán rellenarlo y recibiremos sus comentarios por email.

## Formulario HTML

Crearemos un archivo llamado contactar.php que contendrá el formulario de contacto en HTML.

```html
<form action="contactar.php" method="post">
  <p>
    <label for="mensaje">Mensaje</label>
    <textarea name="mensaje"></textarea>
  </p>
  <p>
    <input type="submit" value="Enviar" />
    <input name="accion" type="hidden" value="enviar_comentario" />
  </p>
</form>
```

En el tag form de html definiremos el método de envío del formulario a **POST**. También es importante que en el atributo action escribamos el nombre del archivo que se ejecutará cuando el usuario haga clic en el botón de envío. En este caso llamaremos el mismo archivo en el que estamos **contactar.php** (Aunque no es obligatorio, nuestro script PHP para procesar el formulario también se encontrará en el mismo archivo que el formulario).

Finalmente definiremos un campo invisible "hidden", de nombre accion y valor enviar_comentario que servirá para controlar que el usuario haya ejecutado el formulario.

## Script PHP

Primero comprobaremos que la variable acción (La que habíamos añadido en modo invisible en el formulario HTML) tenga valor. Si lo tiene ya podemos procesar los datos y enviar el comentario a una dirección de correo que queramos.

```php
if(isset($_POST['accion']) && $_POST['accion']=="enviar_comentario"){
  $mensaje = addslashes($_POST['mensaje']);
  if (mail("tuemail@email.com","Formulario de Contacto",$mensaje)) {
    echo "Gracias por enviar el email, pronto lo leeremos.";
  } else {
    echo "No se pudo enviar el email.";
  }
} else {
    // Aquí va el formulario HTML
}
```

## Código Completo

A continuación mostramos el código completo del script para un formulario de contacto.

```php
<?php
if (isset($_POST['accion']) && $_POST['accion']=="enviar_comentario") {
  $mensaje = addslashes($_POST['mensaje']);
  if (mail("tuemail@email.com", "Formulario de Contacto", $mensaje)){
    echo "Gracias por enviar el email, pronto lo leeremos.";
  } else {
    echo "No se pudo enviar el email.";
  }
} else {
?>
  <form action="contactar.php" method="post">
    <div>
      <label for="mensaje">Mensaje</label>
      <textarea name="mensaje"></textarea>
    </div>
    <div>
      <input type="submit" value="Enviar" />
      <input type="hidden" name="accion" value="enviar_comentario">
    </div>
  </form>
<?}?>
```

Si todo ha salido correctamente, se habrá enviado un email a la cuenta correspondiente con el mensaje entrado.


Script en PHP para recibir comentarios de tus visitantes

Formulario de contacto en PHP

formulario-de-contacto-en-php


A veces, a partir de un texto normal y corriente queremos pasarlo a HTML. Por ejemplo: Si tenemos un texto que contiene una dirección url del tipo "http://www....", tal vez nos interese modificarlo y convertirlo a HTML válido: <a href="http://www...">http://www...</a>

Con esta sencilla función podemos modificar un texto plano en ASCII:

```php
function ASCIIaHTML($texto) {
$texto = htmlentities($texto);
$partes = split("\\n\\n",$texto);
  for ($i = 0, $j = count($partes); $i < $j; $i++) {
  $partes[$i] = preg_replace("/((http:\\/\\/[^\\s&]+)/", "[$1](<)",$partes[$i]>);
  $partes[$i] = "".$partes[$i].""; } return join("\\n\\n",$partes);
}
```

Básicamente, el código reemplazará urls a html, pero utilizando la función preg_replace, podemos agregar cualquier tag que queramos.


Convertir texto plano ASCII en HTML formateado con PHP

Convertir código ASCII a HTML en PHP

convertir-codigo-ascii-a-html-en-php


## Función strtotime

La forma más sencilla de comparar dos fechas es utilizando la función de PHP strtotime que convierte una fecha escrita en una cadena correctamente formateada a un UNIX timestamp, que es como estos sistemas operativos interpretan las fechas (en segundos). Utilizar esta función conlleva un serio problema que veremos más abajo.

$fecha_actual = strtotime(date("d-m-Y H:i:00",time()));
$fecha_entrada = strtotime("19-11-2008 21:00:00");

```php
if( $fecha_actual > $fecha_entrada ){
  echo "La fecha entrada ya ha pasado";
}else{
  echo "Aun falta algun tiempo";
}
```

El problema de trabajar con marcas de tiempo Unix es que el rango de fechas posibles termina sobre el año 2030, es decir que a partir de ese año, como no hay más dígitos para representar una cifra superior se reiniciará a 0 (equivalente al año 1970 aproximadamente). Aunque falte mucho tiempo, es una mala práctica emplear este tipo de factores.

## Comparar Fechas Correctamente

Una forma sencilla de hacerlo sin tener que contar manualmente las fechas, con todo los problemas que esto conlleva: si es año bisiesto o no, si el mes termina en 30 o 31, etc..., lo que se puede hacer es cambiar el sistema de fechas de gregoriano a juliano, para saber la diferencia de días que hay entre dos fechas

```php
function compararFechas($primera, $segunda)
{
  $valoresPrimera = explode ("/", $primera);  
  $valoresSegunda = explode ("/", $segunda);

  $diaPrimera = $valoresPrimera[0];  
  $mesPrimera = $valoresPrimera[1];  
  $anyoPrimera = $valoresPrimera[2];

  $diaSegunda = $valoresSegunda[0];  
  $mesSegunda = $valoresSegunda[1];  
  $anyoSegunda = $valoresSegunda[2];

  $diasPrimeraJuliano = gregoriantojd($mesPrimera, $diaPrimera, $anyoPrimera);  
  $diasSegundaJuliano = gregoriantojd($mesSegunda, $diaSegunda, $anyoSegunda);

  if(!checkdate($mesPrimera, $diaPrimera, $anyoPrimera)){
    // "La fecha ".$primera." no es válida";
    return 0;
  } elseif (!checkdate($mesSegunda, $diaSegunda, $anyoSegunda)){
    // "La fecha ".$segunda." no es válida";
    return 0;
  } else {
    return $diasPrimeraJuliano - $diasSegundaJuliano;
  }
}

$primera = "29/02/2000";
$segunda = "31/01/2000";

echo compararFechas ($primera,$segunda);
```

Este código devuelve el número de días entre dos fechas en caso de que sean válidas (se utiliza la función checkdate de PHP para comprobar que sean fechas válidas).


Distintos métodos para comparar fechas correctamente en PHP

Comparar Fechas en PHP

comparar-fechas-en-php


## La función fopen

PHP dispone de una función del sistema llamada **fopen** para crear archivos.

A esta función se le pueden pasar dos parámetros: el nombre del archivo y el modo de apertura (abrir un archivo existente o crear uno nuevo).

```php
fopen($nombrearchivo,$modo);
```

**$nombrearchivo** - es la variable que contiene el nombre del archivo. También se puede pasar la ruta donde está guardado (ya sea en local o en remoto). Por ejemplo: /htdocs/miweb/archivo.txt  
**$modo** - se utiliza para especificar cómo se quiere crear el archivo (Lectura, escritura, etc). En el manual de php hay una tabla completa con todos los [tipos de modo](http://www.php.net/manual/en/function.fopen.php) que hay.

## Crear un archivo

A continuación se muestra un código para crear un archivo nuevo en modo lectura y escritura (w+), lo que significa que crea un archivo y pone el puntero al principio del mismo, de modo que si ya existía lo sobreescribe y sino, intenta crearlo.

```php
$control = fopen("miarchivo.txt","w+");
if( $control == false ){
    die("No se ha podido crear el archivo.");
}
```


Función fopen de php para crear o leer archivos

Crear archivos en PHP

crear-archivos-en-php


A veces al extraer resultados de la base de datos nos interesará mostrarlos de diferentes formas. En este artículo nos centraremos en cómo se muestran los resultados de una consulta distribuidos por múltiples columnas en PHP.

## Código para mostrar resultados por columna

```php
<table width="100%">
<?php 
  $numcolumnas = 3;
  $consulta = mysql_query("SELECT * FROM tabla");
  $total_resultados = mysql_num_rows($consulta);
   if ( $total_resultados > 0) {
      echo "<tr><td colspan=\"$numcolumnas\">Hay $total_resultados elementos</td></tr>";
      $i = 1;
      while( $fila = mysql_fetch_array($consulta) ){
        $resto = ($i % $numcolumnas); 
        if( $resto == 1 ){ /*si es el primer elemento creamos una nueva fila*/ 
          echo "<tr>";
      }
      echo "<td>".$fila['campo']."</td>";
      /* mostramos el valor del campo especificado */ 
      if( $resto == 0 ){
        /* cerramos la fila */ 
        echo "</tr>"; 
      }
      $i++; 
  }

    if($resto != 0){
      /* Si en la última fila sobran columnas, creamos celdas vacías */
      for ($j = 0; $j < ($numcolumnas - $resto); $j++){
    echo "<td></td>";
    }
    echo "</tr>";
  }
}else{
  echo "<tr><td>0 elementos encontrados</td></tr>";
}
?>
</table>
```

Se supone que ya existe una conexión con la base de datos.


Código para mostrar elementos de la base de datos organizados y distribuidos por columnas en PHP

Mostrar resultados por columnas

mostrar-resultados-por-columnas


Cuando se crea una nueva clase en PHP se puede especificar el nivel de acceso que tendrá cada método o atributo. En PHP5 existen tres modificadores de acceso:

## Public

Los elementos declarados como Public son accesibles tanto desde fuera como desde dentro de la clase.

```php
<?php
   class Vehiculo{
    public  $marca; 

    function  __construct($marca) {
      $this->marca=$marca;
    }
   }

   $micoche = new  Vehiculo("Toyota");

   echo $micoche->marca;

?>
```

El atributo marca es público y por lo tanto es visible desde fuera de la clase.

## Private

Los elementos declarados como Private son accesibles sólo desde la misma clase donde fueron definidos.

```php
<?php

   class  Vehiculo {

    private  $marca; 

    function  __construct($marca) {
      $this->marca=$marca;
    }

   }

   $micoche =  new Vehiculo("Toyota");

   echo  $micoche->marca;

  ?>
```

Si ejecutamos el código obtendremos el siguiente error:

Fatal error: Cannot access private property Vehiculo::$marca

El atributo marca no es visible fuera de la clase en la que se definió.

## Protected

Los elementos declarados como Protected son accesibles desde la misma clase donde fueron definidos y en sus subclases.

```php
<?php

   class Vehiculo

   {

   protected $marca; 

   function __construct($marca)

   {

   $this->marca=$marca;

   }

   }

  

   class Coche extends Vehiculo

   {

   function __construct($marca)

   {

   $this->marca=$marca;

   }

   }

  

   $micoche = new  coche("Toyota");

   echo $micoche->marca;

  ?>
```

Si ejecutamos el código obtendremos el siguiente error

Fatal error: Cannot access protected property Coche

Producido por la línea que contiene este código:

echo $micoche->marca;

Este error sucede por utilizar el atributo marca fuera de la clase Vehículo y quedar así fuera de su visibilidad. En cambio el uso de este atributo en la clase Coche y Vehículo es correcto.

Los métodos o atributos sin ninguna de las declaraciones (public, private o protected) por defecto serán public.


Cómo funciona la especificación de control de acceso a métodos y atributos en PHP5

Public, Private y Protected

public-private-y-protected


## Clase en php para conectar con la base de datos MySQL

En este artículo se verá el código de una clase escrita en PHP para que tus aplicaciones puedan interactuar con la base de datos MYSQL.

La clase está programada siguiendo la filosofía de programación orientada a objetos incorporando las novedades de PHP5.

## La clase MySQL

Guardamos esta clase en un archivo llamado **mysql.php**
```php
class MySQL {

 public function conexion() {
    $this->conexion = (mysql_connect("Servidor","usuario","password"))
            or die(mysql_error());
          mysql_select_db("nombreBD",$this->conexion) or die(mysql_error());
    }
  }

  public function consulta($consulta) { 
      $this->total_consultas++; 
      $resultado = mysql_query($consulta,$this->conexion);
      if (!$resultado) {
        echo 'MySQL Error: ' . mysql_error();
        exit;
      }
    return $resultado;
  }

  public function fetch_array($consulta){
    return mysql_fetch_array($consulta);
  }

  public function num_rows($consulta){
    return mysql_num_rows($consulta);
  }

  public function getTotalConsultas(){
    return $this->total_consultas;
  }
}
?>
```

## Ejemplo de Uso

Veamos el código que crearíamos para seleccionar los elementos de una tabla y mostrarlos por pantalla

```php
include("mysql.php");

$db = new MySQL();
$consulta = $db->consulta("SELECT id FROM mitabla1");
if ($db->num_rows($consulta) > 0) {
  while($resultados = $db->fetch_array($consulta)){
    echo "ID: ".$resultados['id']." ";
  }
}
```


Clase programada en PHP5 para conectar php con mysql y poder realizar consultas

Clase para conectar php con mysql

clase-para-conectar-php-con-mysql


Un tag cloud (nube de etiquetas) es un conjunto de palabras clave ordenadas normalmente alfabéticamente y cada una con distinto tamaño según su relevancia.

Veamos en este tutorial como crear uno. Para ello necesitamos una tabla en nuestra base de datos con una columna que sea el nombre de la etiqueta y otra que contenga el valor que le da relevancia.

```php
<?php
  $link = mysql_connect('server', 'username', 'password');
  if (!$link) {
    die('No se puede conectar: ' . mysql_error());
  }

$db_selected = mysql_select_db('bdname', $link);
  if (!$db_selected) {
    die ('No se puede conectar: ' . mysql_error());
  }
```

Especificamos el tamaño máximo y mínimo de la fuente en pixels

```php
$tamano_maximo = 40;
$tamano_minimo = 9;
```

Hacemos la consulta a la base de datos teniendo en cuenta que **nombre** es cada etiqueta que aparecerá dentro del tag cloud, **descargas** es el valor que le da relevancia a cada etiqueta (en este caso cada etiqueta tendrá tamaño distinto según el número de descargas que tenga, éste es nuestro caso inventado hay muchas maneras de darle relevancia a un item)

```php
$query = "SELECT nombre AS etiqueta, descargas AS cantidad FROM tabla ORDER BY nombre ASC";
$resultado = mysql_query($query);
```

Ponemos cada valor dentro de un array $etiquetas para poder ordenar todas las filas devueltas de la consulta.

```php
while ($fila = mysql_fetch_array($resultado)) {
  $etiquetas[$fila['etiqueta']] = $fila['cantidad'];
}
```

De todos los valores de $etiquetas obtenemos los valores con mayor y menor cantidad

```php
$mayor_cantidad = max(array_values($etiquetas));
$menor_cantidad = min(array_values($etiquetas));
```

Creamos un rango de valores

```php
$rango = $mayor_cantidad - $menor_cantidad;
if (0 == $rango) {
 $rango = 1;
}
```

Determinamos que incremento de tamaño habrá según los tamaños en pixels y el rango de valores

```php
$incremento = ($tamano_maximo - $tamano_minimo)/($rango);
```

Navegamos por toda la array para calcular el tamaño de la fuente, restando en nuestro caso el número de descargas de la fila actual menos el número de descargas de la fila con menos descargas y lo multiplicamos por el incremento, y finalmente le sumamos el tamaño mínimo que hemos establecido al principio.

```php
foreach ($etiquetas as $clave => $valor) {
  $tamano = $tamano_minimo + (($valor - $menor_cantidad) \* $incremento);
  echo " <a href=\"http://\" style=\"font-size: ".$tamano."\">".$clave."</a> ";
}
mysql_close($link);
?>
```


Un tag cloud es una nube de etiquetas ordenadas y con diferente tamaño según su relevancia

tag-cloud


Para trabajar con expresiones regulares en php hay dos grupos de funciones, las que empiezan por ereg y las que empiezan por preg. Las funciones ereg no necesitan ninguna librería adicional, pero no soportan la sintaxis moderna de expresiones regulares. Las funciones preg estan pensadas para soportar toda la sintaxis (Compatible con Perl) de las expresiones regulares y son más rápidas. Sin embargo, necesitan tener instalada la librería [PCRE](http://www.pcre.org/) en el servidor donde se ejecutan. Es recomendable usar las funciones ereg si no dispones de un servidor propio para instalar las librerías requeridas.

## Las funciones ereg

En estas funciones las expresiones regulares deben mostrarse como una cadena de caracteres. Por ejemplo la función [ereg](http://www.php.net/ereg)

ereg('expresionregular',"cadena")

Comprueba si la **expresionregular** existe dentro de la cadena (case-sensitive, usar la función eregi para case-insensitive). Devuelve la longitud de la coincidencia si se encontró, o zero si no se encontraron coincidencias u ocurrió algún error. Es común utilizarlo dentro de estructuras condicionales (if) ya que 0 se evalúa a falso y el resto como verdadero.

Se deben usar comillas simples cuando se pasa una expresión regular como un literal. Algunos caracteres como el dolar ($) y la contra barra (\\) son caracteres especiales en cadenas con comillas dobles, pero no en cadenas PHP de comillas simples.

## La función ereg_replace

```php
echo ereg_replace('expresionregular', "reemplazo", $cadena );
```

Esta función examina la **cadena** buscando coincidencias de **expresionregular**, y reemplaza el texto encontrado con la el contenido de la cadena **reemplazo**. También existe la función eregi_replace para case-insensitive.

## Las funciones preg

En las funciones preg se debe utilizar la sintaxis Perl. De manera que las expresiones regulares en PHP con esta función deben ir entre barras. Ejemplo:

```php
preg_match('/expresionregular/',$cadena);
```

Es por esto que si deseamos usar caracteres '/' dentro de una expresión regular antes deberemos escapar el caracter con una contrabarra. Ejemplo:

```php
preg_match('/http:\\/\\/www.webtutoriales.com\\//',$cadena);
```

Si queremos usar las instrucciones preg en modo case insensitive deberemos poner el parámetro 'i' al final de la expresión regular. Ejemplo:

```php
preg_match('/expresionregular/i',$cadena);
```

Hay más parámetros como 'm', o 's' ([lista completa de modificadores](http://es2.php.net/manual/en/reference.pcre.pattern.modifiers.php)). Para usar más de uno a la vez basta con ponerlos uno detrás de otro:

```php
preg_match('/expresionregular/ims',$cadena);
```

La función preg_match_all guarda en un array (en nuestro ejemplo la variable $resultados) todas las ocurrencias encontradas dentro de la string "$cadena" que cumplen con la expresión regular.

```php
preg_match_all('expresionregular',$cadena,$resultados);
```

Finalmente la función preg_replace, igual que ereg_replace te permite reemplazar una cadena por otra si se encuentran ocurrencias de la expresión regular.

## Ejemplos Útiles

**1**. Ejemplo para comprobar si la sintaxis de un email es correcta o no (devuelve 1 si es cierto 0 si no lo es).

```php
preg_match("/^([a-zA-Z0-9])+@([a-zA-Z0-9_-])+(\\.[a-zA-Z0-9_-]+)+/", "email@dominio.extension");
```

**2**. En este caso utilizaremos la función preg_replace para censurar determinadas palabras en una cadena. (Reemplazaremos las palabras del array por asteríscos.)

```php
$cadena = "La primera palabra y la segunda palabra y la tercera...";
$malaspalabras = array("primera","segunda","tercera");
$numero_palabras = count($malaspalabras);
$i = 0;
while ($i < $numero_palabras) {
  $cadena = str_replace ("$malaspalabras[$i]", " \*\*\*\* ", "$cadena");
  $i++;
}

echo $cadena;
```

**3**. Este ejemplo sirve para extraer 10 caracteres de una cadena de modo que no corte palabras por la mitad. (extraído de php.net)

```php
$expresionregular = "/(^.{0,10})(\\W+.\*$)/";

$cadena = "El veloz murciélago hindú comía feliz cardillo y kiwi";

$reemplazo = "\\${1}";

echo preg_replace($expresionregular, $reemplazo, $cadena); //devolverá la cadena "El veloz" (8 caracteres).
```

Los dos tipos funciones básicas para trabajar con expresiones regulares en php. Diferencias entre ereg y preg.

Tipos de funciones para expresiones regulares

tipos-de-funciones-para-expresiones-regulares


Veamos este algoritmo para calcular los años, meses y días entre dos fechas dadas. No comprobaremos si las fechas entradas son correctas.

Primero especificaremos las dos fechas (Las fechas deberán tener el formato dd/mm/aaaa para que el programa funcione correctamente).

```php
$fechaInicio ="28/02/1999";

$fechaActual = "29/02/2000";
```

Cortamos el texto para seleccionar el dia, mes y año de la fecha Actual y de la fecha de Inicio respectivamente con la función **substr** de php.

```php
$diaActual = substr($fechaActual, 0, 2);

$mesActual = substr($fechaActual, 3, 5);

$anioActual = substr($fechaActual, 6, 10);

$diaInicio = substr($fechaInicio, 0, 2);

$mesInicio = substr($fechaInicio, 3, 5);

$anioInicio = substr($fechaInicio, 6, 10);
```

Ahora utilizaremos una variable auxiliar donde guardaremos el número de días que tiene el mes anterior al mes Inicio. Tendremos en cuenta también el mes de febrero, para calcular si un año es bisiesto utilizaremos la condición ($anioActual%4==0 && $anioActual%100!=0) || $anioActual%400==0

```php
$b = 0;

$mes = $mesInicio-1;

if($mes==2){
  if(($anioActual%4==0 && $anioActual%100!=0) || $anioActual%400==0){
    $b = 29;
  }else{
    $b = 28;
  }
}
else if($mes<=7){
  if($mes==0){
    $b = 31;
  }
  else if($mes%2==0){
    $b = 30;
  }
  else{
    $b = 31;
  }
}
else if($mes>7){
  if($mes%2==0){
  $b = 31;
  }
  else{
  $b = 30;
  }
}
```

Seguimos con el código que calculará los días, meses y años:

```php
if(($anioInicio>$anioActual) || ($anioInicio==$anioActual && $mesInicio>$mesActual) ||
  ($anioInicio==$anioActual && $mesInicio == $mesActual && $diaInicio>$diaActual)){
  echo "La fecha de inicio ha de ser anterior a la fecha Actual";
  } else {
  if($mesInicio <= $mesActual) {
    $anios = $anioActual - $anioInicio;
    if($diaInicio <= $diaActual) {
      $meses = $mesActual - $mesInicio;
      $dies = $diaActual - $diaInicio;
    } else {
    if($mesActual == $mesInicio) {
      $anios = $anios - 1;
    }
    $meses = ($mesActual - $mesInicio - 1 + 12) % 12;
    $dies = $b-($diaInicio-$diaActual);
    }
  } else {
    $anios = $anioActual - $anioInicio - 1;
    if ($diaInicio > $diaActual){
      $meses = $mesActual - $mesInicio -1 +12;
      $dies = $b - ($diaInicio-$diaActual);
    } else {
      $meses = $mesActual - $mesInicio + 12;
      $dies = $diaActual - $diaInicio
    }
  }
  echo "Años: ".$anios." <br />";
  echo "Meses: ".$meses." <br />";
  echo "Días: ".$dies." <br />";
}
```

## Código Completo

```php
<?php $fechaInicio ="28/02/1999";

$fechaActual = "29/02/2000";

$diaActual = substr($fechaActual, 0, 2);
$mesActual = substr($fechaActual, 3, 5);
$anioActual = substr($fechaActual, 6, 10);

$diaInicio = substr($fechaInicio, 0, 2);
$mesInicio = substr($fechaInicio, 3, 5);
$anioInicio = substr($fechaInicio, 6, 10);

$b = 0;
$mes = $mesInicio-1;

if($mes==2){
  if(($anioActual%4==0 && $anioActual%100!=0) || $anioActual%400==0){
    $b = 29;
  }else{
    $b = 28;
  }
}
else if($mes<=7){
  if($mes==0){
    $b = 31;
  }
  else if($mes%2==0){
    $b = 30;
  }
  else{
    $b = 31;
  }
}
else if($mes>7){
  if($mes%2==0){
  $b = 31;
  }
  else{
  $b = 30;
  }
} 

if(($anioInicio>$anioActual) || ($anioInicio==$anioActual && $mesInicio>$mesActual) ||
  ($anioInicio==$anioActual && $mesInicio == $mesActual && $diaInicio>$diaActual)){
  echo "La fecha de inicio ha de ser anterior a la fecha Actual";
  } else {
  if($mesInicio <= $mesActual) {
    $anios = $anioActual - $anioInicio;
    if($diaInicio <= $diaActual) {
      $meses = $mesActual - $mesInicio;
      $dies = $diaActual - $diaInicio;
    } else {
    if($mesActual == $mesInicio) {
      $anios = $anios - 1;
    }
    $meses = ($mesActual - $mesInicio - 1 + 12) % 12;
    $dies = $b-($diaInicio-$diaActual);
    }
  } else {
    $anios = $anioActual - $anioInicio - 1;
    if ($diaInicio > $diaActual){
      $meses = $mesActual - $mesInicio -1 +12;
      $dies = $b - ($diaInicio-$diaActual);
    } else {
      $meses = $mesActual - $mesInicio + 12;
      $dies = $diaActual - $diaInicio
    }
  }
  echo "Años: ".$anios." <br />";
  echo "Meses: ".$meses." <br />";
  echo "Días: ".$dies." <br />";
}
?>
```

Finalmente os recomiendo [esta web](http://www.timeanddate.com/date/duration.html) que contiene una calculadora para poder hacer pruebas de cálculo de fechas.


Algoritmo de programación en php para el calculo de dias meses y años entre dos periodos de tiempo

Calcular el tiempo exacto entre dos fechas

calcular-el-tiempo-exacto-entre-dos-fechas


Cuanto más popular es una web más posibilidades hay de atraer visitantes molestos, como spammers. Es inevitable, pero se puede hacer algo al respecto. El método más sencillo es banear la dirección IP de ese usuario, aunque no es un método infalible en el 90% de los casos será suficiente. Lo que haremos será, a partir de una dirección IP, bloquear el acceso de ese usuario a nuestras páginas.

Antes que nada necesitaremos la IP, para ello usaremos el siguiente código:

```php
<?php $ip = $_SERVER['REMOTE_ADDR']; ?>
```

Luego pondremos dentro de un vector (array) las direcciones que queremos bloquear:

```php
$ips_baneadas = array('10.0.0.1',’192.0.0.1’);
```

$contador = count($ips_baneadas);

Ahora comprobaremos mediante un bucle si el IP del usuario está dentro del array de IP's baneadas:

```php
for ($i=0; $i<$contador; $i++) { 
  if($ip == $ips_baneadas[$i]) {
  die("Lo sentimos, estas baneado . $ip");
  }
} ?>
```

Otros usos para este script: también podemos usar este script si sólo queremos que un determinado usuario con un cierto IP acceda a una página concreta.


Útil script para bloquear el acceso de una dirección IP a nuestras páginas

Banear IP con PHP

banear-ip-con-php


Desde hace ya unos años se hizo muy popular en algunas webs creadas con PHP poner al final de la página el tiempo total que el servidor tardó en interpretar y procesar la archivo antes de enviarlo al navegador del usuario. El dato no aporta demasiada información útil para un visitante, pero es curioso lo aceptado que ha sido para muchos webmasters poner una frase del tipo "La página fue generada en XX segundos/milisegundos" en el pie de sus páginas.

El código para realizar este contador es muy sencillo. Veamos antes los pasos que seguiremos:

1.  Necesitaremos saber el instante de tiempo actual como referencia, para ello utilizaremos la función [microtime()](http://www.php.net/manual/en/function.microtime.php).
2.  Usaremos la función [explode()](http://ww.php.net/manual/en/function.explode.php) para pasar el valor dado por microtime a un vector (array).
3.  Sumaremos las dos partes del array (los micro-segundos con los segundos).
4.  Repetiremos los pasos 1,2 y 3 en el pie de página.
5.  Encontraremos el tiempo total de carga restando el tiempo final obtenido al final de página con el tiempo inicial del paso 1.
6.  Redondearemos y enviaremos el resultado al navegador.

El código es el siguiente:  
Esta parte irá en las primeras lineas del archivo .php que queremos evaluar.

```php
<? 
$t_tiempo = explode(" ",microtime()); 
$t_tiempo = $t_tiempo[0] + $t_tiempo[1]; 
$tiempoinicial = $t_tiempo; 
?>
```

Esta otra parte irá en las últimas lineas del mismo archivo.

```php
<? 
$redondear = 3; // numero de decimales a redondear. 
$t_tiempo = explode(" ",microtime()); 
$t_tiempo = $t_tiempo[0] + $t_tiempo[1]; 
$tiempofinal = $t_tiempo; 
$totaltime = ($tiempofinal - $tiempoinicial); 

echo "La página se ha cargado en :". redondear($totaltime,$redondear) ." segundos"; 
?>
```

Así de sencillo!


Sencillo script para contar el tiempo que tarda PHP en procesar un archivo para luego mostrarlo en el navegador

Tiempo de carga de una página web

tiempo-de-carga-de-una-pagina-web


Con este tutorial sobre AJAX comprobaremos lo fácil que es actualizar el contenido de una página web en tiempo real sin que un usuario tenga que actualizar el navegador.

La idea es muy simple, javascript se encarga de llamar remotamente a un archivo, ejecutarlo para luego extraer la información y mostrarla en nuestra página de forma transparente para el usuario.

El archivo a llamar puede contener la información que queráis por ejemplo puede ser un contador de usuarios online. Para simplificar y ver cómo funcionará el resultado de este tutorial os recomiendo crear un archivo llamado _ajax.php_, ponemos un número cualquiera (en un caso real el archivo ajax.php contendría el código para contar los usuarios online) y guardaremos el archivo.

Ahora creamos un archivo llamado _codigo.php_ con este código:

```js
var RequestObject = false;
//directorio donde tenemos el archivo ajax.php
var Archivo = 'http://localhost/ajax.php';

// el tiempo X que tardará en actualizarse
window.setInterval("actualizacion_reloj()", 2000);

if (window.XMLHttpRequest) RequestObject = new XMLHttpRequest();
if (window.ActiveXObject) RequestObject = new ActiveXObject("Microsoft.XMLHTTP");

function ReqChange() {
  // Si se ha recibido la información correctamente
  if (RequestObject.readyState==4) {
  // si la información es válida
    if (RequestObject.responseText.indexOf('invalid') == -1) {
    // Buscamos la div con id online
      document.getElementById("online").innerHTML = RequestObject.responseText;
    } else {
    // Por si hay algun error document.getElementById("online").innerHTML = "Error llamando";
    }
  }
}
```

```js
function llamadaAjax() {
  // Mensaje a mostrar mientras se obtiene la información remota...
  document.getElementById("online").innerHTML = "";
  // Preparamos la obtención de datos
  RequestObject.open("GET", Archivo+"?"+Math.random() , true);
  RequestObject.onreadystatechange = ReqChange;
  // Enviamos
  RequestObject.send(null);
  }

  function actualizacion_reloj() {
  llamadaAjax();
}
```

Usuarios Online
---

Resumiendo, el contenido del archivo _ajax.php_ se cargará dentro de la etiqueta div con id online del archivo _código.php_ . Este sencillo ejemplo es la base para crear muchas otras utilidades interactivas más complejas.

* Atención: En algunos navegadores como IE8 cachea las llamadas por el método GET, es por esto que en la función llamadaAjax(), al llamar el archivo ajax.php le pasamos como parámetro un valor diferente cada vez para que crea que es otro archivo. Este método no es nada elegante. Porque aunque es difícil, se podría repetir el valor aleatorio. Para solucionar esto lo mejor es que el archivo que se llama en este caso ajax.php contenga en la cabecera alguna instrucción que deshabilite la cache:

```php
<?
 header("Cache-Control: no-cache");
 header("Pragma: no-cache");
?>
```

Estas instrucciones deben ponerse arriba del todo del archivo php que llamemos.

Por último, decir que este método es el que se usaría con javascript puro solamente. Hoy día es recomendable utilizar frameworks como JQuery que nos ahorran mucho código y facilitan hacer llamadas remotas.


Tutorial indispensable que sirve como punto de partida para hacer llamamientos a archivos remotos en tiempo real sin que el usuario tenga que actualizar el navegador

Actualizar el contenido en tiempo real con AJAX

actualizar-el-contenido-en-tiempo-real-con-ajax


Supongamos que tenemos un directorio con miles de enlaces. Sería conveniente repasar cada cierto tiempo los links del directorio para no mostrar las webs que ya no existen o se han movido, etc.

Para ello podemos usar la función fsockopen() de PHP. Ejemplo:

```php
<?php

if(!(@fsockopen("google.com", 80, $errno, $errstr, 20))) 
{
  echo "La url google.com no funciona<br />";
}
?>
```

La función fsockopen permite iniciar una conexión socket (concepto por el cual dos programas se intercambian información). El primer parámetro es la dirección URL, el segundo el puerto, los dos siguientes son para errores estándares de PHP y finalmente el último, es el tiempo de vida máximo que se le dará a cada conexión.


Script para comprobar si una web está online

PHP