Listar contenido de un directorio ordenado por tamaño

Es muy habitual para los usuarios de Linux querer ordenar el contenido de los directorios por tamaño de los ficheros o subdirectorios que contiene. En este caso lo tenemos muy sencillo con la siguiente instrucción:

# du -hs * | sort -h

Esto nos ordenará ascendentemente. En caso de querer que sea descendente el orden, podemos añadir -r y quedaría así:

# du -hs * | sort -h -r

Obtener uso de disco o partición mediante PHP

Si necesitamos saber el tamaño total y el uso del disco en el que tenemos alojada nuestra web, por ejemplo para avisar de que queda poco espacio libre, lo podemos hacer fácilmente mediante PHP. Para ello contamos con dos funciones muy útiles:

• float disk_free_space ( string $directory ): devuelve el número de bytes disponibles en el sistema de archivos o partición de disco que corresponde con el directorio especificado.

• float disk_total_space ( string $directory ): devuelve el número total de bytes del sistema de archivos o partición de disco que corresponde con el directorio especificado.

A modo de ejemplo hemos creado una función que utiliza las funciones anteriomente mencionadas y que nos devolverá una cadena con el total y el uso de discos en GB y el porcentaje de uso y libre si hemos superado un porcentaje límite de uso de disco o partición, que establecemos por defecto en el 90%. Si no superamos dicho límite, devolvemos false:

 function getDiskUsage($dir, $limit=90){
  $freespace = disk_free_space($dir);
  $totalspace = disk_total_space($dir);
  $freespace_mb = $freespace/1024/1024;
  $totalspace_mb = $totalspace/1024/1024;
  $freespace_percent = ($freespace/$totalspace)*100;
  $used_percent = (1-($freespace/$totalspace))*100;

  if ($used_percent > $limit){
   $text = sprintf(_('Espacio total').": %.2fGB", $totalspace_mb/1024).' - ';
   $text.= sprintf(_('libre').": %.2fGB", $freespace_mb/1024).' - ';
   $text.= sprintf(_('%% usado').": %.2f%%", $used_percent).' - ';
   $text.= sprintf(_('%% libre').": %.2f%%", $freespace_percent);
   return $text;
  }

  return false;
 }

Obtener listado de archivos de un directorio por fecha de modificación con PHP

Si necesitáis recorrer un directorio con PHP y obtener los archivos modificados en una fecha en concreto, lo podéis conseguir fácilmente con esta función que creé hace pocos días.

function getFilesFromDate($dir, $day=null){
 if ($day==null)
  $day = time();
  
 // Leo todos los ficheros de la carpeta
 $dir = opendir($dir);
 while ($file = readdir($dir)){
  if ($file!='.' && $file!='..' && is_file($dir.'/'.$file) && date("Ymd", $day)==date("Ymd", filemtime($dir.'/'.$file))){
   $arrfiles[] = $file;
  }
 }
 closedir($dir);
 return $arrfiles;
}

Como vemos, únicamente le tenemos que pasar el directorio y el día. Si no pasamos el día la función cogerá el día actual para realizar la búsqueda.

Calcular la edad con PHP

He visto en algunos posts que para calcular la edad en años de una persona hay problemas si la fecha de nacimiento es menor que el año 1970. Eso se debe a que pasan la fecha a tiempo UNIX y después hacen una resta y la vuelven a convertir a años.

Lo más simple que he visto es esta función que os dejo aquí, que simplemente coge primero la parte de meses y días de la fecha actual y la de nacimiento y mira si ya hemos pasado o todavía no. Después resta la parte de años de ambas fechas y finalmente ajusta.

function getAge($birthdate){
 $adjust = (date("md") >= date("md", strtotime($birthdate))) ? 0 : -1; // Si aún no hemos llegado al día y mes en este año restamos 1
 $years = date("Y") - date("Y", strtotime($birthdate)); // Calculamos el número de años 
 return $years + $adjust; // Sumamos la diferencia de años más el ajuste
}

Se puede complicar más haciendo que el formato de entrada se pueda configurar pero lo hemos puesto en formato inglés YYYY-MM-DD. Los resultados son los siguientes:

// Hoy es 2 de diciembre de 2014
echo getAge("1919-02-21"); // devuelve 95

echo getAge("1952-12-07"); // devuelve 61

Espero que os sirva.

Acceder a las propiedades de un IFRAME mediante Javascript

