Curso php5

Formación
Introducción a PHP5
Kinética Mobile Development

Kinética Mobile Development Curso de PHP5.
Francisco José González Lozano

Kinética Mobile Development
Página 1 de 164
Página 2 de 164
ÍNDICE
Sesión 1. Sitios Web estáticos. ................................................................................... 5

Sesión 2. Primeros pasos. ......................................................................................... 10
Sesión 3. Características básicas.............................................................................. 13
Sesión 4. Decisión y repetición.................................................................................. 24
Sesión 5. Arrays (I). ................................................................................................... 29
Sesión 6. Arrays (II). .................................................................................................. 33
Sesión 7. Funciones (I). ............................................................................................. 41
Sesión 8. Funciones (II). ............................................................................................ 45
Sesión 9. Formularios. ............................................................................................... 48
Sesión 10. Incluyendo ficheros. ................................................................................. 53
Sesión 11. Bases de datos. ....................................................................................... 56
Sesión 12. Fecha y Hora. .......................................................................................... 66
Sesión 13. Subiendo ficheros. ................................................................................... 70
Sesión 14. Sesiones. ................................................................................................. 72
Sesión 15. Orientación a Objetos (I). Introducción. ................................................... 79
Sesión 16. Orientación a Objetos (II). Clases y Objetos. .......................................... 83
Sesión 17. Orientación a Objetos (III). Herencia. ...................................................... 91
Sesión 18. Orientación a Objetos (IV). Interfaces. .................................................... 99
Sesión 19. Introducción al Lenguaje de Modelado Unificado (UML) I..................... 104
Sesión 20. Introducción al Lenguaje de Modelado Unificado(UML)(II). .................. 116
ANEXO. ................................................................................................................... 124

TALLER 1. Primer contacto con PHP. ........................................................................................... 124
TALLER 2. Primera página dinámica. ............................................................................................ 127
TALLER 3. Uso de Arrays. ............................................................................................................. 130
TALLER 4. Uso de funciones. ........................................................................................................ 132
TALLER 5. Acceso a base de datos. ............................................................................................. 134
TALLER 6. Modificando información de base de datos. ................................................................ 136
TALLER 7. Subiendo ficheros. ....................................................................................................... 140
TALLER 8. Proyecto Orientado a Objetos com UML y PHP.......................................................... 142
Referencias.............................................................................................................. 150
Página 3 de 164
Página 4 de 164
Sesión 1. Sitios Web estáticos.

- Objetivo. Trabajar con sitios web estáticos para conocer sus ventajas e inconvenientes.
- Actividades:
o Crear un sitio web en el sistema local.
 Escribimos una página de bienvenida.
ARCHIVO index.html
<html>
<head>
<title>Mis Contactos</title>
<meta name=”AUTHOR” content=”PAKO”>
</head>
<body>
<H>Hola</H>
<br/>
<p>
Bienvenido/a a su página de contactos.
</p>
<p>
<a href=”contactos.html”>Entrar</a>
</p>
</body>
</html>
 Creamos una página índice con 2 nombres de contactos.
ARCHIVO contactos.html
<html>
<head>
</head>
<body>
<H> Mis Contactos</H>
<br/>
<p>
<a href=”JAniston.html”>Jennifer Aniston</a>
<br/>
<a href=”MEsparcia.html”>Manolo Esparcia</a>
<br/>
<br/>
</p>
<p>
Total: 2 contactos.
</p>
</body>
</html>
 Y dos páginas con la información de cada contacto.
ARCHIVO JAniston.html
<html>
<head>
</head>
<body>
<br/>
<p>
Nombre: Jennifer
<br/>
Apellidos: Aniston
<br/>
Página 5 de 164
Teléfono: 924 007 001

<br/>
Correo: janiston@edu.juntaex.es
<br/>
Lugar de Trabajo: Secretaría General
<br/>
Imagen:
<br>
<img src=”janiston.jpg”>
</p>
<p>
<a href="contactos.html">Volver</a>
</p>
</body>
</html>
ARCHIVO MEsparcia.html
<html>
<head>
</head>
<body>
<br/>
<p>
Nombre: Manuel
<br/>
Apellidos: Esparcia Montoya
<br/>
Teléfono: 924 007 557
<br/>
Correo: mesparcia@edu.juntaex.es
<br/>
<br/>
Imagen:
<br>
<img src=”mesparcia.jpg”>
</p>
<p>
</p>
</body>
</html>
 Comprobamos en el navegador.
Hacemos doble clic en el fichero index.html o escribimos la ruta en el navegador.
Página 6 de 164
o Preparar el contexto.
 Concepto de cliente/servidor. Proceso de consulta web, servidor web y

navegador cliente.
1. Escribimos http://si_cursophp/index.html en la barra de direcciones de

nuestro navegador.
2. Nuestro navegador envía un mensaje via Internet al sistema llamado

si_curso.php solicitando la página /index.html.
3. Nuestro servidor Apache, que se está ejecutando en la máquina

si_cursophp, obtiene el mensaje y lee el fichero catalogo.html desde el
disco duro.
4. Apache envía el contenido del fichero de vuelta a nuestro ordenador a

través de internet como respuesta a la solicitud de nuestro navegador.
5. El navegador muestra la página en la pantalla, siguiento las instrucciones

de las etiquetas HTML de la página recibida, de forma similar a cuando
hicimos doble click en el fichero que hemos creado en nuestro ordenador.
Cada vez que escribamos en el navegador http://si_cursophp/index.html, el

servidor devolverá el mismo contenido del fichero index.html. La unica forma
de que ese contenido cambie es modificándolo en el servidor o
sobreescribiendo el fichero con uno modificado.
o Creación y Mantenimiento del sitio web.
Subimos ficheros a nuestro servidor web.
Con una herramienta ftp subimos nuestros ficheros a un servidor web para comprobar
cómo se desarrolla el trabajo normal al crear y mantener un sitio web.
Nota: en nuestro caso a un servidor conectado a nuestra red local para hacer
comprobaciones. También es posible crear un servidor local pero no permite comprender
claramente el concepto cliente-servidor.
Añadimos dos contactos.
ARCHIVO contactos.html
<html>
<head>
</head>
Página 7 de 164
<body>
<br/>
<p>
<a ref=”JAniston.html”>Jennifer Aniston</a>
<br/>
<a ref=”MEsparcia.html”>Manolo Esparcia</a>
<br/>
<a ref=”BDoblador.html”>Bender Doblador</a>
<br/>
<a ref=”FSmith.html”>Fry Smith</a>
<br/>
<br/>
</p>
<p>
Total: 4 contactos.
</p>
</body>
</html>
ARCHIVO BDoblador.html
<html>
<head>
</head>
<body>
<br/>
<p>
Nombre: Bender
<br/>
Apellidos: Doblador
<br/>
Teléfono: 924 007 002
<br/>
Correo: bdoblador@edu.juntaex.es
<br/>
<br/>
Imagen:
<br>
<img src=”bdoblador.jpg”>
</p>
<p>
</p>
</body>
</html>
ARCHIVO FSmith.html
<html>
<head>
</head>
<body>
<br/>
<p>
Nombre: Fry
<br/>
Apellidos: Smith
<br/>
Teléfono: 924 007 003
<br/>
Correo: fsmith@edu.juntaex.es
<br/>
<br/>
Imagen:
<br>
<img src=”fsmith.jpg”>
</p>
<p>
Página 8 de 164
</p>
</body>
</html>
Eliminamos un contacto.
Debemos no solo eliminar los ficheros que muestren información del contacto sino
también modificar el listado de contactos, eliminando las lineas correspondientes.
Modificamos un contacto.
Modificamos la información de un contacto bajándonos el fichero, cambiando sus

datos y subiéndolo de nuevo al servidor.
Modificamos el aspecto del sitio.
Si queremos hacer algún cambio en el aspecto visual de nuestro sitio web, hay que
tener en cuenta que cada cambio tenemos que realizarlo en cada página.
Hay alternativas como las hojas de estilo en cascada (CSS), pero hay situaciones en
las que la apariencia se refiere a cómo se muestra la información, (como tablas, listas
etc.) y las CSS no evitan que cada cambio conlleve una gran cantidad de trabajo.
o Evaluar ventajas e inconvenientes.
 ¿Mantenimiento?
 ¿Trabajo?
 ¿Posibilidad de errores?
 ¿Actualización engorrosa?¿Ver contactos por lugar de trabajo?¿Agrupar
contactos?¿Hacer búsquedas?
 ¿Mantenimiento de un aspecto uniforme?
 ¿Necesidades de acceso?
 ¿Posibilidades de la web dinámica?
- Evaluación:
 Contenido html exclusivamente.
 El contenido no cambia.
 Tenemos tantas páginas web como contactos más el índice.
 La interacción con el usuario se limita a mostrar las páginas web
según se navega por el sitio.
 Para añadir un contacto tenemos que crear una nueva página y
subirla al servidor.
 Para eliminar un contacto debemos acceder al servidor y eliminar el
archivo que contiene la información del contacto.
 Para modificar la información de algún contacto, obtenemos la página
del contacto, la modificamos y la devolvemos al servidor.
 Si modificamos el aspecto de la presentación de un contacto, el resto
no cambia, por lo que podemos encontrarnos muchas presentaciones
diferentes.
 Muchos cambios provocan muchos problemas.
 Muy difícil de mantener y actualizar.
Página 9 de 164
Sesión 2. Primeros pasos.

- Objetivo. Primer contacto con PHP. Crear nuestra primera web dinámica.
- Actividades:
o Sitios web dinámicos. Arquitectura cliente/servidor + PHP.
1. Escribimos http://si_cursophp/index.php en la direccion de nuestro

navegador.
2. Nuestro navegador envía un mensaje a través de internet a un ordenador

llamado si_cursophp (o www.miejemplo.com) solicitando la página
index.php.
3. El servidor web (Apache) obtiene el mensaje, reconoce que solicita un

archivo PHP y se lo pasa al intérprete de PHP instalado en nuestro
servidor para que obtenga el archivo y lo parsee.
4. PHP lee el archivo index.php del disco duro.
5. PHP interpreta los comandos contenidos en index.php, posiblemente

intercambiando datos con un motor de base de datos como MySQL.
6. Después, PHP envía el resultado de la ejecución del archivo index.php

como respuesta al servidor web.
7. El servidor web (Apache) envía el contenido obtenido de PHP de vuelta a

nuestro ordenador a través de internet en respuesta a la solicitud de
nuestro navegador.
8. Finalmente, nuestro navegador interpreta el codigo html recibido y lo

muestra en pantalla.
o Descripción PHP.
• PHP es un lenguaje de programación.

• El lenguaje se ejecuta a través de un intérprete de PHP alojado en nuestro
servidor.
• El intérprete de PHP sigue las instrucciones incluidas en un archivo PHP.
• PHP es conocido como un lenguaje del lado del servidor porque se ejecuta en el
servidor junto a un servidor web.
• En cambio, otros lenguajes o tecnologías como Javascript o Flash se ejecutan en
el lado del cliente, en el escritorio de nuestro PC.
• Las instrucciones de un programa escrito en PHP hacen que el intérprete de PHP
devuelva una página web.
• Las instrucciones de un programa en Javascript hacen que el navegador realice
acciones tales como la aparición de una ventana nueva o el control de la entrada
de usuario en un formulario.
Página 10 de 164
• Una vez que el servidor web ha enviado de vuelta la página web generada al
cliente, PHP ya no interviene.
• Si la página contiene algo de Javascript, éste se ejecuta en el cliente y está
totalmente desconectado del programa PHP que ha generado la página.
o Repaso de HTML.
 Especificación HTML 4.01

• http://html.conclase.net/w3c/html401-es/cover.html
 Etiquetas principales.
<HTML>
<HEAD>
<TITLE></TITLE>
</HEAD>
<BODY>
<BR/>
<P></P>
<TABLE>
<TR><TD></TD></TR>
</TABLE>
</BODY>
</HTML>
 URL
• Get
• Variables en una URL.
http://www.ejemplo.com?variable1=valor1&variable2=valor2
 Formularios.
<FORM NAME=’’ METHOD=’’ ACTION=’POST’>
<INPUT NAME=’’ ID=’’ TYPE=’text’/>

<INPUT NAME=’’ ID=’’ TYPE=’password’/>
<INPUT NAME=’’ ID=’’ TYPE=’checkbox’/>
<INPUT NAME=’’ ID=’’ TYPE=’radio’/>
<INPUT NAME=’’ ID=’’ TYPE=’hidden’/>
<INPUT NAME=’’ ID=’’ TYPE=’file’/>
<INPUT NAME=’’ ID=’’ TYPE=’submit’/>
<TEXTAREA NAME=’’> </TEXTAREA>

<SELECT NAME=’’ ID=’’>
<OPTION VALUE=’’>Item</OPTION>
…
</SELECT>
<SELECT NAME=’’ ID=’’ MULTIPLE>

<OPTION VALUE=’’>Item</OPTION>
…
</SELECT>
</FORM>
Atributo READONLY y DISABLED.
o Taller 1. Primer contacto con PHP. Uso con formularios. (Ver anexo)
Página 11 de 164
- Evaluación. Web dinámicas.
■ Se mezcla html con lenguajes de programación o scripts de alto nivel como PHP.
■ Una página inicial puede mostrar un índice con la lista de todos los contactos
(pej. 100 enlaces), pero mientras en una página estática hay que cambiarlo todo
a mano en la dinámica se puede generar a partir de un origen de datos.
■ Una sola página se usa para mostrar cada contacto, pero no una página html
por contacto, sino una en PHP para todos. En este caso, de forma automática,
se obtienen los datos del contacto y se muestran.
■ Las páginas se generan acorde a las instrucciones de esos scripts, por lo que se
reduce enormemente el tamaño de la página, así como el número de páginas. Lo
que antes tenía en 100 paginas web en html ahora lo tengo en 1.
■ Puedo crear páginas dinámicas con scripts que me permitan crear, eliminar y
modificar la información de la fuente de datos, teniendo actualizada la
información en todo momento y evitando modificar a mano el contenido del sitio
web.
■ La interacción con el usuario es total, ya que el usuario puede enviar información
para consultar o manipular los datos de la fuente de informacion.
Página 12 de 164
Sesión 3. Características básicas.

- Objetivo. Conocer las características básicas de PHP.
- Actividades:
o Características generales.
 Etiquetas de inicio y fin.
<?php
?>
 Múltiples etiquetas de inicio y fin.
Código fuente: Ejemplo 100.
Cinco más cinco son:

<?php echo 5 + 5; ?>
<p>
Cuatro más cuatro es:
<?php
echo 4 + 4;
?>
<p>
<img src="humor1.jpg" alt="Yo no he sido">
Resultado:
Cinco más cinco es:

10<p>
Cuatro mas cuatro son:
8<p>
<img src="humor1.jpg" alt="Yo no he sido">
Algunas aplicaciones en PHP utilizan la etiqueta de inicio en modo abreviado,

es decir “<?” en lugar de <?php. Por lo general es mas aconsejable utilizar el
formato regular de etiqueta “<?php” para garantizar que nuestro código será
bien interpretado en cualquier servidor. Para activar y desactivar esta opción
hay que modificar el fichero de configuración de PHP, php.ini.
 Espacios y ‘case sensitive’.
• Múltiples instrucciones por línea. (“;”). Líneas en blanco entre

instrucciones: se ignoran.

<?php echo "¡Hola"; echo " Mundo!"; ?>
<?php
echo "¡Hola";
echo " Mundo!";
?>
<?php
Página 13 de 164
echo "¡Hola";
echo " Mundo!";
?>
PHP también ignora los espacios en blanco entre los comandos y los
parámetros.
<?php
echo "Demasiados espacios " ;
echo"Sin espacios";
echo "La cantidad idónea de espacios";
?>
Las instrucciones del lenguage (como echo) y los nombres de funciones

(como number_format) no son case-sensitive.
// Estas cuatro líneas hacen lo mismo
echo number_format(285266237);
ECHO Number_Format(285266237);
Echo number_format(285266237);
eChO NUMBER_FORMAT(285266237);
 Comentarios.
• Por línea:
o Comienzan con //.
o PHP tambien soporta # (Perl).
// Esto es una línea de comentario
echo "Puchero de garbanzos";
echo 'precio €3.25.';
# Añadimos otro plato al menú
echo 'Pato a la naranja ';
echo 'precio €9.50.';
// Podemos poner // o # dentro de las líneas de comentario
// Si colocamos un indicador // o # en cualquier parte de una línea también
Página 14 de 164
// inicia un comentario
echo 'Gazpacho Extremeño'; // ¡Qué hambre!
echo 'precio €25.00!'; # Un poco caro, ¿no?
# Si ponemos // o # dentro de una cadena de texto no inicia un comentario
echo 'http://www.elpuchero.com';
echo 'http://www.elpuchero.com/menu.php#cena';
• Múltiples líneas o bloques.

o Comienzan con /* y finalizan */.
o Todo lo que haya entre /* y */ es tratado como un
comentario.
/* Vamos a añadir unas cuantas cosas al menú:
- Pollo al chilindrón
- Patatas con carne
- Revuelto de ajetes
*/
echo ' Pollo al chilindrón, Patatas con carne, Revuelto de ajetes';
echo 'Precio: 3.25 + 9.50 + 25.00';
/* Este es el menú antiguo:
Las líneas siguientes están dentro del comentario, no se ejecutan
echo 'Hamburguesa, Patatas Fritas, Refresco';
echo 'Precio: 0.99 + 1.25 + 1.50';
*/
o Textos, números y variables en PHP.
 Cadenas de texto.
Hay varias maneras de usar cadenas en PHP. La más fácil es acotándola

entre comillas simples:
echo 'Yo quiero un tazón de sopa.';
echo 'pollo';
Página 15 de 164
echo '06520';
echo '"Estoy cenando," añadió él.';
El resultado será:
Yo quiero un tazón de sopa.pollo06520"Estoy cenando," añadió él.
Aparece todo en una línea, sin saltos ni retornos.
Las comillas simples no son parte de la cadena, solo la delimitan. Si

queremos incluir una comilla simple en la cadena tenemos que usar el
carácter de escape que en php es la barra invertida o backslash (\).
echo '¿Tienen vino \‘de la casa\’?';
Resultado:
¿Tienen vino ‘de la casa’?
El carácter de escape también puede ser escapado:
echo 'Usa \\ para escapar una cadena';
Mostrará:
Usa \ para escapar una cadena
También podemos incluir espacios en blanco y nuevas líneas en las cadenas

acotadas:
echo '<ul>
<li>Filete de ternera</li>
<li>Ensalada especial</li>
<li>Cocktail de Mariscos</li>
</ul>';
Resultado:
<ul>
<li>Filete de ternera</li>
<li>Ensalada especial</li>
<li>Cocktail de Mariscos</li>
</ul>
Página 16 de 164
Tambien podemos usar las comillas dobles, que funcionan de forma similar a
las simples, pero añaden más caracteres especiales:
Caracter Significado
\n Nueva línea (ASCII 10)

\r Retorno de carro (ASCII 13)
\t Tabulación (ASCII 9)
\\ \
\$ $
\" "
\0 .. \777 Número octal (base 8)
\x0 .. \xFF Número hexadecimal (base 16)
La mayor diferencia entre ambos tipos de acotados es que con las comillas
dobles podemos incluir en la cadena directamente una variable dibujando su
valor, algo que no ocurre con las simples:
$nombre='Florencio';
echo 'Vota $nombre';
echo "Vota $nombre";
Resultado:
Vota $nombre
Vota Florencio
Para concatenar cadenas se utiliza el carácter punto (‘.’).
echo 'pan' . 'fruta';
echo "Hoy es un gran día, " . 'verás como alguien lo jode.';
echo "El precio es: " . '€3.95';
echo 'Harpo ' . ' Chico ' . ' Zeppo ' . ' y Groucho';
Las cadenas resultantes son:
panfruta
Hoy es un gran día, verás como alguien lo jode.
El precio es: €3.95
Harpo Chico Zeppo y Groucho
 Manipulando texto.
• Validando.
Al validar comprobamos que la entrada obtenida cumple un determinado

formato.
Página 17 de 164
La función trim( ) elimina los espacios en blanco al principio y al final de la

cadena pasada a la función.
La función strlen( ), nos proporciona la longitud de una cadena de texto.
Si combinamos ambas obtenemos la longitud de una cadena ignorando los

