CURSO DE PHP Y MYSQL GRATIS

Introducción - ARRAYS

Un array es una colección de valores con un único nombre. Para acceder a
los distintos valores de la variable se utiliza un índice numérico o alfanumérico.
Nos vamos a servir de la definición de un array en el lenguaje C, para ver
la potencia de este tipo de datos en PHP. La definición es la siguiente:
int mi_array[100]; //Esto es C

Lo primero que debe llamarnos la atención es que la variable está predefinida
como i n t (entero). En PHP los arrays no tienen que definirse de una
forma concreta, sino que pueden tomar distintos tipos de valores: enteros,
caracteres, objetos, etcétera. Lo siguiente es que, en C, se necesita saber
de antemano el número de valores máximo que podrá tomar el array.
Esto no es necesario en PHP, ya que podrá ir creando valores nuevos a
medida que lo vaya necesitando. Lo último es que en C el índice para acceder
a los 100 valores distintos debe ser numérico; en cambio, en PHP, el
índice puede ser numérico o alfanumérico.

<?php
$mi_array[l] = 23;
$mi_array[2] = "Este valor es un string";
$mi_array["ejemplo"] = "Esto es un array asociativo";
?>

Creación de arrays
Vamos a ver tres formas distintas de crear un array dentro de un script de
PHP.

Asignación directa
El camino más simple y, por otro lado lógico, es asignar valores cuando se
necesiten. La primera vez que asignemos un valor, el array se creará en el
entorno:

<?php
$mi_array[l] = 23; // Asignación directa
?>

De esta forma tenemos un valor asignado al índice 1 del array. Puede asignar
cualquier índice en la creación de este tipo de dato, e incluso no asignar ninguno, de forma que PHP se encarga de asociar un índice distinto para cada valor.

<?php
$mi_array[] = 23; // Empieza en el índice 0
$mi_array[] = 54; // índice 1
?>

array()
Esta función crea un array con los valores que pase como datos de entrada.
Los índices serán añadidos automáticamente empezando desde 0.
Si no asigna parámetros a a r r a y ( ) , la función le devolverá un array
vacío.
<?php
$mi_array = array(23,45,76,23,65);
?>
El método es similar a:
<?php
$mi_array[0] = 23;
$mi_array[l] = 4 5;
$mi_array[2] = 76;
$mi_array[3] = 23;
$mi_array[4] = 65;
?>

La función a r r a y () permite también añadir índices a los valores que se
introducen.

Para ello se utiliza el operador => de esta forma:

<?php
$mi_array = array{0 => 23, 1 => 45, 2 => 76);
?>

También es posible añadir índices que no sean correlativos o índices alfanuméricos, incluso mezclar los dos tipos.

<?php
$mi_array = array("cero" => 23, "uno" => 45, 2 => 76);
?>
Para recuperar cualquier valor se utiliza el índice dentro de los corchetes:
<?php
$mi_array = array("cero" => 23, "uno" => 45, 2 => 76);
echo $mi_array [ "uno"]. "<br>";
echo $mi_array[2] ;
?>

Funciones que devuelven arrays
La última forma de obtener un array es utilizando alguna de las funciones
que devuelven este tipo de datos.
Es muy frecuente que las funciones que manejan bases de datos devuelvan
las ocurrencias dentro de un array.

Por ejemplo, la función range () devuelve un array con valores numéricos,
que van desde un número de inicio hasta un número final tal y como
se muestra en el ejemplo:

<?php
$mi_array = range(120,130) ;
?>

Esta función crea un array, empezando desde el índice 0 y el valor 120,
hasta el índice 10 y el valor 130.

Arrays multidimensionales
Hasta aquí hemos visto ejemplos de arrays de una sola dimensión. PHP
soporta el uso de arrays de varias dimensiones fácilmente, aunque son
complejos de entender y de usar. El array siguiente es de 5 dimensiones:

<?php
$ m i _ a r r a y [ l ] [ 1 ] [ 2 3 ] [ 4 3 ] [ 0 ] = "Array de 5 d i m e n s i o n e s ";
?>

Cada índice encerrado entre corchetes corresponde a una dimensión distinta.
En realidad, cada dimensión es un array que se introduce como valor
dentro de la dimensión anterior.

Así, podrá crear un array multidimensional de la siguiente forma:

