Comprende los arreglos en PHP

Spanish (Español) translation by Ana Paulina Figueroa (you can also view the original English article)

En esta publicación aprenderás los fundamentos de los arreglos en PHP. Aprenderás cómo crear un arreglo y cómo usar arreglos asociativos y multidimensionales, además de ver muchos ejemplos de arreglos en acción.

¿Qué es un arreglo?

En PHP, un arreglo es una estructura de datos que te permite almacenar múltiples elementos en una sola variable. Estos elementos se almacenan como pares clave-valor. De hecho, puedes usar un arreglo cada vez que haya la necesidad de almacenar una lista de elementos. La mayoría de las veces, todos los elementos de un arreglo tienen tipos de datos similares.

Por ejemplo, digamos que queires almacenar nombres de frutas. Sin un arreglo, terminarías creando múltiples variables para almacenar los nombres de las diferentes frutas. Por otro lado, si usas un arreglo para almacenar dichos nombres, éste se vería así:

1	<?php
2	$array_fruits = array('Apple', 'Orange', 'Watermelon', 'Mango');
3	?>

Como puedes ver, hemos usado la variable $array_fruits para almacenar los diferentes nombres de las frutas. Algo genial de este enfoque es que puedes añadir más elementos a la variable de tipo arreglo $array_fruits más adelante.

Existen muchas formas de manipular los valores en la variable de tipo arreglo, y vamos a explorarlas en la parte final de este artículo.

Cómo inicializar un arreglo

En esta sección exploraremos cómo inicializar una variable de tipo arreglo y cómo añadir valores a dicha variable.

Cuando se trata de inicializar arreglos, existen algunas maneras diferentes. En la mayoría de los casos es la construcción array() del lenguaje la que se usa para inicializar un arreglo.

1	<?php
2	$array = array();
3	?>

En el fragmento anterior, la variable $array se inicializa con un arreglo vacío.

A partir de PHP 5.4 también puedes usar la siguiente sintaxis para inicializar un arreglo:

1	<?php
2	$array = [];
3	?>

Ahora veamos cómo añadir elementos a un arreglo.

<?php
$array = [];
$array[] = 'One';
$array[] = 'Two';
$array[] = 'Three';
echo '<pre>';
print_r($array);
?>

El fragmento anterior debe generar la siguiente salida:

1	Array
2	(
3	[0] => One
4	[1] => Two
5	[2] => Three
6	)

El aspecto importante a destacar aquí es que el índice de un arreglo comienza en 0. Cada vez que agregues un nuevo elemento a un arreglo sin especificar un índice, el arreglo asigna un índice automáticamente.

Desde luego, también puedes crear un arreglo que ya esté inicializado con valor. Esta es la manera más concisa de declarar un arreglo si ya sabes qué valores tendrá.

1	<?php
2	$array = ['One', 'Two', 'Three'];
3	?>

Cómo acceder a los elementos de un arreglo

En la sección anterior discutimos cómo inicializar una variable de tipo arreglo. En esta sección vamos a explorar algunas maneras diferentes de acceder a los elementos del arreglo.

La primera manera obvia de acceder a los elementos del arreglo es obtenerlos a través de la clave o índice del arreglo.

<?php
$array = ['One', 'Two', 'Three'];

// get the first element of the $array array
echo $array[0];
echo "<br>";

// get the second element of the $array array
echo $array[1];
echo "<br>";

// get the third element of the $array array
echo $array[2];
echo "<br>";
?>

El fragmento anterior debe generar la siguiente salida:

1	One
2	Two
3	Three

Una manera más limpia de escribir el código anterior es a través del uso de un bucle foreach para recorrer los elementos del arreglo.

<?php
$array = ['One', 'Two', 'Three'];

foreach ($array as $element) {
  echo $element;
  echo '<br>';
}
?>

El fragmento anterior debe producir la misma salida, y requiere mucho menos código.

De manera similar, también puedes usar el bucle for para recorrer los elementos del arreglo.

<?php
$array = ['One', 'Two', 'Three'];
$array_length = count($array);

for ($i = 0; $i < $array_length; ++$i) {
  echo $array[$i];
  echo '<br>';
}
?>

Aquí estamos usando el bucle for para pasar a través de cada índice del arreglo y luego usando la instrucción echo con el valor almacenado en ese índice. En este fragmento hemos introducido una de las funciones más importantes que vas a usar al trabajar con arreglos: count. Se usa para contar cúantos elementos hay en un arreglo.

Tipos de arreglos en PHP

En esta sección discutiremos los diferentes tipos de arreglos que puedes usar en PHP.

Arreglos indexados numéricamente

Un arreglo con el índice numérico se encuentra bajo la categoría de un arreglo indexado. De hecho, los ejemplos que hemos discutido hasta ahora en este artículo son de arreglos indexados.

El índice numérico se asigna automáticamente cuando no lo especificas de forma explícita.

1	<?php
2	$array = ['One', 'Two', 'Three'];
3	?>

En el ejemplo anterior no especificamos un índice para cada elemento explícitamente, por lo que será inicializado con el índice numérico automáticamente.

Desde luego, también puedes crear un arreglo indexado usando el índice numérico, como se muestra en el fragmento siguiente,

<?php
$array = [];
$array[0] = 'One';
$array[1] = 'Two';
$array[2] = 'Three';
?>

Arreglos asociativos

Un arreglo asociativo es similar a un arreglo indexado, pero puedes usar valores de tipo cadena para las claves del arreglo.

Veamos cómo definir un arreglo asociativo.

<?php
$employee = [
  'name' => 'John',
  'email' => 'john@example.com',
  'phone' => '1234567890',
];

De forma alternativa, puedes usar la siguiente sintaxis también.

