Estudio de la sintaxis PHP para tipos de datos arreglo

Lo revisado en la sección anterior

En la sección anterior revisamos las funciones de PHP preg_replace(), preg_match_all(), preg_grep() y preg_quote(), útiles para detectar coincidencias de caracteres. Ahora pasamos a los interesantes datos tipo arreglos.

La canasta de huevos

Para Tatroe y MacIntyre (2020) la metáfora que explica un dato tipo arreglo es una caja de huevos. Allí hay secciones que alojan huevos o cualquier otro elemento que pueda ocupar cada espacio. Así mismo, en sintaxis de programación un arreglo da espacios (de memoria) que pueden ser ocupados por otros datos como "cadenas (líneas de caracteres), números, booleanos (Datos true o false), etc. Además, lo arrays también pueden contener otros arrays".

Ya que un arreglo guarda elementos, estos pueden ser reordenados, borrados, insertados, contabilizados o reemplazados. Cada elemento (por lo tanto, cada espacio ocupado).

Arreglos indexados y arreglos asociativos

Eso se relaciona en cómo son identificados los espacios del arreglo ya ocupados por datos. En un arreglo indexado los espacios se contabilizan con enteros, desde el cero en adelante.

En cambio, un arreglo asociativo contiene datos en paralelo (en forma de columnas), en el cual la primera columna son los nombres únicos de identificador (muy importante porque permite ubicar y acceder al dato) y la otra son los datos en sí.

Atención con las comillas dobles o simples

• Los nombres clave pueden ir entre comillas simples o dobles
• Un nombre clave sin comillas es leído como una constante
• Las claves numéricas (en arreglos indexados) no necesitan indicarse con comillas
• Las claves string pueden ser indicadas con comillas dobles o simples
• Ojo: cada elemento de un arreglo está separado por una coma. Excepto el último elemento del arreglo.
• Ojo: todo arreglo debe finalizar en punto y coma.
• Ojo: No confundir elemento de arreglo indexado con uno asociativo.

En .PHP

<?php 

// CONSTANTE SIN COMILLAS
// Una vez definida, el valor nunca cambia
define('CAJA', 'hay mucho dinero');
    define('CAJA', 'hay un peluche');
    define('CAJA', 'Esta vacio');

echo CAJA . "\n"; 
// hay dinero

?>

En .PHP

<?php 

// Arreglo indexado: con índices
$colores = array('rojo', 'verde', 'azul');
// Invoca con número de índice
echo $colores[1] . "\n";
// "verde"

// - - - - - - - - - - - - -

// Variable con arreglo Asociativo: con identificadores clave
$persona = array(
"nombre" => "dudi",
"edad" => 30,
"ciudad" => "Guayaquil"
);

// Invoca con nombre clave
echo $persona["edad"] . "\n"; 
// "Carlos"

// - - - - - - - - - - - - -

// Arreglo asociativo común
$ciudad = [
'Guayaquil' => 'caliente',
"Quito" => 'frio'
];

// Invoca con nombre clave
echo $ciudad['Guayaquil'] . "\n";
// caliente

// - - - - - - - - - - - - -

// Arreglo asociativo con arreglo de índice anidado
$generosColores = [
'rock' => 'negro',
'salsa' => 'rojo',
'baladas' => ['celeste', 'rosa', 'verde pálido']
];

// Invoca con nombre clave e índice
echo $generosColores['baladas'][1];
// rosa

// CUIDADO ESTO DA ERROR
// echo $ciudad[1];

// Es un arreglo indexado. 
// Se debe indicar el nombre con la clave, no con el número-índice.

?>

Definiendo constantes en arreglos

Al igual que en otros lenguajes de programación, un dato constante es un identificador que ALOJA un valor que no podrá ser alterado una vez definido y a lo largo de su ejecución.

Un identificador constante y su valor es creado mediante la función define(). En el ejemplo de abajo, Ni el nombre-clave (MATERIA) ni su valor ('álgebra') podrán cambiar luego.

En .PHP

<?php 
define('MATERIA', 'algebra');
define('MATERIA', 'no quiero estudiar');

echo MATERIA;
// algebra

Por lo tanto, ya que un identificador de un valor constante es un contenedor, entonces al llamar a ese identificador estamos llamando a su valor .

En .PHP

<?php 

// Se crea constante MATERIA con valor 'algebra'
define('MATERIA', 'algebra');  
echo MATERIA . "\n"; 
// algebra

// - - - - - - - - 

