Arrays, mapas ordenados de datos

Cuando hablamos de arrays en programación, nos referimos a una variable donde almacenar múltiples valores de una misma clase, o un tipo de dato estructurado que permite almacenar un conjunto de datos homogéneo, es decir; todos del mismo tipo y relacionados. Dicho de otro modo un array es una especie de tabla donde almacenamos datos en cada una de sus celdas.

03-Dic-2016

Arrays en PHP

Un array en PHP es un tipo especial de datos que representa los llamados mapas ordenados de datos. Un mapa es un tipo de datos que asocia valores con claves,  también llamado ‘array asociativo’.

Los valores que almacenamos en un array no tienen por qué ser del mismo tipo como ocurre en otros lenguajes de programación. La posibilidad de utilizar como valores de un array otros arrays, árboles, les permite la definición de arrays multidimensionales.

Los arrays están optimizados para varios usos diferentes:

  • Vectores: lista de datos unidimensional a los que se accede por medio de su posición llamada  índice.
  • Matriz: lista de datos bidimensional formada por filas y columnas, a los que se accede por medio de su posición de fila y columna.
  • Multidimensional: lista de datos de tres o más dimensiones, a los que se accede por medio de su posición indicando el índice o clave de cada una de sus dimensiones.
  • Tabla asociativa: implementación de un mapa donde se asocia a cada valor una clave de acceso. Puede aplicarse tanto a vectores, matrices como a arreglos multidimensionales.

PHP soporta tanto arrays escalares (índice numérico), como arrays asociativos (índice por clave).

Para acceder a los elementos de un array se utilizan los corchetes [], dentro de los cuales se indicará un índice o clave de localización.

A diferencia de otros lenguajes en PHP no hace falta definir el array antes de utilizarlo. Cuando se definen elementos de un array, PHP reconoce automáticamente que se trata de un array sin necesidad de declaración previa.

Definir un Array

En PHP podemos definir arrays utilizando el constructor del lenguaje array() o utilizando la notación de corchetes [] también llamada sintaxis corta de array() (a partir de PHP 5.4).

Si a la hora de definir el array no se indican los valores, estaremos creando un array vacío.

Especificación con array()

array(Valor1, Valor2, Valor3, ….);
array(); -> Array vacío
$numeros = array(10, 20, 30, 40, 50);
$nombres = array('Luis', 'Juan', 'Pedro');
$vacio = array();

Notación [ ] (corchetes)

[Valor1, Valor2, Valor3, ….];
[] -> Array vacío
$numeros = [10, 20, 30, 40, 50];
$nombres = ['Luis', 'Juan', 'Pedro'];
$vacio = [];

Aunque PHP soporta estas dos sintaxis, se recomienda utilizar la notación de corchetes, que será la que utilizaré para todos los ejemplos que se muestren en este módulo.

Asignar valores

Para asignar valores a los elementos de un array, utilizaremos la sintaxis:

$NombreArray[IndiceClave]=ValorAsignado;
$elementos[10]=100.25;
$elementos[11]=50;
$elementos['Precio']=9.99;

PHP admite también otra posibilidad que no admiten otros lenguajes: se pueden asignar valores a un  array sin especificar el índice, ya que PHP los coloca automáticamente al final de los elementos existentes.

$NombreArray[]=ValorAsignado;
$elementos[]=100.25;
$elementos[]=50;

Eliminar y Vaciar elementos: unset() y NULL

Si queremos eliminar algún elemento del array, utilizaremos la función unset() indicando como argumento la variable de tipo array y el índice o clave del elemento que deseamos eliminar.

¡OJO!: una vez eliminado el elemento, PHP no reorganiza los índices del resto de los elementos, es decir; si eliminamos el elemento [3], el índice 3 del array habrá desaparecido y si intentamos acceder de nuevo al elemento utilizando ese número de índice se producirá un error de ejecución.

// Definimos un array de 4 elementos
  $numeros=[10,20,30,40];

echo $numeros[2];   // Mostramos el elemento con índice 2 (30) unset($numeros[2]); // Eliminamos el elemento echo $numeros[3];   // Ahora el elemento que está en la tercera posición será el que tiene el índice 3 (40) // Si intentamos acceder al elemento con índice 2, se producirá un error de ejecución echo $numeros[2]; // Notice: Undefined offset: 2

Para mantener el orden de los índices después de eliminar un elemento, tendremos que reasignar los valores al array con la función array_values().

// Definimos un array de 4 elementos
  $numeros=[10,20,30,40];
  unset($numeros[2]); // Eliminamos el elemento con índice 2 (30)
  $numeros= array_values($numeros); // Ahora reasignamos al array los valores
  echo $numeros[2]; // Mostramos el elemento con índice 2 (40)