espacios en blanco al principio y al final de la misma.
// $_POST['codigoPostal'] almacena el parametro enviado "codigoPostal"
$codigoPostal = trim($_POST['codigoPostal']);
// Ahora $codigoPostal almacena ese valor sin espacios iniciales y finales
$codigoPostal_longitud = strlen($codigoPostal);
// Comprobamos si tiene una longitud de 5 caracteres
if ( $codigoPostal_longitud != 5 ) {
echo "Por favor introduce un código postal de 5 dígitos.";
Podemos poner juntas ambas funciones:
if ( strlen ( trim( $_POST[ 'codigoPostal' ] ) ) != 5 ) {
echo "Por favor introduce un código postal de 5 dígitos.";
Para comparar dos cadenas se usa el operador (= =).
if ( $_POST [ 'email' ] == ' consejera@edu.juntaex.es ' ) {
echo " ¡Ostia! ¡La jefa! ";
Cuando usamos este operador las mayúsculas y minúsculas son importantes

ya que consejera@edu.juntaex.es no es igual a consejera@edu.juntaex.ES.
Para comparar cadenas sin prestar atención a mayúsculas o minúsculas se

utiliza la función strcasecmp( ).
if ( strcasecmp ( $_POST[ 'email' ] , 'consejera@edu.juntaex.es' ) == 0 ) {

echo " ¡Ostia! ¡La jefa! ";
}
Así, mostrará el mensaje aunque pasemos consejera@edu.juntaex.ES.
• Formateando.
Para pasar de mayúsculas a minúsculas y viceversa:
Página 18 de 164
echo strtolower('Ternera, POLLO, Cerdo, paTO');

echo strtoupper('Ternera, POLLO, Cerdo, paTO');
Resultado:
ternera, pollo, cerdo, pato

TERNERA, POLLO, CERDO, PATO
La función ucwords( ) pone en mayúsculas la primera letra de cada palabra

en una cadena. Cuando se combina con strtolower( ) muestra
correctamente los nombres.
echo ucwords ( strtolower ( 'CARMELE MARCHANTE ' ) ) ;
Resultado:
Carmele Marchante
Con substr( ) podemos extraer parte de una cadena:

// Muestra los 30 primeros caracteres de $_POST['comentario']
echo substr ( $_POST ['comentario' ] , 0 , 30 );
// Añadimos unos puntos suspensivos

echo '...';
Si el valor de la variable comentario es, por ejemplo:
En un lugar de La Mancha de cuyo nombre no quiero acordarme
El resultado será:
En un lugar de La Mancha de cu...
Los argumentos de la función substr( ) son la cadena a cortar, la posición

inicial de la subcadena a extraer y el número de caracteres a extraer.
Si omitimos el número de caracteres nos devolverá toda la cadena desde la

posición indicada hasta el final.
// Muestra la cadena desde la posición 10 de $_POST['comentario']

echo substr ( $_POST ['comentario' ] , 10);

echo '...';
r de La Mancha de cuyo nombre no quiero acordarme...
Si la posición es negativa comenzará por la parte final de la cadena.
// Muestra los 10 últimos caracteres de $_POST['comentario']

echo substr ( $_POST ['comentario' ] , -10,10);

echo '...';
acordarme...
La función str_replace( ) nos permite cambiar partes de una cadena, es

decir, busca una subcadena y la reemplaza por otra.
echo str_replace('{clase}',$mi_clase,
'<span class="{clase}">Cochinillo</span>
<span class="{clase}">Bacalao al ajoarriero</span>');
Si $mi_clase es ‘comida’:
Página 19 de 164
<span class="comida"> Cochinillo <span>

<span class="comida"> Bacalao al ajoarriero </span>
 Números.
echo 56; 56
echo 56.3; 56.3
echo 56.30; 56.3
echo 0.774422; 0.774422
echo 16777.216; 16777.216
echo 0; 0
echo -213; -213
echo 1298317; 1298317
echo -9912111; -9912111
echo -12.52222; -12.52222
echo 0.00; 0
PHP hace una distinción entre números:

o con parte decimal (float)
o sin parte decimal (integer).
Operadores Aritméticos.
echo 2 + 2; 4
echo 17 - 3.5; 13.5
echo 10 / 3; 3.3333333333333
echo 6 * 9; 54
echo 5 % 6; 5
 Variables.
En PHP, se identifican con el símbolo $ seguido del nombre de la variable.
$platos = 5;
$cena = 'Solomillo a la pimienta';
$precioCena = 8.95;
$precioComida = $cost_of_dinner;
$cabeceraPagina = “
<html>
<head><title>Menú</title></head>
<body bgcolor="#fffed9">
<h1>Cena</h1>”;
$piePagina= “
</body>
</html>”;
Los nombres de variable tienen que empezar con una letra o un caracter de
subrayado. El resto puede ser cualquier carácter excepto los que coincidan
con algunos usados por PHP.
Aceptables No aceptables
$longitud $2maso
$bebida $numero-bebidas
$miBebida $bebdor@botellon.com
$_bebidas $bebe!mucho
$bebida 4mas2 $cena+bebida
Los nombres de variable son case-sensitive, es decir $cena, $Cena y $CENA

son variables distintas.
Operaciones con Variables.
<?php
$precio = 3.95;
$impuestos = 0.08;
$totalImpuestos = $precio * $impuestos;
$precioTotal = $precio + $totalImpuestos;
Página 20 de 164
$usuario= 'juan';
$dominio = '@cursophp.com';
$email = $usuario. $dominio;
echo 'De impuestos son ' . $totalImpuestos;

echo 'El precio total son ' .$precioTotal;
echo $email;
?>
El resultado es:
De impuestos son 0.316

El precio total son
juan@cursophp.com
Combinaciones:
// Sumando de forma regular

$precio = $precio + 3;
// Sumando 3 combinando con la asignación

$precio += 3;
///////////////////////////////////////
$usuario = 'juan';
$dominio = '@cursophp.com';
// Concatenamos de forma regular

$usuario= $usuario . $dominio;
// Concatenamos de forma combinada

$usuario .= $dominio;
///////////////////////////////////////
// Añadimos uno a mi edad

$edad = $edad + 1;
// Añadimos otro combinada

++$edad;
// Restamos una a lo que me queda

$restoEdad = $restoEdad - 1;
// Restamos otro
--$restoEdad;
Insertando variables en cadenas de texto:
$email = 'florencio@analista.soy';
echo "Enviar mensaje a: $email";
Resultado:
Enviar mensaje a: florencio@analista.soy
Combinando con una página html:
$tituloPagina = 'Menú';
$carne = 'Cerdo';
$vegetal = 'Frijones';
echo "
<html>
<head><title>$tituloPagina</title></head>
<body>
<ul>
<li> $carne barbacoa
<li> $carne en lonchas
<li> $carne brasa con $vegetal
</ul>
</body>
Página 21 de 164
</html>";
Nos muestra:
<html>
<head><title>Menú</title></head>
<body>
<ul>
<li> Cerdo barbacoa
<li> Cerdo en lonchas
<li> Cerdo brasa con Frijones
</ul>
</body>
</html>
Ejercicios.
1. Busca los errores.
<? php
echo '¿Cuánto tardó?';
echo 'Un total de 1' 45” .';
??>
Solución:
1. La etiqueta de apertura debe ser <?php. Hay un espacio entre ? y php.

2. La cadena 'Un total de 1’ 45” .' se debe acotar entre comillas dobles y usar un
caracter de escape para los segundos (“Un total de 1’ 45\” .”).
3. La etiqueta de cierredebería ser ?>, no ??>.
2. Escribe un programa en PHP que calcule el todal de la siguiente comida: 2 hambuguesas a

€4.95 cada una, un helado de chocolate con leche a €1.95, y un refresco a 85 centimos. Se le
aplica un 7.5% de IVA, pero antes se le aplica un descuento del 16%.
Solución:
$hamburguesa = 4.95;
$helado = 1.95;
$refresco = .85;
$comida = 2 * $hamburguesa + $helado + $refresco;
$descuento = $comida * .16;
$iva = $comida * .075;
$total = $comida + $iva - $descuento;
echo "El precio total de la comida es $total €";
3. Modifica la solución al ejercicio anterior mostrando una factura con formato. Para cada
elemento de la comida dibuja el precio, la cantidad y el total. Imprime la cantidad a descontar, la
cantidad de IVA y el precio total.
Solución:
echo "El precio total de la comida es $total €";

echo "2 Hamburguesas a $hamburguesa € cada una: 2 * $hamburguesa €.<br/>";
echo "1 Helado a $helado €: $helado €. <br/>";
echo " 1 Refresco a $refresco €: $refresco €. <br/>";
echo "<br/>";
echo "Total Comida y Bebida: $comida €. <br/>";
echo "Total más iva: ".($comida + $iva)." €. <br/>";
echo "<br/>";
echo "Con Descuento. TOTAL: ".($comida + $iva - $descuento)." €. ";
4. Escribe un programa en PHP que ponga las variables $nombre y $apellidos con tu valores.
Muestre una cadena con tu nombre y apellidos separados por un espacio. Muestra también la
longitud de la cadena.
Solución:
$nombre = 'Juan';
$apellidos = 'Sanchez Sanchez';
$nombreYapellidos = "$nombre $apellidos";
echo $nombreYapellidos;
echo strlen($nombreYapellidos);
Página 22 de 164
5. Escribe un programa PHP que use el operador de incremento (++) y el de multiplicación

combinado (*=) para mostrar los números del 1 al 5 y las potencias de 2 desde 2(2^1) hasta 32
(2^5).
Solución:
$i = 1; $j = 2;
echo "$i $j";
$i++; $j *= 2;
echo "$i $j";
$i++; $j *= 2;
echo "$i $j";
$i++; $j *= 2;
echo "$i $j";
$i++; $j *= 2;
echo "$i $j";
Página 23 de 164
Sesión 4. Decisión y repetición.

- Objetivo. Conocer las características de decisión y repetición de PHP.
- Actividades:
o Decisiones en PHP.

if ($entradaValida) {
echo "Bienvenido a Contactos.";
}
Múltiples instrucciones en un if:

echo "Esto se muestra siempre.";
echo "Bienvenido a bordo, mari … nero";
echo “Esto solo se muestra si $entradaValida es true”;
}
echo "Esto se muestra siempre.";
If else:
} else {
echo "Lo siento, intruso.";
}
Usando elseif:
// Esto solo se muestra si $entradaValida es true
} elseif ($nuevosMensajes) {
// Este se ejecuta si $entradaValida es false pero $nuevosMensajes es true
echo "Intruso. Hay nuevos mensajes.";
} elseif ($emergencia) {
// Esto se ejecuta si $entradaValida y $nuevosMensajes son false
// y si $emergencia es true
echo "No tiene nuevos mensajes pero hay una emergencia.";
} else {
// Esto se ejecuta si $entradaValida, $nuevosmensajes y $emergencia son false
echo "No te conozco, no tiene mensajes y y no hay ninguna emergencia.";
}
o Decisiones complicadas.
Igualdad.
if ( $mensajesNuevos == 10 ) {
echo "Tienes 10 mensajes nuevos.";
}
if ( $mensajesNuevos == $maxMensajes) {
echo "Tienes el buzon lleno… cafre!";
}
if ( $cena == 'Escalopines') {
echo "¿Ein? ¿otra vez?";
}
NOTA: Cuidado al confundir == con =, pues no da error y se evalue a true.
Desigualdad.
if ( $mensajesNuevos != 10 ) {
echo "No tiene 10 nuevos mensajes.";
}
if ( $cena != 'Escalopines') {
Página 24 de 164
echo "¡Al fin, comemos caliente!";

}
Menor y mayor.
if ( $edad > 17 ) {
echo "Demasiado jóven para ver a Nacho Vidal en acción.";
}
if ( $edad >= 65 ) {
edad "ATENCIÓN: Más de 3 viagras pueden provocar la ira.";
}
if ( $temperatura <= 0 ) {
echo "Cuando el grajo vuela bajo hace un frío del carajo.";
}
if ( $temperatura < 20.3 ) {

echo "¡Bienvenidos a la Antártida!";
}
Comparando números y cadenas.

// Se comparan según orden alfabético
if ( "x54321" > "x5678" ) {
echo 'La cadena “x54321" es mayor que la cadena "x5678".';
} else {
echo 'La cadena "x54321" no es mayor que la cadena "x5678".';
}
// Estas cadenas se comparan usando órden numérico

if ( "54321" > "5678" ) {
echo 'La cadena "54321" es mayor que la cadena "5678".';
} else {
echo 'La cadena "54321" no es mayor que la cadena "5678".';
}
// Aquí usa orden alfabético

if ( '6 paquetes' < '55 tarjetas' ) {
echo 'La cadena "6 paquetes" es menor que la cadena "55 tarjetas".';
} else {
echo 'La cadena "6 paquetes" no es menor que la cadena "55 tarjetas".';
}
// Aquí se usa orden numérico

if ( '6 paquetes' < 55) {
echo 'La cadena "6 paquetes" es menor que el número 55.';
} else {
echo 'La cadena "6 paquetes" no es menor que el número 55.';
}
Resultado:
La cadena "x54321" no es mayor que la cadena "x5678".
La cadena "54321" es mayor que la cadena "5678".
La cadena "6 paquetes" no es menor que la cadena "55 tarjetas".
La cadena "6 paquetes" es menor que el número 55.
Usando strcmp()
Con strcmp() nos aseguramos que la comparación sea por órden alfabético.
strcmp($cadena1, $cadena2)
Esta función devuelve:
Si $cadena1 > $cadena2 -> un número positivo (>0)

Si $cadena1 < $cadena2 -> un número negativo (<0)
Si $cadena1 == $cadena2 -> 0
$x = strcmp("x54321","x5678");
if ( $x > 0 ) {
echo 'La cadena "x54321" es mayor que la cadena "x5678".';
Página 25 de 164
} elseif ( $x < 0 ) {
echo 'La cadena "x54321" es menor que "x5678".';
}
$x = strcmp("54321","5678");
if ( $x > 0 ) {
echo 'La cadena "54321" es mayor que la cadena "5678".';
} elseif ( $x < 0 ) {
echo 'La cadena "54321" es menor que la cadena "5678".';
}
$x = strcmp('6 paquetes','55 tarjetas');
if ( $x > 0 ) {
echo 'La cadena "6 paquetes" es mayor que la cadena "55 tarjetas".';
} elseif ( $x < 0 ) {
echo 'La cadena "6 paquetes" es menor que la cadena "55 tarjetas".';
}
Negación.
// La expresión entera ($terminado == false)
// es true si $terminado es false
if ($finished == false) {
echo 'Aun no terminado.';
}
// La expresión enter (! $terminado)

// es true si $terminado es false
if (! $terminado) {
echo 'Aun no terminado.';
}
if (! strcasecmp($nombre,$apellido)) {
echo '$nombre y $apellido son iguales.';
}
En este caso el echo se imprime si la condición es true. Cuando las dos

cadenas sean iguales, la funcion strcasecmp( ) devuelve 0, es decir, false.
Por tanto estamos negando el valor false, y por tanto, es true.
Operadores lógicos.
if (($edad >= 13) && ($edad < 65)) {
echo "Eres demasiado viejo para descuento de niños y
demasiado joven para descuento por jubilado. ";
}
if (($comida == 'desayuno') || ($postre == '')) {

echo "A comer tostadas.";
}
Taller 2. (Ver anexo)
 Crear un formulario de entrada.

 Crear una página de recepción en php que muestre solo un mensaje
general.
 Crear una página de recepción en php que muestre un mensaje
personalizado.
 Asignar un número a cada contacto.
 Fusionar todas las páginas de contactos en una dinámica.
 Aplicar decisiones a la agenda usando una variable con el número.
o Repeticiones en PHP.
While.
$i = 1;
echo “<select name=’personas’>”;
Página 26 de 164
while ( $i <= 10) {

echo "<option>$i</option>\n";
$i++;
}
echo '</select>';
Resultado:
<select name="personas">
<option>1</option>
<option>2</option>
<option>3</option>
<option>4</option>
<option>5</option>
<option>6</option>
<option>7</option>
<option>8</option>
<option>9</option>
<option>10</option>
</select>
For:
echo “<select name=’personas’>”;
for ( $i = 1; $i <= 10; $i++ ) {
echo "<option>$i</option>";
}
echo “</select>”;
For con múltiples expresiones:
echo “<select name=’donuts’>”;

for ($min = 1, $max = 10; $min < 50; $min += 10, $max += 10) {
echo "<option>$min - $max</option>\n";
}
Resultado:
<select name="donuts">
<option> 1 - 10</option>
<option>11 - 20</option>
</select>
Ejercicios.
1. Sin usar PHP para comprobarlo, determinar si estas expresiones son true
or false:
Solución:
a. 100.00 - 100 a. false
b. "cero" b. true
c. "false" c. true
d. 0 + "true" d. false
e. 0.000 e. false
f. "0.0" f. true
g. strcmp("false","False") g. true
2. Mostrar que dibujaría este programa en PHP:

$edad = 12;
$pie = 13;
if ($edad > $pie) {
echo "Mensaje 1.";
} elseif (($pie++) && ($edad > 20)) {
echo "Mensaje 2.";
} else {
echo "Mensaje 3.";
}
echo "Edad: $edad. Pie: $pie";
Solución:
Página 27 de 164
Mensaje 3.Edad: 12. Pie: 14
3. Utilizando while() muestra una tabla de equivalencias entre las escalas de

temperatura Fahrenheit y Celsius, desde –50 grados F hasta 50 grados F en
incrementos de 5 grados. En la escala Fahrenheit el agua se congela a 32
grados y hierve a 212 grados. En la Celsius, son 0 y 100. Para convertir de
Fahrenheit a Celsius, se restan 32, se multiplica por 5 y se divide entre 9.
Solución:
$ini_fahr = -50;
$fin_fahr = 50;
echo “<table>”;
echo “<tr><th>Fahrenheit</th><th>Celsius</th></tr>”;
while ($ini_fahr <= $fin_fahr) {
$celsius = ($fahr - 32) * 5 / 9;
echo "<tr><td>$fahr</td><td>$celsius</td></tr>";
$fahr += 5;
}
echo '</table>';
4. Modifica el ejercicio anterior usando for() en lugar de while();

Solución:
echo “<table>”;
echo “<tr><th>Fahrenheit</th><th>Celsius</th></tr>”;
for ($fahr = -50; $fahr <= 50; $fahr += 5) {
$celsius = ($fahr - 32) * 5 / 9;
echo "<tr><td>$fahr</td><td>$celsius</td></tr>";
}
echo '</table>';
Página 28 de 164
Sesión 5. Arrays (I).

- Objetivo. Conocer la definición y uso de arrays en PHP (I).
- Actividades:
o Arrays en PHP.
Los arrays se utilizan para almacenar datos, en la forma indice -> valor.
Indice Valor
manzana verde
limon amarillo
patata marron
berenjena negro
De esta forma cualquier valor es accesible de forma directa usando su índice
Un array solo puede contener un elemento por clave, es decir, la clave no se puede
repetir.
Un índice de array sólo puede ser un numero o cadena.
Un valor de un array puede ser una cadena, un número, true, false e incluso otro
array.
Crear arrays.
Para crear un array de forma simple solo hay que asignar un valor a un índice del
array.

// Array $vegetales con cadenas como índices
$vegetales['manzana'] = 'verde';
$vegetales['limon'] = 'amarillo';
$vegetales['patata'] = 'marron';
// Array $cena con índices numéricos

$cena [0] = 'Ensalada de Manzana';
$cena [1] = 'Pollo al Limón';
$cena [2] = 'Callos en salsa';
// Array $maquina con índices numéricos y alfanuméricos

$maquina['trs-80'] = 'Equipo de Radio';
$maquina[2600] = 'Atari';
$maquina['Targon'] = 'Vaya tela';
Crear arrays con array( )
$vegetales = array( 'manzana' => 'verde',

'limon' => 'amarillo',
'patata' => 'marron');
$cena = array( 0 => ' Ensalada de Manzana ',

1 => ' Pollo al Limón ',
2 => ' Callos en salsa');
$equipos = array( 'trs-80' => ' Equipo de Radio ',

2600 => 'Atari',
'Targon' =>'Vaya tela');
Crear arrays numéricos con array( )
$cena = array(' Ensalada de Manzana ',

' Pollo al Limón ',
' Callos en salsa ');
echo "Yo quiero $cena[0] y $cena[1].";
Página 29 de 164
Resultado:
Yo quiero Ensalada de Manzana y Pollo al Limón.
o Manipulando arrays.
Añadiendo elementos con [ ]

// Crear array $comida con dos elementos
// Esto crea $comida[0]
$comida[] = 'Patatas con carne';
// Esto crea $comida[1]

$comida[] = 'Albondigas en salsa';
// Crea $cena con tres elementos

$cena = array(' Ensalada de Manzana ', ' Pollo al Limón ', ' Callos en salsa ');
// Añade un elemento al final de cena

// Esto crea $cena[3]
$cena [] = 'Ternera al Curry';
Obteniendo el tamaño de un array

$tantos = count($cena);
echo "Hay $tantos platos para cenar.";
Resultado:
Hay 3 platos para cenar.
Recorriendo un array con foreach( )
$dieta = array( 'desayuno' => 'Catalana',

'almuerzo' => 'Cocido de Garbanzos',
'aperitivo' => 'Patatas Fritas',
'cena' => 'Ensalada Mixta');
echo "<table>\n";
foreach ($dieta as $indice => $valor) {
echo "<tr><td>$indice</td><td>$valor</td></tr>\n";
}
echo '</table>';
Resultado:
<table>
<tr><td>desayuno</td><td>Catalana</td></tr>
<tr><td>almuerzo</td><td> Cocido de Garbanzos </td></tr>
<tr><td>aperitivo</td><td>Patatas Fritas</td></tr>
<tr><td>cena</td><td> Ensalada Mixta </td></tr>
</table>
Modificando un array con foreach( )
$dietas = array( 'Catalana' => 1,

'Cocido de Garbanzos' => 4.95,
'Patatas fritas' => 3.00,
'Ensalada mixta' => 6.50);
foreach ($dietas as $plato => $precio) {

// $precio = $precio * 2 no funciona
$dietas[$plato] = $dietas[$plato] * 2;
}
// Recorremos de nuevo el array y mostramos los valores que han cambiado

foreach ($dietas as $plato => $precio) {
echo "El nuevo precio de $plato es $precio €";
}
Resultado:
El nuevo precio de Catalana es 2.00 €.
El nuevo precio de Cocido de Garbanzos es 9.90 €.
Página 30 de 164
El nuevo precio de Patatas fritas es 6.00 €.

El nuevo precio de Ensalada mixta es 13.00 €.
Usando foreach( ) con índices numéricos.
Ventaja: más fácil de usar y recordar.
foreach ($cena as $plato) {
echo "Puede comer: $plato";
}
Resultado:
Puede comer: Ensalada de Manzana
Puede comer: Pollo al Limón
Puede comer: Callos en salsa
Recorriendo un array numérico con for().

for ($i = 0, $num_platos = count($cena); $i < $num_platos; $i++) {
echo "Plato número $i is $cena[$i]";
}
Resultado:
Plato número 0 es Ensalada de Manzana
Plato número 1 es Pollo al Limón
Plato número 2 es Callos en salsa
Comprobando que existe un elemento concreto por índice.
Si estamos buscando un elemento específico en un array no es necesario recorrer

el array entero para encontrarlo. Para ello se usa la función use array_key_exists( ),
que devuelve true si existe en el array un elemento con ese índice.
$menu = array( ' Ensalada de Manzana ' => 1,
' Pollo al Limón' => 4.95,
' Callos en salsa' => 3.00,
'Chipirones a la plancha' => 6.50,
'Gambas al ajillo' => 0); // ¡Estas son gratis!
$libros = array(“La guía de los buenos restaurantes”,

“Cocina tradicional extremeña”);
// Esto es true
if (array_key_exists(' Gambas al ajillo ',$menu)) {
echo "Si, tenemos Gambas al Ajillo ";
}
// Esto es false
if (array_key_exists('Pepito de Ternera',$menu)) {
echo "Tenemos Pepitos de Ternera";
}
// Esto es true
if (array_key_exists(1, $libros)) {
echo "El elemento 1 es Cocina tradicional extremeña.";
}
Comprobando si existe un elemento con un valor concreto.
Se usa la función in_array( ).

'Gambas al ajillo' => 0); // ¡Estas son gratis!
$libros = array(“La Guía de los Buenos Restaurantes”,
“Cocina tradicional extremeña”);
Página 31 de 164
// Esto es true: el índice Callos en salsa vale 3.00€

if (in_array(3, $menu)) {
echo 'Hay un elemento de 3€.';
}
// Esto es true
if (in_array('Cocina tradicional extremeña', $libros)) {
echo "Tenemos el libro Cocina tradicional extremeña ";
}
// Esto es false: in_array( ) es case-sensitive

if (in_array("la guía de los buenos restaurantes ", $libros)) {
echo "Tenemos el libro La Guía de los Buenos Restaurantes.";
}
Encontrar elemento por valor con array_search()
La función in_array( ) devuelve true si encuentra el elemento con el valor pasado,

pero es case-sesitive en la comparación de cadenas. La función array_search( ) es
parecida a in_array( ), pero si encuentra un elemento devuelve su índice.
'Gambas al ajillo' => 0);
$plato = array_search(6.50, $menu);
if ($plato) {
echo "$plato cuesta 6.50€";
}
Resultado:
Chipirones a la plancha cuesta 6.50€
Página 32 de 164
Sesión 6. Arrays (II).

- Objetivo. Conocer la definición y uso de arrays en PHP (II).
- Actividades:
o Modificar Arrays
Los elementos de un array se usan igual que cualquier otra variable.
$platos[' Pollo al Limón '] = 12;

$platos[' Pollo al Limón ']++;
$platos['Pato a la Naranja'] = 3;
$platos['total'] = $platos[' Pollo al Limón '] + $platos[' Pato a la Naranja '];

if ($platos['total']> 15) {
echo “Comes demasiado: ";
}
echo 'Has comido ' . $platos[' Pollo al Limón '] . ' platos de Pollo al Limón.';
Resultado:
Comes demasiado: Has comido 13 platos de Pollo al Limón.
Incluyendo elementos de arrays en cadenas de texto
Podemos incluirlos pero si el índice es texto no usamos las comillas para identificarlo.
$dieta['desayuno'] = 'Tostada Media Manchega';
$dieta['almuerzo'] = 'Guiso de Lentejas';
$cantidades= array(2, 1);
echo "Para desayunar, me gustaría $dieta[desayuno] y para almorzar, ";

echo "me gustaría $dieta[almuerzo]. Quiero $cantidades[0] para desayunar y ";
echo "$cantidades [1] para almorzar.";
Resultado:
Para desayunar, me gustaría Tostada Media Manchega y para almorzar,

me gustaría Guiso de Lentejas. Quiero 2 para desayunar y
1 para almorzar.
Eliminar un elemento de un array

unset($platos['Pato a la Naranja']);
Esto no es lo mismo que poner el valor del elemento a 0 o a vacío, sino que se elimina
realmente el indice y el valor, no apareciendo al recorrerlo o al contarlo.
Crear una cadena desde un array con implode( )
Esta función combina todos los elementos de un array en una cadena separados por
un carácter delimitador.
$platos= array('Bonito en Salsa','Filete de Ternera','Tiramisú');

$menu = implode(', ', $platos);
echo $menu;
Resultado:
Bonito en Salsa, Filete de Ternera, Tiramisú
Si no usamos carácter de separación concatenamos todas las cadenas del array.
Página 33 de 164
$letras = array('A','B','C','D');
echo implode('',$letras);
Resultado:
ABCD
implode( ) puede ser útil para crear filas en una tabla HTMl.
$platos = array('Bonito en Salsa','Filete de Ternera','Tiramisu');

echo “<table>”;
echo '<tr><td>' . implode('</td><td>',$platos) . '</td></tr>';
echo “</table>”;
Resultado:
<table>
<tr><td> Bonito en Salsa </td><td> Filete de Ternera </td><td> Tiramisu</td></tr>
</table>
Creando un array desde una cadena con explode( )
Es la función inversa a implode( ). Divide una cadena en partes que componen un array
$pescado = 'Besugo, Carpa, Trucha, Dorada';

$pescadoLista = explode(', ', $pescado);
echo "El segundo pescado es $pescadoLista [1]";
Resultado:
El segundo pescado es Carpa
o Arrays Multidimensionales
Creando arrays multidimensional con array( )

$dietas = array('desayuno' => array('Donuts','Cafe'),
'almuerzo' => array('Solomillo a la Pimienta', 'Macedonia'),
'aperitivo' => array('Cacahuetes','Aceitunas'));
$comidas = array( array('Pollo','Berenjena','Arroz'),

array('Terneta','Mostaza','Fideos'),
array('Berenjena','Pisto'));
$sabores = array('Mejicano' => array('caliente' => 'ensalada de jalapeños',

'salado' => 'fajita de pollo'),
'Italiano' => array('caliente' => 'lasaña',
'picante-salado' => 'pizza picante'));
Accediendo a elementos de un array multidimensional

echo $dietas['almuerzo'][1]; // Macedonia
echo $dietas['aperitivo'][0]; // Cacahuetes
echo $comidas[0][0]; // Pollo
echo $comidas[2][1]; // Pisto
echo $sabores['Mejicano']['salado'] // fajita de pollo
echo $sabores['Italiano']['caliente']; // lasaña
Manejando arrays multidimensionales

$precios['cena']['Setas a la Plancha'] = 12.50;
$precios ['almuerzo']['Revuelto de Esparragos y Sopa de Fideos'] = 4.95;
$precios ['cena']['Ensalada Mixta'] = 8.95;
$precios['cena']['total'] = $precios['cena'][' Setas a la Plancha '] +

$precios['cena']['Ensalada Mixta'];
$especiales[0][0] = 'Tarta de Queso';

$especiales[0][1] = 'Bizcocho de Nueces';
Página 34 de 164
$especiales[0][2] = 'Bizcocho de Almendras';

$especiales[1][0] = 'Almendras saladas';
$especiales[1][1] = 'Ensalada con Nueces';
// Si no indicamos el índice lo añade al final del array

// Esto crea $especiales[1][2]
$especiales[1][] = 'Banderillas';
Recorriendo un array multidimensional con foreach( )
Necesitamos sentencias for() o foreach() anidadas.
$sabores = array( 'Japones' => array( 'caliente' => 'wasabi',

'salado' => 'salsa soja'),
'Chino' => array( 'caliente' => 'mostaza',
'picante-salado' => 'curry'));
// $cultura es el índice y $saboresCultura es el valor (un array)

foreach ($sabores as $cultura => $saboresCultura) {
// $sabor es el índice y $ejemplo es el valor
foreach ($saboresCultura as $sabor => $ejemplo) {
echo "Un sabor $sabor $cultura es $ejemplo.";
echo “<br/>”;
}
}
Resultado:
Un sabor caliente Japonés es wasabi.

Un sabor salado Japonés es salsa de soja.
Un sabor caliente Chino es mostaza.
Un sabor picante-salado Chino es curry.
Con for( )
$especiales =
array( array('Tarta de Queso','Bizcocho de Nueces','Bizcocho de Almendras'),
array('Ensalada con Almendras','Ensalada con Nueces', ‘Ensalada con Avellanas’));
// $numEspeciales es 2: el numero de elementos en la primera dimension

// de $especiales
for ($i = 0, $numEspeciales = count($especiales); $i < $numEspeciales; $i++) {
// $numSub is 3: el numero de elementos en cada sub-array
for ($m = 0, $num_sub = count($specials[$i]); $m < $num_sub; $m++) {
echo "Elemento [$i][$m] es " . $especiales[$i][$m] . "<br/>";
}
}
Resultado:
Elemento [0][0] es Tarta de Queso