// Pero también podemos asignar (en un arreglo asociativo) la clave 'asignatura'...
// ...para etiquetar al identificador de constante MATERIA
// ...y así obtener el valor de esa constante: algebra
$materias = ['asignatura' => MATERIA];
echo $materias['asignatura'] . "\n";
// algebra

?>

También es posible usar como referencia a un nombre identificador de una constante. Sin embargo, eso debe ir vinculado a un uso necesario a causa de una estructura de datos en tablas, eso para que no sea confuso el uso de la referencia.

Por ejemplo, si tenemos una estructura conceptual de tablas, con estos datos.

En .PHP

Nombre | Técnica | Edad 
Juan   | dibujo  | 40
Luisa  | pintura | 35
Lucy   | dibujo  | 45 

Entonces sería posible necesitar una referencia a uno o más valores constantes, y así aprovechar su reutilización:

En .PHP

<?php 

// Constantes
define('TECNICA_A', 'dibujo');
define('TECNICA_B', 'pintura');

$pintores = [
    'Juan' => [
        'tecnica' => TECNICA_A],

    'Luisa' => [
        'tecnica' => TECNICA_B],

    'Lucy' => [
        'tecnica' => TECNICA_A]
];

// La técnica de Juan es
echo $pintores['Juan']['tecnica'] . "\n";
// dibujo

// La técnica de Luisa es
echo $pintores['Luisa']['tecnica']. "\n";
// pintura

?>

Recordemos entonces que si invocamos a un identificador de constante, entonces estamos invocando a su valor. En el siguiente ejemplo agrupamos un conjunto de nombres bajo una de dos categorías constantes: dibujo o pintura. Usamos la función foreach(){} para recorrer los elementos del arreglo.

En .PHP

<?php 

// Definimos las técnicas artísticas como constantes
define('TECNICA_DIBUJO', 'dibujo');
define('TECNICA_PINTURA', 'pintura');

// Agrupamos pintores por técnica (constante como clave)
$pintores = [
    TECNICA_DIBUJO => ['Juan', 'Lucy', 'Sandra', 'Edu'],
    TECNICA_PINTURA => ['Luisa', 'Jaime']
];

// Accedemos a los pintores de una sola categoría
// mediante la función de recorrido foreach()
foreach ($pintores[TECNICA_DIBUJO] as $nombrecito) {
    echo "$nombrecito usa la técnica del dibujo\n";

/*
    - Juan usa la técnica del dibujo
    - Lucy usa la técnica del dibujo
    - Sandra usa la técnica del dibujo
    - Edu usa la técnica del dibujo
*/
}

?>

En otras palabras, recordemos siempre la diferencia entre el contenedor de valor y la vinculación entre una clave y un valor. No entender esto dará confusiones al momento de reconocer cuál es el valor de una variable.

En .PHP

<?php 

// Un contenedor $materia contiene un valor 'algebra'
$materia = 'algebra';  

// Arreglo
$info = [
    // $materia es 'algebra'
    // Entonces 'algebra' tendrá como valor 'matemáticas'
    $materia => 'matemáticas'  
];

// Variable
echo $materia . "\n";
// algebra

// Identificador del valor algebra que de igual manera es = matemáticas
echo $info[$materia] . "\n"; 
// matemáticas

// Valor algebra = matemáticas
echo $info['algebra']; 
// matemáticas

?>

En otro ejemplo de uso de referencias, podemos notar la diferencia entre asignar un valor a una variable y asignar un nuevo valor a ese valor externo desde un arreglo asociativo.

En .PHP

<?php 

$cajaRoja = 'hay un par de zapatos';  
$cosas = [$cajaRoja => 'también puedo guardar zapatillas'];

echo $cajaRoja . "\n";
// hay un par de zapatos

echo $cosas[$cajaRoja] . "\n"; 
// también puedo guardar zapatillas

echo $cosas['hay un par de zapatos']; 
// también puedo guardar zapatillas

?>

Y el mismo ejemplo con una constante, que al fin y al cabo es similar a una variable. Pero en la constante su valor NUNCA podrá ser alterado una vez que ya ha sido definido (aunque el usuario sí puede darle otro valor, obviamente, pero eso de forma manual y externa al programa), tal cual un usuario-dios que puede cambiar el valor de lo que se supone el lenguaje nunca podrá alterar.

En .PHP

<?php 

// El usuario-dios crea algo que el lenguaje no podrá alterar
define('CAJA_ROJA', 'hay un par de zapatos');