<?php
$colores = array("fuertes","suaves");
$colores ["fuertes"] = array ( "rojo" => "FF0000",
"verde" => "00FF00",
"azul" => "0000FF");
$ c o l o r e s [ " s u a v e s " ] = a r r a y ( "rosa" => "FE9ABC",
" a m a r i l l o " => "FDF189"?
"malva" => "9A2F68");
echo $colores["fuertes"] ["rojo"];
?>

Para recuperar los valores se utilizan un índice del primer array (fuertes o
suaves) y un índice de alguno de los dos arrays secundarios.

Otra forma de definir el array anterior es:
<?php
$colores = array( "fuertes" => array ( "rojo" => "FF0000",
"verde" => "00FF00",
"azul" => "0000FF"),
"suaves" => array ( "rosa" => "FE9ABC",
"amarillo" => "FDF189",
"malva" => "9A2F68"));
echo $colores["fuertes"] ["rojo"];
?>

Propiedades de arrays
Existen numerosas funciones que son capaces de averiguar datos de los
arrays, tales como el tamaño, si un valor forma parte del conjunto o si un
determinado índice está registrado.

count()
Cuenta el número de elementos que contiene un array.

<?php
echo "elementos de 1 dimensión " . count ($colores) . "<br>";
echo "elementos de 2 dimensiones " . count
($colores["fuertes"]);
?>

El ejemplo anterior se basa en la definición del array de colores inicializado
antes. Para contar el número de elementos debe ponerse también la
dimensión. Si el array es de una sola dimensión no hace falta. La función
s i z e o f () actúa de la misma forma.

in_array()
Busca dentro de un array un valor pasado como parámetro y, si lo encuentra
devuelve el valor true, si no, devuelve false. Toma dos argumentos, el
valor a buscar y el array dónde buscar.
<?php
$colores = array ("rojo","verde","amarillo","azul");
if (in_array("rojo",$colores)) {
echo "Se ha encontrado el valor rojo";
} else {
echo "No se ha encontrado" ;
}
?>

Borrar ocurrencias
Para borrar un elemento, simplemente se utiliza la misma función que
borra las variables definidas: unset () .

<?php
$colores = array ("rojo","verde","amarillo","azul","rosa") ;
echo "El número de elementos de colores es: " . count
($colores) . "<br>";
unset ($colores[2]);
echo "El número de elementos de colores es: " . count
($colores) . "<br>";
?>

Se puede observar que para borrar un elemento, hay que conocer el índice.
El resultado del ejemplo por pantalla es:
El número de elementos de colores es: 5
El número de elementos de colores es: 0