Si lo que deseamos es eliminar el contenido (su valor) pero no el elemento, lo único que tenemos que hacer es asignarle un valor vacío o nulo al elemento. De esta manera los índices seguirán siendo los mismos, pero habremos vaciado el contenido del elemento.

// Definimos un array de 4 elementos
   $numeros=[10,20,30,40];

// Mostramos el elemento que está en la  tercera posición
   echo $numeros[2]; // 30

// Vaciamos el elemento
   $numeros[2]=NULL; // o también $numeros[2]='';

// Ahora el elemento está vacío
   echo $numeros[2]; // No mostrará nada

Contar los elementos de un array: count()

Para contar los elemento que componen un array utilizamos la función count() indicando como argumento la variable de tipo array.

<?php
  $numeros=[10,20,30,40];
  echo count($numeros); // 4
?>

Si deseamos contar todos los elementos de un array multidimensional, tendremos que indicar la constante COUNT_RECURSIVE como segundo argumento de la función count().

<?php
    $matriz_numeros=[[2,4,6,8],[5,10,15,20],[10,20,30,40]];
    // 15  (ya que se tienen en cuenta los 3 elementos de la primera dimensión
    echo count($matriz_numeros, COUNT_RECURSIVE);
?>

Mostrar su estructura y contenido: print_r()

Si en algún momento deseamos mostrar el contenido de una array para ver de una forma más comprensible su estructura, PHP nos ofrece la función print_r() que como se nos indica en la web www.php.netImprime información legible para humanos sobre una variable’.

Para que la visualización de la estructura y sus elementos sea correcta se recomienda encerrar la salida de la función print_r() entre etiquetas <pre> y </pre> de HTML.

<?php
    $numeros=[10,20,30,40];
    $matriz_numeros=[[2,4,6,8],[5,10,15,20],[10,20,30,40]];
?>
<pre>
<?php 
    echo '<strong>$numeros</strong><br>'; // Mostramos literal con  el nombre del array 
    print_r($numeros); //  Imprimir estructura y contenido del array
?>
</pre>
<pre>
<?php 
    echo '<strong>$matriz_numeros</strong><br>'; // Mostramos literal con  el nombre del array 
    print_r($matriz_numeros); //  Imprimir estructura y contenido del array
?>
</pre>

Tipos de Arrays

Escalares

Los arrays escalares son aquellos en los que para acceder a los elementos utilizamos un índice que representa la posición del valor dentro del array comenzando desde el índice 0.

array(valor1, valor2, valor3, ...);
[Valor1, valor2, valor3, ...];
// Array escalar de valores numéricos  utilizando el constructor array()
   $variable = [10, 20,  30, 40, 50];
   echo $variable[0]; -> 10
   echo $variable[3]; -> 40

// Array escalar de valores cadena  utilizando la notación de corchetes
    $variable = ['Enero', 'Febrero', 'Marzo', 'Abril'];
    echo $variable[0]; -> 'Enero'
    echo $variable[2]; -> 'Marzo'
    
// Array escalar de valores combinados  utilizando la notación de corchetes
    $variable = ['Enero', 10, 'Marzo',  20, 'Abril'];
    echo $variable[0]; -> 'Enero'
    echo $variable[3]; -> 20

Asociativos

Para acceder a los elementos del array utilizamos la clave asociada con el elemento, donde este toma un cierto número de parejas utilizando la sintaxis clave => valor como argumentos.

