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

Obtener el tamaño de las tablas de una base de datos MySQL

En el anterior post hablábamos sobre cómo obtener el tamaño de las base de datos. En esta ocasión nos centramos en el tamaño de las tablas de una base de datos.

Lo que haremos será una SQL que nos devuelva todas las tablas de la base de datos test ordenadas de la que ocupa más tamaño a la que ocupa menos, expresada la información en MB.

La SQL sería así:

mysql> SELECT  table_name, table_rows,
        ROUND(data_length / (1024 * 1024), 2) AS `data_size`,
        ROUND(index_length / (1024 * 1024), 2) AS `index_size`,
        ROUND((data_length + index_length) / (1024 * 1024), 2) AS `total_size`,
    FROM information_schema.TABLES
    WHERE table_schema = 'test'
    ORDER BY 5 DESC;

Obtener el tamaño de una base de datos MySQL

Hace unos días me pidieron en una aplicación web en la que estaba trabajando que mostrase el tamaño que tenía la base de datos MySQL.

Como no tenía ninguna función a mano se me ocurrió investigar un poco y con esta simple SQL pude obtener la información que solicitaban.


Los datos del tamaño los muestro en MB y en la consulta me devuelve la información de todas las bases de datos a las que tiene acceso el usuario con el que lanzamos la query.

mysql> SELECT table_schema AS `name_bd`, sum( data_length + index_length ) / 1024 / 1024 AS `size`
    ->   FROM information_schema.TABLES
    ->   GROUP BY table_schema;

Lo que devuelve esta función es lo siguiente:

+--------------------+--------------+

| name_bd            | size         |

+--------------------+--------------+

| information_schema |   0.00390625 |

| test               | 173.52998352 |

+--------------------+--------------+

2 rows in set (0.80 sec)

Si quisiéramos obtener únicamente una base de datos en concreto, deberíamos añadir a la consulta una condición WHERE.

mysql> SELECT table_schema AS `name_bd`, sum( data_length + index_length ) / 1024 / 1024 AS `size`
    ->   FROM information_schema.TABLES
    ->   WHERE table_schema='test'

    ->   GROUP BY table_schema;

Y el resultado es:

+----------------+--------------+

| name_bd        | size         |

+----------------+--------------+

| test           | 173.52998352 |

+----------------+--------------+

1 row in set (0.84 sec)

Función GROUP_CONCAT de MySQL

En esta ocasión os presento una función muy útil para mostrar datos agrupados cuyo valor de agrupación no es un count() o un sum() o las típicas funciones agregadas. De lo que se trata es de concatenar todos los valores de un campo que cumplan el criterio de un GROUP BY pero separados por el separador que elijamos. Para entenderlo mejor veamos un ejemplo.

Tenemos una tabla llamada ESTUDIANTES con la siguiente estructura:

mysql> select * from estudiantes;

+--------+-------------+------+

| nombre | asignatura  | nota |

+--------+-------------+------+

| María  | Matemáticas |  5.5 |

| María  | Inglés      |    8 |

| María  | Física      | 3.75 |

| Carlos | Matemáticas | 4.25 |

| Carlos | Inglés      |   10 |

| Carlos | Física      |  7.5 |

+--------+-------------+------+

6 rows in set (0.00 sec)

Sobre estos registros queremos extraer por cada estudiante la lista de asignaturas que ha aprobado, es decir, en las que ha sacado más de un 5.

mysql> select nombre, group_concat(asignatura separator '-') from estudiantes where nota>=5 group by nombre;

+--------+----------------------------------------+

| nombre | group_concat(asignatura separator '-') |

+--------+----------------------------------------+

| Carlos | Inglés-Física                          |

| María  | Matemáticas-Inglés                     |

+--------+----------------------------------------+

2 rows in set (0.00 sec)

En este caso hemos indicado que el separador sería un guión pero podríamos haber indicado cualquier otro. Si no indicamos ningún separador nos lo va a devolver separado por comas.

mysql> select nombre, group_concat(asignatura) from estudiantes where nota>=5 group by nombre;

+--------+--------------------------+

| nombre | group_concat(asignatura) |

+--------+--------------------------+

| Carlos | Inglés,Física            |

| María  | Matemáticas,Inglés       |

+--------+--------------------------+

2 rows in set (0.01 sec)

Esto es muy útil y ahora simplemente si recorriésemos los resultados mediante PHP podrías crear fácilmente una tabla HTML

Esta función group_concat() puede devolver como máximo 1024 caracteres que es el límite por defecto tal y como explican en la documentación de MySQL. Sin embargo esto se puede cambiar editando el fichero my.cnf de configuración y modificando el valor de la variable.

group_concat_max_len=16386

Otra forma es ejecutando previamente la siguiente sentencia.

SET GLOBAL group_concat_max_len=4096

Fuentes:

http://dev.mysql.com/doc/refman/5.0/en/group-by-functions.html#function_group-concat