Si necesitamos acceder a las propiedades de un iframe que esté incorporado en nuestra página lo podemos hacer de una forma muy sencilla con la siguiente función:

function getIframe(id){
  var myframe = document.getElementById(id);
  var content = (myframe.contentWindow || myframe.contentDocument);
  return content.document;
}

A esta función le pasamos el id del iframe y obtendremos un objeto que podremos manejar y cambiar por ejemplo el color de fondo. Para ponerle el fondo de color gris lo haríamos así:

  var myframe = getIframe('myframe');
  myframe.body.backgroundColor = '#CCC';
}

La propiedad contentDocument es soportada por los principales navegadores excepto Internet Explorer, que solamente la soporta a partir de la versión 8 si está especificado !DOCTYPE. Para las versiones anteriores de Internet Explorer hay que usar contentWindow.

Acortar urls con goo.gl desde PHP usando la API de Google

Acortar una url es algo bastante común hoy en día, sobretodo en las redes sociales como Twitter donde el número de caracteres es limitado.

Si lo queremos de hacer desde nuestra sitio web de PHP tenemos una forma muy sencilla con la API de Google.

Los pasos a dar serían los siguientes:

1. Lo primero que necesitaremos será darnos de alta una cuenta de Google Developer, que lo puedes hacer fácilmente si tienes una cuenta de Google.

2. Deberemos ir la la consola del desarrollador y dar de alta un nuevo proyecto. Le pondremos el nombre que deseemos y una vez creado iremos en el menú de la izquierda al ítem APIs & Auth (APIs y autenticación en español). Seleccionando APIs en el submenú veremos toda la lista de servicios que nos ofrece Google. Buscaremos URL Shortener API y lo activaremos desde la parte superior de la página. Hecho esto elegiremos en el submenú Credentials (Credenciales en español) y haremos clic en Crear clave nueva. Nos aparecerá una ventana emergente y seleccionaremos Clave de servidor. Ahí nos pedirá que pongamos una IP si queremos limitar desde donde se puede llamar al servicio. Con todo esto realizado ya nos dará la clave de la api que necesitaremos posteriormente para acortar la url.

3. El último paso será coger el código que os dejo a continuación y cambiar únicamente la clave de la api por la vuestra y la url por la que necesitéis.

Código PHP

Lo primero que veremos será la clase que implementa las funciones de acortar y expandir:

class GoogleShortUrl{
 
 // Constructor
 function __construct($key, $apiURL = 'https://www.googleapis.com/urlshortener/v1/url'){
  $this->apiURL = $apiURL.'?key='.$key;
 }
 
 // Acortar la URL
 function shorten($url) {
  $response = $this->send($url);
  return isset($response['id']) ? $response['id'] : false;
 }
 
 // Expandir la URL
 function expand($url) {
  $response = $this->send($url, false);
  return isset($response['longUrl']) ? $response['longUrl'] : false;
 }
 