Siempre deben usarse comillas alrededor de un índice de array tipo string literal. Por ejemplo, $array[‘Nombre'] es correcto, mientras que $array[Nombre] no lo es.

Pero esto no quiere decir que siempre haya que usar comillas en la clave. No usaremos comillas con claves que sean constantes o variables, ya que en tal caso PHP no podrá interpretar sus valores. Por ejemplo, $array[$Nombre] es correcto si existe la variable $Nombre, mientras que $array[‘$Nombre’] no lo es.

No podemos acceder a los elementos por medio de un índice numérico como en el caso de los arrays escalares, a no ser que la clave asociada al valor sea de tipo numérica.

array(clv1=>valor2,clv2=>valor2,clv3=>valor3,...);
[clv1=>valor1,clv2=>valor2,clv3=>valor3,...];
// Array asociativo con claves string y valores  numéricos
   $Notas = ['Luis'=>6, 'Carmen'=>6, 'Pedro'=>3, 'Rosa'=>8);
   echo $Notas['Pedro']; -> 3
   $indice='Luis';
   echo $Notas[$indice]; -> 6 // Accedemos al elemento por medio de una variable

// Array asociativo con claves string y de  valores string
  $Capitales= ['España'=>'Madrid', 'Francia'=>'Paris', 'Italia'=>'Roma', 'Alemania'=>'Berlin');
  echo $Capitales['España']; -> 'Madrid'
  echo $Capitales[0]; -> Error de índice
  
// Array asociativo de claves y valores  numéricos y cadena
  $Valores= ['Peso'=>65, 10=>'Diez', 'Altura'=>1.75, 20=>'Nombre');
  echo $Valores['Altura']; -> 1.75
  echo $Valores[20]; -> 'Nombre'

Multidimensionales

Un array multidimensional es aquel cuyos valores son otros arrays. Para acceder a sus elementos se tienen que indicar los índices de cada una de sus dimensiones, utilizando tantos pares de corchetes como dimensiones se definan en el array: [][] -> 2 dimensiones, [][][] -> 3 dimensiones, etc….

Podemos definirlos con arrays escalares y asociativos o una combinación de ambos.

 

[
  [valor1,valor2,...],
  [valor1,valor2,...],
  …
];
  
//  Se accede a los elementos como:
[índice][índice]
[ 
  clv1=>[valor1, valor2,...],
  clv2=>[valor1, valor2,...],
  …
];
  
//  Se accede a los elementos como:
[clave][índice]
[ 
  [clv1=>valor1,  clv2=>valor2, ...],
  [clv1=>valor1,  clv2=>valor2, ...],
  ....
];
  
//  Se accede a los elementos como:
 [índice][clave]
[ 
  clv1=>[clv1=>valor1, clv2=>valor2, ...],
  clv2=>[clv1=>valor1, clv2=>valor2, ...],
  ....
];
  
//  Se accede a los elementos como:
 [clave][clave]

Multidimensional de índices escalares

<?php
  $matriz_numeros=[[2,4,6,8]),[5,10,15,20],[10,20,30,40]];
?>
<h3>Array Multidimensional de índices escalares</h3>
<pre>
<?php
  echo '$matriz_numeros<br>';  // Mostramos nombre del array
  print_r($matriz_numeros);   // Imprimir estructura y  contenido del array
  // Mostramos algunos de los  elementos del array
  echo '$matriz_numeros[0][3]  -> ',$matriz_numeros[0][3],  '<br>';
  echo '$matriz_numeros[1][1]  -> ',$matriz_numeros[1][1],  '<br>';
  echo '$matriz_numeros[2][2]  -> ',$matriz_numeros[2][2],  '<br>';
?>
</pre>

Multidimensional de índices asociativos

<?php
  $matriz_ciudades=['España'  => ['Valencia','Madrid','Barcelona'],
                    'Francia' => ['Paris',  'Marsella', 'Lion'],
                    'Italia' => ['Roma',  'Nápoles', 'Venecia']];
?>
<h3>Array Multidimensional de índices asociativos</h3>
<pre>
<?php
  echo '$matriz_ciudades<br>';  // Mostramos nombre del array
  print_r($matriz_ciudades);   // Imprimir estructura y  contenido del array
  /* Mostramos algunos de los  elementos del array utilizando una
  variable índice para acceder a los  elementos */
  $indice='España';
  echo "\$indice=  $indice<br>",'$matriz_ciudades[$indice][0] -> ', $matriz_ciudades[$indice][0], '<br><br>';
  $indice='Francia';
  echo "\$indice=  $indice<br>",'$matriz_ciudades[$indice][2] -> ', $matriz_ciudades[$indice][2], '<br>';
?>
</pre>

Multidimensional de índices escalares y subíndices asociativos

<?php
  $matriz_personas=[['Nombre'=>'Luis','Edad'=>45,'Sexo'=>'Hombre'],
                   ['Nombre'=>'Carmen','Edad'=>40,'Sexo'=>'Mujer'],
                   ['Nombre'=>'Pedro','Edad'=>25,'Sexo'=>'Hombre']];
?>
<h3>Array Multidimensional de índices escalares  y subíndices asociativos</h3>
<pre>
<?php
  echo '$matriz_personas<br>'; // Mostramos nombre del array
  print_r($matriz_personas);   // Imprimir estructura y contenido del array
  // Mostramos algunos de los elementos del  array
  echo '$matriz_personas[0][\'Nombre\']  -> ',$matriz_personas[0]['Nombre'],'<br>';
  echo '$matriz_personas[1][\'Nombre\']  -> ',$matriz_personas[1]['Nombre'],'<br>';
  echo '$matriz_personas[2][\'Edad\']  -> ',$matriz_personas[2]['Edad'],'<br>';
?>
</pre>

Multidimensional de índices y subíndices asociativos

<?php
  $matriz_paises=['España'  => ['capital'=>'Madrid','idioma'=>'Español','poblacion'=>46400000],
                  'Francia' => ['capital'=>'Paris','idioma'=>'Frances','poblacion'=>66415161],
                  'Italia' => ['capital'=>'Roma','idioma'=>'Italiano','poblacion'=>59801000]];
