array_combine, array_fill, range y array_count_values en PHP

PHP tiene un conjunto de funciones para construir arrays a partir de cero o de otros arrays que resulta muy cómodo una vez que las conoces. Generadores de secuencias, rellenos rápidos, combinaciones de claves y valores, contadores automáticos... Aquí están las más utilizadas con ejemplos reales y los errores que se cometen al empezar.

range(): secuencias de números y letras

Genera un array con todos los valores entre el inicio y el fin, con paso opcional:

<?php
// Números
print_r(range(1, 5));         // [1, 2, 3, 4, 5]
print_r(range(0, 1, 0.25));   // [0, 0.25, 0.5, 0.75, 1.0]
print_r(range(10, 1, -2));    // [10, 8, 6, 4, 2]

// Letras
print_r(range('a', 'e'));     // ['a', 'b', 'c', 'd', 'e']
print_r(range('A', 'F'));     // ['A', 'B', 'C', 'D', 'E', 'F']

// Uso real: opciones de un select de horas
$horas = array_map(fn($h) => str_pad($h, 2, '0', STR_PAD_LEFT), range(0, 23));
// ['00', '01', ..., '23']

array_fill(): rellenar con un valor

Crea un array de n elementos, todos con el mismo valor:

<?php
$ceros = array_fill(0, 5, 0);
// [0, 0, 0, 0, 0]

// Índice inicial distinto de 0
$desde5 = array_fill(5, 3, 'x');
// [5 => 'x', 6 => 'x', 7 => 'x']

// Inicializar contadores por categoría
$categorias = ['php', 'js', 'python'];
$contadores = array_fill(0, count($categorias), 0);
// [0, 0, 0]

// Objeto como valor — ojo: todas las posiciones apuntan al mismo objeto
$obj = new stdClass();
$arr = array_fill(0, 3, $obj);  // las 3 son la misma instancia

array_fill_keys(): rellenar con un valor usando claves personalizadas

<?php
$idiomas = ['es', 'en', 'fr', 'de'];
$traducciones = array_fill_keys($idiomas, '');
// ['es' => '', 'en' => '', 'fr' => '', 'de' => '']

// Inicializar estadísticas por producto
$ids = [101, 102, 103];
$stats = array_fill_keys($ids, ['visitas' => 0, 'ventas' => 0]);

// Convertir lista de permisos en mapa de acceso rápido
$permisos = ['leer', 'escribir', 'borrar'];
$mapa = array_fill_keys($permisos, true);
// ['leer' => true, 'escribir' => true, 'borrar' => true]
isset($mapa['leer']) // true — O(1)

array_combine(): juntar claves y valores de dos arrays

Toma un array de claves y otro de valores y los combina en un array asociativo:

<?php
$campos = ['nombre', 'email', 'edad'];
$valores = ['Ana', '[email protected]', 28];
$persona = array_combine($campos, $valores);
// ['nombre' => 'Ana', 'email' => '[email protected]', 'edad' => 28]

// Caso real: procesar filas de un CSV con cabecera
$lineas = file('clientes.csv', FILE_IGNORE_NEW_LINES);
$cabecera = str_getcsv(array_shift($lineas));
$clientes = array_map(
    fn($linea) => array_combine($cabecera, str_getcsv($linea)),
    $lineas
);
// Cada elemento: ['nombre' => ..., 'email' => ..., 'ciudad' => ...]

// Error frecuente: arrays de distinto tamaño ? ValueError en PHP 8
try {
    $mal = array_combine(['a', 'b'], [1, 2, 3]);
} catch (ValueError $e) {
    echo $e->getMessage();
    // Both arguments must have the same number of elements
}

array_count_values(): contar repeticiones

Devuelve un array asociativo con cada valor único como clave y el número de veces que aparece como valor:

<?php
$votos = ['php', 'js', 'php', 'python', 'php', 'js'];
$resultado = array_count_values($votos);
// ['php' => 3, 'js' => 2, 'python' => 1]

// Ordenar de mayor a menor
arsort($resultado);
print_r($resultado);  // php(3), js(2), python(1)

// Contar etiquetas de artículos
$etiquetas = array_merge(...array_column($articulos, 'tags'));
$top = array_slice(
    array_count_values($etiquetas),
    0, 10,
    true
);

array_flip(): intercambiar claves y valores

<?php
$paises = ['ES' => 'España', 'FR' => 'Francia', 'DE' => 'Alemania'];
$invertido = array_flip($paises);
// ['España' => 'ES', 'Francia' => 'FR', 'Alemania' => 'DE']

// Búsqueda O(1) en lugar de in_array O(n)
$permitidos = array_flip(['php', 'python', 'javascript']);
$lenguaje = 'php';
if (isset($permitidos[$lenguaje])) {  // más rápido que in_array
    echo "Permitido";
}

// Cuidado: si hay valores duplicados, se queda con el último
$arr = ['a' => 1, 'b' => 2, 'c' => 1];
print_r(array_flip($arr));
// [1 => 'c', 2 => 'b']  — la clave 'a' se pierde

array_pad(): añadir elementos hasta alcanzar un tamaño

<?php
$arr = [1, 2, 3];
print_r(array_pad($arr, 5, 0));   // [1, 2, 3, 0, 0]  — rellena a la derecha
print_r(array_pad($arr, -5, 0));  // [0, 0, 1, 2, 3]  — rellena a la izquierda

// Si el tamaño ya es mayor o igual, no hace nada
print_r(array_pad($arr, 2, 0));   // [1, 2, 3]

// Alinear filas de una tabla para impresión
$columnas = 6;
$filas = [[1, 2, 3], [4, 5], [6, 7, 8, 9]];
$filas = array_map(fn($f) => array_pad($f, $columnas, ''), $filas);

array_repeat() — novedad de PHP 8.4

PHP 8.4 añade esta función que repite un array completo un número de veces (distinto a array_fill, que repite un valor escalar):

<?php
// PHP 8.4+
$semana = ['L', 'M', 'X', 'J', 'V'];
$cuatroSemanas = array_repeat($semana, 4);
// ['L', 'M', 'X', 'J', 'V', 'L', 'M', 'X', 'J', 'V', ...]
// 20 elementos

// Antes de PHP 8.4:
$cuatroSemanas = array_merge(...array_fill(0, 4, $semana));

Combinación práctica: tabla de frecuencias

<?php
function tablaFrecuencias(array $datos): array {
    $total = count($datos);
    $conteo = array_count_values($datos);
    arsort($conteo);

    return array_map(
        fn($n) => [
            'n'          => $n,
            'porcentaje' => round($n / $total * 100, 1),
        ],
        $conteo
    );
}

$lenguajes = ['php', 'js', 'php', 'python', 'php', 'js', 'rust'];
print_r(tablaFrecuencias($lenguajes));
// php => ['n' => 3, 'porcentaje' => 42.9]
// js  => ['n' => 2, 'porcentaje' => 28.6]
// ...

Errores más comunes

  • array_combine con arrays de distinto tamaño: lanza ValueError en PHP 8. Comprueba con count() antes de llamarla.
  • array_fill con objeto como valor: todas las posiciones referencian el mismo objeto. Si necesitas instancias independientes, usa array_map(fn($_) => clone $obj, range(0, $n-1)).
  • array_flip con valores duplicados: se pierden claves. Solo úsalo cuando los valores sean únicos.
  • range con paso que no divide exactamente: puede generar más o menos elementos de los esperados por aritmética en punto flotante.

COMPARTE ESTE ARTÍCULO

COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN LINKEDIN
COMPARTIR EN WHATSAPP