15, octubre - 2018

Funciones con matrices en PHP

Funciones con matrices en PHP

Las matrices en PHP tienen una serie de funciones predefinidas que nos van a facilitar el uso de las mismas en nuestros códigos de programación. Estas funciones nos van a permitir por ejemplo ordenar los arrays de múltiples formas, alterar el orden, invertir el orden, cargar matrices desde archivos externos, desplazarnos en el interior de las matrices, aplicar funciones a los elementos del array, etc…
Veamos de qué forma podemos realizar estas operaciones.

Ordenar matrices con sort(), asort(), ksort() y usort()

Es muy habitual tener que ordenar los elementos de una matriz, ordenar éstos en matrices unidimensionales o simples es realmente sencillo, vemos unos ejemplos.

Usar la función sort()

Esta función se aplica en arrays unidimensionales idexados de forma numérica, no asociativa, su uso podría ser de la siguiente forma:
Sintaxis:

sort ( array , (opcional) SORT_REGULAR (por defecto) SORT_NUMERIC o SORT_STRING )
///////////////////////////////////////////////////////////
$ar = array("valor a", "valor f", "valor b", "valor e", "valor d", "valor c");
sort($ar);
$ic = count($ar);
$i = 1;
foreach($ar as $value => $val ) {
if($i < $ic)
echo $val . " - ";
else
echo $val;
++$i;
}
// declaramos el array ar con tres valores indexados de forma numérica
// ordenamos el array de forma alfabética de la a a la z
// contamos los elementos del array
// declaramos la variable i con el valor de 1
// creamos el bucle foreach para acceder a los elementos ordenados del array
// creamos el condicional si i es menor que ic...
// pones el valor más un guión medio a la derecha de los resultados
// si no es menor o sea si es el último elemento del array
// pones el valor sin guión
// incrementamos en uno cada paso del array la variable i para que funcione el condicional
/** RESULTADO */
/* valor a - valor b - valor c - valor d - valor e - valor f */
///////////////////////////////////////////////////////////

Nota: Hay que tener en cuenta que la función sort() discrimina entre mayúsculas y minúsculas dando prioridad a las primeras, de igual forma, ordena los valores de un array unidimensional de forma alfabética de la Aa-Zz y de forma numérica del 1 al 1x, también que cuenta con un segundo parámetro opcional SORT_REGULAR (por defecto) SORT_NUMERIC o SORT_STRING para indicar de qué forma queremos que se aplique el orden de la matriz.

Usar las funciones asort() y ksort()

Hemos visto cómo se pueden ordenar matrices en PHP unidimensionales indexadas de forma numérica por su valor, si lo que queremos es ordenar matrices unidimensionales ordenadas de forma asociativa tenemos que usar estas dos funciones, en función (valga la redundancia) a si lo que queremos es ordenar los valores o los índices, veamos cómo:
Sintaxis:

ksort ( array , (opcional) SORT_REGULAR (por defecto) SORT_NUMERIC o SORT_STRING )
asort ( array , (opcional) SORT_REGULAR (por defecto) SORT_NUMERIC o SORT_STRING )
///////////////////////////////////////////////////////////
$ar = array("In5" => "valor a", "In2" => "valor f", "In4" => "valor b", "In1" => "valor e", "In3" => "valor d", "In6" => "valor c");
asort($ar);
$ic = count($ar);
$i = 1;
foreach($ar as $index => $val ) {
if($i < $ic)
echo $val . " - ";
else
echo $val; ++$i;
}
// ordenamos el array de forma alfabética de la a a la z por su valor
// contamos los elementos del array
// declaramos la variable i con el valor de 1
//creamos el bucle foreach para acceder a los elementos ordenados del array
// creamos el condicional si i es menor que ic...
// pones el valor más un guión medio a la derecha de los resultados
// si no es menor o sea si es el último elemento del array
// pones el valor sin guión
// incrementamos en uno cada paso del array la variable i para funcione el condicional
/** RESULTADO */
/* valor a - valor b - valor c - valor d - valor e - valor f */
///////////////////////////////////////////////////////////
$ar2 = array("In5" => "valor a", "In2" => "valor f", "In4" => "valor b", "In1" => "valor e", "In3" => "valor d", "In6" => "valor c");
ksort($ar2);
$ic = count($ar2);
$i = 1;
foreach($ar2 as $index => $val ) {
if($i < $ic)
echo $index . " - ";
else
echo $index;
++$i;
}
/** RESULTADO */
/* In1 - In2 - In3 - In4 - In5 - In6 */
///////////////////////////////////////////////////////////