<?php
$employee = [];
$employee['name'] = 'John';
$employee['email'] = 'john@example.com';
$employee['phone'] = '1234567890';
?>

Para acceder a los valores de un arreglo asociativo, puedes usar ya sea el índice o el bucle foreach.

<?php
$employee = [
  'name' => 'John',
  'email' => 'john@example.com',
  'phone' => '1234567890',
];

// get the value of employee name
echo $employee['name'];

// get all values
foreach ($employee as $key => $value) {
  echo $key . ':' . $value;
  echo '<br>';
}
?>

Como puedes ver, aquí obtuvimos el nombre consultándolo directamente, y luego usamos el bucle foreach para obtener todos los pares clave-valor del arreglo.

Arreglos multidimensionales

En los ejemplos que hemos discutido hasta ahora, hemos usado valores escalares como elementos del arreglo. De hecho, incluso puedes almacenar arreglos como elementos dentro de otros arreglos. Esto se conoce como arreglo multidimensional.

Veamos un ejemplo

<?php
$employee = [
  'name' => 'John',
  'email' => 'john@example.com',
  'phone' => '1234567890',
  'hobbies' => ['Football', 'Tennis'],
  'profiles' => ['facebook' => 'johnfb', 'twitter' => 'johntw']
];
?>

Como puedes ver, la clave hobbies en el arreglo $employee almacena un arreglo de pasatiempos (o hobbies). De la misma manera, la clave profiles almacena un arreglo asociativo de los diferentes perfiles.

Veamos cómo acceder a los valores de un arreglo multidimensional.

<?php
$employee = [
  'name' => 'John',
  'email' => 'john@example.com',
  'phone' => '1234567890',
  'hobbies' => ['Football', 'Tennis'],
  'profiles' => ['facebook' => 'johnfb', 'twitter' => 'johntw']
];

// access hobbies
echo $employee['hobbies'][0];
// Football

echo $employee['hobbies'][1];
// Tennis

// access profiles
echo $employee['profiles']['facebook'];
// johnfb

echo $employee['profiles']['twitter'];
// johntw
?>

Como puedes observar, es posible acceder a los elementos de un arreglo multidimensional con el índice o la clave de ese elemento en cada parte del arreglo.

Algunas funciones útiles para los arreglos

En esta sección revisaremos un puñado de útiles funciones para los arreglos que se usan frecuentemente para operaciones con los mimsos.

La función `count`

La función count se usa para contar el número de elementos de un arreglo. Esto es útil a menudo si quieres recorrer un arreglo con un bucle for.

<?php
$array = ['One', 'Two', 'Three'];

// print the number of elements in the array
echo count($array);

// the above code should output
3
?>

La función `is_array`

Esta es una de las funciones más útiles para trabajar con arreglos. Se usa para verificar si una variable es un arreglo o si es de algún otro tipo de dato.

<?php
$array = ['One', 'Two', 'Three'];

// check if the variable is an array
if (is_array($array))
{
  // perform some array operation
}
?>

Siempre deberías usar esta función antes de llevar a cabo cualquier operación de arreglo si no estás seguro del tipo de dato.

La función `in_array`

Si quieres verificar si un elemento existe en el arreglo, la función in_array es la que viene al rescate.

<?php
$array = ['One', 'Two', 'Three'];

// check if a variable is an array
if (in_array('One', $array))
{
  echo 'Yes';
}
else
{
  echo 'No';
}
?>

El primer argumento de la función in_array es un elemento que quieras verificar, y el segundo argumento es el arreglo en sí.

La función `explode`

La función explore divide una cadena en múltiples partes y la devuelve como un arreglo. Por ejemplo, digamos que tienes una cadena separada por comas y que quieres dividirla por las comas.

<?php
$string = "One,Two,Three";

// explode a string by comma
$array = explode(",", $string);

// output should be an array
echo '<pre>';
print_r($array);

// output
/*Array
(
    [0] => One
    [1] => Two
    [2] => Three
)*/
?>

El primer argumento de la función explode es una cadena delimitante (la cadena por la que estés dividiendo), y el segundo argumento es la cadena en sí.

La función `implode`

Esta hace lo opuesto a la función explode. Dado un arreglo y una cadena de unión, la función implode puede generar una cadena uniendo todos los elementos de un arreglo con una cadena de unión entre ellos.

<?php
$array = ['One', 'Two', 'Three'];

$string = implode(",", $array);

// output should be a string
echo $string;

// output: One,Two,Three
?>

El primer argumento de la función implode es una cadena de unión, y el segundo argumento es el arreglo a colapsar.

La función `array_push`

La función array_push se usa para añadir nuevos elementos al final de un arreglo.

<?php
$array = ['One', 'Two', 'Three'];
array_push($array, 'Four');

echo '<pre>';
print_r($array);

// output
/*Array
(
    [0] => One
    [1] => Two
    [2] => Three
    [3] => Four
)*/
?>

El primer argumento es un arreglo, y los argumentos subsecuentes son elementos que serán añadidos al final de un arreglo.

La función `array_pop`

La función array_pop quita un elemento del final de un arreglo.

<?php
$array = ['One', 'Two', 'Three'];
$element = array_pop($array);

echo '<pre>';
print_r($array);

// output
/*Array
(
    [0] => One
    [1] => Two
)*/
?>

La función array_pop devuelve el elemento que se quita de un arreglo, de manera que puedas colocarlo en la variable. Junto con array_push, esta función es útil para implementar estructuras de datos como pilas.

Conclusión

Eso es todo lo que necesitas para comenzar a codificar con arreglos en PHP. Viste cómo crear arreglos y cómo recuperar elementos de los mismos. Aprendiste sobre los diferentes tipos de arreglos en PHP, y pudiste ver algunas de las funciones más útiles integradas en PHP para trabajar con arreglos.