?>
<h3>Array Multidimensional de índices y subíndices  asociativos</h3>
<pre>
<?php
  echo '$matriz_paises<br>';  // Mostramos nombre del array
  print_r($matriz_paises);   // Imprimir estructura y  contenido del array
  // Mostramos algunos de los  elementos del array
  echo '$matriz_paises[\'España\'][\'idioma\']  -> ',$matriz_paises['España']['idioma'],  '<br>';
  echo '$matriz_paises[\'Francia\'][\'capital\']  -> ',$matriz_paises['Francia']['capital'],  '<br>';
  echo '$matriz_paises[\'Italia\'][\'poblacion\']  -> ',$matriz_paises['Italia']['poblacion'],  '<br>';
?>
</pre>

Operadores

Los arrays al igual que ocurre con el resto de tipos de datos soportados por PHP, disponen de operadores que nos permiten realizar comparaciones y uniones entre arrays.

Operadores para arrays
Ejemplo Nombre Resultado
$a + $b Unión Unión de $a y $b.
$a == $b Igualdad TRUE si $a i $b tienen las mismas parejas clave/valor.
$a === $b Identidad TRUE si $a y $b tienen las mismas parejas clave/valor en el mismo orden y de los mismos tipos.
$a != $b Desigualdad TRUE si $a no es igual a $b.
$a <> $b Desigualdad TRUE si $a no es igual a $b.
$a !== $b No-identidad TRUE si $a no es idéntica a $b.

Unión de Arrays

El operador de unión + devuelve el array del lado derecho añadido al array del lado izquierdo; para las claves que existan en ambos arrays, serán utilizados los elementos del array de la izquierda y serán ignorados los elementos correspondientes del array de la derecha.

La unión de arrays escalares, provoca la pérdida de los elementos del array de la derecha cuyos índices (posiciones) coincidan con los índices del array de la izquierda.

La unión de arrays asociativos, provoca la pérdida de los elementos del array de la derecha cuyas claves  coincidan con las claves del array de la izquierda.

<?php
//  UNION DE ARRAYS ESCALARES

   $array1 = [10, 20, 30];
   $array2 = [40, 50];
   $array = $array1 + $array2;
/* El array resultante será idéntico a  $array1, ya que $array2 tiene menos elementos y además los 
   índices de acceso  coinciden [10, 20, 30] */
   print_r($array);

   $array = $array2 + $array1;
/* El array resultante será la unión de los  dos primeros elementos de $array2 con el tercer elemento
   de $array1 ya que los  índices (0 y 1) de acceso coinciden [40, 50, 30] */
   print_r($array);
    
//  UNION DE ARRAYS ASOCIATIVOS

   $array1 = ['Enero'=>10, 'Marzo'=>20, 'Abril'=>30];
   $array2 = ['Enero'=>30, 'Febrero'=>40, 'Mayo'=>50];
   $array = $array1 + $array2;
/* $array contendrá todos los elementos del  array1 y todos los elementos del array2 excepto 'Enero' 
   ya que su clave  coincide con la clave del array1 */
    print_r($array);
    
   $array1 = ['Enero'=>10, 'Febrero'=>20, 'Marzo'=>30];
   $array2 = ['Abril'=>40, 'Mayo'=>50];
   $array = $array1 + $array2;
/* $array contendrá todos los elementos del  array1 y todos los elementos del array2 ya que sus claves 
   no coinciden */
   print_r($array);
?>

Función array_merge()

PHP nos ofrece otra forma de unir el contenido de dos arrays por medio de la función array_merge(). Esta función combina los elementos de uno o más arrays juntándolos de modo que los valores de uno se anexan al final del anterior, devolviendo el array resultante.

array array_merge ($Array1  , $Array2 [,$Array3 ,$...  ] )

Si los arrays de entrada tienen las mismas claves de tipo string, el último valor para esa clave sobrescribirá al anterior. Sin embargo, los arrays que contengan claves numéricas, el último valor no sobrescribirá el valor original, sino que será añadido al final.

<?php
// Definimos dos arrays escalares de tipo  entero
  $variables1 = [10,20,30,40];
  $variables2 = [40,50,60];
   
// Mostramos contenido de los arrays, los  combinamos utilizando la función array_merge() y mostramos el array resultante
  print_r($variables1);
  print_r($variables2);
  $union = array_merge($variables1,$variables2);
  print_r($union);
  
// Definimos dos arrays asociativos donde la última clave del primero coincide con  la primera clave del segundo
  $variables1 = ['uno'=>10, 'dos'=>20, 'tres'=>30];
  $variables2 = ['tres'=>40, 'cuatro'=>50, 'cinco'=>60];
  
// Mostramos contenido de los arrays, los  combinamos utilizando la función array_merge() y mostramos el array resultante
  print_r($variables1);
  print_r($variables2);
  $union = array_merge($variables1,$variables2);
  print_r($union);
?>

Comparación de Arrays