 // Enviar información a Google
 function send($url, $shorten = true){

  // Inicializamos curl y definimos el objeto
  $curlObj = curl_init();
  if ($shorten){
   curl_setopt($curlObj, CURLOPT_URL, $this->apiURL);
   curl_setopt($curlObj, CURLOPT_POST, 1);
   curl_setopt($curlObj, CURLOPT_POSTFIELDS, json_encode(array("longUrl"=>$url)));
   curl_setopt($curlObj, CURLOPT_HTTPHEADER, array("Content-Type: application/json"));
  } else {
   curl_setopt($curlObj, CURLOPT_URL, $this->apiURL.'&shortUrl='.$url);
  }
  curl_setopt($curlObj, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($curlObj, CURLOPT_SSL_VERIFYPEER, 0);
  curl_setopt($curlObj, CURLOPT_HEADER, 0);
  
  // Ejecutamos el post
  $response = curl_exec($curlObj);

  // Cerramos la conexión
  curl_close($curlObj);
  
  // Devolvemos la respuesta
  return json_decode($response, true);
 }  
}

Ahora solamente nos queda hacer la llamada a la clase anterior y acortar o expandir una url:

// Creamos una instancia de la clase
$key = 'miclave';
$shorter = new GoogleShortUrl($key);

// Acortamos la URL
$shortname = $shorter->shorten("http://softontherocks.blogspot.com");
echo $shortname; // devuelve http://goo.gl/VF1HJ

// Expandimos la URL
$longname = $shorter->expand($shortname);
echo $longname; // devuelve http://softontherocks.blogspot.com

Espero que os sirva en vuestros proyectos.

Hacer drag and drop con jQuery

Una de las primeras cosas que aprendí a hacer cuando me inicié con jQuery fue hacer un ejercicio de drag and drop.

Os dejo los pasos que necesitamos para que funcione:

1. Incluir las librerías js de jQuery

2. Crear los divs que vamos a cambiar de posición

 
Item 1
 
Item 2
 
Item 3
 
Item 4
 
Item 5
 

3. Poner el código para que los divs puedan ejecutar el movimiento

4. Añadir CSS para que los divs tengan mejor aspecto

Listar los archivos de un directorio ordenados alfabéticamente con PHP

Hace pocos días tuve que crear una pequeña página en la que leía un directorio y mostraba los ficheros que contenía, usando PHP.

La primera función que os dejo utiliza el readdir() y me listó bien el contenido del directorio en mi servidor de desarrollo, sin embargo cuando lo subí al hosting no me mostró los archivos ordenados alfabéticamente.

function getFiles($dir){
 $files = array();
 // Abrimos el directorio
 if ($dh = opendir($dir)){
  // Recorremos los ficheros del directorio
  while (($file = readdir($dh))!==false){
   // Comprobamos que sea un fichero y no un subdirectorio
   if (is_file($dir.'/'.$file)){
    $files[] = $file;
   }
  }
  closedir($dh);
 }
 return $files;
}

Para mostrarlos de forma ordenada tuve que cambiar la función y usar scandir() que además es más simple ya que directamente nos devuelve un array con los archivos encontrados, ordenados ascendente o descendentemente, según queramos.

function getFiles($dir){
 $files = array();
 // Leemos el directorio ordenado ascendentemente
 $tmp = scandir($dir);
 // Recorremos los ficheros del directorio
 foreach ($tmp as $file){
  // Comprobamos que sea un fichero y no un subdirectorio
  if (is_file($dir.'/'.$file)){
   $files[] = $file;
  }
 }
 return $files;
}

Obtener el tamaño de un fichero y mostrarlo en un formato comprensible mediante PHP

En PHP tenemos la posibilidad de obtener el tamaño de un fichero mediante la función filesize. Esta función nos devuelve un entero con el número de bytes del archivo.

Este tamaño, en el caso de que el fichero sea grande, es posible que lo queramos representar en kilobytes, megabytes..., o simplemente dejar que la función decida la magnitud más adecuada.

En este caso hemos realizado una función que recoge esta posibilidad:

function convertFileSize($file, $size=null, $decimals=2, $dec_sep='.', $thousands_sep=','){
 if (!is_file($file)){
  return "El fichero no existe";
 }
 $bytes = filesize($file);
 $sizes = 'BKMGTP';
 if (isset($size)){
  $factor = strpos($sizes, $size[0]);
  if ($factor===false){
   return "El tamaño debe ser B, K, M, G, T o P";
  }
 } else {
  $factor = floor((strlen($bytes) - 1) / 3);
  $size = $sizes[$factor];
 }
 return number_format($bytes / pow(1024, $factor), $decimals, $dec_sep, $thousands_sep).' '.$size;
}

Los parámetros son:

$file: ruta completa del fichero

$size: magnitud en la que queremos obtener el resultado. Si lo dejamos a null hará el cálculo la propia función

$decimals: número de decimales que queremos que nos muestre. Por defecto nos mostrará 2.

$dec_sep: separador decimal. Por defecto coge el punto que es el que se usa en inglés.

$thousand_sep: separador de miles. Por defecto coge la coma que es el que se usa en inglés.

Ordenar array UTF-8 con Javascript

Ordenar arrays con Javascript es una función muy habitual que ejecutamos los programadores web. Sin embargo, existen ocasiones en que lo que queremos ordenar lleva tildes, eñes o cualquier grafía de otro alfabeto.

Cuando ocurre esto, el método habitual de ordenación sort() no sirve ya que nos los ordena en último lugar. Veamos un ejemplo:

var myarray = ['Álex', 'Juan', 'José', 'Antonio', 'Carlos'];
myarray.sort(); // Queda ordenado como Antonio, Carlos, José, Juan, Álex

Para este tipo de caracteres necesitamos una función específica para ordenar, que podría convertirse en nuestro método sort() si nuestro alfabeto habitual lleva caracteres Unicode. Para realizar la ordenación UTF-8 tenemos que hacer lo siguiente:

var myarray = ['Álex', 'Juan', 'José', 'Antonio', 'Carlos'];
myarray.sort(function(a,b){return a.localeCompare(b);}); // Queda ordenado como Álex, Antonio, Carlos, José, Juan

Enviar tweets desde PHP

Hace pocos días me vi en la necesidad de buscar la forma de enviar tweets desde PHP. Empecé a buscar y encontré varias clases que implementaban lo que necesitaba, pero finalmente me decanté por una llamada Twitter for PHP.

Se trata de una pequeña librería de PHP con funciones muy interesantes para manejar una cuenta de Twitter y además lleva soporte para el protocolo OAuth. Si buscáis información en google encontraréis mucha información sobre este protocolo pero os dejo este enlace que lo explica bastante bien. La librería Twitter for PHP requiere como mínimo la versión PHP 5.0 y tener instalada la librería cURL.

Primeros pasos

Para utilizar esta librería lo primero que tendremos que hacer es descargarla desde su repositorio en GitHub. En el repositorio encontraremos ejemplos de lo que veremos en este mismo post.

A continuación deberemos dar de alta una cuenta de Twitter, si no la tenemos, e ir a http://dev.twitter.com/apps para registrar una aplicación. Una vez creada tienes que ir a la pestaña Key and Access Tokens y darle clic en la parte inferior de la ventana a Create my access token. Con esto ya tendremos los cuatro parámetros que necesitamos: consumer key, consumer secret, access token y access token secret.

Con todos estos datos ya estamos preparados para poder crear un objeto usando la librería:

$twitter = new Twitter($consumerKey, $consumerSecret, $accessToken, $accessTokenSecret);

Enviar

El envío de un tweet lo realizaremos con el método post(). El mensaje debe ir codificado en UTF-8 y además le podremos añadir una imagen al tweet:

$twitter->send('Mi primer tweet');
$twitter->send('Mi primer tweet con imagen', $imageFile);

Ejemplo completo

Veamos ahora un ejemplo completo para enviar un tweet:

// Incluimos la librería descargada
require_once 'src/twitter.class.php';

// Definimos cuatro constantes con nuestros datos de Twitter
define(CONSUMER_KEY, 'myconsumerkey');
define(CONSUMER_ACCESS, 'myconsumeraccess');
define(ACCESS_TOKEN, 'myaccesstoken');
define(ACCESS_TOKEN_SECRET, 'myaccesstokensecret');

// Creamos el objeto
$twitter = new Twitter(CONSUMER_KEY, CONSUMER_ACCESS, ACCESS_TOKEN, ACCESS_TOKEN_SECRET);

// Enviamos manejando el posible error
try {
 $tweet = $twitter->send('Mi primer tweet');
} catch (TwitterException $e){
 echo $e->getMessage());
}

