Operaciones simples con matrices en PHP

Existe la posibilidad de realizar operaciones con matrices que pueden ser muy útiles en determinados casos y que no son muy conocidas. En este tutorial vamos a describir estas operaciones de modo sencillo y comprensible, a la vez que eficaz. Comprobará que, teniendo una base sobre el funcionamiento de las matrices en PHP, el contendio de esta parte es muy asequible. Una cosa importante que veremos aquí es que algunas funciones que parece que puedan operar sobre matrices igual que sobre datos escalares no lo hacen en realidad como cabría esperar: para las matrices deberemos usar las funciones específicamente diseñadas al respecto.

Adición de matrices en PHP

Quizá la más simple de todas sea la adición de dos matrices, simplemente con el operador de suma (+), tal como hacemos a continuación:

$matriz1 = array("A","B","C");
$matriz2 = array(3=>"D", 4=>"E", 5=>"F");
$suma = $matriz1+$matriz2;
print_r($suma);

El resultado es el siguiente:

Array
(
[0] => A
[1] => B
[2] => C
[3] => D
[4] => E
[5] => F
)

Observe que, al definir la segunda matriz, le hemos dado unas claves a los elementos de modo que no entren en conflicto con las de la primera. Si no lo hubiéramos hecho así, aquellos elementos de la segunda matriz cuya clave coincida con alguna de la primera serían ignorados.

Diferencia de matrices en PHP

En ocasiones es necesario determinar qué elementos de una matriz no se encuentran en otras. Para ello, recurrimos a array_diff(). Esta función recibe, como argumentos, dos o mas matrices. Busca aquellos elementos de la primera que no se encuentren en las demás y forma, con estos, una matriz que devuelve. Veamos un ejemplo:

$matriz1 = array("a"=>"verde", "rojo", "azul","rojo");
$matriz2 = array("b"=>"verde", "amarillo", "rojo");
$resultado = array_diff($matriz1, $matriz2);
var_dump($resultado);

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

array(1) {
[1]=>
string(4) "azul"
}

Observe que se mantiene la paridad clave-valor. Sin embargo, la diferenciación se hace en cuanto el valor. Si desea hacer la diferenciación en cuanto al par clave-valor de los elementos, deberá usar array_diff_assoc() en su lugar. Si la diferenciación debe hacerse teniendo en cuenta exclusivamente las claves, con independencia del valor de los elementos, use array_diff_key().

También puede darse el caso de necesitar determinar cuáles son los elementos comunes, en lugar de cuáles no lo son. Para ello, emplearemos array_intersect(), cuya sintaxis es la misma que la de array_diff(), como vemos a continuación:

$matriz1 = array("a" => "verde", "rojo", "azul", "rojo");
$matriz2 = array("b" => "verde", "amarillo", "rojo");
$resultado = array_intersect($matriz1, $matriz2);
var_dump($resultado);

El resultado, en este caso, será el siguiente:

array(3){
["a"] =>
string(5) "verde"
[0] =>
string(4) "rojo"
[2] =>
string(4) "rojo"
}

Observe que se conservan los elementos de la primera matriz que aparecen en la segunda. Las claves son las que dichos elementos tienen en la primera matriz. Una vez más, se respeta, por tanto, la paridad clave-valor, pero la operación en sí se lleva a cabo teniendo en cuenta, únicamente, los valores. Para tener en cuenta ambos datos de cada elemento (la clave y el valor) usaremos array_intersect_assoc(). Si lo que nos interesa tener en cuenta es, exclusivamente, la clave de cada elemento, usaremos array_intersect_key().

Comparación de matrices en PHP

Otra posibilidad que tenemos es la comparación de matrices. Al igual que ocurre con los valores escalares, las matrices pueden ser comparadas para verificar si son iguales o idénticas o no lo son. Para ello usaremos los mismo operadores que veíamos en los condicionales: el de igualdad (==) y el de identidad (===); llegado el caso, como es lógico, también disponemos de los operadores de no igualdad (!=) y no identidad (!==). En el caso de las matrices, estos operadores tienen un significado más elaborado que cuando se trabaja con valores escalares:

  • Se produce igualdad entre dos matrices cuando ambas tienen los mismos elementos, con las mismas claves asignadas a los mismos valores, independientemente del orden en que dichos elementos hayan sido declarados.
  • Se da la identidad cuando ambas matrices tienen los mismos elementos, con las mismas claves asignadas a los mismos valores y, además, los elementos están declarados en el mismo orden.

Para ver el significado de esto, suponga lo siguiente:

$matriz1 = array(0=>"A", 1=>"B", 2=>"C");
$matriz2 = array(1=>"B", 2=>"C", 0=>"A");
var_dump($matriz1 == $matriz2);
echo "<br />";
var_dump($matriz1 === $matriz2);

En la salida estándar del navegador obtendremos los siguientes resultados:

bool(true)
bool(false)

Como ve, estos se corresponden con las definiciones indicadas (y, de paso, vemos una utilidad adicional de la función var_dump(), a la hora de mostrar valores booleanos).

La comparación entre matrices puede llevarse a cabo, también, en términos de mayor y/o menor. Suponga el siguiente fragmento de código:

$matriz1 = array("a" => "alfa", "b" => "beta", "c" => "gamma");
$matriz2 = array("a" => "ALFA", "b" => "BETA", "c" => "GAMMA");
var_dump($matriz1 > $matriz2);
var_dump($matriz1 < $matriz2);

El resultado en la sálida estándar del navegador será el siguiente:

bool(false)
bool(true)