PHP ofrece operadores de comparación por igualdad y por identidad para arrays al igual que ocurre con los operadores aritméticos.

La comparación por igualdad (==) de arrays escalares, devolverá TRUE si ambos arrays tienen la misma cantidad de elementos y sus valores coinciden aunque no sean del mismo tipo.

La comparación por Identidad (===) de arrays escalares, devolverá TRUE si ambos arrays tienen la misma cantidad de elementos, sus valores coinciden y son del mismo tipo.

<?php
// COMPARACIÓN  DE ARRAYS ESCALARES

  $array1 = [10, 20,  30];
  $array2 = [40, 50];
  $array3 = [10, 20, '30'];
  $array4 = [10, 20, 30];
  
  if($array1 == $array2):
    echo 'Son iguales';
  else:
    echo 'Son distintos'; // Valor mostrado
  endif;
    
  if($array1 == $array3):
    echo 'Son iguales'; // Valor mostrado
  else:
    echo 'Son distintos';
  endif;
  
  if($array1 === $array3):
    echo 'Son iguales';
  else:
    echo 'Son distintos'; // Valor mostrado
  endif;
    
  if($array1 === $array4):
    echo 'Son iguales'; // Valor mostrado
  else:
    echo 'Son distintos';
  endif;
    
?>

Recorrer elementos

Bucle for

La estructura de control for se adapta muy bien a la hora de recorrer un array, ya que si obtenemos la cantidad de elementos que lo componen con la ayuda de la función count(), conoceremos el nº de iteraciones que el bucle tiene que realizar y podemos utilizar esta información como condición de finalización del bucle.

Este bucle funciona muy bien con arrays escalares de una dimensión a los que accedemos por su índice, pero no resulta útil a la hora de recorrer arrays asociativos donde las claves están formadas por valores de tipo string.

<?php
  $array = [5, 10,  15, 20];
  
// Mostramos mensaje con la posición  (índice) y valor de cada elemento
  for($i=0; $i<count($array); $i++) {
    echo "Elemento [$i] -> {$array[$i]}<br>";
  }
?>

Para recorrer arrays multidimensionales, necesitaremos tantos bucles for como dimensiones del array deseemos profundizar.

<?php
  $array = [[5, 10, 15],
            [10, 20, 30],
            [100, 200, 300, 400]];
  
// Mostramos mensaje con el índice de cada  array y los valores que contiene
  for($i=0; $i<count($array); $i++) {
    echo "<p>Índice  [$i]:<br>";
    for($x=0; $x<count($array[$i]); $x++) {
      echo "Elemento [$x]  -> {$array[$i][$x]}<br>";
    }
    echo "</p>";
  }
?>

Bucle foreach

Aunque para recorrer los elementos de un array tenemos el bucle for, PHP nos ofrece la estructura foreach que resulta más apropiada y sencilla a la hora de iterar sobre arrays. foreach funciona sólo sobre arrays y objetos, y emitirá un error al intentar usarlo con una variable de un tipo diferente de datos o una variable no inicializada.

Existen dos sintaxis:

foreach(expresión_array as $valor) {
  Sentencias;
}

foreach(expresión_array as $clave =>  $valor):
  Sentencias;
endforeach;
  • La primera forma recorre el array dado por expresión_array. En cada iteración, el valor del elemento actual se asigna a $valor y el puntero interno del array avanza una posición (así en la próxima iteración se estará observando el siguiente elemento).
  • La segunda forma además asigna la clave del elemento actual a la variable $clave en cada iteración, por lo que resulta ideal a la hora de recorrer arrays asociativos en los que aparte del valor, necesitamos obtener la clave.
  • Ambas formas admiten la sintaxis alternativa de dos puntos (:), indicando la palabra endforeach; como finalización de las sentencias del bucle.
<?php
  $array = [5, 10,  15, 20];
  $i=0;
  
// Mostramos mensaje con la posición y  valor de cada elemento
  foreach($array as $valor) {
    echo "Elemento  [$i] -> $valor<br>";
    $i++;
  }

  $array = ['uno'=>5, 'dos'=>10, 'tres'=>15, 'cuatro'=>20];
  $i=0;
  
// Mostramos mensaje con la posición, clave  y valor de cada elemento
  foreach($array as $clave=>$valor):
    echo "Elemento  [$i] -> [$clave]=$valor<br>";
    $i++;
  endforeach;
?>

Al igual que ocurría con el bucle for a la hora de recorrer arrays multidimensionales, con el bucle foreach, tendremos que utilizar tantos foreach como dimensiones tenga el array.

<?php
  $array = ['Luis'=>['piso'=>5, 'escalera'=>'A', 'puerta'=>15],
            'Ana'=>['piso'=>2, 'escalera'=>'A', 'puerta'=>5],
            'Juan'=>['piso'=>3, 'escalera'=>'B', 'puerta'=>10]];
            