Elemento [0][1] es Bizcocho de Nueces
Elemento [0][2] es Bizcocho de Almendras
Elemento [1][0] es Ensalada con Almendras
Elemento [1][1] es Ensalada con Nueces
Elemento [1][2] es Ensalada con Avellanas
o Ordenando Arrays
La función sort( ) ordena un array por el valor de sus elementos.
Se debe usar sólo en arrays con índices numéricos porque reinicia los índices cuando
ordena.
Página 35 de 164
$cena = array( 'Ensalada de Manzana ',

'Pollo al Limón ',
‘Callos en salsa ');
$dieta = array( 'desayuno' => 'Donuts',

'almuerzo' => 'Solomillo a la Pimienta y Macedonia',
'aperitivo' => 'Cacahuetes',
'cena' => ‘Ensalada Mixta’);
echo "Antes de ordenar: <br/>";
foreach ($cena as $indice => $valor) {

echo " \$cena: $indice $valor <br/>";
}

echo " \$dieta: $indice $valor <br/>";
}
sort($cena);
sort($dieta);
echo “Después de ordenar: <br/>”;
foreach ($cena as $indice => $valor) {

echo " \$cena: $indice $valor <br/>";
}

}
Resultado:
Antes de ordenar:
$cena: 0 Ensalada de Manzana
$cena: 1 Pollo al Limón
$cena: 2 Callos en salsa
$dieta: desayuno Donuts
$dieta: almuerzo Solomillo a la Pimienta y Macedonia
$dieta: aperitivo Cacahuetes
$dieta: cena Ensalada Mixta
Después de ordenar:
$cena: 0 Callos en salsa
$cena: 1 Ensalada de Manzana
$cena: 2 Pollo al Limón
$dieta: 0 Cacahuetes
$dieta: 1 Donuts
$dieta: 2 Ensalada Mixta
$dieta: 3 Solomillo a la Pimienta y Macedonia
Ordenando con asort( )
Se utiliza para ordenar un array asociativo por el valor de sus elementos.
Mantiene los índices con sus valores.
$dieta = array( 'desayuno' => 'Donuts',

'almuerzo' => 'Solomillo a la Pimienta y Macedonia',
'aperitivo' => 'Cacahuetes',
'cena' => ‘Ensalada Mixta’);
echo "Antes de ordenar: <br/>";

Página 36 de 164
asort($dieta);
echo “Después de ordenar: <br/>”;

}
Resultado:
Antes de ordenar:
Después de ordenar:
Ejercicios.
1. Según el Instituto Nacional de Estadística, las ciudades más pobladas de España

en el 2006 son:
1. Madrid: 3.128.600.
2. Barcelona: 1.605.602.
3. Valencia: 805.304.
4. Sevilla: 704.414.
5. Zaragoza: 649.181.
6. Málaga: 560.631.
7. Murcia: 416.996.
8. Las Palmas: 377.056.
9. Palma de Mallorca: 375.048.
10. Bilbao: 354.145.
11. Córdoba: 322.867.
12. Alicante: 322.431.
Define un array (o arrays) que almacene esta información sobre ciudades y

habitantes. Dibuja una tabla con la información de ciudades y su población, así
como el total de habitantes de las 12 ciudades.
$poblacion = array( 'Madrid’ => 3128600,

'Barcelona’ => 1605602,
'Valencia’ => 805304,
'Sevilla’ => 704414,
'Zaragoza’ => 649181,
Página 37 de 164
'Málaga’ => 560631,

'Murcia’ => 416996,
'Las Palmas’ => 377056,
'Palma de Mallorca’ => 375048,
'Bilbao’ => 354145,
'Córdoba’ => 322867,
'Alicante’ => 322431);
$totalPoblacion = 0;
echo "<table><tr><th>Ciudad</th><th>Poblacion</th></tr>\n";
foreach ($poblacion as $ciudad => $personas) {
$totalPoblacion += $personas;
echo "<tr><td>$ciudad</td><td>$personas</td></tr>\n";
}
echo "<tr><td>Total</td><td>$totalPoblacion</td></tr>\n";
echo "</table>\n";
2. a) Modifica la solución al ejercicio anterior para que las filas en la tabla estén
ordenadas por población. b) Despúes modifica la solución para ordenar por el
nombre de la ciudad.
a)
Usa asort( ) para ordenar por poblacion.
asort($poblacion);
}
echo "</table>\n";
b)
ksort($poblacion);
}
echo "</table>\n";
3. Modifica la solución al primer ejercicio para que la tabla también contenga filas que
almacenen el total de habitantes por comunidad autónoma para cada comunidad
representada en la lista de ciudades.
// Agrupamos las ciudades por comunidad autónoma
$comunidad = array( 'Madrid' => array ( 'Madrid’ => 3128600),

'Cataluña' => array ( 'Barcelona' => 1605602),
'Valencia' => array ( 'Valencia' => 805304,
'Alicante’ => 322431),
'Andalucia' => array ( 'Sevilla' => 704414,
'Málaga’ => 560631,
'Córdoba’ => 322867),
'Aragon' => array ( 'Zaragoza’ => 649181),
'Murcia' => array ( 'Murcia’ => 416996),
'Canarias' => array ( 'Las Palmas' => 377056),
'Baleares' => array ( 'Palma de Mallorca’ => 375048),
'Euskadi' => array ('Bilbao’ => 354145));
// Usa el array $comunidadTotal para almacenar los totales por comunidad
$comunidadTotal = array( );
echo "<table><tr><th>Comunidad</th></tr>\n";
Página 38 de 164
foreach ($comunidad as $com => $info) {

echo "<tr><td>$com</td></tr>\n";
echo "<tr><th>Ciudad</th><th>Poblacion</th></tr>\n";
// $info es un array con las ciudades de cada comunidad y su poblacion

foreach($info as $ciudad => $poblacion){
$totalPoblacion += $poblacion;
// incrementamosel total por comunidad
$comunidadTotal [$com] += $poblacion;
echo "<tr><td>$ciudad</td><td>$poblacion</td></tr>\n";
}
echo "<tr><td>$comunidadTotal[$com]</td></tr>\n";
}
echo "</table>\n";
4. Para cada uno de los siguientes tipos de información, muestra cómo almacenarlos
en un array y un ejemplo explicativo con varios elementos. Por ejemplo, para el
primer caso, podemos decir “Un array asociativo cuyo índice es el nombre del
estudiante y cuyo valor es otro array asociativo con el curso y un número
identificativo”. Ejemplo:
a) El curso y el número identificativo de los estudiantes de una clase.
$estudiantes = array( 'Juan Sánchez Díaz' => array('curso' => '2','id' => 271231),
'Florencio Martinez' => array('curso' => '5', 'id' => 818211));
b) Cuantos de los elementos almacenados en un inventario está disponible en el almacén.
Un array asociativo cuyo índice es el nombre del elemento y cuyo valor es el número de
elementos en stock.
$stock = array('Cascos' => 5, 'Guantes' => 3, 'Martillos' => 2, 'Linternas' => 6);
c) Comidas escolares de una semana (cada comida se compone de primero, segundo y bebida) y
el coste por dia.
Un array asociativo cuyo índice es el día y cuyo valor es otro array asociativo describiendo
la comida. Este último array tiene un par índice/valor para el precio y un par índice/valor para
cada parte de la comida (primero, segundo y bebida).
$comidas = array( 'Lunes' => array( 'precio' => 1.50,

'primero' => 'Macarrones con Tomate',
'segundo' => 'Merluza a la Plancha',
'bebida' => 'Zumo de Naranja'),
'Martes' => array( 'precio' => 1.50,

'primero' => 'Ensalada Mixta',
'segundo' => 'Pechuga de Pollo Empanada',
'bebida' => 'Agua'),
'Miercoles' => array( 'precio' => 2.00,
Página 39 de 164
'primero' => 'Esparragos con Mahonesa',

'segundo' => 'Pez Espada',
'bebida' => 'Refresco de Cola'),
'Jueves' => array( 'precio' => 1.35,

'primero' => 'Huevos Fritos',
'segundo' => 'Hamburguesa con queso',
'bebida' => 'Agua'),
'Viernes' => array( 'precio' => 2.15,

'primero' => 'Ensalada de Tomate',
'segundo' => 'Filete de Ternera',
'bebida' => 'Te helado'));
d) Los nombres de los componentes de tu familia.
$familia = array('Bart','Lisa','Homer','Marge','Maggie');
e) Los nombres, edades y relaciones de las personas de tu familia.
$familia = array( 'Bart' => array('relacion' => 'hermano', 'edad' => 10),
'Lisa' => array('relacion' => 'hermana', 'edad' => 7),
'Homer' => array('relacion' => 'padre', 'edad' => 36),
'Marge' => array('relacion' => 'madre', 'edad' => 34),
'Maggie' => array('relacion' => 'yomisma', 'edad' => 1));
o En la página inicial, almacenar la información de los contactos en un array y

mostrar la lista con un proceso repetitivo.
o Almacenar la información de los contactos en arrays y aglutinar todas las

páginas de contactos en una.
o Añadir los contactos de Blender y Fry.
Página 40 de 164
Sesión 7. Funciones (I).

- Objetivo. Conocer la definición y uso de funciones en PHP (I).
- Actividades:
o Declarando Funciones.
function paginaCabecera( ) {
echo '<html><head><title>Bienvenido a mi página web</title></head>';

echo '<body bgcolor="#ffffff">';
Los nombres de función siguen las mismas reglas que los nombres de variables: han de
comenzar con una letra o un caracter de subrayado; el resto pueden ser letras, números o
caracteres de subrayado.
o Llamando a una función.
paginaCabecera ( );
echo "Bienvenido, $usuario";
echo "</body></html>";
Resultado:
<html><head><title>Bienvenido a mi página web</title></head>

<body bgcolor="#ffffff">
Bienvenido, invitado
</body></html>
Las funciones pueden ser definidas antes o después de los lugares donde son llamadas.
function paginaCabecera( ) {
echo '<html><head><title>Bienvenid@s a mi sitio web</title></head>';
echo '<body bgcolor="#ffffff">';
}
paginaCabecera( );
echo "Bienvenido, $usuario";
paginaPie ( );
function paginaPie ( ) {
echo '<hr>Gracias por su visita.';
echo '</body></html>';
}
o Pasando parámetros a Funciones.

Primero definimos la función:
function paginaCabecera2($color) {
echo '<html><head><title>Bienvenido a mi sitio web </title></head>';
echo '<body bgcolor="#' . $color . '">';
}
Para llamarla pasándole un parámetro:
paginaCabecera2('cc00cc');
Resultado:
<html><head><title>Bienvenido a mi sitio web</title></head><body bgcolor="#cc00cc">
Página 41 de 164
Si llamamos a la función sin pasarle el parámetro definido, PHP lanza una advertencia
indicando el error. Por ejemplo:
paginaCabecera2( );
El resultado será:
PHP Warning: Missing argument 1 for paginaCabecera2( )
Para evitar esta situación se define el parámetro de la función con un valor por defecto.
function paginaCabeera3($color = 'cc3399') {

echo '<html><head><title>Bienvenido a mi sitio</title></head>';
}
Así, si no se pasa ningún parámetro la función siempre tomará el definido por defecto. Los
valores por defecto para los argumentos nunca pueden ser otras variables.
// Esto es incorrecto
function paginaCabeceraMal ($color = $mi_color) {
...
}
Definiendo una función con dos parámetros
function paginaCabecera4($color, $titulo) {

echo '<html><head><title>Bienvenido a ' . $titulo . '</title></head>';
}
Llamamos a la función:
paginaCabecera4('66cc66','mi sitio web');
Resultado:
<html><head><title>Bienvenido a mi sitio web </title></head><body bgcolor="#66cc66">
Múltiples parámetros opcionales
En este caso se tiene que cumplir que todos los parámetros opcionales deben ir después
de los obligatorios.
// Un parámetro opcional: debe ir el último

function paginaCabecera5($color, $titulo, $cabecera = 'Bienvenido') {
echo "<h1>$cabecera</h1>";
}
// Llamadas correctas a esta función:

paginaCabecera5('66cc99','mi pedazo de página'); // $cabecera por defecto
paginaCabecera5('66cc99','mi pedazo de página','¡Hola!¡Bienvenido!');
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Dos parámetros opcionales: deben ser los dos últimos

function paginaCabecera6($color, $titulo = 'la página', $cabecera = 'Bienvenido') {
echo '<html><head><title>Bienvenido a ' . $title . '</title></head>';
}

paginaCabecera6( '66cc99' ); // usa $titulo y $cabecera por defecto
paginaCabecera6( '66cc99' , 'mi pedazo de página'); // usa $cabecera por defecto
paginaCabecera6( '66cc99' , 'mi pedazo de página','¡El mejor sitio web!');// nada por defecto
Página 42 de 164
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Todos los parámetros opcionales

function paginaCabecera7($color = '336699',$titulo= 'la página', $cabecera = 'Bienvenido') {
}

paginaCabecera7( ); // usa todos por defecto
paginaCabecera7( '66cc99' ); // usa $titulo y $cabecera por defecto
paginaCabecera7( '66cc99' , 'mi pedazo de página'); // usa $cabecera por defecto
paginaCabecera7( '66cc99' , 'mi pedazo de página' , '¡El merjor sitio web!');
Cambiando el valor de los parámetros
Cualquier cambio que hagamos a un parámetro pasado a una función no afecta al

parámetro fuera de la función.
function cuentaAtras($fin) {
while ($fin > 0) {
echo "$fin..";
$fin--;
}
echo "¡boom!\n";
}
$contador = 5;
cuentaAtras($contador);
echo "Ahora, contador es $counter";
Resultado:
5..4..3..2..1.. ¡boom!
Ahora contador es 5
o Devolviendo valores desde Funciones
Capturando un valor de retorno
$numeroAmostrar = numeroFormato(44708964);
echo "La población de España es aproximadamente: $numeroAmostrar";
Resultado:
La población de España es aproximadamente: 44.708.964
Devolviendo un valor desde una función
Para devolver valores desde la función que creemos usamos la palabra return y el valor
que queremos devolver.
Cuando se está ejecutando una función tan pronto encuentre la palabra return, para la
ejecución y devuelve el valor asociado.
function restauranteCuenta($comida, $impuesto, $servicio) {
$totalImpuestos = $comida * ($impuesto / 100);
$totalServicio = $comida * ($servicio / 100);
$total = $comida + $totalImpuestos + $totalServicio;
return $total;
}
Utilizando un valor devuelto en una cláusula if( )
// Calcula el total de una comida de 15.22€ con un 8.25% de servicio y un 7% de iva

$total = restauranteCuenta (15.22, 8.25, 15);
echo 'Solo tengo un billete de 20€ en efectivo, así que ...';
if ($total > 20) {
echo "Tengo que pagar con tarjeta de crédito.";
Página 43 de 164
} else {
echo "Puedo pagar en efectivo.";
}
Devolviendo un array desde una función
Un return solo puede devolver un valor, es decir, no se pueden devolver valores de la

forma return 15, 23.
Si queremos devolver varios valores podemos almacenarlos en un array y devolver el
array.
function restauranteCuenta2($comida, $impuesto, $servicio) {

$totalImpuestos = $comida * ($impuesto / 100);
$totalSinServicio = $comida + $totalImpuestos;
$totalConServicio = $comida + $totalImpuestos + $totalServicio;
return array($totalSinServicio, $totalConServicio);
}
Usando un array devuelto de una función

$totales = restauranteCuenta2(15.22, 8.25, 15);
if ($totales[0] < 20) {
echo 'El total sin servicio es menor de 20€.';
}
if ($totales[1] < 20) {
echo 'El total con servicio es menor a 20€.';
}
Múltiples return en una función
function modoPago ($efectivo, $cantidad) {

if ($cantidad > $efectivo) {
return 'tarjeta de crédito';
} else {
return 'efectivo';
}
}
Pasando un valor de retorno a otra función

$total = restauranteCuenta(15.22, 8.25, 15);
$metodo = modoPago(20, $total);
echo 'Pagaré con ' . $metodo;
Resultado:
Pagaré con efectivo.
Usando valores de retorno en un if( )

if (restauranteCuenta (15.22, 8.25, 15) < 20) {
echo 'Menos de 20€, pago en efectivo.';
} else {
echo 'Demasiado caro, necesito mi tarjeta de crédito.';
}
Funciones que devuelven true o false

function puedoPagarEfectivo ($efectivo, $cantidad) {
if ($cantidad > $efectivo) {
return false;
} else {
return true;
}
}
$total = restauranteCuenta (15.22,8.25,15);

if (puedoPagarEfectivo (20, $total)) {
echo "Puedo pagar en efectivo.";
} else {
Página 44 de 164
echo "Toca tarjeta de crédito.";

}
Sesión 8. Funciones (II).
- Objetivo. Conocer la definición y uso de funciones en PHP(II).
- Actividades:
o Alcance de las variables
Las variables definidas fuera de una función se llaman variables globales.
Aquellas definidas dentro de una función se denominan variables locales.
$cena = 'Bonito en cebolla';

function cenaVegetariana( ) {
echo "Para cenar hay $cena, o ";
$cena = 'Pimientos Rellenos';
echo $cena;
echo "<br/>";
}
function cenaNormal( ) {
echo "Para cenar hay $cena, o ";
$cena = 'Pollo Kung Pao';
echo $cena;
echo "<br/>";
}
echo "Vegetariano <br/> ";

cenaVegetariana( );
echo "Normal <br/> ";
cenaNormal ( );
echo "Normalmente para cenar hay $cena";
Resultado:
Vegetariana
Para cenar hay , o Pimientos Rellenos
Normal
Para cenar hay , o Pollo Kung Pao
Normalmente para cenar hay Bonito en Cebolla
o Variables Globales.
El array $GLOBALS
Hay dos formas de acceder a una variable global desde una función.
La más común es usando el array especial $GLOBALS.
Cada variable global es accesible como un elemento en ese array.
$cena = 'Bonito en Cebolla';

function cenaMacrobiotica( ) {
$cena = "Algunos Vegetales";
echo “Para cenar hay $cena";
// Sucumbe a las delicias del oceano
echo " pero yo preferiría ";
echo $GLOBALS['cena'];
echo "<br/>";
}
cenaMacrobiotica( );
echo "Para cenar hay: $cena";
Resultado:
Para cenar hay Algunos Vegetales pero yo preferiría Bonito en Cebolla

Para cenar hay: Bonito en Cebolla
Modificando una variable con $GLOBALS

Página 45 de 164
function cenaLigera( ) {
$GLOBALS['cena'] = ' Revuelto de Esparragos';
}
echo "Una cena regular sería $cena";
echo "<br/>";
cenaLigera( );
echo "Una cena ligera sería $cena";
Resultado:
Una cena regular sería Bonito en Cebolla
Una cena ligera sería Revuelto de Esparragos
La palabra reservada global
La segunda forma de acceder a una variable global dentro de una función es usando la
palabra clave global.
De esta forma indicamos que la variable a la que se asocia es global.

function cenaVegetariana( ) {
global $cena;
echo "De cena había $cena, pero ahora hay ";
$cena = 'Lomo con Patatas';
echo $cena;
echo "<br/>";
}
echo "Una cena normal sería $cena.<br/>";
cenaVegetariana( );
echo "Una cena normal sería $cena";
Resultado:
Una cena normal sería Bonito en Cebolla.

De cena había Bonito en Cebolla, pero ahora hay Lomo con Patatas
Una cena normal sería Lomo con Patatas
Es recomendable usar siempre $GLOBALS.
Ejercicios.
1. Crea una funcion para escribir una etiqueta HTML de imagen <img>. La función debe
aceptar un argumento obligatorio con la URL de la imagen y otros argumentos opcionales
con el texto alternativo alt, altura y la anchura de la imagen.
function imgHtml($url, $alt = '', $height = 0, $width = 0) {

echo “<img src=’” . $url . “‘”;
if (strlen($alt)) {
echo “ alt='” . $alt . “’”;
}
if ($height) {
echo “ height=’” . $height . “’”;
}
if ($width) {
echo “ width=’”. $width .”’”;
}
echo '>';
}
2. Modifica el ejercicio anterior para que se pase sólo el nombre del fichero como
parámetro URL. Dentro de la función usa una variable global para crear la URL completa
de la imagen. Por ejemplo, si pasamos foto.jpg a la funcion y la variable global contiene
“/imágenes/”, entonces el atributo src de la etiqueta <img> debería ser “/imagenes/foto.jpg”.
function imgHtml2($fichero, $alt = '', $height = 0, $width = 0) {

echo “<img src=’” . $GLOBALS['rutaImagen'] . $fichero. ”’”;
if (strlen($alt)) {
echo “ alt=’$alt’”;
}
if ($height) {
echo “ height=’$height’”;
}
if ($width) {
Página 46 de 164
echo “ width=’$width’”;
}
echo '>';
}
3. ¿ Qué escribe la siguiente función?
$efectivo = 31;
$menu = 25;
$impuesto = 10;
$servicio = 10;
while(($precio = cuentaRestaurante($menu,$impuesto,$servicio)) < $efectivo) {
$servicio++;
echo "Puedo permitirme un servicio del $servicio% ($precio) <br/>";
}
function cuentaRestaurante($comida, $impuesto, $servicio) {

$totalImpuesto = $comida * ($impuesto / 100);
return $comida + $totalImpuesto + $totalServicio;
}
Puedo permitirme un servicio del 11% (30)

Puedo permitirme un servicio del 12% (30.25)
4. Los colores web como #ffffff y #cc3399 se crean concatenando valores hexadecimales
de color para el rojo, verde y azul. Haz una función que acepte valores decimales para los
parámetros del verde, rojo y azul y devuelve una cadena con el color apropiado para su
uso en la web. Por ejemplo, si los parámetros son 255,0 y 255, devolvería la cadena
#ff00ff. Puedes encontrar util la función dechex().
string dechex ( int numero )

Devuelve una cadena que contiene una representación hexadecimal del argumento numero dado. El
mayor número que puede convertirse es 4294967295 en decimal, que resulta en "ffffffff".
function crearColor($rojo, $verde, $azul) {

$rojoHex = dechex($rojo);
$verdeHex = dechex($verde);
$azulHex = dechex($azul);
return “#”.$redhex.$greenhex.$bluehex;
}
Página 47 de 164
Sesión 9. Formularios.
- Objetivo. Aprender a utilizar los formularios en la web.
- Actividades:
o Variables de Servidor.
El array global $_SERVER contiene varios elementos que pueden ser muy útiles por la
información que nos proporcionan.
$_SERVER[QUERY_STRING]
Devuelve la parte de la URL que viene después del signo de interrogación.
Por ejemplo:
http://www.ejemplo.com/catalogo/almacen.php?categoria=cocina&precio=5.
Obtendríamos “category=kitchen&price=5”.
$_SERVER[SERVER_NAME]
Proporciona el nombre del sitio web donde se ejecuta el intérprete de PHP.
Del ejemplo anterior, resultaría: www.ejemplo.com
$_SERVER[DOCUMENT_ROOT]
Es el directorio que contiene las páginas web de mi sitio, en el ordenador que alberga el
servidor web. Si ese directorio es /var/www/ para el sitio web www.ejemplo.com, el URL
http://www.ejemplo.com/catalogo/almacen.php se correspondería con el fichero en el
servidor /var/www/catalogo/almacen.php.
$_SERVER[REMOTE_ADDR]
Es la dirección IP de la máquina del usuario que solicita alguna página a nuestro servidor
web.
$_SERVER[PHP_SELF]
Es la página actual a la que accedemos. Es útil para hacer que un formulario envíe
parámetros a la misma página.
o Accediendo a los parámetros del formulario
Al principio de cada petición PHP inicializa los arrays globales que almacenan los valores
de cualquier parámetro enviado a través de formulario o pasado en la URL.
Los parámetros de la URL y los de formulario con método get se almacenan en el array
$_GET.
Los parámetros de formulario con método post se almacenan en el array $_POST.
Formulario de dos elementos
<form method="POST" action="catalogo.php">

<input type="text" name="idProducto">
<select name="categoria">
<option value="pimienta">Pimienta</option>
<option value="oregano">Oregano</option>
<option value="albahaca">Albahaca</option>
</select>
Página 48 de 164
<input type="submit" name="Enviar">

</form>
En catalogo.php tenemos :
idProducto: <?php echo $_POST['idProducto']; ?>

<br/>
categoria: <?php echo $_POST['categoria']; ?>
Elementos de formulario con valores múltiples
El nombre del elemento tiene que terminar en corchetes [], para que PHP lo trate como un
array.
<form method="POST" action="comer.php">
<select name="comida[ ]" multiple>
<option value="cerdo">Filete de Cerdo </option>
<option value="pollo">Filete de Pollo </option>
<option value="ternera">Filete de Ternera</option>
<option value="cordero">Filete de Cordero</option>
<option value="avestrux">Filete de Avestruz</option>
</select>
<input type="submit" name="Enviar">
</form>
En comer.php tenemos:
<br/>
<?php
foreach ($_POST['comida'] as $seleccion) {
echo "Tu quieres un filete de $seleccion. <br/>";
}
?>
Resultado, si hemos seleccionado pollo y ternera:
Tu quieres un filete de pollo.

Tu quieres un filete de ternera.
También podemos modificar el array, añadiendo algo al final:

$_POST['comida’] = 'cordero’;
o Procesado formularios con funciones

Saludando con funciones
// Lógica que muestra contenido según los parámetros enviados

if (array_key_exists('miNombre',$_POST)) {
procesaForm( );
} else {
muestraForm( );
}
// Hacer algo cuando se envía el formulario

function procesaForm( ) {
echo "Hola, ". $_POST['miNombre'];
}
// Muestra el formulario
function muestraForm( ) {
echo “<form method="POST" action="$_SERVER[PHP_SELF]">
Tu nombre: <input type="text" name="miNombre">
<br/>
<input type="submit" value="Enviar">
</form>”;
}
Usando un parámetro oculto para indicar forma de envio
En el ejemplo anterior la lógica depende del valor de información específica: el parámetro

miNombre. Para resolver este problema usamos variables ocultas (hidden). Si la variable
Página 49 de 164
oculta existe en el array $_POST procesamos el formulario, y si no, lo mostramos.

// Logica dependiente del campo oculto
if ($_POST['_envia_form']) {
procesaForm( );
} else {
muestraForm( );
}
// Procesamos formulario
echo "Hola, ". $_POST['miNombre'];
}
// Muestra el formulario
function muestraForm ( ) {
echo “<form method=’POST’ action=’$_SERVER[PHP_SELF]’>
Tu nombre: <input type=’text’ name=’miNombre’>
<br/>
<input type=’submit’ value=’Enviar‘>
<input type=’hidden’ name=’_envia_form’ value=’1’>
</form>“;
}
Además hace la lógica principal independiente de los parámetros que pueden cambiar en
un formulario.
¿Por qué no se usa el campo submit para hacer esto?

No se usa para tal fin el campo submit porque algunos navegadores no envían el valor de
este campo como parte de la información del formulario.
o Mostrando valores por defecto

Campos de Texto
$defecto=”Escribe aquí tu nombre”;

echo “<input type=’text’ name=’miNombre’ value=’$defecto’”;
Areas de Texto
$comentarios="Añade aquí tus comentarios";

echo “<textarea name=’comentarios’>”;
echo $comentarios;
echo “</textarea>”;
Lista desplegable (Select)
$diasSemana = array( 'lunes' => 'Lunes',

'martes' => 'Martes',
'miercoles' => 'Miércoles',
'jueves' => 'Jueves',
‘viernes’ =>’Viernes’,
‘sabado’ => ’Sábado’,
‘domingo’ => ‘Domingo’);
$defecto=’martes’;
echo “<select name=’diaSemana’>”;
// $opcion es el valor de la opción, $etiqueta es lo que se muestra
foreach ($diasSemana as $opcion => $etiqueta) {
echo “<option value=’$opcion’”;
if ($opcion == $defecto) {
echo “ selected=’selected’”;
}
echo "> $etiqueta</option>\n";
}
echo '</select>';
Funciona igual para listas con opciones múltiples.
Checkboxes y radio buttons

$defecto = array( 'entrega' => 'si',
'capacidad' => 'media’);
Página 50 de 164
echo “<input type=’checkbox’ name=’entrega’ value=’sí’”;

if ($defecto['entrega'] == 'si') { echo “ checked=’checked’”; }
echo “> ¿Entrega?”;
echo “<input type=’radio’ name=’capacidad’ value=’pequeña’”;

if ($defecto['capacidad'] == ‘pequeña') { echo “checked=’checked’”; }
echo '> Pequeña ';
echo “<input type=’radio’ name=’capacidad’ value=’media’”;

if ($defecto['capacidad'] == 'media') { echo “ checked=’checked’”; }
echo '> Media';
echo “<input type=’radio’ name=’capacidad’ value=’grande’”;

if ($defecto['capacidad'] == ‘grande') { echo “ checked=’checked’”; }
echo '> Grande';
Ejercicios.
1. ¿Qué aspecto tiene el array $_POST cuando se envia el siguiente formulario con la
tercera opcion seleccionada de la lista desplegable, el primer y último elemento en la
lista de selección múltiple y un 4 introducido en el campo de texto?
<form method="POST" action="orden.php">

Entrecot de Ternera con:
<select name="salsa">
<option>Pimienta</option>
<option>Queso</option>
<option>Oporto</option>
<option>Finas hierbas</option>
</select>
<br/>
Dulces:
<select name="dulces[ ]" multiple>
<option value="perrunilla">Perrunilla de anís
<option value="donut"> Donut de chocolate
<option value="galleta"> Galleta de coco
<option value="bizcocho"> Bizcocho almendrado
</select>
<br/>
Cantidad de dulces:
<input type="text" name="dulcesCantidad">
<br/>
<input type="submit" name="Enviar" value="Orden">
</form>
Valores de $_POST:
array(4) { ["salsa"]=> string(14) "Oporto"

["dulces"]=> array(2) { [0]=> string(10) "perrunilla"
[1]=> string(8) "bizcocho"
}
["dulcesCantidad"]=> string(1) "4"
["submit"]=> string(5) "Orden"
}
2. Escribe una función procesaForm() que muestre todos los parametros del
formulario enviado y sus valores.
echo "<ul>";
foreach ($_POST as $elemento=> $valor) {
echo "<li> \$_POST[$elemento] = $valor</li>";
}
echo "</ul>";
}
3. Escribe un programa que realize operaciones aritméticas básicas. Muestra un

formulario que tenga dos campos de texto para dos oeprandos y una lista desplegable
para elegir la operación: suma, resta, producto o división. Se deben mostrar los
operandos la operación y el resultado. Por ejemplo: "4 * 2 = 8".
Página 51 de 164
<?php
$ops = array('+','-','*','/');
procesaForm( );
} else {
muestraForm( );
}
function muestraForm() {
// El principio del formulario
echo “<form method=’POST’ action=’”.$_SERVER[PHP_SELF].”’>”;
// El primer operando
echo “<input type=’text’ name=’operando1’ size=’5’ value=’”;
echo $_POST['operando1'].”’/>”;
// El operador
echo “<select name=’operador’>”;
foreach ($GLOBALS['ops'] as $op) {
echo '<option';
if ($_POST['operador'] == $op) { echo “ selected=’selected’”; }
echo "> $op</option>";
}
echo '</select>';
// El segundo operando
echo “<input type=’text’ name=’operando2’ size=’5’ value='”;
echo $_POST['operando2'] .”’/>”;
// El boton de envio
echo “<br/><input type=’submit’ value=’Calcular’/>”;
// El campo oculto _envia_form

echo “<input type=’hidden’ name=’_envia_form’ value=’1’/>”;
// El final del formulario

echo '</form>';
}
if ('+' == $_POST['operador']) {
$total = $_POST['operando1'] + $_POST['operando2'];
} elseif ('-' == $_POST['operador']) {
$total = $_POST['operando1'] - $_POST['operando2'];
} elseif ('*' == $_POST['operador']) {
$total = $_POST['operando1'] * $_POST['operando2'];
} elseif ('/' == $_POST['operador']) {
$total = $_POST['operando1'] / $_POST['operando2'];
}
echo "$_POST[operando1] $_POST[operador] $_POST[operando2] = $total";
}
?>
Página 52 de 164
Sesión 10. Incluyendo ficheros.

- Objetivo. Estructurar la aplicación PHP en varios ficheros.
- Actividades:
o Introducción
PHP permite separar el código en varios archivos e incluirlo en los programas que
necesitemos, reutilizando así el código generado.
Definiendo constantes y funciones comunes
miFoto.php
<?php
define(“ALTO”, 200);
define(“ANCHO”, 200);
?>
<img src=”miFoto.jpg” height=”<?php echo ALTO?>” width=”<?php echo ANCHO?>” />
Según este código tendríamos que repetir la definición de constantes para cada fichero
PHP en el que las utilicemos.
Si almacenamos la definición de las constantes en un archivo aparte, como por ejemplo

constantes.php.
constantes.php
<?php
?>
miFoto1.php
<?php include (“constantes.php”); ?>

<img src=”miFoto.jpg” height=”<?php echo ALTO?>” width=”<?php echo ANCHO?>” />
Ahora solo tenemos que incluir el fichero de constantes en cualquier fichero PHP que las
necesite, teniendo disponible todo su código como si estuviese en el archivo en el que se
incluye.
Esto funciona tanto para definición de variables, codigo, definición de funciones, clases,
etc.
Página 53 de 164
constantes1.php
<?php
function muestraImagen($img){
echo ”<img src=’$img’ height=’”.ALTO.”’ width=’”.ANCHO.”’ />”;
}
?>
miFoto2.php
<?php
include (“constantes1.php”);
muestraImagen(“miFoto.jpg”);
?>
Podemos incluir tantos ficheros como necesitemos.
o include, include_once
include_once(“nombreFichero”);
Cuando queremos incluir ficheros con variables, funciones y clases similares y no

queremos sobreescribirlas o queremos asegurarnos de que no se incluyen los mismos
elementos varias veces.
o require, require_once
Funcionan exactamente igual que include.
Solo se diferencian en la forma en la que manejan los errores en la inclusión de ficheros. Si

incluimos (include) un fichero que no existe recibiremos un aviso o warning y nuestro script
PHP continuará.
Si requerimos (require) un fichero que no existe provocará un error fatal y nuestro

programa en PHP parará.
También es posible usar variables al incluir ficheros:
Página 54 de 164
include (“$archivo”);
o Usar funciones e inclusión de ficheros para obtener las cadenas que muestran
los datos de usuario.
Página 55 de 164
Sesión 11. Bases de datos.

- Objetivo. Interactuar con bases de datos.
- Actividades:
o PHP y las Bases de Datos
PHP soporta la mayor parte de los motores de bases de datos más conocidos:
IBM DB2
Informix
Ingres
Microsoft SQL Server (MS SQL)
mSQL
MySQL
Oracle
PostgreSQL
Sybase
ODBC
Existen varios juegos de funciones específico para cada motor de base de datos.
Vamos a ver como se relaciona PHP con MySQL y Oracle.
La extensión PHP de MySQL utilizada hasta ahora no soporta toda la funcionalidad

proporcionada por las versiones de MySQL superiores a 4.1.0, tal como Procedimientos
Almacenados, Disparadores, Vistas, Precisión Matemática y algunas más.
Para aprovechar todas estas características se utiliza la extensión PHP para MySQL
mysqli disponible como parte de PHP 5.0.
Las principales características de la extensión mysqli son:
Página 56 de 164
- Acceso a todas las ventajas de MySQL 4.1/5.0 .

- Un interface procedimental similar al de la extensión mysql.
- Un interface orientado a objetos más facil de extender.
Las extensiones PHP para acceder a Oracle son php_oracle y php_oci8.
o Conectando con la Base de Datos
Para conectar con la base de datos es necesario proporcionar cuatro parámetros:
- Localización: La base de datos puede no estar situada en el mismo sistema

que el intérprete de PHP, por tanto es necesario proporcionar el nombre del
sistema en el que está la base de datos. Se puede proporcionar tanto un
nombre de dominio como una dirección IP. Si la base de datos se encuentra
en el mismo lugar que PHP se puede usar localhost.
- Usuario: Debe existir una cuenta de usuario válida para acceder a la base de
datos.
- Clave: La clave de acceso de la cuenta de usuario.
- Nombre de la Base de Datos: Un motor de base de datos puede crear y

mantener muchas bases de datos, por tanto tenemos que indicar qué base de
datos queremos utilizar.
Vamos a crear un archivo que contenga las variables necesarias para acceder a nuestra
base de datos y así, poder incluirlo en aquellos ficheros PHP que lo necesiten:
config.php
<?php
$servidor = “localhost”;
$usuario = “admin”;
$clave = “secreto”;
$bd = “cursoPHP5”;
?>
Página 57 de 164
Así podremos incluirlo añadiendo una línea como sigue:
include(“config.php”);
Las funciones para conectar con la base de datos no son las mismas para todos los
motores de bases de datos, aunque tienen un formato similar.
MySQL 4.0 o anteriores versiones:
$conexion = mysql_connect($servidor,$usuario,$clave);
$baseDatos = mysql_select_db($bd, $conexion);
MySQL 4.1 o superiores:
Procedimental
$conexion = mysqli_connect($servidor,$usuario,$clave);
$baseDatos = mysqli_select_db($bd,$conexion);
Orientado a Objetos (Recomendada)
$conexion = new mysqli($servidor,$usuario,$clave,$bd);
Oracle:
$conexion = oci_connect($usuario, $clave);
La conexión de Oracle necesita que esté definida la variable de entorno ORACLE_SID

para indicar la instancia deseada de Oracle.
o Consultando la Base de Datos
Después de conectar con la base de datos podemos consultar, modificar, insertar o

eliminar datos en ella.
Usaremos para nuestros ejemplos la tabla productos de la base de datos cursoPHP5.
Página 58 de 164
Id * Nombre Precio
1 Patatas 10.00
2 Manzanas 5.00
3 Tomate 3.00
4 Limon 2.00
*Clave principal con generación automática.
o phpMyAdmin
Es una herramienta web para administrar servidores de bases de datos MySQL.
Podemos crear nuestra base de datos desde PHP pero es más útil y rápido usar este tipo
de entornos tanto para la creación, como la modificación y administración de nuestras
bases de datos MySQL.
$consulta = “SELECT * FROM productos”;

$resultado = mysql_query ( $consulta ); // mysql_query($consulta,$conexion)
for ( $i = 0 ; $i < mysql_num_rows( $resultado ) ; ++$i )
echo mysql_result ( $resultado , $i, ‘nombre’ )) . “<br/>”;
// mysql_result ( $resultado , $i, 1 ));
Resultado:
Patatas
Manzanas
Tomate
Limon
while ($fila = mysql_fetch_array ( $resultado))

echo " ID: $fila [ id ] Nombre: $fila [ nombre ] Precio: $fila [ precio ] <br/>";
Resultado:
ID: 1 Nombre: Patatas Precio: 10.00

ID: 2 Nombre: Manzanas Precio: 5.00
ID: 3 Nombre: Tomate Precio: 3.00
ID: 4 Nombre: Limon Precio: 2.00
MySQL 4.1 o superiores:
$consulta = " SELECT * FROM productos ";

$resultado = $conexion->query($consulta);
// array numerico
while ( $fila = $resultado->fetch_array())
echo " $fila [ 0 ] , $fila [ 1 ] <br/>"; //echo " $fila[id] , $fila[nombre] <br/>";
Página 59 de 164
echo “Registros: $resultado->num_rows”;
Resultado:
1, Patatas
2, Manzanas
3, Tomate
4, Limon
Registros: 4
Oracle:
$cadena = “SELECT * FROM productos”;

$consulta = oci_parse($conexion,$cadena);
oci_execute($consulta);
while ($fila = oci_fetch_array ($consulta)) {

echo $fila [ 0 ] . " y " . $fila [ ' id ' ] . " es lo mismo. <br/>";
echo $fila [ 1 ] . " y " . $fila [ ' nombre ' ] . " es lo mismo. <br>";
}
Practicamente las tres opciones tienen formatos similares.
Cuando se trata de consultas que no devuelven datos, tales como inserciones,

actualizaciones o eliminaciones, se usan las mismas funciones.
$producto = “Jamón”;
$consulta = “INSERT INTO productos (id, nombre) VALUES (null , ’$producto’)”;
$resultado = mysql_query($consulta);
Si no se devuelve nada, $resultado contiene el valor TRUE.
Esto funciona también para UPDATE y DELETE.
o Cerrando la conexión
Cualquier conexión abierta de base de datos es cerrada cuando finaliza el script PHP.
Página 60 de 164
Sin embargo, en ocasiones es una buena práctica cerrar la conexión explícitamente en el

script para evitar problemas
mysql_close ( $conexión );
mysqli_close ( $conexión );
oci_close ( $conexión );
TRUCO: Para obtener el identificador autogenerado del último insertado:
$conexion->insert_id
mysql_insert_id()
En mysql también podemos hacer la siguiente consulta inmediatamente después de

insertar un elemento, para obtener el id insertado:
SELECT LAST_INSERT_ID( ) ;
Ejercicios.
Para los ejercicios siguientes usaremos una tabla llamada platos:
CREATE TABLE platos (

idPlato INT,
nombrePlato VARCHAR(255),
precio DECIMAL(4,2),
esPicante INT
)
idPlato como clave principal autoincrementable.
Creamos varios registros:
INSERT INTO platos VALUES (1,'Gazpacho',1.00,0)

INSERT INTO platos VALUES (2,'Entrecot de Ternera',4.95,0)
INSERT INTO platos VALUES (3,'Revuelto de Esparragos ',3.00,0)
INSERT INTO platos VALUES (4,'Ensalada de Jalapeños',6.50,1)
INSERT INTO platos VALUES (5,'Crema de Calabacín',1.00,0)
INSERT INTO platos VALUES (6,'Pollo al Curry',5.50,1)
1. Escribe un programa en PHP que muestra todos los platos de la tabla ordenados por
precio.
Página 61 de 164
<?php
require_once “config.php”;
$baseDatos = mysqli_select_db($conexion, $bd);
$consulta=”SELECT nombrePlato,precio FROM platos ORDER BY precio”;
if($resultado->num_rows>0){
while ( $plato = $resultado->fetch_array())
echo " - $plato[nombrePlato] ($plato[precio]) <br/>";
}
}
else{
echo “No hay platos disponibles.”;
}
?>
2. Escribe un programa en PHP que muestre un formulario solicitando un precio. Cuando

se envíe el formulario, la aplicación debe escribir el nombre y el precio de aquellos platos
cuyo precio sea mayor o igual al enviado. No obtener de la base de datos nada que no se
vayan a mostrar en la web.
<?php
procesaForm( );
} else {
muestraForm( );
}
// Comienzo del formulario
echo “<form method=’POST’ action=’”.$_SERVER['PHP_SELF'].”’>”;
echo “<table>”;
// El precio
echo “<tr><td>Precio:”;
echo “<input type=’text’ name='precio' id=’precio’>”;
echo “</td></tr>”;
// Fin del formulario

echo “<tr><td colspan=’2’><input type=’submit’ value=’Buscar platos’>”;
echo “</form>”;
}
global $conexion;
$consulta=”SELECT nombrePlato, precio FROM platos”.
“ WHERE precio >=”.$_POST['precio'];
if ($resultado->num_rows> 0) {
while($plato = $resultado->fetch_array()) {
echo "- $plato[nombrePlato] ( $plato[precio] ) <br/>";
}
} else {
echo “No hay coincidencias.”;
}
}
?>
3. Crea un programa que muestre un formulario con una lista desplegable con los nombres
de los platos. Una vez que el usuario haya elegido un plato de la lista y haya enviado el
Página 62 de 164
formulario, el programa mostrará toda la información referente a ese plato (Id, nombre,
precio, y si es picante).
<?php
// Obtenemos un array con los nombres de platos