Obtener los links que vienen en el contenido de una URL usando DOMDocument de PHP

En un post anterior vimos la forma de obtener un array con los enlaces que nos venían en el contenido de una URL. Este contenido lo obteníamos mediante una función que utilizaba la librería cURL (Client URL) de PHP.

En esta ocasión vamos a simplificar el método ya que utilizaremos para ello la clase DOMDocument.

La función que nos va a descargar y leer las etiquetas de tipo enlace será esta:

function getUrls($url){
 $doc = new DOMDocument;
 $doc->preserveWhiteSpace = false;
 
 // cargamos la url
 @$doc->loadHTMLFile($url);
 
 // buscamos todos los tags del tipo < a >
 $links = $doc->getElementsByTagName("a");
 
 // recorremos cada uno de los tags encontrados
 foreach ($links as $link){
  // obtenemos la parte href de la etiqueta
  $href = $link->getAttribute("href");
  
  if (strlen($href)>=4 && substr($href,0,4)=="http"){
   // url entera
   $urls[] = $href;
  } else if (strlen($href)>0 && substr($href, 0, 1)=="/"){
   // url empieza por / le añadimos el dominio por delante
   $urls[] = $url.$href;
  }else{
   // arhivo
   $urls[] = $url.'/'.$href;
  }
 }

 // eliminamos duplicados
 $urls = array_unique($urls);
 
 // ordenamos alfabéticamente
 sort($urls);
 
 return $urls;
}

La llamada se realizará de esta forma tan sencilla, en la que además mostraremos el resultado del array devuelto por la anterior función:

// especificamos la url
$url = "http://softontherocks.blogspot.com.es";

// obtenemos las url
$urls = getUrls($url);

// mostramos el resultado
echo nl2br(implode($urls, "\n"));

Descargar el contenido de una URL usando DOMDocument de PHP

Un un post anterior hemos visto un ejemplo de cómo descargar el contenido de una web mediante la librería cURL. En este caso, lo haremos más simple si cabe con una función que únicamente utiliza el DOMDocument para ello.

La función os la dejo a continuación:

function getURLContent($url){
    $doc = new DOMDocument;
    $doc->preserveWhiteSpace = FALSE;
    @$doc->loadHTMLFile($url);
    return $doc->saveHTML();
}

Obtener los links que vienen en el contenido de una URL usando cURL de PHP

En el anterior post hemos explicado cómo podemos obtener el contenido de una URL usando la librería cURL de PHP.

En esta ocasión, a partir de lo que nos devuelva dicha función, y mediante el objeto DOMDocument, recorreremos el contenido y buscaremos todos los enlaces que existan.

Lo primero que necesitaremos será la función con la que obtener el contenido de la URL:

function getUrlContent($url){
 $ch = curl_init();
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322)');
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
 curl_setopt($ch, CURLOPT_TIMEOUT, 5);
 $data = curl_exec($ch);
 $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 return ($httpcode>=200 && $httpcode<300) ? $data : false;
}

A continuación desarrollamos la función que recorre el contenido y guarda en un array las direcciones de todos los enlaces que se encuentre:

function getUrls($url){
 // obtenemos el contenido de la url
 $content = getUrlContent($url);

 if ($content==false){
  return false;
 }

 // creamos el array de resultados
 $urls = array();

 // creamos una instanacia a DOMDocument
 $doc = new DOMDocument;
 $doc->preserveWhiteSpace = false;
 
 // cargamos la pagina web desdecargada desde la función getUrlContent()
 @$doc->loadHTML($content);

 // buscamos todos los tags del tipo < a >
 $links = $doc->getElementsByTagName("a");
 
 // recorremos cada uno de los tags encontrados
 foreach ($links as $link){
  // obtenemos la parte href de la etiqueta
  $href = $link->getAttribute("href");
  
  if (strlen($href)>=4 && substr($href,0,4)=="http"){
   // url entera
   $urls[] = $href;
  } else if (strlen($href)>0 && substr($href, 0, 1)=="/"){
   // url empieza por / le añadimos el dominio por delante
   $urls[] = $url.$href;
  }else{
   // arhivo
   $urls[] = $url.'/'.$href;
  }
 }

 // eliminamos duplicados
 $urls = array_unique($urls);
 
 // ordenamos alfabéticamente
 sort($urls);
 
 return $urls;
}

Una vez hecho esto ya solamente nos quedará la llamada a la función y el mostrar en pantalla el resultado:

// especificamos la url
$url = "http://softontherocks.blogspot.com.es";

// obtenemos las url
$urls = getUrls($url);

// mostramos los resultados
if ($urls==false){
 echo "La página no es correcta, o es una redirección.";
} else {
 echo nl2br(implode($urls, "\n"));
}

Descargar el contenido de una URL usando cURL de PHP

Descargar el contenido de una URL es algo que puede ser bastante común para un programador web. Con PHP y la librería cURL (Client URL) podemos conseguirlo con una función bastante simple.

La librería cURL suele venir activa en la configuración de la mayoría de hosting que hay en el mercado. Además, para activarla, si somos nosotros los que configuramos PHP, simplemente debemos descomentar la línea que viene en el php.ini que hace referencia a php_curl.

La función en cuestión es la siguiente:

function getUrlContent($url){
 $ch = curl_init();
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322)');
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
 curl_setopt($ch, CURLOPT_TIMEOUT, 5);
 $data = curl_exec($ch);
 $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 return ($httpcode>=200 && $httpcode<300) ? $data : false;
}

Función para escribir en un fichero log con PHP

Es habitual que cuando realizamos cualquier aplicación queramos guardar un log en fichero de texto plano de ciertas funciones o partes de nuestro código, bien sea para solucionar posibles errores, detectarlos o cualquier otra funcionalidad que le queramos aplicar. En nuestro caso lo usamos para llevar un registro de las consultas SQL que lanzamos sobre la base de datos y ver posibles problemas.

