Trabajando con arrays en PHP: algunas funciones.

PHP evoluciona

Atrás quedó ya aquella época en la que, en el mundo de la programación, PHP era considerado como el “patito feo”. Aquel lenguaje que por muchos era criticado por su caótica sintaxis y por no estar a la altura de otros lenguajes… Pero hoy, todo eso ha quedado atrás y podemos decir que PHP, aparte de ser el líder indiscutible en el desarrollo web, se ha sabido adaptar y evolucionar, implementado muchas características de lenguajes más grandes, estructurados y robustos.

Por ejemplo, hoy podemos crear funciones con valores de retorno, propiedades tipadas en clases, tenemos un manejo de excepciones bastante avanzado… y como no, hoy podemos trabajar adecuadamente con arrays, entre otras muchas cosas claro.

En este post, nos vamos a centrar en los arrays en PHP. Concretamente en algunas funciones bastante útiles que ofrecen muchas posibilidades que vale la pena redescubrir, porque si, aunque parezca algo básico, los arrays en PHP tienen bastante potencial.

Existen un montón de funciones para trabajar con arrays, pero vamos hablar sobre alguna nueva y sobre otras que quizás no sean tan conocidas. Pero eso no quita su utilidad.

Bfff que me enrollo demasiado…

Buscando en un array

Vamos a buscar un valor en un array, pero no, no con array_search() ni array_filter(), sino con array_find() que no únicamente permite buscar un elemento, sino que busca el primer elemento que cumpla una condición.

Por ejemplo, supongamos que tenemos una lista de alumnos y sus respectivas notas:

$alumnos = [
    ['nombre' => 'Pedro', 'Nota' => 4],
    ['nombre' => 'Antonio', 'Nota' => 5.5],
    ['nombre' => 'María', 'Nota' => 8],
    ['nombre' => 'Ana', 'Nota' => 10],
    ['nombre' => 'Elena', 'Nota' => 6],
];

$primerAprobado = array_find($alumnos, fn($alumnos) => $alumnos['Nota'] >= 5);

print_r($primerAprobado);

El código anterior devuelve “Antonio”.

¿Por qué?

Porque en este caso nos interesa el primer resultado que cumple la condición especificada. Es decir, que alumno ha sido el primero en aprobar.

¿Por qué digo esto?

Porque la función array_find() no busca el mayor valor, ni el valor más adecuado dentro de todos. Lo que hace es devolver el primer elemento del array que cumpla una condición, nada más.

Esto es importante tenerlo claro porque si no, podemos pensar en hacer lo siguiente:

$alumnos = [
    ['nombre' => 'Pedro', 'Nota' => 4],
    ['nombre' => 'Antonio', 'Nota' => 5.5],
    ['nombre' => 'María', 'Nota' => 8],
    ['nombre' => 'Ana', 'Nota' => 10],
    ['nombre' => 'Elena', 'Nota' => 6],
];

$mayorNota = array_find($alumnos, fn($alumnos) => $alumnos['Nota'] >= 5);

print_r($mayorNota);

Sigue devolviendo “Antonio” evidentemente y como ves, no tiene sentido usar array_find() para sacar la mayor nota. ¿Entiendes por dónde voy?

Para ese caso deberíamos de usar la función array_reduce().

Otro ejemplo:

$animales = ['perro', 'gato', 'pez', 'loro', 'hamster'];

var_dump(array_find($animales, function (string $value) {
    return str_starts_with($value, 'p');
}));

En este caso queremos encontrar el primer animal cuyo nombre comienza con p, que en este caso es perro. Si buscamos otro nombre que empiece por ejemplo con la letra f u otra que no está en el array, la función devolvería null.

Entonces, viendo todo esto, deducimos que:

La función array_find() es útil cuando:

• Nos interesa el primer resultado que cumpla una condición específica
• Y el orden del array ya está preparado de antemano (por ejemplo, ordenado por fecha, prioridad, etc.)

Otra cosa que deducimos es que como ya dije al principio, array_find() no es igual ni a array_filter() ni mucho menos a array_search().

Entonces, ¿Cuándo usar cada uno?

Aunque de primeras array_search() o array_filter() nos pueden parecer iguales a array_find(), no son lo mismo.

Debemos saber que:

• array_filter: Filtra todos los elementos que cumplen una condición

$alumnos = [
['nombre' => 'Pedro', 'Nota' => 4],
    ['nombre' => 'Antonio', 'Nota' => 5.5],
    ['nombre' => 'María', 'Nota' => 8],
    ['nombre' => 'Ana', 'Nota' => 10],
    ['nombre' => 'Elena', 'Nota' => 6],
];

$aprobados = array_filter($alumnos, fn($a) => $a['Nota'] >= 5);
print_r($aprobados); // Resultado: solo los alumnos con nota ≥ 5

• array_search: Se encarga de buscar el valor exacto en un array

$frutas = ['manzana', 'pera', 'naranja'];
$clave = array_search('pera', $frutas); // 1
if ($clave !== false) {
    echo "Fruta encontrada"; // Devuelve 1 = True
} else {
    echo "Fruta no encontrada"; // Devuelve false
}

• array_find: Busca el primer elemento que cumpla una condición (callback). Ya vimos el ejemplo arriba 😅

Otras funciones

array_is_list()