$platosNombres = array( );
$consulta=”SELECT idPlato,nombrePlato FROM platos”;

while ($plato = $resultado->fetch_array()) {
$platos[ ] = $plato;
}
procesaForm( );
} else {
muestraForm( );
}
// Comienzo del formulario
echo “<form method=’POST’ action='”.$_SERVER['PHP_SELF'].”’>”;
echo “<table>”;
// Lista desplegable de platos
echo “<tr><td>Plato:”;
echo “<select name='idPlato' >”;
foreach($GLOBALS['platos'] as $id=>$plato )
echo “<option value=’$id’>$plato</option>”;
// Fin del formulario

echo “<tr><td colspan=’2’><input type=’submit’ value=’Buscar platos’>”;
echo “</form>”;
}
global $conexion;
$idPlato = $_POST['idPlato'];
$consulta=”SELECT idPlato,nombrePlato, precio, esPicante”.
“ FROM platos WHERE idPlato= $idPlato”;
$tabla=$resultado->fetch_array();
if ($resultado->num_rows > 0) {
echo “ ID: $tabla[idPlato] <br/>";
echo " Nombre: $tabla[nombrePlato] <br/>";
echo " Precio: $tabla[precio] <br/>";
echo " Picante: “;
if($tabla[esPicante] == 1)
echo “ Sí ";
else
echo “ No ";
} else {
echo “Ese plato no existe.”;
}
}
?>
Página 63 de 164
4. Crea una nueva tabla que almacene información sobre los clientes del restaurante. La
tabla deberá contener la siguiente información: idCliente, nombre, telefono, y el id de su
plato favorito. Escribe un programa que muestre un formulario que permite insertar nuevos
clientes en la tabla. La parte del formulario encargada de seleccionar el plato favorito
deberá ser una lista desplegable con todos los platos. El id del cliente no se creará desde
el formulario sino que será generado automáticamente por la base de datos.
CREATE TABLE cliente(

idCliente INT UNSIGNED,
nombre VARCHAR(255),
telefono VARCHAR(15),
platoFavorito INT
PRIMARY KEY (`idCliente`)
) AUTO_INCREMENT=1;
<?php
$platos= array( );
$consulta=”SELECT idPlato,nombrePlato FROM platos”;

while ($plato = $resultado->fetch_array()) {
$platos[ ] = $plato;
}
procesaForm( );
} else {
muestraForm( );
}
global $platos;
// Si se ha enviado el formulario, obtenemos los valores enviados para mostrar
$defecto = $_POST;
} else {
// Si no, no mostramos nada
$defecto = array( );
}
?>
<form method="POST" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<table>
<tr><td>Nombre del Cliente:</td>
<td><input type=’text’ name='nombre' id=’nombre’></td></tr>
<tr><td>Teléfono:</td>
<td><input type=’text’ name=’telefono’ id=’telefono’></td></tr>
<tr><td>Plato Favorito:</td>
<td>
<select name=’platoFavorito’ >
<?php foreach($platos as $indice=>$plato)
echo “<option value=’$indice’>$plato</option>”;
?>
</select>
</td></tr>
<tr><td colspan="2" align="center">
<input type=’submit’ value=’Nuevo Cliente’>
</td></tr>
</table>
<input type="hidden" name="_envia_form" value="1"/>
</form>
<?php
} // El fin del formulario
global $conexion;
$consulta=” INSERT INTO cliente (idCliente, nombre, telefono, platoFavorito)”.

“ VALUES(null,’$_POST[nombre]’,’ $_POST[telefono]’, $_POST[platoFavorito])”;
Página 64 de 164
// Confirmamos al usuario la inserción
echo “Añadido el cliente $_POST[nombre] a la base de datos.”;
}
?>
• Modificar nuestra aplicación para gestionar la información de los contactos

desde una base de datos.
o Crear una tabla de contactos.

o Modificar nuestra aplicación para obtener esos datos.
• Incluir opciones para insertar, modificar y eliminar contactos.
Página 65 de 164
Sesión 12. Fecha y Hora.

- Objetivo. Conocer el uso de las funciones para el tratamiento de la fecha y hora.
- Actividades:
o Mostrando la fecha y la hora.
¿Qué hora es?
echo "strftime( ) muestra: ".strftime('%c');

echo "<br/>";
echo "date( ) muestra: ".date('r');
Si estamos a viernes, 13 de abril de 2007, el resultado será:
strftime( ) muestra: 04/13/07 10:27:51

date( ) muestra: Fri, 13 Apr 2007 10:27:51 +0200
Ambas funciones tienen dos parámetros: el primero controla el formato a mostrar y el

segundo la hora o fecha a tratar. Si se omite el segundo se toma el momento actual.
Mostrando la fecha actual formateada con date( )
echo date(“d/m/y”);
El 13 de abril de 2007 muestra:
13/04/07
Como se puede observar la letra ‘d’ indica el día (13), la ‘m’ el mes (04) y la ‘y’ el año con
dos dígitos (07).
La barra inclinada (/) al no ser un carácter que la función date() reconozca, la imprime
como un carácter más.
Página 66 de 164
Con la función strftime(), los caracteres a reemplazar van acompañados del carácter de
porcentaje (%) y aunque algunos coinciden con date(), tiene sus propios caracteres de
formato.
echo strftime('%d/%m/%y');
El resultado es el mismo:
13/04/07
En el apartado de referencias al final de este texto se encuentra una tabla con los
caracteres de formato de ambas funciones.
Mostrando una hora específica con formato
echo “strftime() muestra: “;

echo strftime('%I:%M:%S', time( ) + 60*60);
echo "<br/>";
echo “date( ) muestra: “;
echo date('h:i:s', time( ) + 60*60);
Resultado a las 01:49:59:
strftime() muestra: 02:49:59

date( ) muestra: 02:49:59
Mostrando una hora con formato desde un texto
echo “strftime( ) muestra: “;

