duduromeroa.com
duduromeroa.com

Programación web

Datos de arreglos dimensionales, constructores list() y array(). Alteraciones de arreglos con array_slice(), array_chunk(), array_keys(), array_key_exists(), array_splice()


www.duduromeroa.com, animación, lector, gif

Por Eduardo Romero

Guayaquil, Ecuador



ATENCIÓN: Los conceptos a continuación requieren de conocimiento previo en fundamentos de programación. Reseñas de otros lenguajes de programación se hallan en este vínculo.



Lo revisado en la sección anterior

En la sección anterior revisamos la sintaxis para los datos tipo arreglo, útiles para agrupar y enlistar datos recuperables mediante posición de índices numéricos.

Ahora revisaremos al arreglo dimensional. Este no es más que una múltiple lista de datos organizados mediante categorías (columnas de datos) y filas (relaciones de datos).

Pensemos en un arreglo dimensional (es decir, de más de una categoría de datos) como la lista de calificaciones de un aula de clases: en las columnas Nombre, Matemáticas y Ciencias existen datos diferentes. Pero cada fila será representada con un código irrepetible, aunque los datos pueden ser similares en cada fila.

En .PHP

Cod. -- Nombre -- Aula -- Matemáticas -- Ciencias
01 ---- Edu       A2      9              8   
02 ---- Adrian    A2      9              8.8

Sin embargo, hay que tener bien claro lo siguiente: los arreglos multidimensión NO deberían contener datos sin relaciones lógicas claras. Cuidar eso ayuda a que la recuperación de datos sea lógica y en relación a los datos de cada columna. En el ejemplo de abajo, la categoría de temperatura de color no pemitiría, por ejemplo, crear un bucle de asignación de elementos en variables por separado mediante el constructor list(). La mejor práctica sería alojar esa última categoría en un arreglo aparte.

En .PHP

<?php 
$ colores = [
    ["azul", "violeta", "gris"],  // colores
    ["naranja", "verde", "amarillo"],  // colores
    ["cálido", "frío"]  // temperatura de color (otro concepto)
]
?>

Los arreglos multidimensionales aplicados en lenguajes de programación están basados en las matrices algebráicas, en la que un literal (la letra R o cualquier otra) aloja un conjunto de subliterales que representan valores y posiciones. \[ R = \left( \begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{matrix} \right) \]

En lenguajes de programación como en PHP podemos armar matrices (también llamados arreglos multidimensión) primero creando los arreglos iniciales a partir del Función especial cuyo argumento crea una estructura de datos con propiedades predefinidas, como un arreglo. constructor array() y luego combinarlos para formar un solo conjunto accesible de datos. OJO: Recordemos que cada elemento de un arreglo tiene un índice de posicionamiento que inicia desde el cero en adelante.

ATENCIÓN CON EL CIERRE DE UN ARREGLO
En PHP cada arreglo finaliza o cierra con un punto y coma.

Lo siguiente dará error, aunque sea un solo arreglo:
$arreglo = ["a", "b", "c"]


Sin el cierre de ; el arreglo se mostrará incompleto y dará error de sintaxis.


En .PHP

<?php 

// Fila índice cero
$numA = array(1, 2, 3);
// Fila índice uno
$numB = array(4, 5, 6);
// Fila índice dos
$numC = array(7, 8, 9);

// Unirlos en nuevo arreglo
$combinadoABC = array($numA, $numB, $numC);

// Apunta a la fila [cero], índice [uno]
$r = $combinadoABC[0][1];
echo "$r\n";
// 2

// Apunta a la fila [dos], índice [dos]
$r = $combinadoABC[2][2];
echo "$r\n";
// 9

?>

