Recuperar el contenido de una matriz en PHP

Existe una herramienta, no demasiado conocida, que permite recuperar los datos de una matriz en forma de variables escalares. Se trata de list(). Antes de seguir adelante, tenemos que hacer una puntualización: como dice muy claro el manual de PHP, list() no es, estrictamente, una función, sino una construcción del lenguaje. La diferencia es muy sutil, meramente conceptual.

Hecho este inciso, continuamos con el tema que nos ocupa: list() puede volcar los valores de cada elemento de una matriz a unas variables escalares especificadas. Esto implica, lógicamente, que deberemos de conocer, a priori, cuántos elementos tiene la matriz. Por supuesto, esto no supone ningún problema. Si la matriz procede, por ejemplo, de una consulta a una base de datos, sabemos los elementos que tiene, ya que sabemos las columnas que hemos especificado en dicha consulta. Si no es así, siempre podemos disponer de la función count() para determinar el número de elementos.

Suponga un código como el siguiente:

$matriz = array(100, 150, 200); //Declaramos la matriz
list($altura, $anchura, $fondo) = $matriz;
echo "Altura: ".$altura."<br />";
echo "Anchura: ".$anchura."<br />";
echo "Fondo: ".$fondo."<br />";

Al ejecutarse, obtendremos lo siguiente:

Altura: 100
Anchura: 150
Fondo: 200

Como ve, cada uno de los valores de los distintos elementos de la matriz ha sido asignado a cada una de las variables especificadas en la construcción list(), tal como se aprecia en el resultado recuperado en la salida estándar del navegador. Esto resulta particularmente útil cuando se trabaja con matrices bidimensionales. Suponga que tiene una matriz declarada del siguiente modo:

$matriz = array(array(100, 150, 200), array(110, 20, 500), array(300, 100, 200), array(200, 220, 250));

Con esto tenemos una matriz bidimensional en la que cada elemento es, a su vez, una matriz en la que se almacenan las medidas de formas geométricas. Por lo tanto, tendremos que recorrer $matriz recuperando cada uno de los valores (cada una de las matrices pequeñas interiores). Para ello, podemos usar un bucle foreach() en el que especifiquemos, únicamente, el valor, sin las claves que, en este caso, no nos hacen falta. La forma de hacerlo será así:

foreach($matriz as $contenido){
}

Dentro del bucle, usaremos list() para recuperar los valores de cada una de las matrices interiores. El fragmento de código completo sería el siguiente:

$matriz = array(array(100, 159, 200), array(110, 20, 500), array(300, 100, 200), array(200, 220, 250));
foreach ($matriz as $contenido){
list($altura, $anchura, $fondo) = $contenido
echo "Altura: ".$altura."<br />";
echo "Anchura: ".$anchura."<br />";
echo "Fondo: ".$fondo."<br />";
echo "===========<br />";

Observe, el uso de list(). En realidad, esto tiene mucha más utilidad cuando se trata de mostrar datos recuperados de una tabla de una base de datos, mediante una consulta. Observe el siguiente fragmento de ejemplo:

$consulta = "SELECT idEmp, nombreEmp, sueldoEmp FROM empleados;";
$resultado = mysql_query($consulta, $conexion);
while(list($id, $nombre, $sueldo) = mysql_fetch_row($resultado)){
echo "Identificador: ".$id."<br />";
echo "Nombre: ".$nombre."<br />";
echo "Sueldo: ".$sueldo."<br />";
}

Observe , como usamos list(), en combinación con while(), para extraer los resultados de un cursor procedente de una consulta MySQL

Una observación final: list() sólo opera sobre matrices numércas cuyo índice debe empezar en 0.

Reflejar e invertir matrices en PHP

Se conoce como reflejar(flipping) una matriz al hecho de intercambiar las claves con los valores, de modo que las claves pasen a ser valores, y estos ocupen el lugar de aquellas. Para ello, recurrimos a la función array_flip(), tal como se muestra a continuación:

$matriz = array("ALFA", "BETA", "GAMMA");
var_dump($matriz);
$matriz = array_flip($matriz);
echo "<br />";
var_dump($matriz);

Como ve, se crea una matriz y se muestra en la salida estándar. Después se refleja con la función indicada y se muestra de nuevo. Lo que veremos es lo siguiente:

array(3) {
[0]=>
string(4) "ALFA"
[1]=>
string(4)"BETA"
[2]=>
string(5) "GAMMA"
}

array(3){
["ALFA"]=>
int(0)
["BETA"]=>
int(1)
["GAMMA"]=>
int(2)
}

Observe como los valores y las claves de los elementos se han intercambiado entre sí.

Por otro lado, contamos con la posibilidad de invertir el orden de los distintos valores de la matriz, mediante la función array_reverse(). Observe el siguiente fragmento de ejemplo:

$matriz = array("ALFA", "BETA", "GAMMA");
var_dump($matriz);
$matriz = array_reverse($matriz);
var_dump($matriz);

El resultado obtenido en la salida estándar del navegador es el siguiente:

array(3) {
[0]=>
string(4) "ALFA"
[1]=>
string(4) "BETA"
[2]=>
string(5) "GAMMA"
}
array(3) {
[0]=>
string(5) "GAMMA"
[1]=>
string(4) "BETA"
[2]=>
string(4) "ALFA"
}

Vea que, en este caso, se altera el orden de los valores de los elementos, pero no el de las claves, que se conservan en su disposición original. Por lo tanto, se pierde la relación incicial entre cada clave y su correspondiente valor. Esta limitación, sin embargo, sólo afecta a matrices de índice numérico. En el caso de matrices asociativas, se mantiene la paridad clave-valor, aunque se cambie el orden de los elementos. Vea el mismo ejemplo anterior, usando, esta vez, una matriz asociativa:

$matriz = array("A"=>"ALFA", "B"=>"BETA", "C"=>"GAMMA");
var_dump($matriz);
$matriz=array_reverse($matriz);
var_dump($matriz);

El resultado es el siguiente:

array(3) {
["A"]=>
string(4) "ALFA"
["B"]=>
string(4) "BETA"
["C"]=>
string(5) "GAMMA"
}
array(3) {
["C"]=>
string(5) "GAMMA"
["B"]=>
string(4) "BETA"
["A"]=>
string(4) "ALFA"
}

Observe como ahora se mantine la paridad, tal como hemos dicho.

Implosión y explosión de matrices en PHP

Bajo este titular aparentemente violento, vamos a conocer dos funciones muy útiles y extendidas para el manejo de matrices. En muchas ocasiones es necesario disponer los valores de los elementos de una matriz, uno a continuación de otro, formando una cadena. La función implode() cumple este objetivo. Esta función recibe dos argumentos. El primero es una secuencia de separación entre elementos, y el segundo es una matriz. La función implode() une los elementos en una cadena, separándolos con la secuencia especificada en el primer argumento. Suponga el siguiente ejemplo:

$matriz = array("Elemento 0", "Elemento 1", "Elemento 2");
$cadena = implode(" - ", $matriz);

El resultado en la página será el siguiente:

Elemento 0 - Elemento 1 - Elemento 2

Por el contario, podemos separar fragmentos de una cadena y formar con ellos una matriz, usando la funcion explode(). Esta recibe dos argumentos. El primero es un carácter o secuencia de caracteres que se deben buscar en la cadena y que se identificarán como separadores entre los elementos. El segundo argumento es la propia cadena a partir de la que se formará una matriz. Suponga el siguiente ejemplo:

$cadena = "elemento1, elemento2, elemento3, elemento4, elemento5, elemento6";
$matriz = explode(", ", $cadena);
var_dump($matriz);

Como ve, la variable $cadena sigue un patrón claramente definido, en el que cada fragmento se separa del siguiente mediante una coma y un espacio en blanco, como resultado se obtiene la siguiente matriz:

array(6) {
[0]=>
string(9) "elemento1"
[1]=>
string(9) "elemento2"
[2]=>
string(9) "elemento3"
[3]=>
string(9) "elemento4"
[4]=>
string(9) "elemento5"
[5]=>
string(9) "elemento6"
}

La función explode() admite un tercer parámetro opcional, que se usa para limitar el número máximo de elementos que tendrá la matriz. Observe la siguiente variación sobre el ejemplo anterior:

$cadena = "elemento1, elemento2, elemento3, elemento4, elemento5, elemento6";
$matriz = explode(", ", $cadena, 3);
var_dump($matriz);

Obseve en la segunda línea cómo hemos incluido el tercer argumento. Es este caso, el resultado será el siguiente:

array(3) {
[0]=>
string(9) "elemento1 "
[1]=>
string(9) "elemento2"
[2]=>
string(42) "elemento3, elemento4, elemento5, elemento6"
}

Como ve, en la cadena original se podrían extraer más fragmentos, pero como hemos dicho que la matriz debe tener sólo tres elementos, se forman correctamente los dos primeros y, en el tercero, se incorpora todo el resto de la cadena.

Si el tercer argumento es mayor que el número de fragmentos que se pueden extraer de la cadena (en nuesto ejemplo, podríamos poner el valor 10), el resultado es el mismo que si no hubiéramos usado este tercer parámetro.

Ademas, la funcion explode() puede extraer fragmentos de una cadena y asignarlos a variables escalares, en lugar de hacerlo sobre una matriz. Observe el siguiente ejemplo:

$datos = "miLogin:miPassword:HTTP:80:/home/usuario:MySQL";
list($usuario, $clave, $protocolo, $puerto, $ruta, $BBDD) = explode(":", $datos);
echo "Usuario: ".$usuario."<br />";
echo "Clave: ".$clave."<br />";
echo "Protocolo: ".$protocolo."<br />";
echo "Puerto: ".$puerto."<br />";
echo "Ruta: ".$ruta."<br />";
echo "Base de Datos: ".$BBDD."<br />";

El resultado será el siguiente:

Usuario: miLogin
Clave: miPassword
Protocolo: HTTP
Puerto: 80
Ruta: /home/usuario
Base de Datos: MySQL

Como ve, cada fragmento de la cadena se ha asignado a una variable escalar de la lista que aparece.


Comparte