ESTRUCTURAS DE ITERACIÓN

Y ARREGLOS EN PHP

permiten controlar cómo el código

fluye en un script
 ESTRUCTURA ITERATIVAS - WHILE

• Se ejecutan las sentencias dentro del while <?php

siempre y cuando se evalúen como true. El
valor de la expresión se comprueba cada $i = 1;
vez al inicio del bucle, Si la expresión while while($i <= 10){
se evalúa como false, las sentencias no se
ejecutarán ni siquiera una vez. echo $i;
$i++;
• También es posible agrupar varias }
instrucciones while dentro de una.
 ESTRUCTURA ITERATIVAS – DO WHILE

• Muy similares a los bucles while, <?php

simplemente aquí la expresión para el
$i = 0;
bucle se verifica al final en lugar de al
principio, esto garantiza que el código se do {
ejecute por lo menos la primera vez.
echo $i;
} while ($i > 0);
 ESTRUCTURA ITERATIVAS – FOR
• Los bucles for son los más complejos • La primera expresión, $i = 1, se ejecuta una
en PHP.
vez incondicionalmente al comienzo del
<?php
bucle.
for ($i = 1; $i <= 10; $i++) {
• La segunda expresión, $i <= 10, es una
echo $i; condición, si es true, se ejecutará la tercera
} // Devuelve 123456789 expresión.
• La tercera expresión, $i++, es la acción a
• Las expresiones o conjunto de
expresiones van separadas por punto y realizar si se cumple la segunda expresión.
coma ; y sólo hay 3.
 ESTRUCTURA ITERATIVAS – FOR
• Todos los siguientes ejemplos son válidos y devuelven // EJEMPLO 3
lo mismo, 123456789 $i = 1;
For ( ; ; ){
// EJEMPLO 1 // EJEMPLO 2 if ($i > 10){
for($i = 1; $i <= 10; $i++) { for ($i = 1; ; $i++){ break;
echo $i; if($i > 10) { }
} break; echo $i;
} $i++;
echo $i; }
}
// EJEMPLO 4
Dependiendo de donde se coloque el operador for ($i = 1, $j = 0;
incremento o decremento, dará un resultado distinto: $i <= 10; $j += $i,
for ($i = 1; $i <= 10; print $i++); // 12345678910 print $i, $i++);
for ($i = 1; $i <= 10; print ++$i); // 234567891011
 ALMACENAMIENTO MULTIPLE – ARREGLOS
• No se requiere declarar el largo

<?php

$frutas = array( “naranja”, “manzana”, “durazno” );

$frutas[3] = “pera”;
$frutas[] = “melón”; // tomará automáticamente la pos. 4

$frutas[23] = “papaya”;

Lo que tenemos es:

 ARREGLOS ASOCIATIVOS
• En vez de usar números, usamos strings

$lista = array(
‘fruta’ => ‘manzana’,
‘verdura’ => ‘lechuga’, ‘numero’ => 4,
1 => ‘algo’,
);
$lista[‘cereal’] = ‘maiz’;

Lo que tenemos es:

 ARREGLOS ASOCIATIVOS
• EJEMPLO

$lista = array(
‘fruta’ => ‘manzana’, ‘verdura’ => ‘lechuga’,
);

print( ‘una fruta es ‘.$lista[‘fruta’] ); print( ‘una verdura es ‘.$lista[‘verdura’] );

SALIDA

una fruta es manzana una verdure es lechuga

 ALMACENAMIENTO MULTIPLE – ARREGLOS
• Un array puede crearse de dos formas:

• Mediante el constructor del lenguaje array(): • Mediante corchetes []:

$miArray = array( $miArray = [

'key' => 'value', 'key' => 'value',
'key2' => 'value2', 'key2' => 'value2',
'key3' => 'key3'
'key3' => 'value3'
//...
// ...
];
);

• La coma después del último elemento del array es opcional.

• La key puede ser un integer o un string.

• El value puede ser de cualquier tipo.

 ALMACENAMIENTO MULTIPLE – ARREGLOS
Consideraciones respecto a las keys de un array:

• Un string que contenga un integer válido se amoldará a tipo integer. Ejemplo: "8" se guardará como
integer 8 (no ocurre lo mismo con "08").

• Un float también se amoldará a un integer, la parte fraccionaria se elimina. Ejemplo: 8,7 se guardará
como 8.

• Los booleanos se amoldan a integers también, true se almacena como 1 y false como 0.

• Un null se amoldará a un string vacío, "".

• Los arrays y objetos no pueden utilizarse como keys.

• Si varios elementos usan el mismo key, se devolverá el último, los demás serán sobreescritos.
 ALMACENAMIENTO MULTIPLE – ARREGLOS

• Especificar la key es opcional, si no se hace

$animales = [
se añade automáticamente como key un
1 => "Perro", // 1 integer incremental:
"1" => "Gato", // 1, sobreescribe al anterior
1.6 => "Avestruz", // 1, sobreescribe al anterior $miArray = [
true => "Rinoceronte" // 1, sobreescribe al anterior "a",
]; "b",
5 => "c",
"d"
// El único valor del array será [1] => "Rinoceronte“
];
// El key integer será último key numérico + 1
array (size=4)
0 => string 'a' (length=1)
1 => string 'b' (length=1)
5 => string 'c' (length=1)
6 => string 'd' (length=1)
 ACCESO Y MODIFICACIÓN DE ELEMENTOS DE