Existen dos sintaxis válidas para crear arreglos. La primera es extensa mediante subarreglos creados con el constructor array() y alojando cada arreglo en una variable por separado. Esto permite crear (de forma asíncrona o luego de cumplida una condición), alterar o verificar cada subarreglo y luego unirlo en uno solo; sin embargo crea código más largo. La otra forma es breve y directa, donde los elementos se agrupan en una sola variable, pero no permite controlar cada conjunto de arreglos por separado.

En .PHP

<?php 

// 1) FORMA DIRECTA Y BREVE
// Útil con datos ya definidos
$usuarios = [
    ["Ana", "Gómez", 25],
    ["Luis", "Martínez", 30]
];

echo $usuarios[0][1] . "\n";
// Gómez

// 2) FORMA EXTENSA PERO MÁS CÓDIGO
// Útil cuando los datos se generan a mediano plazo
$usuariosA = array("Ana", "Gómez", 25);
$usuariosB = array("Luis", "Martínez", 30);
$todos = array($usuariosA, $usuariosB);

echo $todos[0][1];
// Gómez

?>

Igual para crear un arreglo multidimensión con caracteres o palabras. Ojo con el uso del constructor array() en cada generación de un subarreglo y para crear el arreglo multidimensional combinado.

En .PHP

<?php 

// índice cero
$frasesA = array("hola buen", "Guayaquil", "Quito");

// índice uno
$frasesB = array("dia", "noche");

// El arreglo multidimensional completo
$frasesAB = array($frasesA, $frasesB);

// Ojo con apuntar al elemento y al índice correcto
$r = $frasesAB[0][0] . " " . $frasesAB[1][0] . " " . $frasesAB[0][1];
echo "$r\n";
// hola buen dia Guayaquil

?>

Constructor list()

Toma los valores de un arreglo indexado y los asigna, uno por uno, a variables individuales. En otras palabras, si un arreglo es una cajonera de valores, entonces list() extrae cada elemento de esa cajonera (respetando su ubicación, en orden) y los guarda en una nueva caja externa e independiente con su respectivo índice de ubicación: un elemento y un índice por caja.

Cuidado. Podemos confundir que la función list() es una "lista" de elementos (o peor, que es un arreglo nuevo). Pero no lo es. En realidad el contenido de list() es uno o más variables que (luego) alojarán elementos extraídos de un arreglo anterior.

En .PHP

<?php 

// arreglo con elementos
$ciudades = ["Ecuador", "Guayaquil", "Cuenca"];

// Extraer desde $ciudades cada elemento y 
// alojarlo (en orden) según estas nuevas variables creadas
list($pais, $costa, $sierra) = $ciudades;

echo "Las ciudades de $costa ". "y ". "$sierra son de $pais.\n";
// Las ciudades de Guayaquil y Cuenca son de Ecuador.

?>

Igualmente, para arreglos multidimensionales el constructor list() extrae cada elemento y lo aloja (en orden) en cada variable; pero también la función foreach() recorrerá cada elemento y lo asignará a un nuevo arreglo.

En .PHP

<?php 

// Categoria A
$colores = [
    ["azul", "violeta", "gris"],
    ["naranja", "verde", "amarillo"]
];

// Categoria B
$categorias = ["fríos", "cálidos"];

// Recorrido
// Para cada elemento de $colores
// recorre cada índice 
// y aloja en $paraCadaGrupo
foreach ($colores as $ApuntaEnCadaIndice => $paraCadaGrupo) {
    // Crea variables de alojamiento
    // Extrae cada color de $paraCadaGrupo
    list($colorA, $colorB, $colorC) = $paraCadaGrupo;

    // Nueva variable aloja $categorias 
    // apuntando a cada indice
    $tipo = $categorias[$ApuntaEnCadaIndice];

    // Muestra los colores de $paraCadaGrupo 
    // y recorre $tipo, que es quien aloja las categorias
    echo "Los colores $colorA, $colorB y $colorC son $tipo.\n";
}

/*
Los colores azul, violeta y gris son fríos.
Los colores naranja, verde y amarillo son cálidos.
*/
?>