Desde hace tiempo utilizo esta sencilla función que os dejo aquí:

function writeLog($data) {
 list($usec, $sec) = explode(' ', microtime());
 $datetime = strftime("%Y%m%d %H:%M:%S",time());
 $msg = "$datetime'". sprintf("%06s",intval($usec*1000000)).": $data";
 $save_path = 'foo.txt';
 $fp = @fopen($save_path, 'a'); // open or create the file for writing and append info
 fputs($fp, "$msg\n"); // write the data in the opened file
 fclose($fp); // close the file
}

Después, la llamada a esta función se haría de una forma muy simple:

writeLog('Este es el primer log');

Y el resultado que nos aparecería en el fichero foo.txt sería este:

20141111 07:26:14'914062: Este es el primer log

Función json_last_error y json_last_error_msg de PHP

En el anterior post vimos el funcionamiento de la función json_decode() que decodificaba una cadena JSON y la convertía a una variable PHP. Ahí provocamos un error estableciendo una profundidad de la recursividad menor de la que tenía el JSON.

Con las funciones json_last_error() y json_last_error_msg() obtenemos el error, si se produce, que ha ocurrido en la última codificación o decodificación JSON mediante las funciones json_encode() o json_decode().

La primera de las funciones, json_last_error() devuelve un valor entero con el ID del último error que se haya producido. Esta función está disponible a partir de PHP 5.3.0.

En cambio, json_last_error_msg() está disponible únicamente a partir de PHP 5.5.0 y devuelve un string con el error de la última llamada a json_encode() o a json_decode().

Ejemplo

Con este ejemplo lo que haremos será provocar el mismo error que en el anterior post y obtener el resultado. El ejemplo lo vamos a ejecutar en un PHP 5.3.29, con lo que la función json_last_error_msg() no estará disponible, con lo que nos devolverá el resultado la función que creemos nosotros:

$json = '{"users":[{ "user": "Carlos", "age": 30, "country": "Spain" }, { "user": "John", "age": 25, "country": "United States" }]}';

// Si existe la función json_last_error_msg devuelve su valor. En caso contrario si existe json_last_error devuelve el texto que tenemos asociado. Si usamos una versión anterior a PHP 5.3 nos devuelve el mensaje de que no se puede mostrar el error
function getJSONError(){
 return (function_exists('json_last_error_msg')) ? json_last_error_msg() : ((function_exists('json_last_error')) ? getJSONErrorMsg(json_last_error()) : 'This PHP cannot show the error');
}

// A partir del código de error nos muestra un mensaje
function getJSONErrorMsg($code){
 switch ($code) {
  case JSON_ERROR_NONE:
   $msg = 'No errors';
  break;
  case JSON_ERROR_DEPTH:
   $msg = 'Maximum stack depth exceeded';
  break;
  case JSON_ERROR_STATE_MISMATCH:
   $msg = 'Underflow or modes mismatch';
  break;
  case JSON_ERROR_CTRL_CHAR:
   $msg = 'Unexpected control character found';
  break;
  case JSON_ERROR_SYNTAX:
   $msg = 'Syntax error, malformed JSON';
  break;
  case JSON_ERROR_UTF8:
   $msg = 'Malformed UTF-8 characters, possibly incorrectly encoded';
  break;
  default:
   $msg = 'Unknown error';
  break;
 }
 return $code.' '.$msg;
}

// Limitamos la profundidad de la recursividad a 2
$obj = json_decode($json, true, 2);
var_dump($obj);
/* devuelve
NULL -> la profundidad es 4
*/

if ($obj==null){
 $error = getJSONError();
 echo $error;
 /* devuelve
 1 Maximum stack depth exceeded
 */
}

Función json_decode de PHP

La función json_decode() convierte un string codificado en JSON a una variable de PHP apropiada. Si la cadena no puede ser decodificada o se alcanza el límite de profundidad de la recursividad, devuelve un NULL. En caso de error, se puede usar la función json_last_error() para conocer el motivo exacto.

Sintaxis

mixed json_decode ( string $json [, bool $assoc = false [, int $depth = 512 [, int $options = 0 ]]] )

Parámetros

json: cadena JSON que queremos decodificar. 

assoc: si lo ponemos a TRUE indicaremos que queremos convertir el objeto resultado en un array asociativo. 

depth: límite de profundidad de la recursividad. Por defecto está a 512. Si se supera el límite devolverá un error.