Con la primera función asort() ordenamos el array asociativo por su valor de igual forma que con sort(), con la segunda ksort() ordenamos el array asociativo por su índice, sin tener en cuenta su valor.

Invertir el orden de matrices unidimensionales

Las funciones de matriz que invierten el orden de los índices o los valores se utilizan igual que sus homólogas, éstas nos van a devolver la matriz ordenada de forma opuesta y son:

  • sort() = orden inverso rsort()
  • asort() = orden inverso arsort()
  • ksort() = orden inverso krsort()

Ordenar matrices multidimensionales de indexación numérica usando usort()

PHP puede ordenar una matriz unidimensional de forma sencilla ya que ésta contiene valores en un solo lugar, ahora bien, para el caso de matrices multidimensionales la cosa se complica ya que estos arrays contienen en su interior más arrays y PHP no sabe qué comparación es la que tiene que aplicar para realizar el ordenamiento, para estos casos tendremos que definir nuestras propias funciones comparativas dependiendo de cómo deseemos aplicar la comparación y el ordenamiento. Usaremos la función de matrices usort() que le indicará a la aplicación que queremos pasar una función definida por el usuario (nosotros) al array. Veamos pues algunas de estas funciones.
Si aplicamos el ejemplo anterior de matriz bidimensional indexada de forma numérica, podemos aplicar la siguiente función para indicar a PHP cómo deseamos ordenarla.

///////////////////////////////////////////////////////////
$arm = array(
array(8, 5, 7),
array(27, 2, 1),
array(12, 8, 6)
);
function ordena0($col, $val) {
return $col[0] - $val[0];
}
function ordena1($col, $val) {
return $col[1] - $val[1];
}
function ordena2($col, $val) {
return $col[2] - $val[2];
}
usort($arm, "ordena0");
foreach($arm as $index) {
foreach($index as $i => $v) {
if($i == 0)
echo $i . ": " . $v . "
";
}
}
/* RESULTADO */
/**
0: 8
0: 12
0: 27
*/
usort($arm, "ordena1");
foreach($arm as $index) {
foreach($index as $i => $v) {
if($i == 1)
echo $i . ": " . $v . "
";
}
}
/* RESULTADO */
/**
1: 2
1: 5
1: 8
*/
usort($arm, "ordena2");
foreach($arm as $index) {
foreach($index as $i => $v) {
if($i == 2)
echo $i . ": " . $v . "
";
}
}
/* RESULTADO */
/**
2: 1
2: 6
2: 7
*/
///////////////////////////////////////////////////////////
// definimos el array bidimensional $arm indexado de forma numérica
// definimos la función a utilizar en usort() las funciones ordena(0,1,2) en las que pasamos los índices sobre los que queremos hacer la comparación
// pasamos el bucle foreach para ver la ordenación de cada una de las funciones

Ordenar matrices multidimensionales de indexación asociativa usando array_multisort()

En los casos en los que la matriz sea multidimensional y además esté indexada de forma asociativa tendremos que usar otra función de matrices de PHP para lograr su ordenamiento. Veamos cómo.