Cortando arreglos con array_slice()

Extrae un nuevo arreglo (es decir, vuelve a contar los elementos extraídos desde el índice cero) a partir del arreglo alterado.

En .PHP

<?php 

// Indices ---------0 ---- 1 ---- 2 ---- 3 ---- 4
$arreglo = array("aaa", "bbb", "ccc", "ddd", "eee"); 

// parámetros (ElArreglo, desdeEsteIndice, cuántosElementosHaciaAdelante) 
// El tercer argumento representa número de elementos a tomar
$cortado = array_slice($arreglo, 2, 2); 

// Recordar esta función para mostrar el contenido del areglo
// Mostrar un nuevo arreglo
print_r($cortado);

// Corta desde el tercer elemento "ccc"
// Extae dos elementos hacia adelante: 
// toma "ccc" (primero) y "ddd" (segundo)

/*
(
[0] => ccc
[1] => ddd
)
*/

?>

Combinando con la función list() podemos extraer por separado cada elemento mediante asignación en variables:

En .PHP

<?php 
// Arreglo
// Indices -------0------1-------2------3
$nombres = array("Gye", "Uio", "Cue", "Man"); 

// Ojo, parámetros de list() son nombres de Variables, NO arreglos
// En variable $segundo va el elemento 1
// En variable $tercero va el elemento 2
// En list(); el nombre de cada variable es arbitrario
list($segundo, $tercero) = array_slice($nombres, 1, 2);

// En var $segundo se aloja el elemento 01
echo $segundo."\n";
// En var $tercero se aloja el elemento 02
echo $tercero."\n";

// Uio
// Cue
?>

Extrayendo agrupaciones (porciones) de elementos en nuevos arreglos con array_chunk()

Definamos qué es una porción. En el contexto de arreglos una porción es un nuevo arreglo cuyos elementos están identificados con su propio índice.

Con array_chunk() indicamos cuántos elementos deseamos por subarreglos. ¿Entonces, también indicamos la cantidad de subarreglos? NO. El sistema automatiza eso (cada nuevo arreglo será indexado desde 0). A array_chunk() solo le damos la cantidad de elementos por grupo.

En el ejemplo gráfico de abajo (código azul) se indica que hayan dos elementos por subarreglo a partir de un arreglo padre. (Recordemos que la cantidad de elementos se dará en automático). Pero en el código morado habrán igual cantidad de elementos por arreglo, pero los índices de cada nueva porción de arreglo se presevarán gracias al operador true.

Explicación visual de la función array_chunk() en PHP. duduromeroa.com

Concepto visual. Mediante array_chunk() indicamos que, a partir de un arreglo padre, se extraigan nuevos subarreglos con solo dos elementos cada subarreglo. Imagen: www.duduromeroa.com

En el código de ejemplo de abajo, se indica que a partir de un rango numérico (arreglo), agrupar 4 elementos por subarreglo. Cada subarreglo tendrá sus elementos agrupados desde el índice cero.

En .PHP

<?php 

// Arreglo con RANGO de 1 al 7
$rango = range(1, 7);

// Extraer 4 elementos por subarreglo
$porciones = array_chunk($rango, 4);

// Mostar estructura
print_r($porciones);

/*
    [0] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
            [3] => 4
        )

    [1] => Array
        (
            [0] => 5
            [1] => 6
            [2] => 7
        )
)
*/
?>

Por otro lado, indicamos ahora que los índices no se reordenen en las nuevas agrupaciones (nuevos arreglos); sino que se mantengan fieles al arreglo original:

En .PHP

<?php 

// Arreglo con RANGO de 1 al 7
$rangoNuevo = range(1, 7);

// Mantener fieles los índices del arreglo original
$porcionesNuevo = array_chunk($rangoNuevo, 4, true);

// Mostar estructura
print_r($porcionesNuevo);