Advertencia:
Debe tener cuidado el lector con utilizar unset () con el nombre
de un array sin índice, pues esto causará el borrado del conjunto de
datos en su totalidad. Unset ($colores) borra el array completo,
unset ($colores [2] borra sólo el índice 2 del conjunto.

Interactuar con arrays
Anteriormente, tuvo la oportunidad de conocer las estructuras de control
existentes en PHP. La estructura f oreach quedó en el aire para tratarlo a
fondo en el presente capítulo. El uso es así:

<?php
$ciudades = array ("Badajoz","Mérida","Cáceres","Plasencia") ;
foreach ($colores as $valor) {
echo ("El valor es $valor<br>");
}
?>

La construcción anterior recorre el array desde el principio. En el ejemplo
se puede ver que f oreach toma el array a recorrer y sus valores los va
almacenando en la variable $ v a l o r a medida que el bucle se ejecuta. Existe
una segunda construcción que permite recuperar el índice y el valor. Veamos
un ejemplo de esto:

<?php
$ciudades = array ("Badajoz","Mérida","Cáceres","Plasencia");
foreach ($cíudades as $índíce => $valor) {
echo ("El índice $indice tiene el valor: $valor<br>") ;
}
?>

Es un método muy bueno para imprimir los valores de un array que tiene
índices numéricos y alfanuméricos.
<?php
$ciudades = array ("Badajoz","Mérida","Cáceres","Plasencia");
$ciudades["España"] = "Madrid";
$ciudades["Portugal"] = "Lisboa";
$ciudades["Francia"] = "Paris";
foreach ($ciudades as $indice => $valor) {
echo ("El Índice $indice tiene el valor: $valor<br>") ;
}
?>

Funciones para avanzar en un array
Cada vez que creamos un array dentro de un programa PHP, se crea un
puntero que permite recorrer en su totalidad el conjunto de valores. Este
puntero se inicializa al valor inicial del array. La función c u r r e n t () devuelve
el valor al que apunta el puntero. La función n e x t () hace avanzar
el puntero una posición en el conjunto de datos.
Si el puntero se encuentra al final del conjunto next () devuelve un valor
false. El ejemplo siguiente muestra cómo utilizar estas funciones para
recorrer un array:

<?php
$ciudades = array ("Badajoz","Mérida","Cáceres","Plasencia") ;
$ciudades["España"] = "Madrid";
$ciudades["Portugal"] = "Lisboa";
$ciudades["Francia"] = "Paris";
do {
$valor = current($ciudades);
echo ("El valor es: $valor<br>");
}while (next($ciudades) ) ;
?>

Podemos crear una función que realice este trámite:

<?php
$ciudades = array ("Badajoz","Mérida","Cáceres","Plasencia") ;
Sciudades["España"] = "Madrid";
$ciudades["Portugal"] = "Lisboa";
$ciudades["Francia" ] = "Paris";
function recorre($ciudades) {
do {
$valor = current($ciudades) ;
echo ("El valor es: $valor<br>") ;
Jwhile (next($ciudades));
}
recorre($ciudades);
recorre($ciudades);
?>

La función r e c o r r e () utiliza un array como parámetro y va utilizando
las funciones de introspección para sacar los resultados. Puesto que los
valores son pasados por valor, la función r e c o r r e () crea una copia de
los datos que recibe y genera el resultado de la figura 7.2.
De esta forma no hay manera de controlar el puntero, porque siempre que
pase la variable $ c i u d a d e s el puntero comenzará desde el principio.

La forma de arreglar esto es hacer las llamadas por referencia:
recorre (Sc$ciudades) ;
recorre (&$ciudades) ;

Ahora, ya no es una copia de $ ciudades lo que se pasa como parámetro,
sino una referencia al valor real. Esto hace posible tener una memoria de
la situación del puntero.

Una vez recorrido elarray, el puntero queda fijado al final del conjunto de
datos. Para volver al principio se puede utilizar la función r e s e t (), que
envía al puntero al principio. La función puede quedar así:

function recorre($ciudades) {
if (!current($ciudades)) {
reset($ciudades);
}
do {
$valor = current($ciudades) ;
echo ("El valor es: $valor<br>");
Jwhile (next($ciudades));
}

Ahora lo que hacemos es comprobar si el puntero está al final del array;
si esto es así se llama a la funciónreset 0 y el puntero se coloca al principio.

Funciones para retroceder en un array
La función prev () retrocede una posición el puntero y la función end ()
se coloca al final de una lista de valores. Esto puede ser útil para mostrar
el contenido en sentido inverso, como puede ver en la nueva función que
hemos creado:

<?php
$ciudades = array ("Badajoz","Mérida","Cáceres","Plasencia");
$ciudades["España"] = "Madrid";
$ciudades["Portugal" ] = "Lisboa";
$ciudades["Francia" ] = "Paris";
function recorre($ciudades) {
if ( lcurrent($ciudades)) {
reset($ciudades);
}
do {
$valor = current($ciudades);
echo ("El valor es: $valor<br>") ;
jwhile (next($ciudades));
}
function recorre_atras($ciudades) {
end($ciudades);
do {
$valor = current($ciudades);

echo ("El valor es: $valor<br>") ;
}while (prev($ciudades));
}
recorre(&$ciudades);
recorre_atras(&$ciudades);
?>

El navegador muestra:
El valor es: Badajoz
El valor es: Mérida
El valor es: Cáceres
El valor es: Plasencia
El valor es: Madrid
El valor es: Lisboa
El valor es: Paris
El valor es: Paris
El valor es: Lisboa
El valor es: Madrid
El valor es: Plasencia
El valor es: Cáceres
El valor es: Mérida
El valor es: Badajoz

Por último, para obtener el valor del índice puede utilizar la función key().
La función r e c o r r e () la puede actualizar de la siguiente forma:
function recorre($ciudades) {
if ( ! current($ciudades) ) {
reset($ciudades);
}
do {
$valor = current($ciudades);
$indice = key($ciudades);
echo ("$indice: valor: $valor<br>");
}while (next($ciudades));
}

Intercambio de valores
La función a r r a y _ f l i p () intercambia los valores de índices y datos, es
decir, los índices serán guardados como datos y los valores serán sus nuevos
índices.

<?php
function recorre ($numero) {
foreach ($numero as $indice => $valor) {
echo "$indice: $valor<br>" ,-
}
}

$numero = array("uno" => l,"dos" => 2, "tres" => 3,"cuatro" => 4);
echo ("Números<br> " ) ;
recorre($numero);
echo ("Números intercambiados<br>") ;
recorre(array_flíp{$numero));
?>
El resultado es el esperado:
Números
uno: 1
dos : 2
tres: 3
cuatro: 4
Números intercambiados
1: uno
2 : dos
3: tres
4: cuatro

Inversión del contenido
También es posible ordenar a la inversa una lista de datos. Esto se consigue
con la función a r r a y _ r e v e r s e () .

Si modifica el código anterior tendrá:
echo ("Números intercambiados<br>" ) ;
recorre(array^reverse($numero));
Dando como resultado:

Números
uno: 1
dos : 2
tres: 3
cuatro: 4
Números intercambiados
cuatro: 4
tres: 3
dos: 2
uno: 1

Mezcla de los valores
Si necesita alguna vez elegir un valor aleatorio de un array, la función shuf
f le () puede ser de gran ayuda, ya que mezcla todos los valores cada
vez que se ejecuta. Parte del código puede ser este:
echo ("Números mezclados<br> " ) ;
shuffle($numero);
recorre($numero);

Pilas
Las pilas son estructuras de datos que se utilizan mucho en el mundo de
la informática. La filosofía básica de las pilas es que todos los valores deben
introducirse en un orden específico y sólo podemos recuperar esos
valores en el orden inverso estricto al que fueron insertados.

Las pilas LIFO (Last ln First Out: el último en entrar es el primero en salir)
utilizan unas funciones específicas que permiten manejar todos los datos.
Array_push () permite insertar en la pila un dato y a r r a y _ p o p () extrae
un valor. Es necesario, antes que nada, definir la variable como array,
pues ninguna de las funciones descritas lo hace.

Array_push () y array_pop () toman como argumento la variable array
y los valores a introducir.
< ?php
$pila = array();
array_push($pila,"uno","dos","tres");

array_jpush($pila,"cuatro","cinco");
while ($valor = arrayjop($pila) ) {
echo "valor extraído es $valor<br>";
}
?>

El resultado por pantalla muestra que la extracción de los valores se hace
en orden inverso del que fueron introducidos:
valor extraído es cinco
valor extraído es cuatro
valor extraído es tres
valor extraído es dos
valor extraído es uno

Ordenación de los valores
Finalmente, PHP ofrece una gran variedad de funciones para ordenar
arrays. Las funciones pueden verse en la tabla siguiente:

Función Explicación

Puede ver actuar todas las funciones de ordenación en el ejemplo siguiente:
<?php
function recorre ($numero) {
foreach ($numero as $indice => $valor) {
echo "$indice: $valor<br>";

}
}

$pila =
array("cinco" = >5,"uno" = >l, "cuatro" = >4,"dos" = >2 , "tres" = >3) ;
echo "Array sin ordenar<br>" ;
recorre($pila);
echo "Ordenación asort()<br>" ;
asort($pila);
recorre($pila);
echo "Ordenación arsort{)<br>" ;
arsort($pila);
recorre($pila);
echo "Ordenación ksort()<br>";
ksort($pila);
recorre ($pila) ;
echo "Ordenación krsort()<br>";
krsort ($pila) ,-
recorre($pila);
echo "Ordenación sort()<br>";
sort($pila);
recorre($pila);
echo "Ordenación rsort()<br>";
rsort($pila);
recorre($pila);
?>

Resumen
En este capítulo ha conocido el tipo de variable estrella de PHP, el array.
Controlar los métodos y las funciones para extraer la información le dará
ventaja en los capítulos posteriores. Muchas funciones que tienen que ver
con el manejo de datos, como funciones de bases de datos, XML o generación
de plantillas, devuelven un array como respuesta.
El tipo array es el vehículo estándar para la recuperación de datos estructurados
como veremos en los próximos capítulos.