// Mostramos contenido del array multidimensional con la clave asociada a  cada dimensión y los valores de sus elementos
  foreach($array as $inquilino=>$datos):
    echo "<p>Inquilino:  $inquilino<br>";
    foreach($datos as  $dato=>$valor) {
      echo "$dato: $valor<br>";
    }
    echo "</p>";
  endforeach;
?>

Búsqueda en Arrays

Aunque a la hora de realizar búsquedas en un array ya sea escalar o asociativo, unidimensional o multidimensional lo más normal es utilizar bucles, que nos permitan recorrer los elementos del array hasta localizar el valor buscado, PHP dispone de una serie de funciones de búsqueda para arrays que nos pueden facilitar la tarea de buscar datos, siempre y cuando la búsqueda se realice en una dimensión. Estas funciones permiten localizar un valor dentro del array, un índice o una clave.

Buscar un valor: in_array() y array_search()

La función in_array() comprueba si un valor existe en un array, devuelve TRUE en se encuentra, o FALSE en caso contrario.

  bool in_array(ValorBuscado, Array [, BuscarPoIdentidad = false ])

Recibe como argumentos el valor que deseamos buscar, el array en el que se busca y opcionalmente un valor de tipo booleano que indica si la búsqueda se tiene que hacer de forma esctricta, es decir; que el valor coincida tanto en contenido como en tipo con el valor buscado.

La función array_search(), busca un valor determinado en un array y devuelve la primera clave o índice correspondiente en caso de éxito, o FALSE si no se encuentra.

  mixed array_search(ValorBuscado, Array [, BuscarPoIdentidad = false ]) 

Recibe los mismos argumentos que la función in_array(). Lo que la diferencia de la función in_array() es que obtenemos el índice o clave en caso de localizar el valor buscado.

Para comprobar de forma correcta si el valor no se ha localizado en el array tendremos que utilizar el operador de comparación por identidad (===), comparando el valor devuelto por la función con la constante false (ValorDevuelto===false).

<?php
  $inquilinos = [1  =>'Luis',
                 8  =>'Ana',
                 3  =>'Juan',
                 4  =>'Antonio',
                 10 =>'Pablo',
                 5  =>'Carmen'];

// Mostramos el nombre del array y la  cantidad de elementos
  echo '<br><strong>$inquilinos</strong> ',count($inquilinos),' elementos.<br>';
// Mostramos estructura y valores del array
  print_r($inquilinos);
    
// Buscamos un inquilino
  $persona='Pablo';
  echo "<br>\$persona=$persona<br>";
// Realizamos la búsqueda
  $puerta=array_search($persona,$inquilinos);
// Si no se ha localizado el elemento  mostramos un mensaje, de lo contrario mostramos en que puerta vive
  if($puerta===false):
    echo "<br>El/la inquilino/a $persona no forma parte de esta  comunidad<br>";
  else:
    echo "<br>El/la inquilino/a $persona vive en esta comunidad en la  puerta $puerta<br>";
  endif;
  
// Buscamos otro inquilino
  $persona='Rosa';
  echo "<br>\$persona=$persona<br>";
  $puerta=array_search($persona,$inquilinos);
  if($puerta===false):
    echo "<br>El/la inquilino/a $persona no forma parte de esta  comunidad<br>";
  else:
    echo "<br>El/la inquilino/a $persona vive en esta comunidad en la  puerta $puerta<br>";
  endif;
?>

Buscar un índice o clave: array_key_exists()

Esta función más que buscar, verifica si el índice o clave dada existe en el array, devolviendo TRUE si existe o FALSE en caso contrario. Si el índice o clave existe podremos acceder al valor sin posibilidad de equivocarnos.

<?php
  $inquilinos = ['Luis'  => ['piso'=>1, 'escalera'=>'A', 'puerta'=>1],
                 'Ana'   => ['piso'=>2, 'escalera'=>'A', 'puerta'=>5],
                 'Pedro' => ['piso'=>2, 'escalera'=>'B', 'puerta'=>6], 
                 'Carmen'=> ['piso'=>4, 'escalera'=>'A', 'puerta'=>8],               
                 'Juan'  => ['piso'=>5, 'escalera'=>'B', 'puerta'=>10]];

// Mostramos el nombre del array y la  cantidad de elementos
  echo '<br><strong>$inquilinos</strong> ',count($inquilinos),' elementos.<br>';
// Mostramos estructura y valores del array
  print_r($inquilinos);
  
// Buscamos un inquilino
  $persona='Luis';
  echo "<br>\$persona=$persona<br>";
// Si existe la clave, mostramos los datos  del inquilino (piso, escalera y puerta) 
  if(array_key_exists($persona,$inquilinos)):
    echo "<br>$persona vive en el piso {$inquilinos[$persona]['piso']},  
          escalera {$inquilinos[$persona]['escalera']} y 
          puerta {$inquilinos[$persona]['puerta']}<br>";
  else:
    echo "<br>$persona no forma parte de esta comunidad<br>";
  endif;
  