/*(
    [0] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
            [3] => 4
        )

    [1] => Array
        (
            [4] => 5
            [5] => 6
            [6] => 7
        )
)*/

// Índices se mantienen fieles
//  0   1   2   3   4   5   6 --> Indices
// [1] [2] [3] [4] [5] [6] [7] --> Elementos

?>

Hasta ahora, apenas hemos creado nuevas agrupaciones (de arreglos) a partir de los elementos de un arreglo padre. Lo siguiente es obtener todos o algunos de esos elementos mediante un recorrido de esos elementos.

En .PHP

<?php 

// Arreglo padre
$frutas = ["Manzana", "Aguacate", "Uva", "Banano", "Papaya"];

// Agrupar en dos elementos
$grupos = array_chunk($frutas, 2);

// Recorre los chunks
foreach ($grupos as $punterito_Recorredor => $arregloTemporal) {
    echo "Grupo $punterito_Recorredor:\n";

// recorre los elementos dentro de cada chunk.
    foreach ($arregloTemporal as $fruta) {
        echo "- $fruta\n";
    }
    echo "\n";
}

/*
Grupo 0:
- Manzana
- Aguacate

Grupo 1:
- Uva
- Banano

Grupo 2:
- Papaya
*/

?>

Devolver las claves de un arreglo mediante array_keys()

Definamos el término 'clave'. En el contexto de los datos tipo arreglos, una clave es el único identificador asociado a un valor.

CONCEPTO

Clave | Valor
País    Ecuador
---     ---    
001     Eduardo
---     --- 
color   Rojo    
---     ---

Los arreglos que contienen claves son los arreglos asociativos, en donde una clave se asocia a un valor.

En .PHP

<?php 

    $numeros = [
    10 => "diez", 
    20 => "veinte", 
    30 => "treinta"
    ];

     echo $numeros[10]; 
    // diez

?>

Si únicamente deseamos las claves (junto con el índice de cada clave). En el ejemplo de abajo, las claves corresponden a la categoría de tonos (cálido, frio, neutro):

En .PHP

<?php 

$tonos = [
"color_calido"  => "sepia", 
"color_frio"    => "violeta", 
"color_neutro"  => "gris"
];

$soloClaves = array_keys($tonos);
print_r($soloClaves);

/*
Array
(
    [0] => color_calido
    [1] => color_frio
    [2] => color_neutro
)
*/

?>

En otro ejemplo, indicamos desde el segundo parámetro array_keys() que deseamos las claves cuyos valores serán dados por nosotros. Sin embargo, las indicaciones del segundo parámetro deben ser exactas (como en "Julio Jaramillo"). De haber indicado otro contenido (como por ejemplo, "Jaramillo") la función buscará exactamente esa palabra. Y de no hallarla, retornará un arreglo vacio.

En .PHP

<?php 

$tonos = [
"boleros" 	=> "Julio Jaramillo", 
"rock_clasico" 	=> "Led Zeppelin", 
"pasillos" 	=> "Julio Jaramillo"
];

$soloClaves = array_keys($tonos, "Julio Jaramillo");
print_r($soloClaves);

/*
Array
(
    [0] => boleros
    [1] => pasillos
)
*/

?>

O, alojando el valor en una variable para luego usar esa variable como segundo argumento:

En .PHP

<?php 

$tonos = [
"encebollado" => "plato 1", 
"bolon" 	=> "plato 2"
];

$buscarDesdeValor =  "plato 1";
$soloClaves = array_keys($tonos, $buscarDesdeValor);
print_r($soloClaves);

/*
Array([0] => encebollado)
*/

?>

Indicar existencia de clave con array_key_exists()

Solo indica (mediante un booleano explícito –no un número–) la existencia o no de claves. Pero NO busca sus valores. Recordar: la función var_dump() describe el tipo de dato. Nota: ver más abajo la aplicación de la función var_dump(), que da el tipo explícito de su parámetro.