///////////////////////////////////////////////////////////
$arma3[] = array("Verdura" => "Tomate", "Cantidad" => 5);
$arma3[] = array("Verdura" => "Cebolla", "Cantidad" => 1);
$arma3[] = array("Verdura" => "Zanahoria", "Cantidad" => 12);
foreach ($arma3 as $l => $v) {
$x[$l] = $v['Verdura'];
}
foreach ($arma3 as $l => $v) {
$y[$l] = $v['Cantidad'];
}
$i = count($arma3);
array_multisort($x, SORT_ASC, $arma3);
$ii = 1;
foreach ($arma3 as $l => $r) {
if($ii < $i)
echo $r['Verdura'] . " - ";
else
echo $r['Verdura']; ++$ii; }
/** RESPONDE */
/* Cebolla - Tomate - Zanahoria */
array_multisort($y, SORT_ASC, $arma3);
$ii = 1;
foreach ($arma3 as $l => $r) {
if($ii < $i)
echo $r['Cantidad'] . " - ";
else
echo $r['Cantidad'];
++$ii;
}
/** RESPONDE */
/* 5 - 1 - 12 */
///////////////////////////////////////////////////////////

Ordenar matrices de forma inversa con array_reverse()

Puede que lo que necesitemos sea invertir el orden de una determinada matriz de elementos, ésto lo podemos llevar a cabo con la función array_reverse() similar a rsort(), y es válida tanto para arrays unidimiensionales como multidimensionales.

///////////////////////////////////////////////////////////
$arm = array(1, 2, 3, 4);
$cn = count($arm);
$in = 1;
foreach($arm as $i => $v) {
if($in &lt; $cn) echo $v . ", "; else echo $v; ++$in; }
/** RESULTADO */
/* 1, 2, 3, 4 */
$armrev = array_reverse($arm);
$inn = 1;
foreach($armrev as $i => $v) {
if($inn < $cn) echo $v . ", ";
else echo $v; ++$inn;
}
/** RESULTADO */
/* 4, 3, 2, 1 */
///////////////////////////////////////////////////////////
$arma3[] = array("Verdura" => "Tomate", "Cantidad" => 5);
$arma3[] = array("Verdura" => "Cebolla", "Cantidad" => 1);
$arma3[] = array("Verdura" => "Zanahoria", "Cantidad" => 12);
foreach($arma3 as $i => $v) {
foreach($v as $ii => $vv) {
echo $vv . " ";
}
}
/** RESULTADO */
/* Tomate 5 Cebolla 1 Zanahoria 12 */
$arma3rev = array_reverse($arma3);
foreach($arma3rev as $i => $v) {
foreach($v as $ii => $vv) {
echo $vv . " ";
}
}
/** RESULTADO */
/* Zanahoria 12 Cebolla 1 Tomate 5 */
///////////////////////////////////////////////////////////

Nota: array_reverse() tiene un segundo parámetro opcional en el que le indicamos si deseamos preservar los índices (aplicarlo solo a los valores) o no, por defecto es false.

Matrices desde archivos con la función file()

Si tenemos un archivo tipo txt o similares, PHP nos permite acceder al contenido de dicho archivo almacenando éste en una matriz, cada línea del archivo se convertirá en un elemento de dicha matriz, utilizamos la función file() para lograrlo, a su vez, podemos usar la función count() para ver el número de elementos que contiene la matriz y así poder ver dónde acaba. Podemos ver el siguiente ejemplo práctico:

///////////////////////////////////////////////////////////
$rz = $_SERVER['DOCUMENT_ROOT'];
$archivo = file($rz.'/archivo.txt');
$lineas = count($archivo);
if($lineas == 0)
echo "Archivo vacío...";
else {
for($i = 0; $i < $lineas; $i++) {
 echo $archivo[$i] . "
";
}
}
// almacenamos la ruta raíz del documento mediante la variable de servidor DOCUMENT_ROOT
// cargamos el array en la variable archivo mediante la función line()
// contamos el número de líneas del archivo con la función count() y lo almacenamos en la variable lineas
// analizamos si el array está vacío con la instrucción if
// declaramos un bucle for que recorrerá hasta la última línea del archivo y lo imprimirá en pantalla
///////////////////////////////////////////////////////////

Contar elementos de una matriz mediante el uso de count(), sizeof() y array_count_values()

Las funciones count() y sizeof() tienen la misma función, la de contar los elementos de una determinada matriz y su uso es el mismo, con array_count_values() la operación es diferente, esta función nos va a devolver una matriz en la que se va a analizar el número de veces que se repiten los valores de la matriz analizada, de tal forma que si por ejemplo en la matriz hay dos veces repetido el valor 5, nos devolverá un 2 para ese valor, como vemos en el siguiente ejemplo.