UN ARRAY
• Se puede acceder a los elementos de un array con la • También es posible hacer referencia al
sintaxis de llaves array{key} o de corchetes array resultado de una función:
array[key]:
function misAnimales()
{
$planetas = [
return array("perro", "gato",
1 => "Marte",
"avestruz");
"Otro" => "Júpiter", };
"4" => "Saturno", $miPerro = misAnimales()[0];
"Otromas" => "Plutón" echo $miPerro; // Devuelve perro
];
• Si se intenta acceder a una key de un array
echo $planetas[1] . PHP_EOL; // Devuelve Marte que no se ha definido ocurrirá lo mismo
echo $planetas{"Otro"} . PHP_EOL; // Devuelve Júpiter que al intentar acceder a una variable sin
definir: el resultado será null y se emitirá
un mensaje de error E_NOTICE.
 CREAR ELEMENTOS EN UN ARRAY

• Para crear los elementos de un array se utilizan // Crear elementos de un array:

también los corchetes de la misma forma.
$animales["rinoceronte"] = "Brutus";
• Si no se incluye nada en los corchetes la key será un // Se crea el key rinoceronte con el nombre
Brutus
integer incremental automático, igual que cuando se
crean arrays y no se indica el key:
$animales[] = "Bob";
// Se crea directamente el nombre de la
$animales = [ mascota, con key numérica 0r
"perro" => "Bobby",
"gato" => "Puskas",
"avestruz" => "Charles"
];
 MODIFICAR ELEMENTOS EN UN ARRAY

• Para modificar elementos de un array se hace lo mismo, salvo que en los corchetes se incluye el
elemento que se quiere modificar, sea numérico o asociativo:

• $animales["perro"] = "Casanova"; // Se modifica el nombre del perro a Casanova

• $animales[0] = "Browneyes"; // Se modifica el valor Bob del key 0 por Browneyes

• Si el array al que se quiere añadir o modificar un elemento no existe, se crea, por lo que ésta también
es una forma de crear un array, pero no es aconsejable. Siempre es mejor iniciar variables mediante
asignación directa.
 ELIMINAR ELEMENTOS EN UN ARRAY

• Para eliminar elementos de un array se emplea unset():

unset($animales["perro"]) // Elimina el elemento de key perro

unset($animales); // Elimina el array entero

• Con unset() el array no se reindexa. Los keys numéricos en el array guardan el último key que ha estado
presente en el array, aunque se haya eliminado con unset() y luego se cree de nuevo. A los nuevos
valores que se inserten sin key, se les asignará el número de ese último key anterior al unset:
 ELIMINAR ELEMENTOS EN UN ARRAY
// Crear un array simple.
$miArray = array(1, 2, 3, 4, 5);
print_r($miArray);
// Devuelve: Array (
[0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )
// Ahora elimina cada elemento,
// pero deja el mismo array intacto:
foreach ($miArray as $i => $value) {
unset($miArray[$i]);
} print_r($miArray);
print_r($miArray); // Devuelve: Array ( )
// Agregar un elemento (nótese que la nueva clave es 5,
en lugar de 0).
$miArray[] = 6;
print_r($miArray); // Devuelve: Array ( [5] => 6 )
// Para evitar esto se puede emplear array_values
// La función array_values modifica este
// comportamiento y resetea los keys:
$miArray = array_values($miArray);
$miArray[] = 7;
// Devuelve: Array ( [0] => 6 [1] => 7 )
 ARRAYS MULTIDIMENSIONALES

• Son arrays que contienen uno o más arrays. Sirven para guardar valores con más de un key. PHP
interpreta arrays multidimensionales de cualquier nivel de profundidad, pero más de tres niveles es
considerado poco práctico y complejo de entender.

• Para acceder a un valor de un array de segundo nivel, se necesita emplear dos veces los corchetes, para
acceder a un valor de un array de tercer nivel, tres corchetes, y así sucesivamente.

Ejemplo con dos niveles:

// El array guarda datos de Animal, Nombre y Edad
$animales = array echo "El animal es un " . $animales[0][0] . " tiene " .
( $animales[0][2] . " años y se llama " . $animales[0][1];
array("perro","Peanut",7),
array("gato","Prince",13), // El animal es un perro tiene 7 años y se llama Peanut
array("avestruz","Schmoopie",4),
);
 ARRAYS MULTIDIMENSIONALES
Ejemplo con tres niveles:

$animales = array
(
array("perro", array("Sparky")),
array("gato", "Soldier", 13),
array("avestruz", "Spunky", 4),
);
echo "El animal es un " . $animales[0][0] . " y se llama " . $animales[0][1][0];

// El animal es un perro y se llama Sparky

 REFERENCIAS EN ARRAYS
• Es posible pasar los valores de un array por referencia, de esta forma se pueden modificar todos los
valores de un array de vez mediante un bucle:

$animales = array('perro', 'gato', 'liebre', 'jabalí');

foreach ($animales as &$animal)

{
$animal = mb_strtoupper($animal);
}
unset($animal);
var_dump($animales);

• Se hace unset($animal) para asegurar que las escrituras subsiguientes a $animal no modifiquen el
último elemento del array, ya que hemos empleado foreach.
 COMPARACIÓN DE ARRAYS
• La comparación de arrays, como en los strings, se puede realizar con los símbolos de igual (==) o
idéntico (===).
$a = array('a'=>1, 'b'=>2, 'c'=>3);
$b = array('a'=>1, 'b'=>2, 'c'=>3);
$c = array('a'=>1, 'b'=>2);
$d = array('a'=>1, 'b'=>100, 'c'=>3);
$e = array('a'=>1, 'c'=>3, 'b'=>2);
echo '$a == $b es ', var_dump($a == $b);
echo '$a === $b es ', var_dump($a === $b);
echo '$a == $c es ', var_dump($a ==$c);
echo '$a === $c es ', var_dump($a === $c);
echo '$a == $d es ', var_dump($a ==$d);
echo '$a === $d es ', var_dump($a === $d);
echo '$a == $e es', var_dump($a ==$e);
echo '$a === $e es', var_dump($a === $e);
// Array de referencia
// Igual e idéntica
// Un elemento menos
// Un elemento tiene un valor diferente
// Mismos key=>value pero en diferente orden
// $a == $b es boolean true
// $a === $b es boolean true
// $a == $c es boolean false
// $a === $c es boolean false
// $a == $d es boolean false
// $a === $d es boolean false
// $a == $e es boolean true
// $a === $e es boolean false
 ESTRUCTURA DE CONTROL – FOR CON ARRAY
• Se pueden hacer iteraciones por medio de
arrays:
var_dump($gente);
$gente = array( /*
array('nombre' => 'Carlos', ‘clave' => 123), * array (size=2)
array('nombre' => 'Maria', ‘clave' => 124)); 0 =>
// Numero de gente array (size=2)
$size = count($gente); 'nombre' => string 'Carlos' (length=6)
// Bucle que da una “clave” de 4 dígitos aleatorio ‘clave' => int 2029
for ($i=0; $i < $size; ++$i) { 1 =>
$gente[$i][‘clave'] = mt_rand(0000, 9999); array (size=2)
} 'nombre' => string 'Maria' (length=5)
‘clave' => int 9724
*/
 ESTRUCTURA DE CONTROL – FOR CON ARRAY
• Permite una forma fácil de iterar sobre arrays u
objetos.
• Cuando foreach inicia su ejecución, el puntero
apunta directamente al primer elemento del array,
por lo que no es necesario llamar a la función
reset() antes que un bucle foreach. Es
recomendable no cambiar el puntero dentro del
bucle.
Se puede iterar de las siguientes dos formas:
<?php
// Devuelve directamente el value de
cada key, comenzando desde el primero
foreach ($array as $value) {
// Lo que se desee mostrar
}
// Devuelve cada key con cada value, para
poder trabajar con cualquiera de los dos
foreach ($array as $key => $value){
// Lo que se desee mostrar
}
 ESTRUCTURA DE CONTROL – FOR CON ARRAY

• Se pueden modificar los elementos del array dentro • La función unset() elimina la referencia
del bucle, anteponiendo & a $value (asignándolo del último elemento, pero el array sigue
por referencia). valiendo 2, 4, 6, 8.

<?php • Es recomendable hacer unset() porque

la referencia del $valor y el último
$array = array(1, 2, 3, 4);
elemento del array permanecen aún
foreach ($array as &$value){ después del bucle foreach.

$value = $value * 2;
}
// cada valor del array vale ahora : 2, 4, 6, 8
unset($value);
 ESTRUCTURA DE CONTROL - FOREACH Y LIST

• foreach y list pueden devolver los mismos • La función list() coge un array y lo
resultados de la siguiente forma: convierte en variables individuales.

• each() coge un array y devuelve claves y

<?php valores actuales, es decir, donde está
// list apuntando el cursor en el array. Es
$array = array("uno", "dos", "tres"); necesario hacer un reset() del array para
reset($array); asegurarse que el cursor comienza
while (list($clave, $valor) = each($array)){ desde el principio (cosa que no es
echo "Clave: $clave; Valor: $valor </br>"; necesaria con el foreach).
}
// foreach • Suele ser más óptimo y legible utilizar el
foreach ($array as $clave => $valor){
foreach para iterar, aunque ambos se
utilizan más o menos con la misma
echo "Clave: $clave; Valor: $valor </br>";
frecuencia.
}