En .PHP

<?php 

$datos = [
    "nombre" => "Luis",
    "edad" => 30
];

// Solo indica presencia o no mediante booleano
var_dump(array_key_exists("nombre", $datos)); // true  
var_dump(array_key_exists("ciudad", $datos)); // true  

// Con una condicional
if (array_key_exists("nombre", $datos)){
	echo "Aquello existe!";
} else {
	echo "Esa cosa no existe.\n";
}

/*
bool(true)
bool(false)
Aquello existe!
*/


// *** APLICACIÓN DE LA FUNCIÓN ***
var_dump(true);
var_dump(123);
var_dump("hola");
var_dump(null);

/*
int(123)
string(4) "hola"
NULL
*/

?>

Insertar o eliminar elementos en un arreglo con array_splice()

Para Tatroe y MacIntyre (2020, p. 236) esta función "remueve o inserta elementos en un arreglo y opcionalmente crea otro arreglo a partir de esos elementos".

En su uso se debe tener en cuenta lo siguiente:

  • array_splice() altera el arreglo original
  • Reindexa los elementos (del arreglo original) alterado
  • Un arreglo asociativo lo convierte a numérico
  • Finalmente:array_splice() SOLO DEVUELVE los elementos borrados. Si se desea mostrar el arreglo alterado, es ése el que debe ser mostrado.

En .PHP

<?php 

// QUITANDO ELEMENTOS
// -----------0--------1--------2------3 Indices
$colorA = ["rojo", "verde", "azul", "amarillo"];

// En arreglo, desde el índice 1, eliminar 2 elementos
array_splice($colorA, 1, 2); 

// El arreglo quedó así
print_r($colorA);
/* ([0] => rojo [1] => amarillo) */

// + + + + + 

// REEMPLAZANDO ELEMENTOS
// -----------0--------1--------2------3 
$colorA = ["rojo", "verde", "azul"];

// Desde el índice 2, eliminar 1 elementos
// y desde allí en adelante insertar ["Guayaquil", "Quito"]
// "Comienza desde el índice que indico, elimina lo que indico, y mete lo que indico."
array_splice($colorA, 2, 1, ["Guayaquil", "Quito"]); 

// El arreglo quedó así
print_r($colorA);
/* (
    [0] => rojo
    [1] => verde
    [2] => Guayaquil
    [3] => Quito
)
*/
?>

NOTA: En lo que respecta a arreglos asociativos, las funciones como unset() –para eliminar–, array_merge() –para combinar– y array_slice() (no modifica el original) no alteran las claves de los elementos del arreglo.

Finalmente, la función array_splice aplica también para arreglos asociativos (clave --> "valor"). Pero ojo: solo preservará las claves asociativas si el arreglo tiene solo claves tipo string. Es decir, si el arreglo fuera mixto o numérico, las claves se reindexan (reinician desde cero) automáticamente después del array_splice.

En .PHP

<?php 

$actores = array(
'Actor 1' => "Pedro",	// 0
'Actor 2' => "Roberta", // 1	
'Actor 3' => "Angela", 	// 2 Desde aqui: Borrar (elem 1) 
'Actor 4' => "Sara" 	// 3 Borrar este (elem 2)
);

// Quitar Angela y Sara
$actualizarLista = array_splice($actores, 2, 2); 

// Mostrar lo borrado
print_r($actualizarLista);

/*
Array
(
    [Actor 3] => Angela
    [Actor 4] => Sara
)
*/

// Mostrar el arreglo alterado
print_r($actores);

/*
Array
(
    [Actor 1] => Pedro
    [Actor 2] => Roberta
)
*/

?>

Luego de revisar ámbitos como los arreglos multi dimensionales y a las alteraciones de la cantidad de elementos de un arreglo, pasaremos a la conversión de los arreglos en tipos de datos mediante otras funciones como extract(), foreach() entre otros.