options: se trata de una máscara de bits de opciones de la decodificación. Actualmente está disponible únicamente JSON_BIGINT_AS_STRING que convertiría los enteros grandes a cadena, en lugar de a float como lo haría por defecto.

Ejemplo

Veamos con un ejemplo su funcionalidad y lo que devuelve en cada caso. Los nombres y valores de la cadena JSON siempre deben ir entre comillas dobles:

$json = '{"users":[{ "user": "Carlos", "age": 30, "country": "Spain" }, { "user": "John", "age": 25, "country": "United States" }]}';

// Decodificamos la cadena JSON
$obj = json_decode($json);
var_dump($obj);
/* devuelve
object(stdClass)#1 (1) { ["users"]=> array(2) { [0]=> object(stdClass)#2 (3) { ["user"]=> string(6) "Carlos" ["age"]=> int(30) ["country"]=> string(5) "Spain" } [1]=> object(stdClass)#3 (3) { ["user"]=> string(4) "John" ["age"]=> int(25) ["country"]=> string(13) "United States" } } }
*/

// Devolvemos el resultado como array
$obj = json_decode($json, true);
var_dump($obj);
/* devuelve
array(1) { ["users"]=> array(2) { [0]=> array(3) { ["user"]=> string(6) "Carlos" ["age"]=> int(30) ["country"]=> string(5) "Spain" } [1]=> array(3) { ["user"]=> string(4) "John" ["age"]=> int(25) ["country"]=> string(13) "United States" } } }
*/

// Limitamos la profundidad de la recursividad a 2
$obj = json_decode($json, true, 2);
var_dump($obj);
/* devuelve
NULL -> la profundidad es 4
*/

Buscar múltiples textos en un texto con PHP

A la hora de buscar si un texto aparece dentro de un texto más amplio mediante PHP tenemos una función muy conocida llamada strpos() que nos devuelve la posición de dicho texto en el otro.

Con la función estándar, si queremos buscar varios textos deberíamos repetir la llamada tantas veces como necesitemos. 

Para facilitar la tarea tenemos esta función en la que la lista de cadenas a buscar la pasaremos mediante un array y además le podremos decir si es una búsqueda sensible a mayúsculas/minúsculas o no.

La función es la siguiente:

function getMultiPos($haystack, $needles, $sensitive=true, $offset=0){
    foreach($needles as $needle) {
        $result[$needle] = ($sensitive) ? strpos($haystack, $needle, $offset) : stripos($haystack, $needle, $offset);
    }
    return $result;
}

La llamada a la función sería como veremos a continuación. La primera llamada es sensible a mayúsculas/minúsculas y la segunda no:

$haystack = "A cat in gloves catches no mice.";
$needles = array("glove", "mouse", ".", "cat", "No");

var_dump(getMultiPos($haystack, $needles));
/* output:
array(5) { ["glove"]=> int(9) ["mouse"]=> bool(false) ["."]=> int(31) ["cat"]=> int(2) ["No"]=> bool(false) }
*/

var_dump(getMultiPos($haystack, $needles, false));
/* output:
array(5) { ["glove"]=> int(9) ["mouse"]=> bool(false) ["."]=> int(31) ["cat"]=> int(2) ["No"]=> int(24) }
*/

Contar los elementos de un array en PHP

Para contar cuántos elementos tiene un array que hayamos creado tenemos dos funciones en PHP. Se trata de las funciones count() y sizeof(). La segunda de ellas es realmente un alias de la primera, con lo que la sintaxis y comportamiento es exactamente el mismo.

En algunos blogs he leído que sizeof() puede llegar a ser más rápido que count() pero mis pruebas siempre han sacado unos resultados prácticamente idénticos.

Sintaxis

count(array, modo);
sizeof(array, modo);

Parámetros

array: Obligatorio. Especifica el array del que queremos contar los elementos
modo: Opcional. Especifica el modo de contar. Los valores posibles son:
             0 - Valor por defecto. No hace falta especificarlo. Cuenta los elementos de primer nivel
             1 - Cuenta el array recursivamente y devuelve el total de elementos si es multidimensional
Veamos un par de ejemplos de funcionamiento:

$comida = array('frutas' => array('naranja', 'pera', 'manzana'),
                          'verduras' => array('tomate', 'pimiento'));

// Count normal
count($comida); // devuelve un 2

// Count recursivo
count($comida, 1); // devuelve un 7