Vemos que la primera comparación, en la que se evalúa si $matriz1 es mayor que $matriz2, da como resultado false. En la segunda comparación, en la que se evalúa si $matriz1 es menor que $matriz2, el resultado es true. Dado que ambas matrices tienen los mismos elementos, con la única diferencia de la capitalización de los literales de los valores, deducimos que la comparación se hace en base a dicha capitalización. Si una matriz tuviera más elementos que otra, esto ya sería suficiente para determinar que la primera será mayor que la segunda.

Conteo de elementos en una matriz

Como usted sabe, para contar los elementos de una matriz, se emplea la función count(), tal como vemos a continuación:

$matriz = array(0=>"A", 1=>"B", 2=>"C");
echo "Elementos de la matriz: ".count($matriz);

Algunos programadores noveles tienen la tendencia a usar esta función para determinar si una variable es una matriz o un valor escalar. Sin embargo, esto tiene un problema. Si se trata de una valor escalar, la función count() devuelve 1, y no hay forma de saber si no es una matriz con un solo elemento. Para determinar esto, es mejor emplear la funcion is_array(), que devuelve true si el argumento es una matriz o false en caso contrario. A continuación tenemos un ejemplo:

$escalar = 2;
$matriz = array(0=>"A", 1=>"B", 2=>"C");
var_dump(is_array($escalar);
var_dump(is_array($matriz);

Determinar un elemento

A menudo nos vemos en la necesidad de determinar si un elemento existe en la matriz o no. Podríamos pensar que usar la conocida función isset(), que empleamos con valores escalares. Sin embargo, como usted sabe, si el valor que se usa como argumento de esta función es NULL, el resultado es false. Esto nos lleva a la posibilidad de declarar la clave de un elemento de la matriz y asignarle el valor NULL. En ese caso, isset() nos dirá que el elemento no existe. Suponga que declara una matriz de la siguiente forma:

$matriz = array(0=>"A", 1=>null, 2=>"C");

Lo que necesitamos para saber si un elemento existe es poder determinar si la clave se ha asignado. Después de todo, un elemento de una matriz consta de la clave y el valor, y tan significativo es este como aquella. Para ello contamos con la función array_key_exists(). Esta recibe la clave del elemento buscado y el nombre de la matriz en la que hay que buscar. Si dicha clave existe, devuelve true. En caso contrario, devuelve false. Observe el ejemplo a continuación:

$matriz = array(0=>"A", 1=>null, 2=>"C");
var_dump(array_key_exists(1, $matriz));

Esto nos mostrará en la salida estándar bool (true). Observe, y esto es importante, la disposición de los argumentos de la función: primero, la clave que buscamos y luego el nombre de la matriz en la que buscar. Observe que, en este caso, se trata de una clave numérica. Si fuera una clave asociativa, debería ir entrecomillada, como es lógico, tal como se muestra a continuación:

array_key_exists("clave", $matriz)

Como acabamos de ver, es fácil determinar si un elemento de la matriz ha sido declarado, con independencia de que tenga o no un valor. Sin embargo, en ocasiones, necesitamos determinar si un valor existe en una matriz. Por supuesto, podríamos usar un bucle foreach() para ello, así:

$matriz = array(0=>"A", 1=>"B", 2=>"C");
foreach ($matriz as $clave=>$valor){
if ($valor == "B") {
echo "El valor \"B\" existe en la matriz.";
break;
}
}

Pero esto no es necesario, dado que existe una función nativa de PHP específica para esta finalidad. Se trata de in_array(), cuyo uso es el siguiente:

$matriz = array(0=>"A", 1=>"B", 2=>"C"); //Declaramos la matriz
//A continuación, buscamos el valor "B".
var_dump(in_array("B", $matriz));

Esta función recibe dos argumentos: el primero es el valor del elemento que deseamos buscar y el segundo es la matriz en la que hay que hacer la búsqueda. Sin embargo, es necesario tener en cuenta algunas cosas. Lo primero es que la búsqueda es sensible a mayúsculas y minúsculas. Así si en la matriz del ejemplo buscáramos un elemento con el valor «b», en lugar de «B», no lo encontraríamos. Otro aspecto que debe tener en cuenta es que esta función adminte un tercer parámetro, de tipo booleano. Por defecto, se asume el valor false. Si especificamos true, la búsqueda se hará también, de acuerdo al tipo de dato. Suponga el siguiente ejemplo:

$matriz = array(100, 150, 200); //Declaramos la matriz
//se busca el valor 150, que sí existe.
var_dump(in_array(150, $matriz, true));
echo "<br />";
//Se busca el valor "150", que no existe.
var_dump(in_array("150", $matriz, true));

Si lo prueba verá que, en el primer caso, se obtiene un resultado verdadero , mientras que, en el segundo, se obtiene un false, al no coincidir el tipo de dato y estar especificado el tercer parámetro.

Para eliminar un elemento de una matriz, al igual que para eliminar variables escalares, empleamos la conocida función unset(). Esta resulta muy adecuada, ya que elimina completamente un elemento de la matriz, es decir, que elimina la clave y el valor correspondiente. Vea el siguiente ejemplo:

$matriz = array(100, 150, 200); //Declaramos la matriz
unset($matriz[1]); //Eliminamos el segundo elmento.
//Mostramos la matriz.
forech ($matriz as $clave=>$valor){
echo $clave."=".$valor."<br />";
}

El resultado en la salida del navegador será el siguiente:

0=100
2=200

Como ve, el segundo elemento (con la clave 1, ya que estas empiezan por 0) ha desaparecido completamento.

Y por otra cosa importante. Desde la versión 4.2.0 de PHP, el primer parámetro (el valor que buscamos) puede ser una matriz, si es necesario buscar una dentro de otra (caso de las matrices profundas).

Comparte