// Buscamos otro inquilino
  $persona='Pedro';
  echo "<br>\$persona=$persona<br>";
  if(array_key_exists($persona,$inquilinos)):
    echo "<br>$persona vive en el piso {$inquilinos[$persona]['piso']},  
          escalera {$inquilinos[$persona]['escalera']} y 
          puerta {$inquilinos[$persona]['puerta']}<br>";
  else:
    echo "<br>$persona no forma parte de esta comunidad<br>";
  endif;
?>

Ordenación

PHP ofrece muchas funciones para realizar ordenación de arrays, donde sus principales diferencias radican en el tipo de ordenación: por claves o por valores, mantener la correlación entre claves y el sentido de la ordenación: ascendente y descendente.

Vamos a comentar las más importantes:

sort y rsort – Ordenar un array escalar

Estas funciones reciben como argumento el nombre de la variable de tipo array por referencia, ordena sus elementos y devuelve TRUE si se ha podido realizar la ordenación o FALSE en caso de error.

    bool sort(&$Array);
    bool rsort(&$Array); 

La diferencia entre ambas es el sentido de la ordenación, donde sort ordena los elementos de menor a mayor y rsort los ordena de mayor a menor.

<?php
  $array = [10, 20,  30, 5, 3, 25, 50];
  echo $array[2];  // 30 
  sort($array);
  echo $array[2];  // 10 [3, 5, 10, 20, 25, 30, 50]
  rsort($array);
  echo $array[2];  // 25 [50, 30, 25, 20, 10, 5, 3] 
?>

ksort y krsort – Ordenar un array asociativo

Estas funciones reciben como argumento el nombre de la variable de tipo array por referencia, ordena sus elementos por la clave, por lo que el tipo de array tendrá que ser asociativo y devuelve TRUE si se ha podido realizar la ordenación o FALSE en caso de error.

    bool ksort(&$Array);
    bool krsort(&$Array);

La diferencia entre ambas es el sentido de la ordenación, donde ksort ordena las claves de menor a mayor y krsort las ordena de mayor a menor.

<?php
  $array = ['Enero'=>100, 'Marzo'=>20, 'Abril'=>30];
  print_r($array); // Enero, Marzo, Abril
  ksort($array);
  print_r($array); // Abril, Enero, Marzo
  krsort($array);
  print_r($array); // Marzo, Enero, Abril
?>

Inserción y Extracción de elementos

array_push y array_unshift – Insertar elementos

PHP nos ofrece dos funciones muy útiles para añadir nuevos elementos al final (array_push) o al principio (array_unshift) de un array.

    int array_push(&$Array, $Valor1, $Valor2, …);
    int array_unshift(&$Array, $Valor1, $Valor2, …);

Ambas funciones reciben como primer argumento la variable de tipo array por referencia, y el resto de los argumentos serán cada uno de los valores que deseamos insertar en la variable.

Una vez finalizada la inserción devuelven un número que representa el nuevo número de elementos del array.

NOTA: si lo que deseamos es añadir un solo elemento al final del array es conveniente utilizar la sintaxis $array[]=Valor en lugar de array_push ya que de este modo evitamos la sobrecarga de la función y el consumo innecesario de recursos.

<?php
  $numeros = [100, 20, 30];
  $meses = ['Marzo','Abril'];
  
  echo 'Elementos de $numeros: ', count($numeros), '<br>'; // 3 
  echo 'Elementos de $meses: ', count($meses), '<br>'; // 2
// Añadir elementos al final
  array_push($numeros,50,60); 
  print_r($numeros); // 100, 20, 30, 50, 60
  array_push($meses, 'Mayo', 'Junio'); 
  print_r($meses); // Marzo, Abril, Mayo, Junio
  echo 'Elementos de $numeros: ', count($numeros), '<br>'; // 5 
  echo 'Elementos de $meses: ', count($meses), '<br>'; // 4
  
// Añadir elementos al principio
  array_unshift($numeros,10,6); 
  print_r($numeros); // 10, 6, 100, 20, 30, 50, 60
  array_unshift($meses, 'Enero', 'Febrero'); 
  print_r($meses); // Enero, Febrero, Marzo, Abril, Mayo, Junio
  echo 'Elementos de $numeros: ', count($numeros), '<br>'; // 7 
  echo 'Elementos de $meses: ', count($meses), '<br>'; // 6
?>

array_pop y array_shift – Extraer elementos

Disponemos de dos funciones para extraer elementos de un array: array_pop() desde el final o array_shift()  desde el principio.

    mixed array_pop(&$Array);
    mixed array_shift(&$Array);