/* 
Este arreglo usa la referencia CAJA_ROJA 
para asignar un valor par, pero SOLO desde el arreglo
*/
$cosas = [CAJA_ROJA => 'también puedo guardar zapatillas'];

echo CAJA_ROJA . "\n"; 
// hay un par de zapatos

echo $cosas[CAJA_ROJA] . "\n"; 
// también puedo guardar zapatillas

echo $cosas['hay un par de zapatos'] . "\n"; 
// también puedo guardar zapatillas

?>

Creando arreglos y llenandolos con elementos-dato

En .PHP

<?php 

// Creando un arreglo vacio
$bandas = array();

// Insertando valores en índices
// Arreglo $bandas
$bandas[0] = "Rockola Bacalao";
$bandas[1] = "Los Pescados";
$bandas[2] = "Vibora Julieta";

print_r($bandas); 
/*
    [0] => Rockola Bacalao
    [1] => Los Pescados
    [2] => Vibora Julieta
*/

// - - - - -

// Insertando valores para valores pares
$camisetas['roja'] = 15.29;
$camisetas['verde'] = 75.25;
$camisetas['azul'] = 50.00;

print_r($camisetas); 
/*
(
    [roja] => 15.29
    [verde] => 75.25
    [azul] => 50
)
*/

// - - - - - - 

// Llenando un arreglo con elementos simples
$vocales = array("a", "b", "c");
print_r($vocales); 

/*
(
    [0] => a
    [1] => b
    [2] => c
)
*/

// - - - - - - 

// Llenando un arreglo con pares de valores
// Usando simbolo  =&#x3E;
$palabras = array( 
    'nice' => 'naiz',
    'house' => 'haus',
    'friends' => 'frends'
);

?>

Otro método abreviado permite asignar un número índice inicial a un conjunto de elementos, y luego la asignación de índices será automática.

En .PHP

<?php 

// Índice inicia desde 5
$days = array(5 => "a", "b", "c");

print_r($days);
/*
(
    [5] => a
    [6] => b
    [7] => c
)
*/

echo $days[5];
// a

?>

Insertando valores posterioresy rangos de valores en arreglos

Una vez creado el arreglo e insertado valores iniciales, es posible agregar nuevos elementos puntuales o en forma de rangos de elementos.

En .PHP

<?php 

$proceres = array("Olmedo", " Letamendi", "Elizalde");

// Agregado
$proceres[] = "Urdaneta";

echo $proceres[0] . "\n";
// Olmedo

echo $proceres[2];
// Elizalde

?>

También es posible agregar rangos a partir de un elemento inicial usando la función range():

En .PHP

<?php 

$edades = range(19,21);
print_r($edades);
/*
(
    [0] => 19
    [1] => 20
    [2] => 21
)
*/

echo $edades[0];
// 19

// - - - - -

$inicialesLetras = range('m','o');
print_r($inicialesLetras);
/*
(
    [0] => m
    [1] => n
    [2] => o
)
*/

echo $inicialesLetras[1];
// n

?>

Tamaño o cantidad de elementos de un arreglo

Las funciones count() y sizeof() indican la cantidad de elementos de un arreglo.

En .PHP

<?php 

$colores = array("rojo", "verde", "azul");
$conteo = count($colores); 
echo "El arreglo contiene " . $conteo . " elementos";
// El arreglo contiene 3 elementos

?>

Automatizando el relleno de elementos en un arreglo

La función array_pad() permite tres argumentos: el primero, el arreglo a rellenar; el segundo, la cantidad de elementos deseados para el relleno, y el tercero es el caracter (número, letra o alfanumérico) que será usado como elemento de relleno para los espacios en el arreglo.

En .PHP

<?php 

// A este arreglo
$arreglo = array(1, 10);

/*
Se lo rellenará hasta con 4 elementos 
y se usará "holi amiwi **" para rellenar 
los casilleros faltantes
*/
$expandir = array_pad($arreglo, 4, "holi amiwi **"); 
print_r($expandir);

/*
(
    [0] => 1
    [1] => 10
    [2] => holi amiwi **
    [3] => holi amiwi **
)
*/

?>

Luego de esta breve introducción a los datos tipo arreglo en PHP, revisaremos los conceptos de arreglo dimensional y alteraciones en la cantidad de elementos del arreglo. Como avance, un arreglo de múltiples dimensiones representa datos relacionados con más de una columna y más de una fila.