echo strftime(“Hoy es %d/%m/%y y son las %I:%M:%S');
echo "<br/>";
echo “date( ) muestra: “;
echo “Hoy es “ . date(“d/m/y”) .” y son las “ . date(“h:i:s”);
El viernes, 13 de abril de 2007 a las 12:00 :
strftime( ) muestra: Hoy es 13/04/07 y son las 12:00:00

date( ) muestra: Hoy es 13/04/07 y son las 12:00:00
La característica más importante que hace más atractivo el uso de date() sobre strftime()
es que la primera es una función nativa de PHP mientras que la segunda utiliza una
función subyacente del sistema en el que se instala PHP.
Página 67 de 164
Creando una marca de tiempo
// obtenemos los valores de un formulario

$usuarioFecha = mktime($_POST['hora'], $_POST['minuto'], 0, $_POST['mes'],
$_POST['dia'], $_POST['año']);
// 1:30 pm (y 45 segundos) el 13 de abril de 2007

$tarde = mktime(13,30,45,04,13,2007);
echo strftime('A las %I:%M:%S de %m/%d/%y, ', $tarde);
echo "$tarde segundos han pasado desde el 1/1/1970.";
Resultado:
A las 01:30:45 on 10/20/82, 403965045 segundos han pasado desde el 1/1/1970.
Todos los parámetros de mktime() son opcionales, de forma que aquellos que omitamos
los completa con la hora actual. Por ejemplo mktime(15,30,0) devuelve las 3:30 p.m. de
hoy.
Uso de la función strtotime( )
Cuando quieres obtener una fecha relativa a algun evento concreto se usa strtotime( ).
Solo reconoce descripciones en inglés de momentos concretos y devuelve la fecha
correspondiende.
$ahora = time( );
$despues = strtotime('Thursday',$ahora); // Busca la fecha del próximo martes
$antes = strtotime('last thursday',$ahora); // Busca la fecha del martes anterior
echo strftime("ahora: %d/%m/%Y \n", $ahora);
echo strftime("despues: %d/%m/%Y \n", $despues);
echo strftime("antes: %d/%m/%Y \n", $antes);
Resultado, el viernes 13 de abril de 2007 es:
ahora: 13/04/2007
despues: 19/04/2007
antes: 12/04/2007
Ejercicios.
Página 68 de 164
1. Usa strftime( ) para mostrar lo siguiente:
Hoy es día 13 de abril y el día 294 del año 2007. Son las 07:45 PM (es decir las 19:45).
Para mostrar exactamente lo mismo que el ejemplo utiliza mktime() para obtener la marca
de tiempo correspondiente al 13 de abril de 2007 a las 7:45 p.m.
$marca = mktime(19,45,0,10,20,2004);
echo strftime(“Hoy es día %d de %B y el día %j del año %Y. Son las %I:%M %p
(es decir las %H:%M).”, $marca);
2. Usa date( ) para mostrar el mismo resultado que el ejercicio anterior.
$marca = mktime(19,45,0,10,20,2004);
echo “Hoy es día “.date(“d”,$marca).” de “.date('F',$marca).” y día “. (date(“z”,$marca)+1);
echo “ del año “.date(“Y”,$marca.”. Son las “.date(“h:i A”,$marca);
echo “ (es decir las “.date(“H:i”,$marca).”).”;
3. Crea una tabla que muestre la fecha en la que cae el último domingo de mayo desde el
2007 al 2020.
echo “<table>”;
echo “<tr><th>Year</th><th>Elecciones</th></tr>”;
for ($anio = 2007; $anio <= 2020; $anio++) {
// Obtenemos la fecha del 1 de mayo del año $anio
$marca = mktime(12,0,0,6,1,$anio);
// Avanzamos hasta el primer domingo
$marca = strtotime('last sunday', $marca);
echo "<tr><td>$anio</td><td>";
echo date('F j', $marca);
echo "</td></tr>\n";
}
echo '</table>';
Página 69 de 164
Sesión 13. Subiendo ficheros.

- Objetivo. Aprender a subir ficheros a nuestro sitio web.
- Actividades:
o Subir ficheros a través de formulario.
El elemento de formulario <input type="file"> nos permite subir a nuestro servidor web
todo el contenido de un fichero.
Cuando un formulario enviado incluye entre sus elementos uno de tipo file, PHP
proporciona acceso al fichero subido a través del array global $_FILES.
if ($_POST['_enviado']) {
if ($formErrores = validaForm( )) {
muestraForm($formErrores);
} else {
procesaForm( );
}
} else {
muestraForm( );
}
function muestraForm($errores = '') {

if ($errores) {
echo “Es necesario corregir los siguientes errores: <ul><li>”;
echo implode(“</li><li>”,$errores);
echo “</li></ul>”;
}
echo " <form enctype=’multipart/form-data’ method=’POST’ ".

" action=’$_SERVER[PHP_SELF]’>".
" Archivo a subir: <input name=’miFichero’ type=’file’/>”.
" <input type=’hidden’ name=’MAX_FILE_SIZE’ value=’131072’/>".
" <input type=’hidden’ name=’_enviado’ value=’1’>".
" <input type=’submit’ value=’Subir’/></form>”;
}
function validaForm( ) {
$errores = array( );
if (($_FILES['miFichero']['error'] == UPLOAD_ERR_INI_SIZE)||
($_FILES['miFichero']['error'] == UPLOAD_ERR_FORM_SIZE)) {
$errores[ ] = “El tamaño del archivo es demasiado grande.”;
} elseif ($_FILES['miFichero']['error'] = = UPLOAD_ERR_PARTIAL) {
$errores[ ] = 'La subida del fichero ha sido interrumpida.';
} elseif ($_FILES['miFichero']['error'] = = UPLOAD_ERR_NO_FILE) {
$errores[ ] = 'No hay ficheros para subir. ';
}
return $errores;
}
echo "Has subido un archivo llamado {$_FILES['miFichero']['name']} ";
echo " de tipo {$_FILES['mFichero']['type']} que tiene un tamaño de ";
echo "{$_FILES['miFichero']['size']} bytes.";
echo “{$_FILES['miFichero']['name']}”;
$ficheroDestino = '/var/www/cursoPHP5/ficheros/imagen.jpg';
$ficheroOrigen=$_FILES['miFichero']['tmp_name']; // La ruta de almacenamiento temporal
// del fichero subido en el servidor
if (copy ($ficheroOrigen, $ficheroDestino)) {
echo "Fichero subido como $destination_file.";
} else {
echo "No ha sido posible subifr el fichero.";
}
}
Página 70 de 164
También es posible usar move_uploaded_file para mover el fichero.

• Modificar nuestra aplicación para subir la imagen de cada contacto.
Página 71 de 164
Página 72 de 164
Sesión 14. Sesiones.

- Objetivo. Conocer cómo gestiona PHP las sesiones web.
- Actividades:
o Activando sesiones.
Una cookie identifica un cliente particular para un servidor web y un intérprete PHP. Cada
vez que un cliente hace una solicitud envía una cookie con esa solicitud. PHP lee la cookie
e identifica que la petición viene del mismo cliente web que hizo otras peticiones antes con
la misma cookie.
El inconveniente de las cookies es que sólo almacenan un valor para cada cookie.
Cuando queremos almacenar más información son más útiles las sesiones.
Una sesión usa una cookie para distinguir entre cada usuario y almacena una pila temporal
de datos para cada usuario en el servidor.
Los datos permanecen durante las peticiones, de forma que en una solicitud podemos
añadir una variable a la sesión de usuario y en una posterior podemos recuperarla sin
problemas.
Página 73 de 164
Las sesiones usan una cookie llamada PHPSESSID.
Cuando iniciamos una sesión en una página, PHP comprueba la presencia de esta cookie
y la inicializa si no existe.
El valor de PHPSESSID es una cadena alfanumérica aleatoria.
Cada cliente web obtiene un identificador de sesión distinto, identificándolo unívocamente

en el servidor. Esto permite mantener pilas separadas de datos para cada cliente.
Para usar sesiones en una página utilizamos la función session_start( ) al principio de

nuestro script. Es importante señalar que esta función debe ser llamada antes de que envie
nada.
o Almacenando y recuperando información.
Los datos de sesión se almacenan en el array global $_SESSION.
Contando de accesos con sesiones.
session_start( );
$_SESSION['contador'] = $_SESSION['contador'] + 1;
echo "Has visitado esta página " . $_SESSION['contador'] . ' veces.';
Resultado:
Página 74 de 164
Has visitado esta página 1 veces.
A medida que vayamos visitando la página sin cerrar el navegador y sin cerrar la sesion
explícitamente con PHP iremos viendo como se incrementa el contador:
...
o Guardando datos de formulario en una sesión.

<?php
session_start( );
$platosPrincipales = array( 'garbanzos' => 'Cocido de Garbanzos',

'arroz' => "Arroz con Pollo",
'macarrones' => 'Macarrones con Tomate',
'ensalada' => 'Ensalada de Verduras',
'ajetes' => 'Revuelto de Ajetes',
'gazpacho' => 'Gazpacho Extremeño');
procesaForm( );
} else {
muestraForm( );
}
echo “<form method=’POST’ action=’".$_SERVER['PHP_SELF']."’>”;
echo “ Plato: <select name=’dish’>”;
foreach($GLOBALS[‘platosPrincipales’] as $indice=>$plato)
echo “<option value=’$indice’> $plato</option>”;
echo “ </select><br/>“;
echo “Cantidad: <input type=’text’ name=’cantidad’ value=’$POST[cantidad]’>”;
echo “<br/>”;
echo “<input ytpe=’submit’ value=’Enviar’>”;
echo “</form>”;
}
$_SESSION['orden'][ ] = array('plato' => $_POST['plato'],
'cantidad' => $_POST['cantidad']);
echo “Gracias por su pedido.”;
} ?>
Los datos de sesion no están restringidos a cadenas y números como las cookies.
Mostrando los datos de sesión.
<?php
session_start( );
$platosPrincipales = array( 'garbanzos' => 'Cocido de Garbanzos',
Página 75 de 164
'arroz' => "Arroz con Pollo",

'macarrones' => 'Macarrones con Tomate',
'ensalada' => 'Ensalada de Verduras',
'ajetes' => 'Revuelto de Ajetes',
'gazpacho' => 'Gazpacho Extremeño');
if (count($_SESSION['orden']) > 0) {
echo “<ul>“;
foreach ($_SESSION['orden'] as $orden) {
$platoNombre = $platosPrincipales [ $orden['plato'] ];
echo "<li> $orden[cantidad] de $platoNombre </li>";
}
echo "</ul>";
} else {
echo "No has pedido nada.";
}
?>
o ¿Por qué session_start( ) tienen que estar al principio de la página?
Cuando un servidor web responde a un cliente web la mayor parte de la respuesta es el

documento html que el navegador convierte para mostrarlo como una página web.
Ese html es una sección de la respuesta que además contiene las cabeceras o headers,
que están situadas antes del html.
Estas cabeceras no se utilizan para mostrar algo en nuestra web sino para indicar ciertas
órdenes o incluir información útil para el navegador.
Todas las cabeceras de la respuesta del servidor web han de estar al principio de la
respuesta, antes del cuerpo de la página, que es donde html controla lo que se muestra en
el navegador. Si se envía algo del cuerpo, aunque sea una línea e incluso un espacio, ya
no es posible enviar más cabeceras.
Las funciones como setcookie( ) y session_start( ) añaden cabeceras a la respuesta.

Para que sean enviadas de forma adecuada deben ser añadidas antes de cualquier tipo de
etiqueta de salida. Esto es por lo que estas funciones tienen que ser llamadas antes de
cualquier echo() o etiqueta fuera de php.
Si se envia cualquier salida antes de session_start( ) se muestra el siguiente error:
Warning: Cannot modify header information - headers already sent by
(output started at /www/htdocs/contactos.php:2) in /www/htdocs/contactos.php on line 4
Página 76 de 164
Para eliminar una variable de sesión es necesario utilizar unset(), al igual que cualquier
otra variable.
Para cerrar una sesión se utiliza la función session_destroy().
Ejercicios.
1. Crea una página web que use una variable de sesión que almacene el número de veces
que un usuario ha visto la página. Debe mostrar :
Número de vistas: 1.
Número de vistas: 2.
...
session_start( );
$_SESSION['contador'] = $_SESSION['contador'] + 1;
echo "Número de vistas: " . $_SESSION['contador'] . “.”;
2. Modifica la página web del primer ejercicio para que muestra un mensaje especial para
la vez quinta, décima y décimo quinta. Para la vigésima vez elimina la sesión y comienza
de nuevo.
<?php
session_start( );
$contadorPag = $_SESSION['contador'] + 1;
if ($contadorPag == 20) {
// un valor vacío elimina la variable
session_destroy();
echo "Comenzamos de nuevo.";
} else {
$_SESSION['contador']= $contadorPag;
echo "Número de vistas: $contadorPag";
if ($contadorPag == 5) {
echo "<br/> Ésta es tu quinta visita.";
} elseif ($contadorPag == 10) {
echo "<br/> Ésta es tu décima visita.";
} elseif ($contadorPag == 15) {
echo "<br/> Ésta es tu décimo quinta visita.";
}
}
?>
Página 77 de 164
3. Escribe un programa PHP que muestra un formulario que permita al usuario elegir un
color de una lista. Crea otra página cuyo color de fondo se establezca al color elegido por
el usuario. Almacena el valor del color en $_SESSION para que ambas páginas puedan
utilizarlo.
<?php
session_start( );
$colores = array( '#ff0000' => 'rojo',
'#ff6600' => 'naranja',
'#ffff00' => 'amarillo',
'#0000ff' => 'verde',
'#00ff00' => 'azul',
'#ff00ff' => 'purpura');
procesaForm( );
} else {
muestraForm( );
}
echo “<form method=’POST’ action=’".$_SERVER['PHP_SELF']."’>”;
echo “Color: <select name=’color’>“;
foreach($GLOBALS[‘colores’] as $indice=>$color)
echo “<option value=’$indice’>$clor</option>”;
echo “</select><br/>”;
echo “<input type=’submit’ value=’Selecciona Color’>”;
echo “</form>”;
}
$_SESSION['color'] = $_POST['color'];
echo "Tu colo favorito es: " . $GLOBALS['colores'][ $_SESSION['color'] ];
}
?>
color.php
<?php
session_start( );
echo “<html>
<body bgcolor=’$_SESSION[color]’>
Esta página tiene tu color de fondo personalizado.
</body>
</html>”;
?>
Página 78 de 164
Sesión 15. Orientación a Objetos (I). Introducción.

- Objetivo. Conocer qué es la Programación Orientada a Objetos y cómo se implementa en
PHP.
- Actividades:
o Introducción.
¿Qué es la Programación Orientada a Objetos (POO)?
La POO necesita una forma diferente de pensar al crear nuestras aplicaciones, nos
acercamos con código a tareas, procesos e ideas del mundo real.
Con la programación estructurada vemos nuestra aplicación como un conjunto de procesos

que intercambian información.
Con la POO modelamos nuestra aplicación como un conjunto de objetos que colaboran
entre sí y realizan de forma independiente ciertas actividades.
Cuando se construye una casa los carpinteros no necesitan saber si los circuitos de una
habitación son de 10 o 20 amperios. Sólo necesitan conocer lo relacionado con su
actividad. Un contratista se asegura que cada subcontratista termine su trabajo para
terminar la obra pero no le interesan los detalles particulares de cada tarea.
La POO es similar ya que cada objeto oculta a los demás los detalles de su
implementación. Cómo haga cada uno su trabajo es irrelevante para el resto de
componentes del sistema. Lo interesante es el servicio que cada objeto es capaz de
proveer.
Ventajas de la POO
• La facilidad con la que se pueden trasladar requerimientos individuales de negocios

a modulos individuales de código.
Debido a que la POO permite modelar nuestra aplicación basándonos en la idea de

objetos del mundo real, a menudo podremos identificar una relación directa entre
personas, cosas y conceptos con sus clases equivalentes. Estas clases tienen las
mismas propiedades y comportamientos que los conceptos del mundo real que
representan, permitiéndonos identificar rápidamente el código que necesitamos
escribir y cómo tienen que interactuar entre sí las diferentes partes.
Página 79 de 164
• La reutilización de código. Normalmente necesitamos el mismo tipo de datos en

diferentes lugares en la misma aplicación. Por ejemplo, una aplicación que de un
hospital que gestiona el registro de sus pacientes necesita una clase llamada
Persona. Para el cuidado del enfermo es necesario cierto número de personas (el
paciente, los doctores, las enfermeras, los administrativos, etc.). Para cada acción
en el cuidado que recibe el paciente, el registro incluye una nota acerca de la
persona que realiza esa acción (prescribir una medicina, un tratamiento, etc.) y una
indicación sobre si esa persona esta autorizada para realizarla. Si definimos una
clase genérica llamada Persona que contenga todos las propiedades y métodos
comunes a toda esa gente, habremos reutilizado mucho código, algo que en la
programación estructurada se puede hacer bastante complicado.
Una clase Persona bien hecha puede ser facilmente copiada de un proyecto a otro
con alguno o ningún cambio, ofreciendonos toda la funcionalidad desarrollada
previamente. Esta es otra de los grandes beneficios de la POO, la reutilización de
código entre proyectos.
• Otra de las ventajas viene de la mano de la modularidad de las clases. Si

descubrimos un error en nuestra clase Persona o queremos añadir algún cambio
para que funcione, solo hay un sitio dónde buscar. Toda la funcionalidad de la
clase está contenida en un único archivo. Cualquier proceso de la aplicación que
utilice la clase Persona, ser verá inmediatamente afectado por el cambio. Esta
característica simplifica enormemente la detección y búsqueda de errores y hace la
adición de características algo trivial.
o Conceptos de POO
• Clases: son el molde de un objeto donde reside el código que define las
propiedades y los métodos.
• Objetos: son instancias concretas de una clase que contienen toda la información
necesaria para que nuestra aplicación funcione.
• Herencia: es la habilidad de definir una clase como un subtipo o hija de una

superclase o clase padre.
• Polimorfismo: permite definir una clase como miembro de mas de una categoría
de clases ( tal como un coche es “una cosa con motor” y “una cosa con ruedas”)
• Interfaces: define un contrato específicando que un objeto es capaz de

implementar un método sin definir realmente cómo
Página 80 de 164
• Encapsulación: la habilidad que tiene un objeto de proteger el acceso a sus datos

internos.
Clases
En el mundo real los objetos tienen características y comportamientos.
Un coche tiene un color, un peso, un fabricante y un depósito de combustible con una

cierta capacidad. Estas son sus características.
Un coche puede acelerar, parar, poner el interminente para indicar un giro y hacer sonar el
claxon. Estos son sus comportamientos.
Estas características y comportamientos son comunes a todos los coches. Aunque unos
coches pueden tener distinto color, todos tienen un color.
Utilizando el concepto de CLASE la POO permite establecer la idea de coche como algo
con todas esas características.
Una clase es una unidad de código, compuesto de variables y funciones, que describen las
características y comportamientos de todos los miembros del conjunto.
Un clase llamada Coche describiría las propiedades y métodos comunes a todos los
coches.
Las características de una clase se conocen como sus PROPIEDADES.
Las propiedades tienen un nombre y un valor. Algunas permiten que su valor cambie y
otras no.
Por ejemplo, en la clase Coche, podemos tener propiedades como el color y el peso.
Aunque el color del coche se puede cambiar con una mano de pintura, el peso del coche
(sin carga ni pasajeros) es un valor fijo.
Página 81 de 164
Algunas propiedades representan el estado del objeto, que son aquellas características
que cambian debido a ciertos eventos pero no son modificables directamente. En una
aplicación que simule el funcionamiento de un vehículo, la clase Coche puede tener una
propiedad llamada velocidad. La velocidad del coche no es un valor que se pueda cambiar
directamente, sino que es un producto de la cantidad de combustible enviada al motor, las
características de funcionamiento de ese motor y el terreno sobre el que el coche se
desplaza.
Los comportamientos de una clase se conocen como sus MÉTODOS.
Los métodos son equivalentes a las funciones utilizadas en la programación estructurada.
Como las funciones, pueden aceptar cierto número de parámetros.
Algunos métodos actúan sobre datos externos pasados como parámetros, pero también
pueden actúar sobre las propiedades de su objeto, incluso pueden utilizarlas para indicar
acciones realizadas por el método o cambiar el estado del objeto modificando valores
como la velocidad del coche.
Objetos
Podemos pensar en una clase como en un plano para construir un objeto. De la misma
forma que, en la mayoría de los casos, muchas casas se pueden construir con el mismo
plano, podemos crear múltiples instancias de un objeto desde su clase.
Pero el plano no especifica detalles tales como el color de las paredes o el tipo de suelo.
Sólo indica que esos elementos existirán. Las clases funcionan de la misma forma. La
clase define el comportamiento y las características que tendrán los objetos, pero no
necesariamente los valores que tendrán esas características.
Un objeto es una entidad concreta construida usando el plano proporcionado por una
clase. La idea de casa es análoga a una clase. Tu casa es análoga a un objeto de esa
clase.
Con el plano en mano y algunos materiales de construcción, podemos construirnos una

casa. En POO, usamos la clase para construir un objeto, este proceso se conoce como
instanciación. Instanciar un objeto requiere dos cosas:
Página 82 de 164
• Una zona de memoria donde cargar el objeto. Esto lo hace PHP automáticamente.
• Los datos para dar valores a las propiedades. Estos datos pueden venir de una
base de datos, un fichero de texto plano, otro objeto o algun otro origen.
Una clase nunca tendrá propiedades con valores o un estado. Solo lo tienen los objetos.
Tenemos que usar el plano para construir la casa antes de empapelar las paredes o
pintarla con gotelé. De igual forma, tenemos que instanciar un objeto de la clase antes de
que podamos interactuar con sus propiedades o invocar sus métodos.
Las clases se manipulan en tiempo de diseño cuando haces cambios en los métodos o
propiedades.
Los objetos se manipulan en tiempo de ejecución cuando los valores se asignan a sus
propiedades y se invocan sus métodos.
Después de que un objeto es instanciado, se puede poner a trabajar implementando la

lógica de la aplicación.
Sesión 16. Orientación a Objetos (II). Clases y Objetos.

- Objetivo. Conocer qué es la Programación Orientada a Objetos y cómo se implementa en
PHP.
Página 83 de 164
- Actividades:
o Clases y Objetos en PHP.
Creando una Clase
class.Demo.php
<?php
class Demo {
}
?>
Convención de código:
• Poner cada clase en un archivo distinto.

• Nombrar el archivo class.[NombreClase].php.
Podemos instanciar un objeto de tipo Demo así:
testdemo.php
<?php
require_once('class.Demo.php');
$objDemo = new Demo();
?>
Incluimos el fichero que contiene la clase y creamos con new una nueva instancia de la
clase Demo.
El valor que devuelve esta clausula es una referencia a la instancia que se asigna a una
nueva variable, $objDemo.
Ahora podemos invocar los métodos del objeto y examinar o establecer el valor de sus
propiedades.
Página 84 de 164
Aunque la clase no haga nada ni tenga propiedades con las que trabajar, es una forma
válida de definir una clase.
Añadiendo un método.
La clase Demo no es muy útil si no es capaz de hacer algo.
class.Demo1.php
<?php
class Demo1 {
function diHola ( $nombre ) {
echo "¡Hola $nombre!";
}
}
?>
Un objeto derivado de nuestra clase ahora es capaz de mostrar un mensaje de bienvenida

a cualquiera que invoque el método diHola.
Para invocarlo se usa el operador ->:
testdemo1.php
<?php
require_once('class.Demo1.php');
$objDemo = new Demo1();

$objDemo->diHola(‘Florencio’);
?>
El operador -> se usa para acceder a todos los métodos y propiedades de nuestros
objetos.
Añadiendo una Propiedad
Página 85 de 164
Simplemente declaramos una variable dentro de la clase.
Esta variable la declaramos al principio de la declaración de la clase, dentro de las llaves

que conforman el cuerpo de la clase.
class.Demo2.php
<?php
class Demo2 {
public $nombre;
function diHola() {
echo " ¡Hola $this->nombre!";
}
}
?>
Hemos creado una propiedad de la clase Demo llamada $nombre.
Para acceder a esta propiedad usamos el mismo operador que antes -> junto al nombre de
la propiedad.
testdemo2.php
<?php
$objDemo->nombre = ‘Florencio';
$objOtroDemo = new Demo2();
$objOtroDemo->nombre = 'Epi';
$objDemo->diHola();
$objOtroDemo->diHola();
?>
Resultado:
¡Hola Florencio!¡Hola Epi!
La palabra clave public es usada para indicar que la variable pueda ser usada desde fuera
de la clase.
Algunas propiedades existen sólo para uso interno de la clase, por tanto no deben ser
accesibles desde código externo.
Página 86 de 164
En este ejemplo, queremos que el valor de la propiedad se pueda establecer y recuperar.
La forma de trabajar del método diHola() ha cambiado, en lugar de pasarle un parámetro,

toma el valor de la propiedad $nombre de la clase.
El objeto usa la variable $this para obtener información sobre sí mismo, es decir, es una
referencia a sí mismo. Podemos tener múltiples objetos de una clase y como no es posible
conocer de antemano el nombre del objeto, la variable $this nos ayuda a referenciar el
objeto cuestión
En el ejemplo, la variable $this permite a cada objeto acceder a sus propiedades y métodos
sin tener que saber el nombre de la variable que lo representa en la aplicación.
Recordad, la sintaxis correcta es $objeto->propiedad , no $objeto->$propiedad.
o Protegiendo el acceso
Podemos asignar el valor de una propiedad a cualquier cosa que queramos, tanto a otro
objeto, como a un array de enteros, un manejador de fichero o cualquier otro valor.
Sin embargo, en el momento de establecer el valor de la propiedad no puede ser

ordenada, validada o actualizada, con lo que, por ejemplo, tampoco podemos proteger la
clase de un posible error al establecer su valor o un acceso no autorizado al obtenerla.
Para ello, por convenio, el acceso a las propiedades se hace en forma de funciones que
obtienen y establecen las propiedades de la clase. Se conocen como getters y setters
porque suelen nombrarse como get[nombrePropiedad]() y set[nombrePropiedad]().
Creamos el fichero class.Demo3.php:
class.Demo3.php
<?php
class Demo3 {
private $nombre;
Página 87 de 164
public function diHola() {

echo "¡ Hola ". $this->getNombre() . " ! ";
}
public function getNombre() {

return $this->nombre;
}
public function setNombre($nuevoNombre) {
if(!is_string ($nuevoNombre) || strlen($nuevoNombre) == 0){

die("Valor de nombre inválido. ");
}
$this->nombre = $nuevoNombre;
}
}
?>
Comprobamos en testdemo3.php:
testdemo3.php
<?php
$objDemo->setNombre('Florencio');
$objDemo->diHola();
$objDemo->setNombre(37); // esto mostrará un error
?>
La palabra reservada private protege el código haciéndolo inaccesible desde fuera del
objeto, tanto las propiedades como los métodos
Si las propiedades se convierten en privadas estamos forzados a acceder a ellas a través

de los setters/getters, asegurando que los valores a asignar serán siempre evaluados por
la clase.
Además hemos etiquetado el acceso al método como público.
Si no etiquetamos un miembro de una clase, tanto propiedades como métodos, el nivel de

visibilidad que se establece por defecto es public. Sin embargo, es una buena práctica
siempre establecer el nivel de visibilidad.
Una propiedad o método puede tener tres niveles diferentes de visibilidad:
• public, accesibles por cualquier código.

• private, accesibles únicamente por la clase en la que se definen.
Página 88 de 164
• protected, accesibles por la clase en la que se definen y por aquellas que

heredan de ésta.
Utilizar getter/setters con nuestras propiedades hará mucho más simple cualquier cambio
debido a nuevos requerimientos en el futuro.
o Inicializando Objetos
En la mayoría de las ocasiones, cuando creamos clases, necesitamos realizar diversas

acciones justo cuando se instancia un objeto de la clase.
A veces es necesario obtener cierta información de una base de datos, inicializar algunas
propiedades, etc.
Para ello creamos un método llamado constructor, usual en POO, que permite realizar las
acciones necesarias al instanciar el objeto. En PHP, por norma, se llama __construct(), y
será PHP quien lo invoque automáticamente cuando instanciemos un objeto de la clase.
class.Demo4.php
<?php
class Demo4 {
private $nombre;
public function __construct($nombre) {

$this->nombre = $nombre;
}
function diHola() {
echo "¡ Hola $this->nombre !";
}
}
?>
testdemo4.php
<?php
$objDemo = new Demo3(‘Florencio’);
$objDemo->diHola();
?>
Nota: En PHP4, los constructores tenían el mismo nombre que la clase. Con PHP5, para
mantener la compatibilidad hacia atrás, se busca en primer lugar el método __construct() y
si no se encuentra busca un método con el mismo nombre que la clase.
Página 89 de 164
Si no necesitamos hacer algo especial en la instanciación del objeto, no es necesaria la

creación de constructor.
o Destruyendo Objetos
Las variables de objeto que creamos se eliminan de la memoria del sistema cuando la
página solicitada se ha terminado de ejecutar o cuando se establece como nula.
En PHP5 es posible detectar cuando se va a destruir un objeto y realizar acciones al

efecto.
Para hacer esto creamos una función llamada __destruct sin parámetros, de forma que
antes de que el objeto sea destruido será llamada automáticamente.
Esto nos permite realizar acciones de última hora como cerrar ficheros o conexiones con
bases de datos.
Página 90 de 164
Sesión 17. Orientación a Objetos (III). Herencia.

- Objetivo. Conocer la herencia en PHP.
- Actividades:
o Herencia.
Si estamos creando una aplicación de inventario de un concesionario de coches,

probablemente tendríamos clases para Turismo, Furgoneta y MonoVolumen, que se
corresponderían con los mismos tipos de automoviles que tendríamos en el inventario.
La aplicación necesitaría no solo mostrar cuántos de estos elementos tenemos en stock

sino también las características de estos vehículos para que los vendedores proporcionen
información a los clientes.
Un turismo es un coche de cuatro puertas, y probablemente necesitaremos registrar el

espacio del habitáculo y la capacidad del maletero. Una furgoneta no tiene maletero pero
tiene una capacidad de carga y un peso máximo aproximado. Para una monovolumen
necesitaremos saber el número de puertas corredizas y número de asientos.
Aunque son diferentes tipos de vehículos comparten ciertos tipos de características como
el color, fabricante, modelo, año, número de bastidor, etc.
Para asegurar que cada una de estas clases tiene las mismas propiedades podemos
copiar el código que las define en cada fichero que contiene la definición de las clases.
Pero en POO, esto no es necesario, se puede reutilizar código usando un proceso llamado
HERENCIA, que es la habilidad que tiene una clase para asumir los métodos y
propiedades de una clase padre o superclase.
La herencia nos permite definir una clase base, en este caso Automovil, y decir que otras
clases son un tipo de Automovil y que tales clases tienen todas las mismas propiedades y
métodos que tiene Automovil.
Podemos decir que un Turismo es un Automovil y por lo tanto automáticamente hereda