///////////////////////////////////////////////////////////
$ar = array(1, 2, 3, 4, 5, 5);
echo count($ar);
/** RESULTADO */
/* 6 */
echo sizeof($ar);
/** RESULTADO */
/* 6 */
///////////////////////////////////////////////////////////
$claves = array_count_values($ar);
foreach($claves as $in => $val) {
echo "Clave: " . $in . " - Veces: " . $val . "
";
}
/** RESULTADO */
/*
Clave: 1 - Veces: 1
Clave: 2 - Veces: 1
Clave: 3 - Veces: 1
Clave: 4 - Veces: 1
Clave: 5 - Veces: 2
*/
///////////////////////////////////////////////////////////

Aplicar funciones a elementos de una matriz con array_walk()

A diferencia de la función usort() que servía específicamente para pasar una función de ordenación a una matriz, con array_walk() vamos a poder pasar una función a una determinada matriz, además con parámetros de función, definidos previamente y pasados mediante array_walk(), podemos ver un ejemplo de su uso a continuación.

///////////////////////////////////////////////////////////
$ar = array(1, 2, 3, 4, 5, 5);
function multiplicamatriz(&$value, $key, $factor) {
$value *= $factor;
}
array_walk($ar, 'multiplicamatriz', 2);
foreach($ar as $in => $val) {
echo "Valor anterior " . $val/2 ."<br />";
echo "Nuevo valor " . $val . "<br />";
}
// declaramos la matriz ar
// declaramos la función multiplicamatriz, con los parámetros value, el valor de los elementos de la matriz, key, los índices y factor, el valor a operar
// pasamos la función mediante array_walk()
// recorremos los resultados mediante bucle foreach
/** RESULTADO */
/*
Valor anterior 1
Nuevo valor2
Valor anterior 2
Nuevo valor4
Valor anterior 3
Nuevo valor6
Valor anterior 4
Nuevo valor8
Valor anterior 5
Nuevo valor10
Valor anterior 5
Nuevo valor10
*/
///////////////////////////////////////////////////////////
$ar2 = array(1, 2, 3, 4, 5, 5);
function multiplicamatriz2(&$value, $key, $factor) {
 if ($key == 1)
 $value *= $factor;
}
array_walk($ar2, 'multiplicamatriz2', 2);
foreach($ar2 as $in => $val) {
 if($in == 1)
 echo " CAMBIADO Nuevo valor " . $val ."<br />";
 else
 echo "Nuevo valor " . $val . "<br />";
}
// igual que la anterior pero esta vez operando sólo en índice 2 de la matriz
/** RESULTADO */
/*
Nuevo valor 1
CAMBIADO Nuevo valor 4
Nuevo valor 3
Nuevo valor 4
Nuevo valor 5
Nuevo valor 5
*/
///////////////////////////////////////////////////////////

Desplazamientos dentro de matrices con current(),  reset(), each(), end(), etc…

Toda matriz tiene un elemento en el que se está trabajando, se suele llamar con el nombre de puntero y hace referencia al orden y al índice en el que se esté trabajando en cada momento, bien, ese puntero puede ser manipulado con una serie de funciones que vamos a ver a continuación. Partimos de la base que cuando declaramos la matriz, el puntero apunta al primer elemento indexado de la matriz, de tal modo que si declaramos la matriz array(1, 2, 3) el puntero inicialmente estará apuntando al elemento 0 de la matriz, en este caso el valor 1.

Veamos primero lo que hace cada una de las funciones

  • Función each() – Devuelve el elemento del índice actual antes de que el puntero avance
  • Función current() – Devuelve el primer elemento de índice actual
  • Función next() – Devuelve el elemento siguiente al del índice actual
  • Función prev() – Devuelve el elemento anterior al del índice actual
  • Función reset() – Reinicia el puntero al primer elemento de la matriz
  • Función end() – Devuelve el último elemento indexado de la matriz

Podemos ver unos ejemplos simples:

///////////////////////////////////////////////////////////
$ar = array("Orden primero", "Orden medio 1", "Orden medio 2", "Orden último");
print_r($ar);
/** RESULTADO */
/*
Array ( [0] => Orden primero [1] => Orden medio 1 [2] => Orden medio 2 [3] => Orden último )
*/
$arsiguiente = next($ar);
echo $arsiguiente;
/** RESULTADO */
/*
Orden medio 1
*/
reset($ar);
$arfinal = end($ar);
echo $arfinal;
/** RESULTADO */
/*
Orden último
*/
///////////////////////////////////////////////////////////

Conversión de matrices en variables escalares con extract()

Para finalizar, veamos cómo convertir una matriz en una o mejor dicho, en varias variables escalares, gracias a función extract(), esta función se aplica únicamente en el caso de matrices indexadas de forma asociativa, que tengan declarado un valor en el índice, la función le dará a cada variable el nombre de ese valor indexado y el mismo valor que posea en la matriz. Vemos un ejemplo:

///////////////////////////////////////////////////////////
$ar = array(
"VariableUno"=>"Orden primero",
"VariableDos"=>"Orden medio 1",
"VariableTres"=>"Orden medio 2",
"VariableCuatro"=>"Orden último"
);
extract($ar);
echo $VariableUno . " " . $VariableDos . " " . $VariableTres . " " . $VariableCuatro;
/** RESULTADO */
/*
Orden primero Orden medio 1 Orden medio 2 Orden último
*/
</div>
///////////////////////////////////////////////////////////

La función extract() posee dos parámetros opcionales para manejar las coincidencias en los índices, ya que como sabemos, si se declara una variable dos veces ésta tomará como valor el de la última declaración realizada, para que esto no suceda podemos usar los parámtros

  • EXTR_SKIP – Salta el elemento cuando tiene lugar la coincidencia
  • EXTR_OVERWRITE – Sobre escribe el elemento o variable anterior cuando tiene lugar la coincidencia
  • EXTR_PREFIX_NAME – Crea una nueva variable ($prefix_key) con el tercer parámetro prefijo
  • EXTR_PREFIX_ALL – Crea delante de todos los nombres de variables el tercer parámetro establecido, el prefijo
  • EXTR_PREFIX_INVALID – Coloca delante de todos los nombres de variables el parámetro prefijo, de ese modo crea variables válidas
  • EXTR_IF_EXISTS – Crea o extrae únicamente variables que hayan sido declaradas previamente, si la variable ya existe la sobreescribe con el valor de la matriz
  • EXTR_PREFIX_IF_EXISTS – Crea la versión con prefijo en caso de que ya exista una versión sin prefijo
  • EXTR_REFS – Extra variables en modo referencia

Lo mejor es experimentar con cada uno de los parámetros para ver las variables que van creando, dejamos un ejemplo con prefijo:

///////////////////////////////////////////////////////////
$ar = array(
 "VariableUno"=>"Orden primero",
 "VariableDos"=>"Orden medio 1",
 "VariableTres"=>"Orden medio 2",
 "VariableCuatro"=>"Orden último"
 );
extract($ar, EXTR_PREFIX_ALL, "varray");
echo $varray_VariableUno . " " . $varray_VariableDos . " " . $varray_VariableTres . " " . $varray_VariableCuatro;
/** RESULTADO */
/*
Orden primero Orden medio 1 Orden medio 2 Orden último
*/
///////////////////////////////////////////////////////////

 

¿Te ha parecido interesante este contenido..?
En ese caso, te pedimos por favor que nos des tu valoración graicas a esto podemos mejorar nuestras lecciones. Gracias.
1 estrella2 estrellas3 estrellas4 estrellas5 estrellas (Ninguna valoración todavía)
Cargando…

Social Media

  • YouTube

    Suscríbete a nuestro canal de YouTube para ver todos nuestros vídeos sobre programación

  • Twitter

    Síguenos en Twitter e infórmanos de ello, es muy probable que también te sigamos

  • Facebook

    Estamos pensando si abrir una página de Facebook o no...

  • LinkedIn

    En breve...

  • Instagram

    En breve...

  • Github

    En breve...

A %d blogueros les gusta esto: