Conceptualmente un arreglo es una colección de elementos de un mismo tipo. Una variable de tipo arreglo contiene elementos de un mismo tipo, que pueden ser accedidos mediante un número entero, denominado índice. El valor 0 es el índice o localizador del primer elemento y n-1 es el índice del último elemento localizado en el Arreglo. Por lo tanto la dimensión, tamaño o longitud del arreglo está dada por el valor de n.
Un arreglo de enteros almacenará valores enteros, un arreglo de booleanos almacenará valores booleanos (true o false), un arreglo de strings almacenará valores string (cadena de caracteres), un arreglo de reales almacenará números reales, un arreglo de arreglos, donde cada elemento almacenará un nuevo arreglo.
Es decir, los elementos almacenados dentro de un Arreglo pueden ser de cualquier tipo, como los visto hasta el momento: string, entero, punto flotante, booleano y hasta otro Arreglo.
Por ejemplo podemos implementar un arreglo que almacena información de los n empleados de una empresa.
De esta manera $empleado[23] podría tomar como valor “Juan Pérez Suárez” (i.e: $empleado[23] = “Juan Pérez Suárez”). En este caso se trataría de un arreglo de cadenas de texto, es decir, un arreglo de string. En otro caso $empleado[23] podría contener el número de legajo del empleado dentro de la empresa, por ejemplo: $empleado[23] = 2312. En este caso se trataría de un arreglo de valores numéricos.
Según el lenguaje de programación, la implementación de las estructuras de datos es diferente. PHP cuenta con una gran variedad de tipos de datos que permiten representar la información según como esté estructurada. En esta unidad se estudian los arreglos existentes en PHP, que son tipos de datos utilizados cuando se quiere agrupar elementos.
PHP soporta tanto arrays escalares como asociativos. De hecho, no hay diferencias entre los dos. Se puede crear una array usando la funcion array(), o se puede asignar el valor de cada elemento del array de manera explícita. Además, como PHP es un lenguaje dinámico, sin declaración de tipos, en cada elemento del arreglo puede ser de un tipo distinto.
<?php
$a[ 0 ] = "abc" ;
$a[ 1 ] = "def" ;
$b[ "foo" ] = 13;
?>Dentro de un arreglo podemos almacenar información estructurada en otro arreglo. Por ejemplo, en la estructura que almacena la información correspondientes a los empleados de una empresa, podemos almacenar datos vinculados a cada empleado como el nombre, apellido, antiguedad, fecha nacimiento etc.
<?php
$emp1 = array("nombre" => "Juan",
"apellido" => "Suarez",
"antiguedad" => 3,
"fecha de Nacimiento" => "22/10/1979");
$emp2 = array("nombre" => "Pedro",
"apellido" => "Martinez",
"antiguedad" => 13,
"fecha de Nacimiento" => "22/10/1983");
$empleados = array();
$empleados[0] = $emp1;
$empleados[1] = $emp2;
?>Para recorrer un arreglo es posible utilizar las estructura de control Repetitivas vistas hasta el momento: for, while, do while. Si requerimos acceder a TODOS los elementos del arreglo desde el elemento 0 al elemento N-1, siendo N la cantidad de elementos de un arreglo, la estructura mas adecuada es el for, logrando un recorrido total. En cambio, si necesitamos recorrer el arreglo hasta encontrar un elemento con determinadas características, la estructura mas adecuada es el While, siendo la condición de corte la obtención del elemento buscado. En este último caso, el recorrido es un recorrido parcial. Para obtener la cantidad de elementos que se encuentran en un arreglo, se debe invocar a la función count().
Recorriendo un arreglo con una estructura de control for:
<?php
$arreglo = array(12, 24, 67, 34);
for ($i = 0; $i < count($arreglo); $i++) {
echo "Elemento de la posicion ". $i . "=" . $arreglo[$i] ."\n ";
}
?>Recorriendo un arreglo con una estructura de while:
<?php
// Mostrar los elementos del arreglo hasta encontrar un elemento mayor a 60
$arreglo = array(12, 24, 67, 34);
$i = 0;
while ($i < count($arreglo) && $arreglo[$i] <= 60) {
echo "Elemento de la posicion ". $i . "=" . $arreglo[$i] ."\n ";
$i = $i + 1;
}
?>Otra forma habitual de recorrer un array es utilizando la estructura de control repetitiva foreach() que nos permite acceder a cada elemento y clave del arreglo.
Recorriendo un arreglo con una estructura de control foreach:
<?php
$arreglo = array(12, 24, 67, 34);
foreach ($arreglo as $indice => $unElemento){
echo "Elemento de la posición". $indice . "=" . $unElemento . "\n ";
}
?>Recorriendo un arreglo asociativo con una estructura de control foreach:
<?php
$arreglo = array('a' => 4, 'b' => 8, 'c' => -1, 'd' => -9);
foreach ($arreglo as $indice => $unElemento){
echo "Elemento de la posición". $indice . "=" . $unElemento . "\n ";
}
?>Nos puede interesar que los elementos de un arreglo estén ordenados: una vez que finalizó la inscripción en un curso, tener a los padrones de los alumnos por orden de inscripción puede ser muy incómodo, siempre será preferible tenerlos ordenados por número para realizar cualquier comprobación.
Los arrays se pueden ordenar usando las funciones asort(), arsort(), ksort(), rsort(), sort(), uasort(), usort() y uksort() dependiendo del tipo de ordenación que se desee. A continuación vamos a ver alguna de ellas:
<?php
$frutas = array("l" => "limon",
"n" => "naranja",
"m" => "manzana",
"d" => "durazno");
sort($frutas);
foreach ($arreglo as $indice => $unaFruta){
echo $indice = $unafruta . "\n ";
}
?><?php
$frutas = array("l" => "limon",
"n" => "naranja",
"m" => "manzana",
"d" => "durazno");
rsort($frutas);
foreach ($arreglo as $indice => $unaFruta){
echo $indice = $unafruta . "\n ";
}
?><?php
$frutas = array("l" => "limon",
"n" => "naranja",
"m" => "manzana",
"d" => "durazno");
asort($frutas);
foreach ($arreglo as $indice => $unaFruta){
echo $indice = $unafruta . "\n ";
}
?><?php
$frutas = array("l" => "limon",
"n" => "naranja",
"m" => "manzana",
"d" => "durazno");
arsort($frutas);
foreach ($arreglo as $indice => $unaFruta){
echo $indice = $unafruta . "\n ";
}
?><?php
$frutas = array("l" => "limon",
"n" => "naranja",
"m" => "manzana",
"d" => "durazno");
ksort($frutas);
echo "Orden alfabético basado en las claves \n";
foreach ($arreglo as $indice => $unaFruta){
echo $indice = $unafruta . "\n ";
}
?><?php
// Función de comparación
function comparar($a, $b) {
if ($a == $b) {
$resultado = 0;
}
else {
$resultado = ($a < $b) ? -1 : 1;
}
return $resultado;
}
$miArray = array( "a" => 4,
"b" => 8,
"c" => -1,
"d" => -9);
uasort($miArray, 'comparar');
echo "Ordenado según función de comparación \n";
foreach ($arreglo as $indice => $unaFruta){
echo $indice = $unafruta . "\n ";
}
?>A partir de una cadena de caracteres, podemos obtener un arreglo con sus componentes usando la función explode.
Por ejemplo, si queremos obtener las palabras (separadas entre sí por espacios) que componen la cadena \(c escribiremos simplemente explode(" ",\)c):
<?php
$c = "Una cadena con espacios";
$arrPalabra = explode(" ",$c);
?>De manera inversa, para obtener los elementos de un arreglo en una cadena de caracteres, es posible utilizar la función implode. La función retorna la cadena que resulta de unir todas las componentes separadas entre sí por medio del separador que es indicado como parámetro de la función
<?php
$arreglo = array("apellido", "email", "telefono");
$cadenaSeparadaPorComas = implode(",",$arreglo);
echo $cadenaSeparadaPorComas; // "apellido,email,telefono"
?>PHP nos provee varias estructuras que nos permiten agrupar diferentes tipos datos. En particular, los arreglos son estructuras mutables que permiten agrupar valores, con la posibilidad de agregar, quitar o reemplazar sus elementos.
Los arreglos se utilizan en situaciones en las que los elementos a agrupar pueden ir variando a lo largo del tiempo. Por ejemplo, para representar las notas de un alumno en diversas materias, los inscriptos para un evento o la clasificación de los equipos en una competencia
Un estudio de cine quiere sistematizar su trabajo para llevar un registro de películas para analizarlas y consultar su información. De cada película al estudio de cine le interesa:
Defina una función que retorne la siguiente colección de peliculas con los atributos: nombre, año, duración y recaudación:
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| nombre | TITANIC | AVENGERS ENDGAME | STAR WARS EPISODIO VII | AVATAR | JURASSIC WORLD |
| anio | 1997 | 2019 | 2015 | 2009 | 2014 |
| duracion | 120 | 125 | 110 | 135 | 95 |
| recaudacion | 2010.60 | 2597.8 | 3660 | 3975.2 | 2407.7 |
<?php
/**
* funcion sin parametros que retorna un estructura de datos de peliculas
* @return ARRAY
*/
function coleccionPeliculas(){
//ARRAY $arreglo
$arreglo = [];
$arreglo[0] = ["nombre" => "TITANIC", "anio" => 1997, "duracion" => 120, "recaudacion" => 2010.60];
$arreglo[1] = ["nombre" => "ADVENGERS ENDGAME", "anio" => 2019, "duracion" => 125, "recaudacion" => 2597.8];
$arreglo[2] = ["nombre" => "STAR WARS EPISODIO VII", "anio" => 2015, "duracion" => 110, "recaudacion" => 3660];
$arreglo[3] = ["nombre" => "AVATAR", "anio" => 2009, "duracion" => 135, "recaudacion" => 3975.2];
$arreglo[4] = ["nombre" => "JURASSIC WORLD", "anio" => 2014, "duracion" => 95, "recaudacion" => 2407.7];
return $arreglo;
}
?>Defina una función cuyo parámetro de entrada sea un arreglo asociativo con la información de una película y muestre los datos en pantalla. Por ejemplo si la entrada es el arreglo asociativo que contiene nombre :“RAPIDO Y FURIOSO 7”, anio: “2015”, duración: 145, recaudación: 1516.04 deberá visualizar en pantalla lo siguiente:
| Película: |
|---|
| Película: RAPIDO Y FURIOSO 7 |
| Estreno: 2015 |
| Duración: 145 min |
| Recaudación: 1516.04 |
| Antigüedad: 9 años |
Observación: Considere que la Antigüedad se obtiene como el año actual 2024 menos el año de estreno
<?php
/**
* funcion cuyo paremtro de entrada es un arreglo asociativo peliculas y muestra los datos en la pantalla
* @param ARRAY $arregloPeliculas
*/
function mostrarPelicula($arregloPeliculas){
echo " Pelicula: \n";
echo " Pelicula: " . $arregloPeliculas["nombre"] . "\n";
echo " Estreno: " . $arregloPeliculas["anio"] . "\n";
echo " Duracion: " . $arregloPeliculas["duracion"] . " min\n";
echo " Recaudacion: " . $arregloPeliculas["recaudacion"] . " md**\n";
echo " Antiguedad: " . (2024 - $arregloPeliculas["anio"]) . " anios\n";
}
?>Defina una función cuyo parámetro de entrada sea una colección de películas y retorne la duración promedio de todas las peliculas. Responda: ¿Qué tipo de recorrido debe implementar: exhaustivo o parcial? ¿Cuál/es es/son la/s estructura/s de control necesarias para implementar el recorrido?
<?php
/** 3)
* funcion cuyo paremtro de entrada es un arreglo de coleccion de peliculas y retorna el promedio de recaudacion
* @param ARRAY $arrayPeliculas
* @return FLOAT
*/
function promedioRecaudacion($arrayPeliculas){
//INT $i, $acum, $cantPeliculas
//FLOAT $calculoPromedio
//inicializo variable acumuladora
$acum = 0;
$cantPeliculas = count($arrayPeliculas);
//acumula toda la recaudacion
for($i = 0; $i < count($arrayPeliculas); $i++){
$acum = $acum + $arrayPeliculas[$i]["recaudacion"];
}
//calculo del promedio
$calculoPromedio = ($acum / $cantPeliculas);
return $calculoPromedio;
}
?>Defina una función que, a partir de una colección de películas como parámetro de entrada, retorne el índice de la película con la mayor recaudación. Si dos películas tienen la máxima recaudación, la mayor será la primera película.
<?php
/**
* funcion cuyo paremtro de entrada es un arreglo de coleccion de peliculas y
* retorna el indice de la pelicula de mayor duracion
* @param ARRAY $datosPeliculas
* @return INT
*/
function indiceMayorDuracion($datosPeliculas){
//INT $u, $mayor, $indice
//inicializacion de etique
$mayor = -1000;
//realiza un recorrdio Exhaustivo para verificar todas las duraciones e indicar cual es el primero
for($u = 0; $u < count($datosPeliculas); $u++){
if($datosPeliculas[$u]["duracion"] > $mayor){
$mayor = $datosPeliculas[$u]["duracion"];
$indice = $u;
}
}
return $indice;
}
?>Defina una función cuyos parámetros de entrada sean: una colección de películas y un año, y retorne una nueva colección de películas cuyo año de estreno sean superior al año ingresado como parámetro. Si ninguna película fue estrenada luego de ese año, la función devolverá un arreglo vacío.
<?php
/**
* funcion cuyo paremtros de entrada es un arreglo de coleccion de peliculas y una recaudacion.
* Retorna una nueva coleccion de peliculas, cuyas pelis son menores a dicho valor de recaudacion
* sino devolvera un arreglo vacio
* @param ARRAY $colectionPeliculas
* @param INT $recaudacionUnaPelicula
* @return ARRAY
*/
function nuevoArregloPeliculas($colectionPeliculas, $recaudacionUnaPelicula){
//ARRAY $nuevaColeccionPeliculas
//INT $y, $e
//inicializacion de array y contador
$nuevaColeccionPeliculas = [];
$e = 0;
//Asigna valores al nuevo arreglo
for($y = 0; $y < count($colectionPeliculas); $y++){
if($colectionPeliculas[$y]["recaudacion"] < $recaudacionUnaPelicula){
$nuevaColeccionPeliculas[$e]["nombre"] = $colectionPeliculas[$y]["nombre"];
$nuevaColeccionPeliculas[$e]["anio"] = $colectionPeliculas[$y]["anio"];
$nuevaColeccionPeliculas[$e]["duracion"] = $colectionPeliculas[$y]["duracion"];
$nuevaColeccionPeliculas[$e]["recaudacion"] = $colectionPeliculas[$y]["recaudacion"];
$e++;
}
}
return $nuevaColeccionPeliculas;
}
?>Programe una función que solicite los datos de una película a un usuario, agregue n-película a la colección de películas y retorne la colección modificada. Debe asegurarse que el nombre de la película sea agregada a la colección en letras mayúsculas.
<?php
/**
* funcion que solicita los datos de una pelicula a un usuario, agregue la pelicula a la coleccion
* de peliculas y retorna la coleccion modifica.
* @param ARRAY $arrayPeliculas
* @param INT $cantPeliculasAgregar
* @return ARRAY
*/
function agregarPeliculaColeccion($arrayPeliculas, $cantPeliculasAgregar){
//ARRAY $arregloPeliculasNueva
//INT $j, $indiceNuevoArrayPeliculas
$arregloPeliculasNueva = [];
// Recorrido PARA las N peliculas solicitadas a agregar
for($j = 0; $j < $cantPeliculasAgregar; $j++){
// Interaccion del programa al usuario sobre agregar nueva pelicula
echo "\n Ingrese nombre de la Pelicula: ";
$arregloPeliculasNueva["nombre"] = strtoupper(trim(fgets(STDIN)));
echo "Ingrese anio de la Pelicula: ";
$arregloPeliculasNueva["anio"] = trim(fgets(STDIN));
echo "Ingrese duracion de la Pelicula: ";
$arregloPeliculasNueva["duracion"] = trim(fgets(STDIN));
echo "Ingrese recaudacion de la Pelicula: ";
$arregloPeliculasNueva["recaudacion"] = trim(fgets(STDIN));
// Se asigna el valor total de elementos del array de coleccion de pelis a esta etiqueta
$indiceNuevoArrayPeliculas = count($arrayPeliculas);
// La/s nueva/s pelicula/s se agrega/n a la Coleccion de Peliculas
$arrayPeliculas[$indiceNuevoArrayPeliculas] = $arregloPeliculasNueva;
}
// Retorna el nuevo array modificado de nueva/s pelicula/s
return $arrayPeliculas;
}
?>Observación: Se utiliza la funcion predefinida de php: strtoupper() para pasar a mayúscula un string.
Programe un programa principal que ejecute las siguientes acciones. NO implemente un menú opciones, sólo se respete el orden de ejecución siguiente:
<?php
//PRINCIPAL
//ARRAY $cargarColecionPeliculas, $nuevoArrayPelis, $cantidadPeliculasMenores
//INT $numPeliculas, $indiceMayorDuracion
//FLOAT $promedio
//7.1) Cargar coleccion de Peliculas Precargada // RTEVISAR!!!!
$cargarColecionPeliculas = coleccionPeliculas();
//7.2) Solicitar al usuario: cantidad de peliculas que desea agregar a la coleccion de peliculas.
echo "Ingrese cantidad de peliculas que desea agregar: ";
$numPeliculas = trim(fgets(STDIN));
// Si la cantidad de peliculas para agregar son mayores a 0, entonces llama la funcion para que el programa interactue con el usuario asi obteniendo el nuevo arreglo modificado de peliculas nuevas. Caso contrario se mostrara solamente el arreglo de peliculas que estaba ya precargado antes.
if($numPeliculas > 0){
// Se asigna una etiqueta a la funcion agregarPeliculaColeccion(...) para poder ser utilizable.
$nuevoArrayPelis = agregarPeliculaColeccion($cargarColecionPeliculas, $numPeliculas);
// Se asigna una etiqueta a la coleccion de peliculas precargada al nuevo arreglo modificado con las peliculas aregadas. Esto permite que pueda guardar las nuevas peliculas al arreglo precargado.
$cargarColecionPeliculas = $nuevoArrayPelis;
}
//7.3) Mostrar en pantalla los datos de la pelicula de mayor duracion
$indiceMayorDuracion = indiceMayorDuracion($cargarColecionPeliculas);
echo "La Pelicula con mayor duracion es: \n";
mostrarPelicula($cargarColecionPeliculas[$indiceMayorDuracion]);
//7.4) Mostrar en pantalla cual es el promedio de recaudacion
$promedio = promedioRecaudacion($cargarColecionPeliculas);
echo "En promedio la recaudacion fue: " . $promedio . "\n";
//7.5) Mostrar en pantalla la cantidad de peliculas cuya recaudacion sea menor al promedio calculado en el
// inciso anterior
$cantidadPeliculasMenores = nuevoArregloPeliculas($cargarColecionPeliculas, $promedio);
echo "La cantidad de Peliculas cuya recaudacion es menor al promedio es: " . count($cantidadPeliculasMenores) . "\n";
//7.6) Mostrar en pantalla la cantidad total de peliculas
echo "La cantidad de Peliculas que administra la empresa es: " . count($cargarColecionPeliculas) . "\n";
?>$Arreglo : Los arreglos son estructuras que nos permiten
manipular una colección de datos de un mismo tipo. Los arreglos se
acceden a partir de indices numéricos o asociativos
Casos particulares:
$arreglo = [] arreglo vacio
$arreglo[1] = $elemento significa que
$elemento es el valor asignado a la posición 1 del
arreglo
$arreglo[$i] = $elemento significa que
$elemento es el valor asignado a la posición
$i del arreglo
$arreglo[“nombre”] = “Andrea” Arreglo asociativo cuya clave nombre tiene el valor Andrea
count(): Función que retorna la cantidad de elementos de un arreglo.
asort(), arsort(), ksort(), rsort(), sort(), uasort(), usort(), y uksort(): Funciones que permiten ordenar los elementos de un arreglo ya sea a partir de sus elemento, sus claves o funciones implementadas por los programadores.