todo lo definido por la clase Automovil sin tener que copiar ningún código.
Página 91 de 164
Solo es necesario que añadamos a la clase Turismo las propiedades y métodos que no se
comparten con el resto de clases que heredan también de Automovil. Es decir, solo
tenemos que definir las diferencias; las similitudes se heredan de la clase base.
Tenemos una ventaja mayor con la herencia. Por ejemplo, tenemos una clase Cliente con
un método comprarAutomovil, que toma un parámetro que es un objeto de la clase
Automovil. Este método imprime la factura y decrementa el stock.
Como todos los Turismos, Furgonetas y MiniVolumenes son Automoviles, podemos pasar
objetos de estas clases al método que espera un Automovil. Como heredan de Automovil,
estas tres clases contienen las mismas propiedades y métodos base. Siempre que
necesitemos trabajar con métodos o propiedades comumes a todos los Automoviles,
podemos aceptar objetos de cualquier clase que hereden de Automovil.
o Herencia en PHP.
Consideremos el ejemplo de los felinos. Todos los felinos comparten las mismas
actividades. Comen, duermen, escupen bolas de pelo y cazan. También comparten
propiedades como el peso, color, longitud de pelo y velocidad en carrera.
Sin embargo, los leones tienen melena y rugen. Los guepardos tienen manchas. Los gatos
domésticos no tienen ninguna de estas cosas, pero los tres son felinos.
En PHP se especifica que una clase es una subclase de otra usando extends.
Si tuviesemos que diseñar una aplicacion para gestionar los animales de un zoo,
necesitaríamos una clase Felino, Leon y Guepardo.
Antes de escribir código vamos a planificar nuestra jerarquía de clases con diagramas
UML, para tener algo sobre lo que trabajar. (Más adelante veremos un poco de UML)
Página 92 de 164
Este diagrama de clases contiene una clase padre Felino con dos subclases: León y
Guerpardo que heredan de Felino.
Además, León implementa la propiedad longitudMelena y el método rugir(), y Guepardo la

propiedad numeroManchas.
class.Felino.php
<?php
class Felino {
public $peso; // en kg
public $color;
public $longitudPelo;
public $velocidadCarrera; // en km/h
public function comer() {

// código para comer
}
public function dormir() {

// código para dormir
}
public function cazar(Presa $objPresa) {

//código para cazar objetos de tipo Presa
// que no definiremos
}
public function escupirBolaPelo() {

echo "jjjjjjjjjjjjjjj..." . "<br/>";
}
}
?>
Esta clase establece los métodos y propiedades comunes a todos los felinos.
class.Leon.php
Página 93 de 164
<?php
require_once('class.Felino.php');
class Leon extends Felino {
public $longitudMelena; // en cm
public function rugir() {

echo "Roarrrrrrrrr!";
}
}
?>
Ahora podemos hacer lo siguiente:
testLeon.php
<?php
include('class.Leon.php');
$objLeon = new Leon();
$objLeon->peso = 200; // kg
$objLeon->color = 'marron';
$objLeon->longitudMelena = 36; // cm
$objLeon->comer();
$objLeon->rugir();
$objLeon->dormir();
?>
Si en otro objeto de nuestra aplicación definimos un método como este:
class.Casa.php
class Casa {
public function miMascota(Felino $objFelino) {

$objFelino->escupirBolaPelo();
}
}
Podríamos hacer esto:
testCasa.php
<?php
include('class.Leon.php');
include('class.Casa.php');
Página 94 de 164
$objLeon = new Leon();

$objCasa = new Casa();
$objCasa->miMascota($objLeon);
?>
Cualquier cambio que hagamos en la clase Felino lo hereda automáticamente la clase

Leon.
Vamos a ver cómo un constructor puede extender y especializar una clase.
class.Guepardo.php
<?php
require_once('class.Felino.php');
class Guepardo extends Felino {
public $numeroManchas;
public function __construct() {

$this->velocidadCarrera = 100;
}
}
?>
testFelinos.php
<?php
require_once('class.Guepardo.php');
function miMascota(Felino $objFelino) {

if($objFelino->velocidadCarrera < 5) {
$objFelino->escupirBolaPelo();
} else {
echo "No puedo atrapar al gato, se mueve a " .
$objFelino->velocidadCarrera . " km/h.";
}
}
$objGuepardo = new Guepardo();

miMascota($objGuepardo);
$objFelino = new Felino();

miMascota($objFelino);
?>
o Sobrescribiendo Métodos.
Heredar de una clase padre no significa que la clase hija tenga que usar la implementación
que la clase padre hace en un método.
Página 95 de 164
Por ejemplo, si necesitamos crear un programa que calcule el area de diferentes figuras
geométricas y tenemos clases como Rectangulo y Triangulo, ambas pueden heredar de
una clase padre llamada Poligono.
La clase Poligono puede tener una propiedad llamada numeroLados y un método llamado
getArea.
Todos los polígonos tienen un area calculable, solo que la forma de calcularla varía con los
diferentes tipos de polígonos.
Area = (1/2 h) ⋅ b Area = w ⋅ h
Si redifinimos el método de la clase podemos tener nuestra propia implementación del

cálculo del area.
En el caso de la clase Rectangulo, necesitamos crear dos propiedades nuevas: alto y

ancho y sobreescribir el método de Poligono getArea().
Heredando y sobrescribiendo métodos de la clase padre podemos permitir a las subclases

especializar la implementación de algunos métodos.
Una función que tenga como parámetro un Poligono y necesite mostrar el area de ese
polígono llamará al método getArea() de la subclase de Poligono que le pasemos
(Rectangulo o Triangulo).
Esta capacidad de averiguar en tiempo de ejecución qué método llamar se llama

Polimorfismo. Es la habilidad de una aplicación para hacer cosas diferentes basándose
en el objeto sobre el que actúa.
o Sobrescribiendo Métodos en PHP.
class.Rectangulo.php
Página 96 de 164
<?php
class Rectangulo {
public $alto;
public $ancho;
public function __construct($ancho, $alto) {

$this->ancho = $ancho;
$this->alto = $alto;
}
public function getArea() {

return $this->alto * $this->ancho;
}
}
?>
class.Cuadrado.php
<?php
require_once('class.Rectangulo.php');
class Cuadrado extends Rectangulo {

public function __construct($lado) {
$this->alto = $lado;
$this->ancho = $lado;
}
public function getArea() {

return pow($this->alto, 2);
}
}
?>
Preservando la funcionalidad de la clase padre
En ocasiones no necesitamos sobrescribir por completo un método de la clase padre, sino

parte de él.
Para obtener la funcionalidad de un método de la clase padre que estamos sobrescribiendo

escribimos parent::[nombre método].
Cuando queremos solo añadir cierta funcionalidad al método que hemos heredado,
llamamos en primer lugar al método de la clase padre y a continuacióna añadimos nuestro
código.
class.Cliente.php
<?php
class Cliente {
public $id;
Página 97 de 164
public $numeroCliente;
public $nombre;
public function __construct($clienteID) {
// Vamos a escribir los datos de cliente

// aunque en una aplicación real
// obtendríamos los datos de la base de datos
$datos = array();
$datos['numeroCliente'] = 1000000;
$datos['nombre'] = 'Florencio Analista';
// Asignamos los valores al objeto

$this->id = $clienteID;
$this->nombre = $datos['nombre'];
$this->clienteNumero = $datos['clienteNumero'];
}
}
?>
class.PremioCliente.php
<?php
require_once('class.Cliente.php');
class PremioCliente extends Cliente {
public function __construct($clienteID) {
parent::__construct($clienteID);
if($this->clienteNumero == 1000000) {
echo "¡Felicidades $this->nombre! " .
"¡Eres el cliente un millón! " .
"¡ Has ganado un cepillo de dientes! ";
}
}
}
?>
Vamos a ver cómo funciona:
testCliente.php
<?php
require_once('class.PremioCliente.php');
function bienvenidaCliente (Cliente $objCliente) {

echo "¡Bienvenido de nuevo a la tienda $objCliente->nombre!";
}
// Cambiamos este valor para elegir la clase del cliente
$promocionActiva = true;
if ($promocionActiva) {
$objCliente = new PremioCliente (12345);
} else {
$objCliente = new Cliente(12345);
}
bienvenidaCliente($objCliente);
?>
Página 98 de 164
Sesión 18. Orientación a Objetos (IV). Interfaces.

- Objetivo. Aprender a definir y usar Interfaces en PHP.
- Actividades:
o Interfaces.
A veces tenemos un grupo de clases que no están necesariamente relacionadas a través

de la herencia, pero tienen comportamientos en común.
Por ejemplo, tanto un tarro como una puerta se pueden abrir y cerrar, sin embargo, no
tienen otro tipo de relación.
¿Que hacen los Interfaces?
Este concepto es aplicable a la POO. Un interfaz permite especificar que un objeto es

capaz de realizar una determinada función, pero no nos dice cómo lo hace.
Un interfaz es como un contrato entre varios objetos para confirmar que realizan una
determinada función.
Un objeto que implemente este interfaz garantiza a quien lo use que es capaz de realizar
todas las funciones definidas en la interfaz.
Las bicicletas y las pelotas de futbol son cosas totalmente diferentes; sin embargo, un buen
sistema de inventario en un almacen de deportes debe ser capaz de tratar los objetos que
representan estos elementos sin problemas.
Declarando un interface e implementándolo en nuestros objetos, podemos llamar a

funciones comunes desde clases completamente diferentes.
interface.Abierto.php:
<?php
interface Abierto {
abstract function abrir();
Página 99 de 164
abstract function cerrar();

}
?>
Convención: para llamar a los ficheros de interfaz interface.[nombreInterface].php.
Un interfaz no tiene propiedades y no implementa ninguno de sus métodos, que son

definidos como abstractos.
Definirlos como abstractos implica que cualquier clase que implemente este interfaz está
obligado a implementar sus métodos. Si no lo hacemos así PHP producirá un error.
o ¿Cómo trabajan los Interfaces?
El interfaz Abierto es un contrato con otras partes de la aplicación indicando que cualquier
clase que implemente este interfaz debe propocionar dos métodos, llamados abrir() y
cerrar(), sin parámetros. Con este acuerdo permitimos que muchos objetos diferentes
reconozcan la misma función sin la necesidad de relaciones de herencia entre ellos.
class.Puerta.php
<?php
require_once('interface.Abierto.php');
class Puerta implements Abierto {
private $_bloqueada = false;
public function abrir() {
if($this->_bloqueada) {
echo "No puedo abrir la puerta, está bloqueada.";
} else {
echo "crack...<br>";
}
}
public function cerrar() {

echo "¡¡ Blam !!<br>";
}
public function bloquearPuerta () {

$this->_bloqueada = true;
}
public function desbloquearPuerta() {

$this->_bloqueada = false;
}
}
?>
Página 100 de 164

class.Tarro.php
<?
require_once('interface.Abierto.php');
class Tarro implements Abierto {
private $contenidos;
public function __construct($contenidos) {

$this->contenidos = $contenidos;
}
public function abrir() {

echo "el tarro ahora está abierto <br/>";
}
public function cerrar() {

echo "el tarro ahora está cerrado <br/>";
}
}
?>
testAbierto.php
<?php
require_once('class.Puerta.php');
require_once('class.Tarro.php’);
function abrirAlgo (Abierto $obj) {

$obj->abrir();
}
$objPuerta = new Puerta();

$objTarro = new Tarro("miel");
abrirAlgo ($objPuerta);
abrirAlgo ($objTarro);
?>
Tanto Puerta como Tarro implementan el interface Abierto, por lo que podemos pasar sus
objetos a la función abrirAlgo(). Como la función únicamente acepta aquellos objetos que
implementen el interface Abierto, podemos llamar a los métodos abrir() y cerrar(), pero no
podemos acceder a la propiedad $contenidos de Tarro ni a los métodos bloquearPuerta() y
desbloquearPuerta(), porque no forman parte de la interfaz.
Página 101 de 164

o Encapsulación
Los objetos son capaces de ocultar ciertos detalles de su implementación a otros objetos.
Podemos tener una clase en la que no necesitamos saber si la información está

almacenada en base de datos, en un fichero de texto o en un archivo XML. Tampoco
necesitamos saber si la información que contiene un objeto se implementa como variables
simples, arrays o incluso otros objetos.
La habilidad de ocultar detalles de implementación se conoce como encapsulación y está

relacionada con dos conceptos:
• Proteger la información interna de la clase de código externo.

• Ocultar los detalles de implementación.
Una clase bien diseñada proporciona un escudo completo y presenta un interfaz hacia el
exterior totalmente separada de su parte interna. Haciendo esto obtenemos dos ventajas:
1. Podemos cambiar los detalles de implementación en cualquier momento sin que

afecte al código que usa nuestra clase.
2. Como nada fuera de nuesta clase puede modificar el estado o las propiedades de
un objeto de nuestra clase sin querer, podemos confiar en que el estado del objeto
y el valor de sus propiedades son válidos.
Tanto las propiedades como los métodos de una clase tienen visibilidad, es decir, pueden
ser referenciadas o no desde fuera.
Los miembros privados no son accesibles desde fuera y se utilizan para la

implementación interna de la clase.
Los miembros protegidos solo son visibles para las subclases que heredan de nuestra
clase.
Los miembros públicos son utilizables por cualquier código, dentro o fuera de la clase.
Página 102 de 164

Por lo general, todos las propiedades internas de la clase deben ser declaradas como
privadas.
Cualquier acceso a estas variables desde fuera de la clase debe ser hecho a través de
métodos de acceso (getters/setters).
Normalmente, es muy aconsejable que cualquier propiedad que pueda se modificada

desde fuera se encapsule en un método público para validar y aceptar o denegar los
cambios.
Página 103 de 164

Sesión 19. Introducción al Lenguaje de Modelado Unificado (UML) I.

- Objetivo. Analizar y diseñar una aplicación usando UML.
- Actividades:
o Contexto.
Vamos a analizar y diseñar un hipotético sistema de gestión de bandas de música:

Triunfitos.
Un cliente de una discográfica ha contactado con nosotros para desarrollar un sistema web
para gestionar las bandas de sus clientes.
En una conversación telefónica inicial, el cliente nos explica que Triunfitos:
1. Debe permitir a los usuarios web ver detalles de las diferentes bandas que la
compañia representa y conocer sus próximos conciertos.
2. Alguien de la discográfica debe ser capaz de añadir nuevas bandas al sistema,

editar la información de las bandas existentes e incluir la reserva de entradas para
nuevas actuaciones.
En este momento ya disponemos de los requerimientos iniciales de nuestra aplicación.
o Reunión con el cliente.
En la conversación telefónica concertamos una reunión con el cliente.
Las personas que intervienen en la reunión son Juan, el propietario de la empresa; Silvia,
la gerente; y Florencio, un administrativo de la empresa.
Al principio de la reunión, es importante identificar bien los roles implicados.
Página 104 de 164

La persona clave a identificar en la obtención de requisitos es aquella que dispone de los

conocimientos detallados acerca del dominio, es decir, el area en el que vamos a modelar
nuestro sistema.
Esa persona puede ser alguien que realiza de forma manual el proceso que se intenta
automatizar, o alguien que conoce cómo funciona el negocio y qué necesita nuestro
software para modelar correctamente algun proceso de ese negocio. Esta persona se
suele llamar Experto en el Dominio.
Volvamos a nuestra entrevista. Observamos que Silvia es quién habla la mayor parte del
tiempo. Describe cómo espera ella que el sistema funcione y cómo maneja la empresa
actualmente esos procesos. Por tanto, podemos determinar a Silvia como nuestra Experta
en el Dominio. Durante las siguientes reuniones contactaremos directamente con ella. Juan
no está atento durante la entrevista y es interrumpido constantemente por el móvil para
atender asuntos de alto nivel de la empresa. Florencio solo aclara que el será la persona
responsable de introducir la información en nuestro sistema.
Hemos obtenido la siguiente lista de anotaciones de la entrevista:
1. Los usuarios pueden visitar el sitio web de Triunfitos y navegar consultando la

información de las bandas. Esa información incluye el tipo de banda, los músicos de la
banda y qué instrumentos tocan.
2. Los usuarios pueden ver información acerca de las próximas actuaciones que pueden
incluir una o varias bandas.
3. El administrador del sitio puede:
a) Añadir información sobre las bandas.
b) Editar la información existente de una banda.
c) Añadir una nueva actuación. Esto incluye reservar un local y generar

entradas. La reserva de un local y la generación de entradas se gestiónan
a través de otras empresas. Estas empresas tienen sistemas de reserva
que usaremos para notificar nuestras actuaciones vía Triunfitos.
Página 105 de 164

o Diagramas de Casos de Uso
Los diagramas de casos de uso muestran el sistema desde el punto de vista del usuario.
Un caso de uso representa una tarea que el usuario intenta realizar con el sistema.
Este es un diagrama de caso de uso simple que muestra que los usuarios visitan el sitio
web Triunfitos y navegan consultando la información de las bandas.
El monigote se denomina actor y la elipse es el caso de uso.
La línea indica que este actor puede realizar ese caso de uso.
El actor normalmente es un rol asociado a una persona, aunque también puede

representar un sistema externo que actúa sobre el nuestro.
El caso de uso Navegar Información Bandas es bastante general. Para empezar, en este
caso, no es necesario mayor nivel de detalle.
Ahora cubriremos todos los casos de uso que nuestro sistema vaya a contemplar.
Si es necesario, los casos de uso se pueden dividir en escenarios separados.
Un escenario es la secuencia de pasos que comprende un caso de uso.
Por ejemplo, el escenario para el caso de uso anterior sería:
Página 106 de 164

1. El usuario visita el sitio web Triunfitos.

2. El usuario navega por el sitio utilizando el menú.
3. El usuario examina la información de las bandas/músicos/actuaciones.
El caso de uso para las tareas administrativas nos

quedaría así:
Los casos de uso administrativos son las tareas separadas que el administrador puede
realizar al usar el sistema Triunfitos.
El cliente mencionó que la sección de administración del sitio estuviese protegida

accediendo a través de una contraseña.
Como el acceso al sistema puede ser visto como una tarea en sí misma, necesaria para los
casos de uso de administración, podemos usar un include para indicar que ese caso de
uso es parte de los otros tres casos.
En un diagrama de casos de uso pueden aparecer varios actores.
De hecho, actores diferentes pueden compartir un caso de uso.
Como tanto el administrador como los usuarios normales pueden consultar la información
de las bandas, ambos comparten ese caso de uso.
Página 107 de 164

Además, el caso de uso incluirá un actor no humano, el sistema de reserva, que realiza la
tarea de actualizar la información acerca de las próximas actuaciones.
Los dos diagramas siguientes completan los casos de uso del sistema Triunfitos.
o Diagramas de Clases
Modelando el Dominio
En nuestra aplicación, los usuarios pueden ver información sobre los diferentes tipos de
músicos.
Sería una buena idea tener una clase Musico, o incluso mejor, un interface Musico que
todos los tipos de músicos puedan implementar.
Los diagramas de clase son los más importantes en un proyecto.
Describen el dominio que estamos modelando, y permiten un nivel variable de detalle

desde un nivel muy alto hasta uno muy específico sobre los métodos y propiedades de una
clase.
Este es el diagrama de clases básico:
Página 108 de 164

Musico
- tipo : String
- nombre : String
- apellidos : String
La caja de arriba muestra el nombre de la clase. - nombreBanda :
String
+ getBanda() : String
+ getNombre() : String
+ getTipo() : String
La caja del medio muestra sus atributos y la de abajo los + setBanda()
métodos. + setTipo()
+ setNombre()
Los tipos de atributos se indican después de los dos puntos.
El signo menos indica que el atributo es un miembro privado de la clase.
El signo más indica que los métodos son públicos. Si alguno de los métodos devuelve un
valor, se indica después de los dos puntos.
class.Musico.php
class Musico
{
private $apellidos;
private $nombre;
private $nombreBanda;
private $tipo;
function __construct($apellidos, $nombre, $tipoMusico) {
$this->apellidos = $apellidos;
$this->tipo = $tipoMusico;
}

echo $this->nombre . ‘ ’ . $this->apellidos;
}
public function getBanda() {

echo $this->nombreBanda;
}
public function getTipoMusico () {

echo $this->tipo;
}
public function setNombre($nombre, $apellidos) {

$this->ultimo = $ultimo;
}
public function setBanda($nombreBanda) {

$this->nombreBanda = $nombreBanda;
}
public function setTipoMusico($tipoMusico) {

$this->tipo = $tipoMusico;
}
}
Página 109 de 164

Relaciones
Como Triunfitos necesita varias clases, necesitamos conocer cómo interactúan entre ellas.
En nuestro ejemplo usamos cadenas de texto para los tipos de las propiedades y métodos
de nuestra clase.
Esta no es una buena idea. Si un músico fuese parte de una banda, querremos conocer
algo más acerca de la banda además de su nombre. Por ejemplo, los otros componentes
de la banda, el genero de música que tocan, etc.
Estas ideas nos ayudan en el diseño. Cuando se nos presentan ciertos elementos
variables que necesitan mayor grado de complejidad es necesario que tengan sus propias
clases.
Asociaciones
Como se observa en la siguiente figura, el atributo nombreBanda ha sido movido a como

un atributo de la clase Banda.
En ocasiones no es necesario mostrar todos los atributos y métodos de una clase, sino
sólo lo relevante en el contexto .
La línea que conecta las dos clases es un tipo de relación conocida como asociación.
Para este ejemplo, la asociación es de uno-a-muchos (1 a *), una Banda puede tener
muchos Musicos, o muchos Musicos pueden estar en una Banda.
La línea de asociación puede indicar también la navegabilidad.
Página 110 de 164

En el ejemplo, la línea sin flechas muestra que nos podemos mover en ambas direcciones,
es decir, una navegabilidad bidireccional. Es decir, cada clase tiene una referencia interna
a la otra.
Si la asociación nos permite navegar en una sola dirección, se trata de una navegabilidad
unidireccional.
En la figura siguiente, la clase Musico tiene acceso a cualquier Instrumento en su colección

interna, pero el Instrumento no es consciente de qué Musico lo posee.
Realizaciones y Generalizaciones
Como antes vimos, es una buena

idea crear un interface Musico que
las otras clases puedan implementar.
De esta forma, se pueden derivar
otras clases como Guitarrista y
Percusionista, que siguen las reglas
de comportamiento impuestas por
Musico.
Cuando queremos mostrar un

interface y las clases que lo
implementan, indicamos una relación
entre ellas llamada realización.
La realización se dibuja como una línea discontinua con una punta de flecha vacia.
Los interfaces en UML son parecidos a los diagramas de clases pero se incluye la palabra
interface entre comillas españolas.
Cuando queremos mostrar herencia desde una clase abstracta o regular usamos la
generalización, que es idéntica a la realización pero con línea contínua.
Página 111 de 164

Composiciones
A menudo, las relaciones entre clases no están basadas en las asociaciones o la herencia
sino en la forma en la que se agrupan las clases.
Consideremos el ejemplo de la batería.
En nuestra aplicación, el interface Instrumento se implementa en una clase concreta como

Guitarra o Piano.
Las clases Bateria, Tambor y Platillo también la implementan.
La nueva notación de las líneas con un diamante negro indica que Bateria es una
composición de clases Tambor y Platillo.
Una instancia de Bateria contendrá instancias de clases Tambor y Platillo.
Una composición es una relación estricta que se caracteriza por dos elementos:
1. La parte de una composición no puede ser parte de otra relación.

2. Cuando se elimina una instancia de Batería, las partes que lo componen también
se eliminan.
Un tipo más general de composición se denomina agregación.
La notación para la agregación es la misma que para la composición pero el diamante está
vacío.
Página 112 de 164

La agregación permite compartir instancias de otras clases y no es necesario eliminarlas

cuando el todo es eliminado.
Implementación
Vamos a ver un ejemplo en código que ilustre todo esto:
ejemplo122.php
<?php
interface Banda {
public function getNombre();
public function getGenero();
public function nuevoMusico(Musico $musico);
public function getMusicos();
}
interface Musico {
public function nuevoInstrumento(Instrumento $instrumento);
public function getInstrumentos();
public function asignarAbanda(Banda $banda);
public function getTipoMusico();
}
interface Instrumento {
public function getNombre();
public function getCategoria();
}
class Guitarrista implements Musico {

private $apellidos;
private $nombre;
private $tipoMusico;
private $instrumentos;
private $referenciaBanda;
function __construct($nombre, $apellidos) {

$this->apellidos = $apellidos;
$this->instrumentos = array();
$this->tipoMusico = "guitarrista";
}

return $this->nombre . " " . $this->apellido;
}
public function nuevoInstrumento(Instrumento $instrumento) {

array_push($this->instrumentos, $instrumento);
}
public function getInstrumentos() {

return $this->instrumentos;
}
public function getBanda() {

return $this->referenciaBanda;
}
public function asignarAbanda(Banda $banda) {

$this->referenciaBanda = $banda;
}
public function getTipoMusico () {

return $this->tipoMusico;
Página 113 de 164

public function setTipoMusico ($tipoMusico) {

$this->tipoMusico = $tipoMusico;
}
}
class GuitarristaPrincipal extends Guitarrista {
function __construct($nombre, $apellido) {

parent::__construct($nombre, $apellido);
$this->setTipoMusico ("guitarrista principal");
}
}
class BandaRock implements Banda {

private $nombreBanda;
private $generoBanda;
private $musicos;
function __construct($nombreBanda) {
$this->nombreBanda = $nombreBanda;
$this->musicos = array();
$this->generoBanda = "rock";
}

return $this->nombreBanda;
}
public function getGenero(){

return $this->generoBanda;
}
public function nuevoMusico (Musico $musico){

array_push($this->musicos, $musico);
$musico->asignarAbanda($this);
}
public function getMusicos() {

return $this->musicos;
}
}
class Guitarra implements Instrumento {

private $nombre;
private $categoria;
function __construct($nombre) {
$this->categoria = "guitarra";
}

return $this->nombre;
}
public function getCategoria() {

return $this->categoria;
}
}
// Probar Objetos
$banda = new BandaRock("Los Variables");
$bandaMiembroA = new Guitarrista("Juan", "Float");
$bandaMiembroB = new GuitarristaPrincipal("Tommy", "Integer");
$bandaMiembroA->nuevoInstrumento(new Guitarra("Gibson Les Paul"));
$bandaMiembroB->nuevoInstrumento(new Guitarra("Fender Stratocaster"));
$bandaMiembroB->nuevoInstrumento(new Guitarra("Hondo H-77"));
$banda->nuevoMusico($bandaMiembroA);
$banda->nuevoMusico($bandaMiembroB);
foreach($banda->getMusicos() as $musico) {
echo "Musico ".$musico->getNombre() . "<br>";
echo "es el " . $musico->getTipoMusico() . "<br>";
echo "en la banda de " . $musico->getBanda()->getGenero();
echo " conocida como " . $musico->getBanda()->getNombre() . "<br>";
foreach($musico->getInstrumentos() as $instrumento) {
echo "Y toca la " . $instrumento->getCategoria() . " ";
Página 114 de 164

echo $instrumento->getNombre() . "<br>";

}
echo "<p>";
}
?>
Vemos como no es necesario saber con qué tipo de Musico o Instrumento estamos
tratando antes de llamar a sus métodos. Como se siguen las reglas definidas en la
interface sabemos que los objetos responderán apropiadamente.
Esto es un ejemplo de polimorfismo. Si necesitamos añadir otro tipo de músico escribimos

la nueva clase y definimos su comportamiento implementanto el interface Musico.
Página 115 de 164

Sesión 20. Introducción al Lenguaje de Modelado Unificado(UML)(II).

- Objetivo. Analizar y diseñar una aplicación usando UML.
- Actividades:
o Diagramas de Actividad.
Silvia mencionó en la reunión que la aplicación Triunfitos, al añadir una nueva actuación,
necesitará enganchar con otros dos sistemas de terceros: el sistema de entradas y el
sistema de reserva de locales.
Para comprender el orden en el que tienen que realizarse las diferentes tareas podemos
dibujar lo que se conoce como diagrama de actividad.
Los diagramas de actividad son muy recomendables en aquellas situaciones en las que es
necesario comprender el flujo de las actividades que tienen lugar en un caso de uso.
En este ejemplo, el caso de uso es la reserva de una actuación por parte del administrador
de Triunfitos.
Conversaciones posteriores con Silvia revelaron que el sistema no solo tendrá que enviar
un mensaje al sistema de reservas del local, sino que también necesita recibir información
de ambos sistemas.
El sistema de locales enviará una confirmación de que el local está disponible y el sistema
de entradas devolverá cierta información tal como el precio.
Si el administrador intenta reservar un local en una hora o fecha no disponible, el sistema

de reserva de locales debe indicarlo al sistema y éste al administrador, que lo intentará con
otra fecha.
Página 116 de 164

La siguiente figura muestra el diagrama de actividades descrito:
Los diagramas de actividad comienzan con un círculo negro, llamado punto de inicio.
Desde ahí el flujo del proceso sigue las flechas, llamadas transiciones, hacia los
rectángulos redondeados que representan actividades.
Un diamante vacío indica un punto de decisión. El flujo se divide según la condición

expresada en la decisión. La decisión en el ejemplo es si el local está o no disponible para
la fecha dada.
Después de la decisión, una barra negra (fork) divide el flujo en dos actividades diferentes.
En el sistema de locales, se genera una confirmación que será enviada de vuelta al

sistema Triunfitos y el sistema de entradas genera las entradas para el evento.
Tanto el sistema de entradas como el de locales envían información de vuelta a Triunfitos

hacia otra barra negra (join). El join indica que los mensajes de vuelta de ambos sistemas
tienen que llegar para proceder con el paso final del diagrama: almacenar y actualizar la
información sobre la nueva actuación.
Página 117 de 164

Los tres grandes rectángulos (calles o carriles) dividen el diagrama en las actividades
particulares de cada sistema. Aunque los carriles no son obligatorios, ayudan a clarificar el
diagrama cuando están implicados varios sistemas.
El diagrama termina en un circulo doble negro que indica la finalización de las actividades.
o Diagramas de Secuencia
Triunfitos tiene una jerarquía de clases. Las Bandas contienen Musicos que tienen
Instrumentos que pueden estar compuestos por otros instrumentos.
Durante el uso de la aplicación, los mensajes se retransmiten a través de las relaciones

entre los objetos.
Podemos considerar las llamadas a métodos como un tipo de mensaje que un objeto envía
a otro.
Por ejemplo, si una instancia de Banda necesita conocer qué Instrumentos tocan sus
Musicos, enviará un mensaje llamando al método getInstrumentos() de todos sus Musicos.
Es útil visualizar cómo los mensajes se mueven entre los objetos. Para ello UML
proporciona el diagrama de secuencias.
Los diagramas de secuencia normalmente se ciñen a un caso de uso individual.
Anteriormente vimos un caso de uso general llamado “Navegar Información Bandas”.

Podemos dividir ese caso de uso en otros más específicos.
Página 118 de 164

Para el caso de uso “buscar instrumentos por banda’’, el diagrama de secuencia debería
mostrar todos los objetos implicados y los mensajes pasados entre ellos para realizar la
tarea.
Las cajas superiores muestran las instancias de objetos implicados en la secuencia.
Una caja con un nombre subrayado denota una instancia de clase.
La linea discontinua que desciende de cada objeto es la línea de vida del objeto.
En este caso, la linea de vida no indica la creación (mensaje create()) o destrucción (X en

la línea de vida) de nuestros objetos, se supone que están y estarán ahí después de esta
tarea.
El rectángulo vertical muestra la activación del objeto, es decir, el tiempo durante el cual el
objeto está implicado en la ejecución de una operación concreta.
Página 119 de 164

En este diagrama se introduce otro objeto en la aplicación: el objeto Sistema. En nuestra

aplicación, el objeto Sistema recibe todos los mensajes del interfaz de usuario web; opción
mejor que interactuar directamente con nuestros objetos. De esta forma, la aplicación tiene
un único punto de entrada.
Las flechas indican mensajes. Se nombran con el nombre de método correspondiente del
objeto. Siguiendo los mensajes la secuencia es como sigue:
1. Un usuario solicita ver todos los instrumentos de una banda particular

escribiendo su nombre.
2. El objeto sistema busca la referencia a la banda haciéndose una llamada a sí
mismo.
3. El objeto sistema utiliza la referencia a la banda encontrada para llamar a su
método getMiembrosBanda().
4. El objeto banda llama al método getInstrumentos() de los músicos asignados a
esa banda.
5. El objeto musico llama al método getNombre() en cada uno de sus instrumentos
asignados.
6. Los nombres de los instrumentos son devueltos al objeto sistema para postrarlos
al usuario.
o Diagramas de Estado.
Los diagramas de estado son muy útiles cuando queremos mostrar los cambios que
soporta un objeto durante su vida.
Los cambios de estado pueden ser desde simples diferencias en las propiedades hasta
cosas más complejas como sondear esperando una respuesta de una fuente externa.
En Triunfitos, la clase Actuacion tiene una vida que podemos documentar con un diagrama
de estados.
Página 120 de 164

Cuando se crea un nuevo objeto Actuacion, éste debe contactar con el sistema de reserva
de locales y esperar una confirmación. Si la respuesta confirma la reserva, se almacena la
actuación en la base de datos. Si no se acepta la reserva, el objeto Actuacion informa al
sistema y es destruido.
El círculo sólido muestra el comienzo de la vida del objeto.
Las flechas indican las transiciones de un estado a otro.
Después de inicializar un nuevo objeto Actuacion y enviar un mensaje al sistema de

reservas, se espera confirmación de ese sistema.
Para indicar alguna información extra, como que el estado de esperando confirmación se
mantiene como máximo un minuto, se utiliza una Anotación o Nota. Este elemento se
puede utilizar en cualquier diagrama UML para aclarar algún concepto.
o Diagramas de Componentes y Despliegue
Los diagramas de componentes proporcionan una visión abstracta de alto nivel de nuestro
software.
Para el diagrama de componentes de Triunfitos, la mayor parte del código se reduce a un

único componente en el servidor web. Normalmente representan el almacenamiento físico
de nuestros componentes en los archivos del sistema de ficheros.
Página 121 de 164

Elementos técnicos como un servidor web forman parte de otro diagrama UML llamado
diagrama de despliegue.
Los diagramas de despliegue nos muestran algunos elementos físicos de la infraestructura

de nuestra aplicación, como por ejemplo los distintos servidores que están involucrados.
En la figura, los cubos se denominan nodos. Los nodos identifican piezas separadas del
hardware físico o, conceptualmente, como sistemas separados de software como un
servidor web.
Los componentes son pequeños rectángulos dentro de los nodos.
Las flechas discontinuas son dependencias. La parte web de Triunfitos (GUI) depende de
la aplicación Triunfitos en el servidor web, pero no al contrario.
Las líneas continuas muestran una conexión entre nodos, como, por ejemplo, el navegador
web comunicándose sobre HTTP.
Los círculos pequeños son un tipo de atajo para mostrar un interface. Como vimos
anteriormente, nuestra aplicación tiene un interface único llamado Sistema que todos los
clientes tienen que utilizar.
Otro interface se muestra dentro del nodo del sistema de reservas.
La empresa que maneja el sistema de reservas nos ha pasado una lista de métodos
públicos que podemos usar. No necesitamos nada mas para trabajar con este sistema de
reservas, solo necesitamos conocer los métodos del API que nos pasan.
Página 122 de 164


• Crear un proyecto en PHP orientado a objetos y modelado con UML.
Página 123 de 164

ANEXO.
TALLER 1. Primer contacto con PHP.

Utilidades:
- Editor de textos sencillo.
- Navegador web.
- Cliente ftp.
 Cuando pasamos un programa PHP al intérprete, éste presta atención únicamente a la parte
del contenido que se encuentra entre las etiquetas de inicio “<?php” (en algunos casos la
abreviada “<?”) y fin “?>” de PHP.
 Todas las páginas escritas en PHP se identifican con la extensión “.php”.
 Cualquier elemento que se encuentra fuera de esas etiquetas será dibujado sin modificaciónes.
Esto hace fácil embeber pequeños trozos de código PHP que mayoritariamente contienen
HMTL, aunque lo aconsejable es no mezclar.
Ejemplo 1. ¡Hola Mundo! Estático
<html>
<head>
<title>PHP dice hola</title>
</head>
<body>
<b>
¡Hola Mundo!
</b>
</body>
</html>
Ejemplo 2. ¡Hola Mundo! Dinámico.
<html>
<head>
<title>PHP dice hola</title>
</head>
<body>
<b>
<?php
echo "¡Hola Mundo!";
?>
</b>
</body>
</html>
La salida es:
<html>
<head>
<title>PHP says hello</title>
</head>
<body>
<b>
Hello, World!
</b>
</body>
</html>
En el navegador aparece así:
Página 124 de 164

• Una de las mayores fuentes de información para los programas en PHP es el mismo usuario
que visita nuestro sitio.
• El navegador muestra un formulario, el usuario introduce información y pulsa el botón enviar, el
navegador envía esa información al servidor y éste finalmente lo pasa al intérprete PHP donde
es finalmente accesible por tu aplicación PHP.
Ejemplo 3.1. Formulario HTML para enviar datos.

<form method="POST" action="diHola.php">
Tu nombre:
<input type="text" name="usuario">
<br/>
<input type="submit" value="Di Hola">
</form>
Nos aparece así.
Ejemplo 3.2. Fichero en PHP diHola.php que muestra el saludo dependiendo del nombre introducido en
el formulario.
<?php
echo "Hello, ";
// Muestra la información enviada por el formulario en el parámetro ‘usuario’
echo $_POST['usuario'];
echo "!";
?>
Si escribimos Florencio en la caja de texto y enviamos el formulario, nuestro programa dibuja ¡ Hola
Florencio!.
Página 125 de 164

• Observaciones.
o Todas las variables en PHP comienzan con el carácter ‘$’.
o La variable global de PHP $_POST almacena todos los valores enviados por un
formulario con el método POST. Realmente se trata de un array que puede ser
modificado.
Página 126 de 164

TALLER 2. Primera página dinámica.

Herramientas:
- Navegador web.
- Cliente ftp.
• Modificar la página de bienvenida en contactos haciéndola dinámica.
o Crear un formulario de entrada.

o Crear una página de recepción en php que muestre solo un mensaje general.
o Crear una página de recepción en php que muestre un mensaje personalizado.
o Asignar un número a cada contacto y modificar enlaces para apuntar a una sola
página: contactoDatos.php. Modificamos contactos.php
o Fusionar todas las páginas de contactos en una dinámica y aplicar decisiones a la
agenda usando una variable con el número. Creamos contactoDatos.php
Nuestra página de inicio tiene este contenido:
<html>
<head>
<meta name="AUTHOR" content="PAKO">
</head>
<body>
<center>
<h1>Hola</h1>
<br/>
<p>
Bienvenido/a a su página de contactos.
</p>
<p>
<a href="contactos.html">Entrar</a>
</p>
</center>
</body>
</html>
Vamos a incluir un formulario de bienvenida para introducir el nombre del usuario que accede a
nuestros contactos:
<p>
Por favor, introduzca su nombre de usuario.<br/>
<form action="contactos.php">
Usuario: <input type="text" name="usuario" method=”POST”>
<input type="submit" value="Entrar">
</form>
</p>
Modificamos la página que muestra la lista de contactos para que muestre un mensaje de bienvenida
general. Ésta página ya contiene php (contactos.php):
<?php
echo "Bienvenido/a a la página de contactos.";
?>
Ahora uno mostrando la bienvenida al usuario pasado en el formulario:

<?php
echo "Hola ".$_POST["usuario"]." <br/>";
?>
• Asignar un número a cada contacto y modificar enlaces para apuntar a una sola página:
contactoDatos.php. Modificamos contactos.php
<p>
<a href="contactoDatos.php?contacto=1">Jennifer Aniston</a>
<br/>
Página 127 de 164

<a href=" contactoDatos.php?contacto=2">Manolo Esparcia</a>

<br/>
<br/>
</p>
• Fusionar todas las páginas de contactos en una dinámica y aplicar decisiones a la agenda
usando una variable con el número. Creamos contactoDatos.php
<html>
<head>
</head>
<body>
<center>
<h1>Mis Contactos</h1>
<br/>
<p>
Nombre:
<?php
$contacto=$_GET["contacto"];
if( $contacto == 1 )
echo "Jennifer";
elseif( $contacto == 2)
echo "Manuel";
?>
<br/>
Apellidos:
<?php
echo "Aniston";
echo "Esparcia";
?>
<br/>
Teléfono:
<?php
echo "924 007 001";
echo "924 007 002";
?>
<br/>
Correo:
<?php
echo "janiston@edu.juntaex.es";
echo "mesparcia@edu.juntaex.es";
?>
<br/>
Lugar de Trabajo:
<?php
if( $contacto == 1 || $contacto == 2 )

echo "Secretaría General";
?>
<br/>
Imagen:
<br/>
<?php
echo "<img src='janiston.jpg'>";
echo "<img src='mesparcia.jpg'>";
?>
</p>
<p>
<a href="contactos.php">Volver</a>
</p>
</center>
</body>
Página 128 de 164

</html>
De esta forma, según el contacto, nos mostrará una información u otra.

Observemos el enlace para volver a la pagina de contactos:
<p>
<a href="contactos.php">Volver</a>
</p>
Así, el mensaje de bienvenida anterior usando la variable usuario no funcionará porque al volver, el
enlace no pasa ninguna variable, por lo tanto será necesario pasarle el usuario a la página
datosContacto.php para luego devolverlo.
En contactos.php, el enlace de cada contacto queda:
<?php
$usuario=$_POST["usuario"];
echo "Hola $usuario. <br/>";
?>
<a href="contactoDatos.php?contacto=1&usuario="<?php echo $usuario;?>Jennifer Aniston</a>

<a href="contactoDatos.php?contacto=2&usuario="<?php echo $usuario;?>">Manolo Esparcia</a>
Enlazamos variables en la url con el carácter &.
Ahora modificamos datosContacto.php:

<?php
$usuario=$_GET["usuario"];
?>
<p>
<a href="contactos.php?usuario=<?php echo $usuario;?>">Volver</a>
</p>
Aun así observamos que tampoco muestra el usuario en el mensaje de bienvenida. Eso es porque
usamos la variable global $_POST pero pasamos la variable en la URL, por lo que tambíen tenemos
que contemplar esta posibilidad. Actualizamos contactos.php:
<?php
if($_POST["usuario"])
$usuario=$_POST["usuario"];
elseif($_GET["usuario"])
?>
Página 129 de 164

TALLER 3. Uso de Arrays.

Herramientas:
- Navegador web.
- Cliente ftp.
• En la página inicial, almacenar la información de los contactos en un array y mostrar la lista con
un proceso repetitivo.
<?php
$contactos = array( 1 => "Jennifer Aniston",

2 => "Manolo Esparcia");
?>
<p>
<?php
foreach($contactos as $indice => $item){
?>
<a href="contactoDatos.php?contacto=<?php echo $indice;?>&usuario=<?php
echo $usuario;?>"><?php echo $item;?></a>
<br/>
<?php
}
?>
<br/>
</p>
<p>
Total: <?php echo count($contactos);?> contactos.
</p>
• Almacenar la información de los contactos en arrays y aglutinar todas las páginas de contactos
en una.
<?php
$contactos= array (array ( 'nombre' => 'Jennifer',
'apellidos' => 'Aniston',
'tfno' => '924 007 001',
'email' => 'janiston@edu.juntaex.es',
'lugar' => 'Secretaría General',
'img' => 'janiston.jpg'),
array ( 'nombre' => 'Manuel',
'apellidos' => 'Esparcia Montoya',
'tfno' => '924 007 002',
'email' => 'mesparcia@edu.juntaex.es',
'img' => 'mesparcia.jpg'));
?>
<html>
<head>
</head>
<body>
<center>
<br/>
<?php
$item=$contactos[$contacto];
echo "<p>";
echo "Nombre: {$item['nombre']} <br/>";
echo "Apellidos: {$item['apellidos']} <br/>";
echo "Tfno: {$item['tfno']} <br/>";
echo "Email: {$item['email']} <br/>";
echo "Lugar de Trabajo: {$item['lugar']} <br/>";
echo "<br/>";
echo "<img src='{$item['img']}'/>";
echo "</p>";
?>
Página 130 de 164

<p>
</p>
</center>
</body>
</html>
• Añadir el contacto de Blender Doblador y Fry Smith.

array ( 'nombre' => 'Bender',
'apellidos' => 'Doblador',
'tfno' => '924 007 003',
'email' => 'bdoblador@edu.juntaex.es',
'img' => 'bdoblador.jpg'),
array ( 'nombre' => 'Fry',
'apellidos' => 'Smith',
'tfno' => '924 007 004',
'email' => 'fsmith@edu.juntaex.es',
'img' => 'fsmith.jpg'));
Página 131 de 164

TALLER 4. Uso de funciones.

Herramientas:
- Navegador web.
- Cliente ftp.
• Separamos el array que almacena los datos de usuario en otro fichero: datos.php.
datos.php
<?php
$contactos= array (array ( 'nombre' => 'Jennifer',
'apellidos' => 'Aniston',
'tfno' => '924 007 001',
'email' => 'janiston@edu.juntaex.es',
'img' => 'janiston.jpg'),
array ( 'nombre' => 'Manuel',
'apellidos' => 'Esparcia Montoya',
'tfno' => '924 007 002',
'email' => 'mesparcia@edu.juntaex.es',
'img' => 'mesparcia.jpg'));
?>
• Incluimos el fichero de datos en el archivo contactos.php para poder usar esos datos.
<?php require_once "datos.php"; ?>
• En otro fichero guardaremos las funciones comunes que vamos a usar para mostrar diversos
datos, como por ejemplo el mensaje de bienvenida (hola()) y la lista de contactos
(listaContactos()).
funciones.php
<?php
function hola(){
global $usuario;
$usuario=usuario();
}
function usuario(){
if($_POST['usuario'])
return $_POST['usuario'];
elseif($_GET['usuario'])
return $_GET['usuario'];
else return "";
}
function listaContactos(){
global $contactos;
global $usuario;
foreach($contactos as $indice=>$item){
echo "<a href='contactoDatos.php".
"?contacto=$indice&usuario=$usuario'>$item[nombre]</a><br/>";
}
}
function detalleContacto($cont){
global $contactos;
$item=$contactos[$cont];
echo "<p>";
echo "Nombre: $item[nombre] <br/>";
echo "Apellidos: $item[apellidos] <br/>";
Página 132 de 164

echo "Tfno: $item[tfno] <br/>";

echo "Email: $item[email] <br/>";
echo "Lugar de Trabajo: $item[lugar] <br/>";
echo "<br/>";
echo "<img src='$item[img]'/>";
echo "</p>";
}
?>
• El archivo contactos.php nos queda así:
<?php
require_once "datos.php";
require_once "funciones.php";
?>
<html>
<head>
</head>
<body>
<center>
<br/>
<p>
<?php
hola();
?>
</p>
<p>
<?php
listaContactos();
?>
<br/>
</p>
<p>
Total: <?php echo count($contactos);?> contactos.
</p>
</center>
</body>
</html>
• El archivo con la información de cada contacto resulta:
<?php
require_once "datos.php";
?>
<html>
<head>
</head>
<body>
<center>
<br/>
<?php
detalleContacto($contacto);
?>
<p>
</p>
</center>
</body>
</html>
Página 133 de 164

TALLER 5. Acceso a base de datos.

Herramientas:
- Navegador web.
- Cliente ftp.
- PhpMyAdmin.
• Modificar nuestra aplicación para gestionar la información de los contactos desde

una base de datos.
o Crear una tabla de contactos.
CREATE TABLE contactos (

idContacto INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
nombre VARCHAR( 64 ) NOT NULL ,
apellidos VARCHAR( 64 ) NOT NULL ,
tfno VARCHAR( 20 ) NULL ,
email VARCHAR( 255 ) NULL ,
lugar VARCHAR( 255 ) NULL ,
img VARCHAR( 255 ) NULL
)
o Insertamos los dos registros que tenemos actualmente.
INSERT INTO `contactos` VALUES (

NULL , 'Jennifer', 'Aniston', '924 007 001',
'janiston@edu.juntaex.es', 'Secretaría General', 'janiston.jpg');
INSERT INTO `contactos` VALUES (
NULL , 'Manuel', 'Esparcia Montoya', '924 007 002',
'mesparcia@edu.juntaex.es', 'Secretaría General',
'mesparcia.jpg');
o Modificar nuestra aplicación para obtener esos datos.
En primer lugar, el archivo datos.php que contiene el array con los datos ya no es
necesario.
Incluimos en nuestro proyecto el archivo de ejemplo usado anteriormente para guardar

la configuración de acceso a la base de datos, config.php.
config.php
<?php
$datosConexion= array( 'servidor'=> "localhost",

'usuario' => "usuario",
'clave' => "clave",
'bd' => "cursoPHP5");
?>
Añadimos en el archivo funciones.php, las funciones necesarias para conectar a la

base de datos y para obtener la información a mostrar.
funciones.php
<?php
require_once("config.php");
function hola(){
global $usuario;
$usuario=usuario();
Página 134 de 164

function usuario(){
if($_POST['usuario'])
return $_POST['usuario'];
elseif($_GET['usuario'])
return $_GET['usuario'];
else return "";
}
global $conexion;
global $usuario;
$lista = array( );
$conexion=conecta();
$consulta="SELECT idContacto,nombre,apellidos FROM contactos";
while ($contacto = $resultado->fetch_array()) {
$lista[]=$contacto;
}
foreach($lista as $indice=>$item){
echo "<a href='contactoDatos.php? ".
"contacto=$item[0]&usuario=$usuario'>".
"$item[nombre] $item[apellidos]</a><br/>";
}
}
function detalleContacto($cont){
$consulta="SELECT * FROM contactos WHERE idContacto=$cont";
$contacto = $resultado->fetch_array();
echo "<p>";
echo "Nombre: $contacto[nombre] <br/>";
echo "Apellidos: $contacto[apellidos] <br/>";
echo "Tfno: $contacto[tfno] <br/>";
echo "Email: $contacto[email] <br/>";
echo "Lugar de Trabajo: $contacto[lugar] <br/>";
echo "<br/>";
echo "<img src='$contacto[img]'/>";
echo "</p>";
}
function conecta(){
global $datosConexion;
$conexion = mysqli_connect($datosConexion['servidor'],
$datosConexion['usuario'],
$datosConexion['clave']);
$baseDatos = mysqli_select_db($conexion, $datosConexion['bd']);
return $conexion;
}
function numContactos(){
$consulta="SELECT * FROM contactos";
$num = $resultado->num_rows;
return $num;
}
?>
El archivo que muestra la lista de contactos inicial no varía con respecto al Taller 4,
excepto en la sección que muestra el número de contactos que tenemos registrados.
Para ello usamos la función que hemos añadido en el archivo funciones.php. Otra
forma de hacerlo sería obteniendo ese número aprovechando la consulta que muestra
la lista de contactos.
Total: <?php echo numContactos();?> contactos.
Finalmente, el fichero con el detalle de los contactos difiere únicamente en la inclusión

del fichero de datos, que, como ya hemos mencionado, no es necesario; por lo tanto
eliminamos esa referencia.
Página 135 de 164

TALLER 6. Modificando información de base de datos.

Herramientas:
- Navegador web.
- Cliente ftp.
- phpMyAdmin
• Incluir opciones para insertar, modificar y eliminar contactos.
Comenzamos creando un archivo que contenga un formulario para solicitar los datos
del contacto a insertar.
nuevoContacto.php
<?php
?>
<html>
<head>
</head>
<body>
Nuevo Contacto
<?php
if(!$_POST['_envia_form'])
{
?>
<form action='nuevoContacto.php' method='POST'>
Nombre: <input type='text' name='nombre'>
Apellidos: <input type='text' name='apellidos'>
Telefono: <input type='text' name='telefono'>
Email: <input type='text' name='email'>
Lugar de Trabajo: <input type='text' name='lugar'>
Imagen: <input type='text' name='imagen'>
<input type='submit' value='Enviar'>

<input type='hidden' name='_envia_form' value='1'>
</form>
<?php
}
else{
nuevoContacto();
echo "Contacto añadido.";
}
?>
</body>
</html>
En la página de funciones creamos una nueva que haga la inserción en la base de

datos del nuevo contacto que queremos crear.
function nuevoContacto(){
$campos= array();
$campos[]=$_POST['nombre'];
$campos[]=$_POST['apellidos'];
$campos[]=$_POST['telefono'];
$campos[]=$_POST['email'];
$campos[]=$_POST['lugar'];
Página 136 de 164

$campos[]=$_POST['imagen'];
$consulta= "INSERT INTO contactos (idContacto, nombre, apellidos,”.
"tfno, email, lugar, img) VALUES (null, '$campos[0]', ".
"'$campos[1]','$campos[2]','$campos[3]','$campos[4]','$campos[5]')";
}
A continuación, en la lista de contactos, añadimos una opción para poder acceder a la

página que acabamos de agregar.
<a href="nuevoContacto.php">Nuevo Contacto</a>
Para modificar un contacto hacemos algo similar a lo hecho para crear uno nuevo.
Creamos un fichero que muestre un formulario con los datos del contacto, ofreciendo la
posibilidad de modificar esa información y enviarla para actualizar la base de datos.
editarContacto.php
<?php
?>
<html>
<head>
</head>
<body>
<p>
Editar Contacto
</p>
<?php
{
$datos=obtenerDatos($_GET['cont']);
?>
<form action='editarContacto.php' method='POST'>
Nombre: <input type='text' name='nombre' value='<?php echo $datos['nombre']?>'>
Apellidos: <input type='text' name='apellidos' value='<?php echo $datos['apellidos']?>'>
Telefono: <input type='text' name='telefono' value='<?php echo $datos['tfno']?>'>
Email: <input type='text' name='email' value='<?php echo $datos['email']?>'>
Lugar de Trabajo: <input type='text' name='lugar' value='<?php echo $datos['lugar']?>'>
Imagen: <input type='text' name='imagen' value='<?php echo $datos['img']?>'>

<input type='hidden' name='idContacto' value='<?php echo $datos['idContacto']?>'>
</form>
<?php
}
else{
modificarContacto();
echo "Contacto modificado.";
}
?>
</body>
</html>
En la página de funciones creamos una nueva que nos permita obtener los datos del
contacto a modificar y otra que haga la modificación en la base de datos del contacto
editado.
function obtenerDatos($cont){
Página 137 de 164

$consulta="SELECT * FROM contactos WHERE idContacto=$cont";
return $contacto = $resultado->fetch_array();
}
function modificarContacto(){
$campos= array();
$campos[]=$_POST['idContacto'];
$campos[]=$_POST['imagen'];
$consulta= "UPDATE contactos set ".
" nombre='$campos[1]'," .
" apellidos='$campos[2]'," .
" tfno='$campos[3]'," .
" email='$campos[4]'," .
" lugar='$campos[5]'," .
" img='$campos[6]'".
" WHERE idContacto=$campos[0]";
}
Para eliminar un contacto creamos una página que simplemente nos pida la
confirmación para borrar ese contacto de la base de datos.
eliminarContacto.php
<?php
?>
<html>
<head>
</head>
<body>
<p>
Eliminar Contacto
</p>
<?php
{
$datos=obtenerDatos($_GET['cont']);
?>
¿Desea eliminar el siguiente contacto?
<br/>
<form action='eliminarContacto.php' method='POST'>
<?php echo $datos['nombre']." ".$datos['apellidos']?>'
<input type='submit' value='Aceptar'>
<input type='hidden' name='idContacto' value='<?php echo $datos['idContacto']?>'>
</form>
<?php
}
else{
eliminarContacto();
echo "Contacto eliminado.";
}
?>
</body>
</html>
Como en los casos anteriores agregamos una función que nos permita hacer el borrado
del contacto de la base de datos.
function eliminarContacto(){
Página 138 de 164

$contacto =$_POST['idContacto'];
$consulta = "DELETE FROM contactos WHERE idContacto=$contacto";
}
Finalmente, en la lista de contactos, añadimos los enlaces necesarios para poder llevar
a cabo estas acciones. Bastará con incluir al final de cada contacto dos enlaces, uno
para editar y otro para borrar.
funciones.php
global $conexion;
global $usuario;
$lista = array( );
$consulta="SELECT idContacto,nombre,apellidos FROM contactos";
while ($contacto = $resultado->fetch_array()) {
$lista[]=$contacto;
}
echo "<table width='60%'>";
foreach($lista as $indice=>$item){
echo "<tr><td width='90%' style='border-bottom: 1px solid #CCC'>";
echo "<a href='contactoDatos.php?contacto=$item[0] ".
"&usuario=$usuario'>$item[nombre] $item[apellidos]</a>";
echo "</td><td width='5%'style='font-size: 12px'>";
echo "<a href='editarContacto.php?cont=$item[0]'>Editar</a>";
echo "</td><td width='5%' style='font-size: 12px'>";
echo "<a href='eliminarContacto.php?cont=$item[0]'>Borrar</a></td>";
echo "</tr>";
}
echo "</table>";
}
Página 139 de 164

TALLER 7. Subiendo ficheros.

Herramientas:
- Navegador web.
- Cliente ftp.
- phpMyAdmin
• Incluir opciones para subir imágenes a nuestros contactos.
Modificamos el archivo encargado de crear un contacto nuevo.
nuevoContacto.php
<?php
?>
<html>
<head>
</head>
<body>
Nuevo Contacto
<?php
{
?>
<form action='nuevoContacto.php' method='POST' enctype="multipart/form-data">
Nombre: <input type='text' name='nombre'>
Apellidos: <input type='text' name='apellidos'>
Telefono: <input type='text' name='telefono'>
Email: <input type='text' name='email'>
Lugar de Trabajo: <input type='text' name='lugar'>
Imagen: <input type='file' name='imagen'>

</form>
<?php
}
else{
nuevoContacto();
echo "Contacto añadido.";
}
?>
</body>
</html>
En el archivo encargado de las funciones genéricas añadimos las líneas de cósigo

necesarias para el tratamiento de ficheros.
funciones.php
function nuevoContacto(){
$campos= array();
Página 140 de 164

$campos[]=$_FILES['imagen'][‘name’];
if($_FILES['imagen']) {
subirFichero();
$campos[]=$_FILES['imagen'][‘name’];
}
$consulta= "INSERT INTO contactos (idContacto, nombre, apellidos,”.
"tfno, email, lugar, img) VALUES (null, '$campos[0]', ".
"'$campos[1]','$campos[2]','$campos[3]','$campos[4]','$campos[5]')";
}
function subirFichero( ) {
$ficheroOrigen = str_replace('/', '', $_FILES['imagen']['name']);
$ficheroOrigen = str_replace('..', '', $ficheroOrigen);
$ficheroDestino = '/var/www/cursoPHP5/' . $ficheroOrigen;
if (move_uploaded_file($_FILES['imagen']['tmp_name'], $ficheroDestino)) {
echo "Fichero subido como $destination_file.";
} else {
echo "No ha sido posible subifr el fichero.";
}
}
Modificamos el archivo encargado de editar un contacto y modificarlo, cambiando el

formulario de la misma forma que el de nuevoContacto.php.
De igual forma modificamos funciones.php para que la modificacion de archivo también

sea posible.
funciones.php
function modificarContacto(){
$campos= array();
$campos[]=$_POST['idContacto'];
if($_FILES['imagen']) {
subirFichero();
$campos[]=$_FILES['imagen']['name'];
}
$consulta= "UPDATE contactos set ".
" nombre='$campos[1]'," .
" apellidos='$campos[2]'," .
" tfno='$campos[3]'," .
" email='$campos[4]'," .
" lugar='$campos[5]'," .
" img='$campos[6]'".
" WHERE idContacto=$campos[0]";
}
Al eliminar un contacto también tenemos que tener en cuenta la eliminación del archivo
de imagen asociado.
function eliminarContacto(){
$contacto =$_POST['idContacto'];
$consulta= "SELECT img FROM contactos WHERE idContacto=$contacto".
" and img not like ''";
$imagen=$resultado->fetch_array();
unlink("c:\\wamp\\www\\cursoPHP5\\taller\\taller7\\".$imagen[0]);
$consulta="DELETE FROM contactos WHERE idContacto=$contacto";
Página 141 de 164

TALLER 8. Proyecto Orientado a Objetos com UML y PHP.

Herramientas:
- Navegador web.
- Cliente ftp.
- PhpMyAdmin.
- Herramienta de modelado UML (ArgoUML).
o Creando la Agenda de Contactos.
Vamos a variar un poco nuestra aplicación de agenda de contactos para practicar creando un proyecto
en PHP, orientado a objetos y modelado con diagramas UML.
Es importante aclarar que la solución aplicada en este caso es una de las muchas posibles, ya que el
modelado puede variar tanto por los elementos a tener en cuenta como por los diseñadores que lo
lleven a cabo.
Nuestra agenda de contactos maneja datos sobre personas. Vamos a ampliar su espectro hacia la
organización de la Secretaría General de la Consejería de Educación de la Junta de Extremadura.
Por tanto tendremos en cuenta que cada persona trabaja en cero o una sección y que una sección
pertenece a un servicio.
Tanto la sección, como el servicio tendrá, cada uno, un responsable. También tendrán un identificador,
un nombre, una dirección física, una página web, un correo electrónico, un télefono y un fax.
Además los datos de cada contacto son: un identificador, un nombre, apellidos, dirección del trabajo,
dirección personal, teléfono del trabajo, teléfono personal, fax, email del trabajo y email personal.
Debe permitir al usuario consultar y manejar la información de esos contactos.
Descripción grosso modo de lo que se espera que haga la aplicación:
- Debe almacenar información sobre personas y la estructura en una base de datos y

mostrarlas en una página web.
- Los contactos pueden tener ninguna o muchas direcciones, e-mails y números de teléfono.
- Una persona pertenece a una organización.
- Una organización tiene ninguno o muchos empleados.
Esta lista de requisitos, en el análisis, se detalla en más profundidad, obteniendo una lista de requisitos
identificados a los que poder referirnos durante el diseño y que podamos validar con el cliente, una vez
terminada esa fase de diseño.
Diagrama UML de la Agenda de Contactos
Antes de nada se debe hacer un análisis de los requisitos y a continuación obtener casos de uso de
alto nivel, tanto en diagramas como en plantillas textuales. Lo que nosotros veremos aquí sería la etapa
de diseño. Tanto el análisis como el diseño se hacen en este taller de forma combinada y con la mayor
brevedad. Existe una metodología de desarrollo de software basada en Métrica v.3 aun en estudio, que
será la utilizada en el desarrollo de cualquier aplicación en la sección de desarrollo del servicio de
informatica de la Consejeria de Educacion. Esta metodología incluye mayor nivel de detalle y
documentación, y utiliza también UML para el modelado.
Con nuestra aplicación de modelado (ArgoUML) vamos a crear un nuevo fichero llamado
AgendaContactos. Aun no tenemos en cuenta cómo almacenamos esos datos de forma permanente,
es decir, el diseño de las tablas en la base de datos. Eso lo retomamos después del modelado en el
apartado del diseño del dominio de la aplicación.
Hemos identificado dos roles o perfiles: uno encargado de crear, modificar y eliminar contactos
(administrador); y otro que solo consulta los contactos (usuario).
Página 142 de 164

Aunque nuestra aplicación no contemple diferencia entre ambos, ya que no hay control de acceso, los
trataremos como tales para ver como interactuan diferentes roles con nuestros casos de uso.
Creamos nuestros caso de uso.
Página 143 de 164

Las clases que obtenemos según nuestros casos de uso son:
Como vemos, están representadas las asociaciones entre los contactos y las secciones y servicios.
Pero si observamos detenidamente podemos determinar que:
1. Los servicios y las secciones son también contactos.

2. Hay mucha información y actividades repetidas.
De ambas observaciónes podemos determinar que en lugar de contacto la clase que se refiere a las
personas en sí, se llame, obviamente, Persona y establecemos una nueva clase Contacto que
contenga tanto las propiedades como los métodos comunes a todas las clases. Así, hacemos que esas
clases hereden de la clase Contacto. Esa clase por sí sola no tiene sentido, así que la creamos como
abstracta.
Página 144 de 164

Para indicar además que hay un responsable tanto en Seccion como en Servicio añadimos una
asociación con Persona desde ambas clases.
Para tratar con los datos de la base de datos creamos una clase llamada GestorDatos.
Para que nuestra aplicación funciones de forma que exista un solo punto de entrada, nos creamos una
clase Aplicación, que será con la que tratemos para ejecutar todas las peticiones que necesitemos.
Por tanto, el diagrama de clases nos queda así:
En el caso del nombre de la persona, se sobreescribe la propiedad denominacion, que en este caso
será igual a la concatenación del nombre y los apellidos.
Añadimos un interfaz que indica que todas aquellas clases que lo realicen deben implementar un
método validar(), encargado de la validación de los valores que se establezcan para las propiedades de
Página 145 de 164

esas clases.
Ahora que hemos hecho una primera aproximación a la solución del problema, tenemos que diseñar
cómo almacenar la información en la base de datos MySQL, es decir, el modelo de dominio de la
aplicación.
0..N 0..1
Persona pertenece Seccion
0..N
pertenece
0..1
Servicio
Por tanto las tablas resultantes son:
Persona: { id_persona, nombre, apellidos, direccion, telefono, fax, email, id_seccion}

Seccion: { id_seccion, denominacion, direccion, telefono, fax, email, id_servicio }
Servicio: { id_servicio, denominacion, direccion, telefono, fax, email }
El modelo relacional y el modelo orientado a objetos suele variar sustancialmente. En ocasiones

podemos modelar nuestras clases para que sean simples gestores de consultas, es decir, que
contengan una serie de métodos encargados de consultar, insertar, eliminar o actualizar datos de las
tablas resultantes del modelo de dominio.
Existe una aproximación que permite relacionar de una forma más directa ambos modelos. Crear cada
clase como encargada de mantener una tabla de la base de datos.
En nuestro caso nos permitiría tener una nueva tabla, Contactos, que almacenaría aquellos campos
comunes a las demás tablas.
Contacto: { id_contacto, denominacion, direccion, telefono, fax, email }

Persona: { id_persona, id_contacto, nombre, apellidos, id_seccion}
Seccion: { id_seccion, id_contacto, id_servicio, id_responsable }
Servicio: { id_servicio, id_responsable}
Podemos mejorar este diseño combinando las tablas de Sección y Servicio en una única tabla: Unidad.

Persona: { id_persona, id_contacto, nombre, apellidos, id_unidad}
Unidad: { id_unidad, id_contacto, id_responsable, id_unidadSuperior}
De forma que aquel registro cuya id_unidadSuperior sea cero indicará que es un servicio y si es distinto
de cero, indica que se trata de una sección y de que unidad (servicio) depende.
Si además, como puede observarse, Contacto tiene una relación de uno a uno con Persona y Unidad,
podemos hacer coincidir la clave de Contacto con la clave de Persona y Unidad.

Persona:{id_contacto,nombre, apellidos, direccionPersonal, telefonoPersonal,emailPersonal ,id_unidad}
Unidad: { id_contacto, id_responsable, id_unidadSuperior}
Si además, desde contactos necesitamos saber de qué tipo de contacto se trata, es decir, si es una
Persona o una Unidad, necesitamos crear un campo tipo en contactos.
Contacto: { id_contacto, denominacion, direccion, telefono, fax, email, tipo}

Persona:{id_contacto,nombre,apellidos,direccionPersonal,telefonoPersonal,emailPersonal,id_unidad}
Unidad: { id_contacto, id_responsable, id_unidadSuperior}
Página 146 de 164

Se podría mejorar mucho más hasta hacer que toda esa información provenga de una única tabla, pero
a efectos de mostrar cómo funciona el modelado con UML, dejamos este diseño como válido.
Contacto
Es un
Es un
0..1 0..1
Persona Unidad
0..N
depende
Es
responsable
Estos cambios en el modelo de dominio también pueden afectar a nuestro modelo de diseño de
objetos. Es decir, es posible que nuestras clases se vean condicionadas por el resultado en el modelo
de datos.
Ya hemos finalizado el modelado de la parte estática de nuestra aplicación.
Ahora veremos cómo podemos dibujar el comportamiento de nuestras clases, es decir, el

funcionamiento de nuestra aplicación.
Hemos determinado que la clase Aplicación gestione todos los mensajes que podemos pasar a nuestro
programa. Pero nuestra aplicación tiene que tener un comienzo, un punto de entrada. Con el cliente,
hemos confirmado que el caso de uso Listar Contactos sea lo primero que se ejecute al llamar a
nuestro programa.
Página 147 de 164

Según el caso de uso Listar Contactos, tenemos que mostrar una lista de todos los contactos.
Cada elemento de la lista es la denominación del contacto y un enlace para ver la información detallada
del mismo.
Definimos un diagrama de secuencia.
Vamos a llegar hasta este punto en el diseño para no extendernos demasiado en el taller.
Continuamos con la fase de implementación en la que también cubriremos sólo hasta este caso de
uso.
Creamos el interfaz y las clases necesarias en PHP.
El código está en el cd que acompaña a este manual.
Página 148 de 164

Página 149 de 164

Referencias
Caracteres de formato de strftime( ) y date( )

Tipo strftime( ) date( ) Descripción Rango
%H H Hora, numérico, formato 24 horas. 00-23
%I h Hora, numérico, formato 12 horas. 01-12
%k Hora, numérico, formato 24 horas, con espacio a la 0-23

iquierda.
%l Hora, numérico, formato 12 horas, con espacio a la 1-12
Hora iquierda.
%p A A.M. o P.M.
%P a a.m. o p.m.
G Hora, numérico, formato 24 horas, cero principal 0-23

ajustado.
g Hora, numérico, formato 12 horas, cero principal 0-11
ajustado.
Minuto %M i Minuto, numérico. 00-59
[2]
Segundo %S s Segundo, numérico. 00-61
%d d Día del mes, numérico. 01-31
%e Día del mes, numérico, con espacio a la izquierda. 1-31
001-366 strftime(),
%j z Día del año, numérico. 0-365 date()
Día %u Día de la semana, numérico, 1 = Lunes. 1-7
%w w Día de la semana, numérico, 0 = Domingo. 0-6
j Día del mes, numérico, sin cero. 1-31
"st", "th", "nd",

S Sufijo ordinal en inglés para el día del mes, texto.
"rd"
%a D Abbreviated weekday name, text for current locale,

texto.
%A l Nombre completo del dia de la semana, texto.
Semana Número de semana del año, numérico, la primera

%U 00-53
semana comienza el primer domingo del año.
Número de semana del año, numérico, la primera

%W 00-53
semana comienza el primer lunes del año.
%B F Nombre completo del mes, texto.
%b M Nombre abreviado del mes, texto.
%h Igual que %b.

Mes
%m m Mes, numérico. 01-12
n Mes, numérico, sin cero a la izquierda. 1-12
t Número de días del mes, numérico. 28, 29, 30, 31
%C Siglo, numérico. 00-99
Año %y y Año con 2 dígitos, numérico. 00-99
%Y Y Año con 4 dígitos, numérico.
%z O Diferencia horaria GMT, +/-HHMM (e.j., -0400, +0230). -1200-+1200

Zona Horaria
%Z T Zona horaria, nombre o abreviación, texto.
Compuesta %c Formato estándar de fecha y hora.
%D Igual que %m/%d/%y.
Página 150 de 164

Caracteres de formato de strftime( ) y date( )

Tipo strftime( ) date( ) Descripción Rango
%F Igual que %Y-%m-%d.
%r Hora en A.M. o P.M.
%R Hora en formato 24 horas.
%T Hora en formato 24 horas ( igual que H:%M:%S).
%x Formato estándar de fecha (sin hora).
%X Formato estándar de hora (sin fecha).
Formato de fecha RFC 822

r
ej. "Vie, 13 Abr 2007 16:01:07 +0200".
%% Carácter %
Edición %n Carácter de nueva línea.
%t Carácter de tabulación.
[2]
El rango de segundos se extiende a 61 por el salto de segundos.
Página 151 de 164

Página 152 de 164

Página 153 de 164

Página 154 de 164

Página 155 de 164

Página 156 de 164

Manual Básico de phpMyAdmin

Con phpMyAdmin podremos gestionar nuestras bases de datos MySQL, la
pantalla inicial (imagen 2) da la opción tanto de seleccionar una base de datos ya
creada desde el menú de la izquierda, como de crear una nueva base de datos:
Imagen 2
Para seleccionar una base de datos existente, desplegaremos el combo de la

izquierda de la pantalla, y elegimos la base de datos (imagen 3):
Imagen 3
Una vez seleccionada procederemos a gestionar la base de datos, a partir de

aquí podemos crear tablas, sentencias SQL, insertar datos en una tabla ya creada
anteriormente, buscar registros, modificarlos, etc.
Las secciones principales en phpMyAdmin para realizar estas gestiones son:
1) Estructura (imagen4). En la pestaña de estructura podremos crear tablas

dentro de nuestra base de datos, modificar el nombre de la base, y el cifrado.
Página 157 de 164

imagen 4
Para crear una nueva tabla introduciremos el nombre que le queramos asignar
y el número de campos (imagen 5).
imagen 5
Una vez pinchado el botón de continuar, accederemos a la configuración de los

campos de la tabla (imagen 6):
imagen 6
Dispone las siguientes opciones para configurar cada campo:
1. Nombre del campo.

2. Tipo de campo (texto, numérico, fecha/hora, etc.)
3. Longitud/Valores.
4. Collation (cifrado).
5. Atributos.
6. Nulo.
7. Predeterminado.
Página 158 de 164

8. Extras (Aquí establecemos la propiedad Autoincrement: autonumérico).

9. Clave primaria / Índice / Único.
10. Como opciones de la tabla tenemos las siguientes:
1. Comentarios de la tabla.
2. Tipo de tabla.
3. Collation.
Una vez creados los campos podremos insertar registros completando el

siguiente formulario (imagen 7):
Imagen 7
2) Consultas sql e importar bases de datos. Mediante consultas SQL

también podremos realizar cualquier operación de las tablas, insertar, modificar
o eliminar registros, realizar búsquedas, etc.
Página 159 de 164

Imagen 8
También puede crear la sentencia SQL en un fichero *.txt,*.sql y después

subirlo mediante el apartado localizar del archivo de texto . Desde aquí también
podremos importar las bases de datos, incluyendo la sentencia SQL en el fichero
*.SQL, el tamaño máximo de dicho fichero debe ser 2 megas.
Las sentencias SQL también puede generarlas con el propio generador de

consultas (imagen 9)
Página 160 de 164

imagen 9
3) Exportar. Desde esta pestaña usted puede exportar de una forma sencilla
sus bases de datos (imagen 10).
Imagen 10
4) Operaciones. En esta pestaña disponemos de una serie de operaciones

básicas de modificación y mantenimiento de la base de datos (imagen 11).
Página 161 de 164

imagen 11
1) Modificar el orden de aparición de los campos en una tabla.

2) Cambiar el nombre de la tabla.
3) Mover tablas de una base de datos a otra.
4) Copiar tablas de una base de datos a otra.
5) Añadir comentarios a una tabla.
6) Definir el tipo de tabla..
7) Collation.
8) Distintas opciones de tabla.
En lo referente a Mantenimiento de la tabla, podremos:
1) Revisar la tabla.
2) Analizar la tabla.
3) Reparar la tabla.
4) Optimizar la tabla.
5) Vaciar caché.
Se recomienda encarecidamente realizar las tareas de mantenimiento de las

bases de datos periódicamente, tanto revisar posibles fallos en las tablas, como
analizar las bases en busca de errores, para posteriormente poder repararla. Todas
estas tareas de mantenimiento hacen que las bases funcionen fluidamente evitando
problemas a la hora de navegar por el sitio web.
Página 162 de 164

Página 163 de 164

Curso php5

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Curso php5

Transféré par

Droits d'auteur :

Formats disponibles

Formación

Kinética Mobile Development

Francisco José González Lozano

Sesión 1. Sitios Web estáticos. ................................................................................... 5

ANEXO. ................................................................................................................... 124

Sesión 1. Sitios Web estáticos.

o Crear un sitio web en el sistema local.

 Escribimos una página de bienvenida.

 Creamos una página índice con 2 nombres de contactos.

 Y dos páginas con la información de cada contacto.

Teléfono: 924 007 001

Hacemos doble clic en el fichero index.html o escribimos la ruta en el navegador.

 Concepto de cliente/servidor. Proceso de consulta web, servidor web y

1. Escribimos http://si_cursophp/index.html en la barra de direcciones de

2. Nuestro navegador envía un mensaje via Internet al sistema llamado

3. Nuestro servidor Apache, que se está ejecutando en la máquina

4. Apache envía el contenido del fichero de vuelta a nuestro ordenador a

5. El navegador muestra la página en la pantalla, siguiento las instrucciones

Cada vez que escribamos en el navegador http://si_cursophp/index.html, el

o Creación y Mantenimiento del sitio web.

Subimos ficheros a nuestro servidor web.

Añadimos dos contactos.

Modificamos la información de un contacto bajándonos el fichero, cambiando sus

Modificamos el aspecto del sitio.

o Evaluar ventajas e inconvenientes.

Sesión 2. Primeros pasos.

o Sitios web dinámicos. Arquitectura cliente/servidor + PHP.

1. Escribimos http://si_cursophp/index.php en la direccion de nuestro

2. Nuestro navegador envía un mensaje a través de internet a un ordenador

3. El servidor web (Apache) obtiene el mensaje, reconoce que solicita un

4. PHP lee el archivo index.php del disco duro.

5. PHP interpreta los comandos contenidos en index.php, posiblemente

6. Después, PHP envía el resultado de la ejecución del archivo index.php

7. El servidor web (Apache) envía el contenido obtenido de PHP de vuelta a

8. Finalmente, nuestro navegador interpreta el codigo html recibido y lo

• PHP es un lenguaje de programación.

 Especificación HTML 4.01

<FORM NAME=’’ METHOD=’’ ACTION=’POST’>

<INPUT NAME=’’ ID=’’ TYPE=’text’/>

<TEXTAREA NAME=’’> </TEXTAREA>

<SELECT NAME=’’ ID=’’ MULTIPLE>

- Evaluación. Web dinámicas.

Sesión 3. Características básicas.

 Etiquetas de inicio y fin.

 Múltiples etiquetas de inicio y fin.

Código fuente: Ejemplo 100.

Cinco más cinco son:

Cinco más cinco es:

Algunas aplicaciones en PHP utilizan la etiqueta de inicio en modo abreviado,

 Espacios y ‘case sensitive’.

• Múltiples instrucciones por línea. (“;”). Líneas en blanco entre

Código fuente: Ejemplo 101.

echo " Mundo!";

echo " Mundo!";

echo "Demasiados espacios " ;

echo "La cantidad idónea de espacios";

Las instrucciones del lenguage (como echo) y los nombres de funciones

// Estas cuatro líneas hacen lo mismo

Código fuente: Ejemplo 102.

// Esto es una línea de comentario

echo "Puchero de garbanzos";

echo 'precio €3.25.';

# Añadimos otro plato al menú