Ambas funciones reciben como argumento la variable de tipo array por referencia, extraen un elemento y lo devuelven acortando el tamaño del array.

<?php
  $numeros = [100, 20, 30,  40];
  $meses = ['Marzo', 'Abril', 'Mayo', 'Junio'];

  print_r($numeros); 
  print_r($meses); 
 // Extraer elementos del final
  $numero = array_pop($numeros); 
  $mes = array_pop($meses); 
  echo 'Elemento extraído de $numeros: ', $numero, '<br>'; // 40
  echo 'Elemento extraído de $meses: ', $mes, '<br>'; // Junio
 
 // Extraer elementos del principio
  $numero = array_shift($numeros); 
  $mes = array_shift($meses); 
  echo 'Elemento extraído de $numeros: ', $numero, '<br>'; // 100
  echo 'Elemento extraído de $meses: ', $mes, '<br>'; // Marzo
  print_r($numeros); // 20, 30
  print_r($meses); // Abril, Mayo
?>

Implementación de PILAS

Una pila, es una lista ordenada o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (Last Input First Out, último en entrar, primero en salir) o de tipo FIFO (First Input First Out, primero en entrar, primero en salir) que permite almacenar y recuperar datos.

Por medio de las funciones vistas en el apartado anterior para introducir y extraer los elementos de un array, podemos implementar la utilización de listas tanto de tipo LIFO como FIFO.

En ambos casos tendremos que comprobar que quedan elementos en la pila antes de extraer el elemento.

LIFO

Para el tipo de pila LIFO utilizaremos las funciones array_push() para insertar el elemento en la pila y la función array_pop() para extraer el elemento.

<?php
// PILA TIPO LIFO
  $pila = []; // Definimos un array vacio

// Insertamos 2 elementos en la pila
  array_push($pila, 5, 10);
// Insertamos 1 elemento
  array_push($pila, 50);
// Mostramos contenido de la pila [5, 10,  50]
  print_r($pila);

// Extraemos elemento (último) comprobando  que existen elementos
  if(count($pila)>0):
    $elemento = array_pop($pila);
    echo "Extraido: $elemento<br>";
  else:
    echo "Pila vacía.<br>";
  endif; 
// Mostramos contenido de la pila [5, 10]
  print_r($pila);

// Añadimos dos elementos nuevos
  array_push($pila, 15, 60);
// Mostramos contenido de la pila [5, 10,  15, 60]
  print_r($pila);

// Extraemos 3 elementos
  for($i=0;$i<3;$i++):
    if(count($pila)>0):
      $elemento = array_pop($pila);
      echo "Extraido: $elemento<br>";
    else:
      echo "Pila vacía.<br>";
      break;
    endif; 
  endfor;
// Mostramos contenido de la pila [5]
  print_r($pila);

// Intentamos extraer 2 elementos  
  for($i=0;$i<2;$i++):
    if(count($pila)>0):
      $elemento = array_pop($pila);
      echo "Extraido: $elemento<br>";
    else:
      echo "Pila vacía.<br>";
      break;
    endif; 
  endfor;
?>
 

FIFO

Para el tipo de pila FIFO utilizaremos las funciones array_push() para insertar el elemento en la pila y la función array_shift() para extraer el elemento.

<?php
// PILA TIPO FIFO
  $pila = []; // Definimos un array vacio

// Insertamos 2 elementos en la pila
  array_push($pila, 5, 10);
// Insertamos 1 elemento
  array_push($pila, 50);
// Mostramos contenido de la pila [5, 10,  50]
  print_r($pila);

// Extraemos elemento (primero) comprobando  que existen elementos
  if(count($pila)>0):
    $elemento = array_shift($pila);
    echo "Extraido: $elemento<br>"; // 5 
  else:
    echo "Pila vacía.<br>";
  endif; 
// Mostramos contenido de la pila [10, 50]
  print_r($pila);

// Añadimos dos elementos nuevos
  array_push($pila, 15, 60);
// Mostramos contenido de la pila [10, 50,  15, 60]
  print_r($pila);

// Extraemos 3 elementos
  for($i=0;$i<3;$i++):
    if(count($pila)>0):
      $elemento = array_shift($pila);
      echo "Extraido: $elemento<br>"; // 5 
    else:
      echo "Pila vacía.<br>";
      break;
    endif; 
  endfor;
// Mostramos contenido de la pila [60]
  print_r($pila);

// Intentamos extraer 2 elementos (sólo  podremos extraer uno)
  for($i=0;$i<2;$i++):
    if(count($pila)>0):
      $elemento = array_shift($pila);
      echo "Extraido: $elemento<br>"; // 5 
    else:
      echo "Pila vacía.<br>";
      break;
    endif; 
  endfor;
?>

En la documentación que acompaña a este módulo, podréis encontrar un script con todos los ejemplos mostrados de una forma más detallada.