Esta función también es nueva (a partir de PHP 8.1) y se encarga de comprobar si el array dado es una lista.

Se considera una lista cuando sus claves están compuestas de números consecutivos empezando por 0.

Por ejemplo:

$array1 = ['a', 'b', 'c'];
$array2 = [0 => 'a', 2 => 'b'];
$array3 = ['nombre' => 'Óscar', 'edad' => 99];
$array4 = ['manzana', 'pera', 'naranja'];

var_dump(array_is_list($array1)); // true
var_dump(array_is_list($array2)); // false
var_dump(array_is_list($array3)); // false
var_dump(array_is_list($array4)); // true

Y aquí los ejemplos oficiales.

¿Cuándo la podemos necesitar?

Cuando necesitemos validar una estructura de datos. Por ejemplo, si queremos convertir un array a JSON, pero solo si es una lista válida (es decir, claves numéricas consecutivas empezando desde 0):

$datos = ['a', 'b', 'c']; // lista válida

if (array_is_list($datos)) {
    echo json_encode($datos); 
    // Resultado: ["a","b","c"]
} else {
    echo "No es una lista!";
}

De esa manera, nos estamos asegurando de que se exporten como array JSON.

Si tuviéramos esto otro:

$datos = [0 => ‘a’, 2 => ‘b’]; // claves no consecutivas

Al no ser las claves consecutivas, no se considera una lista. YPHP lo convierte en objeto JSON en lugar de array.

Otro caso de uso es cuando queremos distinguir entre listas y mapas (array asociativo).

Por ejemplo, si tenemos datos provenientes de diferentes fuentes (API, formularios, etc.), podríamos necesitar aplicar una lógica distinta según el tipo de estructura:

$entrada1 = ['nombre' => 'Óscar', 'edad' => 99]; // array asociativo
$entrada2 = ['Óscar', 99];                      // lista

function procesar($arr)
{
    if (array_is_list($arr)) {
        echo "Es una lista: " . implode(', ', $arr) . "\n";
    } else {
        echo "Es un mapa:\n";
        foreach ($arr as $clave => $valor) {
            echo " - $clave: $valor\n";
        }
    }
}

procesar($entrada1);
procesar($entrada2);

array_column()

Aunque esta función existe desde la versión 5.5 de PHP, es quizás una de las desconocidas y es que, sobre todo cuando empezamos a programar, lo primero es hacer lo típico, consultar qué clave tiene un determinado valor, añadir elementos nuevos a un array, eliminar elementos, ordenador arrays, etc. Sin embargo, la función array_column() es bastante útil porque nos sirve para extraer de forma rápida y sencilla los valores de una columna.

Por ejemplo, siguiendo con los alumnos, podemos hacer:

$alumnos = [
    ['nombre' => 'Pedro', 'Nota' => 4],
    ['nombre' => 'Antonio', 'Nota' => 5.5],
    ['nombre' => 'María', 'Nota' => 8],
    ['nombre' => 'Ana', 'Nota' => 10],
    ['nombre' => 'Elena', 'Nota' => 6],
];

$nombres = array_column($alumnos, 'nombre');
print_r($nombres); // Resultado: ['Pedro', 'Antonio', 'María', 'Ana', 'Elena']

array_key_first()

Esta función, introducida en la versión 7.3 de PHP, nos devuelve la primera clave del array sin necesidad de hacer “malabares”.

$edades = [
    'Ana' => 28,
    'Luis' => 17,
    'María' => 35,
];

$primeraClave = array_key_first($edades); // 'Ana'

Si ya llevas tiempo con PHP seguro que ahora puedes pensar que esta función, bueno, una similar ya existía y hacia exactamente lo mismo y en parte es cierto. La función key(), nos devuelve la clave de un array, sin embargo, mucho cuidado, porque si, en principio nos “sacará” la primera clave del array peeeeeeero, como dice la documentación oficial:

 “La función key() devuelve simplemente la clave del elemento del array que es actualmente apuntado por el puntero interno…”.

Así que no nos asegura que nos devuelva la primera clave, porque todo depende del puntero. Es decir, mientras no hayamos movido el puntero ningún problema.

Por eso, antes los más viejos solíamos hacer lo siguiente:

reset($edades); // Asegura que el puntero esté al inicio
$primeraClave = key($edades); // Devuelve 'Ana'

array_key_last()

También introducida en PHP 7.3, esta función devuelve la última clave del array y, una vez más, sin complicaciones:

$edades = [
    'Ana' => 28,
    'Luis' => 17,
    'María' => 35,
];

$ultimaClave  = array_key_last($edades);  // 'María'

Antes, teníamos que hacer esto:

$claves = array_keys($edades);
$ultimaClave = end($claves);
echo "Última clave del array: $ultimaClave\n"; // Resultado: Última clave del array: María

Y como no, también dependía de la posición del puntero.

Como ves, el manejo de arrays en PHP ha mejorado bastante con las versiones más modernas del lenguaje y funciones como array_find y array_is_list nos ayudan a escribir código más limpio, eficiente y legible.

Una vez más, espero que te haya resultado útil. Un saludo 😉

Sobre el autor

Oscar

See author's posts

Publicaciones relacionadas:

Instalación y uso de phpDocumentor. Traits en PHP Polimorfismo y Override Errores en PHP