Programacionen PHP

Programación en PHP
Version imprimible
Este documento deber servir exclusivamente como material de apoyo al contenido
del curso interactivo accesible a través de internet.
Indice
Módulo I. Introducción.................................................................
U.D.1. Lenguajes de programación Web............................. 3
U.D.2. ¿Qué es PHP?.................................................... 6
U.D.3. ¿Qué es apache?................................................ 9
U.D.4. Instalación........................................................ 10
Módulo II. Conceptos básicos........................................................
U.D.1. Panorámica del lenguaje...................................... 17
U.D.2. Variables......................................................... 21
U.D.3. Operadores...................................................... 24
U.D.4. Sentencias de control.......................................... 33
Módulo III. Conceptos avanzados...................................................
U.D.1. Cadenas.......................................................... 44
U.D.2. Arrays............................................................. 53
U.D.3. Funciones........................................................ 61
U.D.4. Formularios...................................................... 70
U.D.5. Manejo de ficheros..............................................80
Módulo IV. PHP y las bases de datos..............................................
U.D.1. Estructura de una aplicación web con bases de datos... 88
U.D.2. ¿Qué es MySQL?............................................... 89
U.D.3. El lenguaje SQL................................................. 90
U.d.4. Funciones de PHP con MySQL............................. 102
Módulo V. Aplicaciones comunes en PHP.........................................
U.D.1. Fecha y hora................................................... 111
U.D.2. Envío de emails................................................ 116
Plataforma de Teleformación de IFES Página 1 de 143

U.D.3. Sesiones........................................................ 120

U.D.4. Control de acceso............................................. 126
U.D.5. Registro de accesos.......................................... 131
U.D.6. Plantillas........................................................ 135
Página 2 de 143 Programación en PHP

Módulo I. Introducción
U.D.1. Lenguajes de programación Web
Tipos de páginas web. Estáticas y dinámicas.
Las primeras páginas que aparecieron en Internet eran muy sencillas y poco
interactivas. Solo permitían mostrar información (texto o imágenes) y seguir enlaces a
nuevas páginas.
Para compensar esta falta de interactividad aparecieron los lenguajes de programación

en el cliente (el navegador de Internet) que permitían una interactividad limitada. En
esta categoría el principal lenguaje es Javascript. Un ejemplo típico
de programación mediante un Javascript es el de un menú jerarquico desplegable.
Pero hay multitud de funcionalidades que están fuera del alcance de los lenguajes de
programación en el cliente. La interactividad que permiten se reduce prácticamente a
mejorar la apariencia de la información en la página web, y a añadir efectos visuales
que aunque puedan ser curiosos no aportan un valor añadido.
Con la llegada de los lenguajes de servidor aparecieron las primeras páginas

dinámicas. Hoy en día la mayor parte de Internet está formada por este tipo de páginas.
El buscador de Internet que usamos cada vez que queremos encontrar páginas de una
temática es una página dinámica. La Plataforma de Teleformación de IFES es también
una página dinámica.
Generación de páginas web
Para poder comprender la diferencia entre una página estática y una página dinámica
hay que tener presente el proceso que sigue una página web desde que la
solicitamos (haciendo clic en un enlace del navegador) hasta que la recibimos y se
muestra por pantalla.
Página estática

Elementos del proceso:
a) Navegador - Aplicación que permite al usuario recibir y mostrar

páginas web.
b) Cliente - En el ámbito de Internet, es el ordenador que está
conectado a la red. Su función se limita a realizar peticiones de páginas
web y mostrar los resultados.
c) Internet.
d) Servidor web (hardware) - Ordenador conectado a Internet que aloja
páginas web.
e) Servidor web (software) - Programa que transfiere páginas web a
los cllientes mediante el protocolo HTTP.
El término servidor web se usa indistintamente para denominar tanto al ordenador

conectado a Internet que aloja páginas web como a la aplicación software que gestiona
la transferencia de páginas web.
Página dinámica

Ahora hay un nuevo elemento, el servidor de aplicación.
f) Servidor de aplicación - Es el programa que colabora con el servidor

web para generar páginas dinámicas.
A diferencia de las páginas estáticas, en las que se guardaba en el disco duro el

archivo html, las páginas dinámicas no están directamente almacenadas en el disco
duro. En su lugar hay un programa, que se ejecuta en el servidor de aplicaciones, que
es el encargado de crear el archivo que se transferirá al cliente.
Lenguajes de programación web
Para generar páginas web se han usado a lo largo del tiempo un gran número de
tecnologías. En los comienzos no había ningún lenguaje de programación específico,
por lo que se hacía uso de lenguajes de uso más general como C, C++, Basic o Pascal.
Para comunicar estos programas con el servidor web se hacía uso de la especificación
CGI (Common Gateway Interface o Pasarela de Interfaz Común). Hoy en día aún hay
aplicaciones que siguen este enfoque, y comúnmente se las conoce como CGI's.
Pero el uso de lenguajes de uso general hacía complicado el proceso de construir

páginas web dinámicas. El código se escribía de forma casi artesanal y era difícil de
mantener y actualizar. Además el código que funcionaba en un servidor web podía no
funcionar en otro o requerir de un esfuerzo grande para su instalación. Para colmo de

todos los males, por lo general, los CGI son poco eficientes.
Afortunadamente hoy en día el panorama ha cambiado radicalmente. El éxito de

Internet ha ido acompañado de la aparición de lenguajes de programación web que
faciliten todo el proceso. Para especializarse en la creación de páginas web dinámicas
estos lenguajes intentar cumplir los siguientes objetivos:
• Ser de fácil uso, para permitir una curva de aprendizaje sencilla.

• Adaptarse rápidamente a la rápida evolución de Internet, ofreciendo
continuamente nuevas características y actualizaciones de seguridad.
• Tener una gran comunidad de usuarios que garanticen el éxito del producto.
De hecho han proliferado tanto que ahora hay una gran cantidad de tecnologías
disponibles, que lanzan los fabricantes con la intención de acaparar la mayor cuota de
mercado posible. Aún así hay tres tecnologías mediante las cuales se desarrollan la
mayoría de los sitios web.
ASP- Active Server Pages
Esta es una tecnología propietaria de Microsoft. Actualmente está engloba en su

estrategia .NET. Su principal ventaja es su sencillez, además de una muy buena
integración con otros productos de Microsoft como su entorno de desarrollo .NET que
permite crear aplicaciones es un tiempo record. Se integra muy bien con el servidor
web de Microsoft, el IIS (Internet Information Center).
JSP - Java Server Pages
Esta es una tecnología basada en uno de los lenguajes de uso general más populares,
Java. Es quizás el más complejo de los 3 pero a su vez el más potente. La gran
comunidad de usuarios garantiza la existencia de numerosas herramientas, librerías de
código abierto y bases de conocimiento. Además se integra muy bien en el servidor
web mayoritario, Apache gracias a la extensión Tomcat.
PHP - PHP Hypertext Preprocessor
A su favor tiene el ser una iniciativa de código abierto, por lo que es mantenido e
impulsado por una gran comunidad de programadores. Además es el más sencillo de
los tres, por lo que atrae a usuarios de muy diferentes procedencias: programadores en
lenguajes de programación más generalistas, diseñadores que desean completar sus
conocimientos...
U.D.2. ¿Qué es PHP?

Un poco de historia

Ya hemos visto que PHP responde a las siglas PHP Hypertext Procesor. Pero, ¿como
surgió?
En el año 1994 el programador danes-canadiense Rasmus Lerdorf lo creo para poder

programar su página web personal, que consistía básicamente en un curriculum vitae y
un registro del tráfico que recibía. Un año más tarde lo publicó con el nombre de
Personal Home Page Tools. En 1997 atrajo el interés de dos programadores israelíes
del Technion que reescribieron el interprete gramatical de este lenguaje creando la
base de la primera versión realmente popular de PHP, PHP 3.
En 1999 reescribieron el lenguaje y lo dotaron de mayor eficiencia mediante el motor

Zend, dando lugar a la versión estable más utilizada actualmente, PHP 4.
Existe ya una versión 5 de este lenguaje, que incluye un sistema novedoso, el PDO
(Objetos de Información de PHP o PHP Data Objects) y mejoras utilizando las ventajas
que provee el nuevo Zend Engine 2. Los cambios que incorpora la versión son
notables, y posicionan a PHP como un lenguaje dinámico muy potente.
Durante este curso se recomienda el uso de Xampp, que viene con la versión 5.04 de
PHP. No obstante, como el curso es de iniciación, no se hará uso de las características
avanzadas, por lo que no nos afectará la versión que estemos utilizando. De todas
formas siempre es conveniente conocecer la versión en la que ejecutaremos nuestras
aplicaciones/ejemplos.
Características de PHP
A nivel técnico se pueden destacar los siguientes aspectos:
• Es un lenguaje interpretado (también llamado de tipo script).

• La sintaxis es similar a los lenguajes de programación estructurada más
populares, como C, por lo que resulta muy sencilla la transición desde otros
lenguajes.
• En el código fuente se mezclan habitualmente fragmentos de código PHP
con el cuerpo de la página HTML, generando dinámicamente el contenido de
la misma.
• Dispone de una gran cantidad de módulos (también llamados extensiones)
que amplian su funcionallidad.
• Es un lenguaje portable, es decir, puede ser ejecutado en la mayoría de los
sistemas operativos. También existen módulos interprete para casi todos los
servidores web, y en muchos de ellos viene ya instalado en el paquete
básico.
• Soporta algunas características de la programación orientada a objetos.
• Se integra bien con otras tecnologías, como XML, Javascript...
• Ofrece conexión a numerosas bases de datos en modo nativo: MySQL,

Postgres, Oracle, SQL Server...
Un uso común es dotar a una aplicación web de un servidor de base de datos, en el

mundo PHP y Apache esta es MySQL, lo que en conjunto se ha denominado como la
solución LAMP (Linux, Apache, MySQL y Php).
¿Por qué PHP?
Hay muchas razones para aprender a usar PHP:
• Como ya se ha dicho con anterioridad el aprendizaje de este lenguaje es

muy sencillo.
• No obstante PHP ofrece muchas características avanzadas al alcance del
programador experto.
• Es seguro y robusto, cumpliendo con las exigencias de cualquier entorno
profesional.
• Es gratuito (open source), por lo que ha atraído a una gran comunidad de
usuarios. Todos contribuyen de una u otra forma. Los desarrolladores

expertos arreglando errores y aportando mejoras, los usuarios testeando el

código e intercambiando ideas que podrían mejorar el lenguaje.
• Existe una gran cantidad de aplicaciones de código abierto que están
desarrolladas en PHP. Conociendo PHP se tiene siempre la posibilidad de
ampliarlas, personalizarlas y darles el mantenimiento adecuado.
• La práctica totalidad de los proveedores de alojamiento de páginas web
ofrece soporte para este lenguaje y acceso a una base de datos MySQL.
U.D.3. ¿Qué es apache?

Apache es un producto software desarrollado por una asociación de caracter no
lucrativo, la Apache Software Foundation (ASF). La ASF no solo desarrolla el servidor
HTTP Apache, también engloba múltiples proyectos, algunos como extensiones del
servidor web y otros independientes.
Dentro de toda la gama de servidores web Apache es sin duda el que mejor
considerado está por parte de los usuarios. La prueba es que el 71% de los sitios web
están alojados en servidores de este tipo (estadísticas de noviembre del 2005 de
http://news.netcraft.com/archives/web_server_survey.html ).
Apache se ha ganado la confianza de los usuarios principalmente debido a las

siguientes razones:
• Es muy eficiente, robusto y seguro.

• Dispone de características avanzadas como mensajes de error altamente
configurables, contenido negociable, autentificación...
• Está disponible para la mayoría de las Plataformas, incluyendo Windows y
Linux.
• Es software libre, con las ventajas que esto supone. No solo es que sea
gratuito, sino que además dispone de una numerosa comunidad de usuarios
que contribuyen a su continua mejora.
La mayor objeción que se le ha puesto a Apache es que no dispone de un modo gráfico

amigable para su configuración, por lo que su aprendizaje puede suponer más esfuerzo
que el de otros servidores.
Durante este curso se propone la utilización de Apache como servidor al que se le

añade como extensión el interprete de PHP.
Otros servidores web
La principal alternativa a Apache es el servidor HTTP de Microsoft. Actualmente

aproximadamente un 20% de las páginas web están alojadas en este tipo de
servidores. La ventaja de este servidor es que dispone de un interfaz gráfico amigable

que hace más sencilla su instalación, configuración y despliegue de sitios web. Existen
otros servidores, que, o bien son pequeños productos con pocas características, o bien
son desarrollos de grandes empresas que no son accesibles al público en general.
U.D.4. Instalación
Las páginas con código PHP son archivos que usan la extensión .php . Como hemos
visto, para poder visualizarlas, tienen que estar alojadas en un servidor web remoto.
Esta solución no es factible para practicar con el lenguaje ya que tiene las siguientes
desventajas:
• Hay que contratar un servicio de alojamiento, lo que puede resultar costoso.

• Hay dependencia de la conexión a Internet.
• Gestionar los archivos que subimos al servidor a través de FTP es algo
engorroso y lento, por lo que no se pueden hacer pruebas de código con
agilidad.
La solución no puede ser más sencilla. Haremos que nuestro ordenador actúe como
servidor web. A esta forma de trabajo se le llama coloquialmente desarrollar en local.
Dependiendo de las habilidades de cada uno en el manejo e instalacion de

aplicaciones un poco mas complejas, como es el caso que nos lleva, del servidor
Apache y su módulo para PHP, se necesitaría un curso para todo ello. Apache se ha
criticado en este aspecto de no contar con una instalación y/o configuración
gráfica/amigable al usuario, tanto nóvel como experto.
Afortunadamente existen en el mercado soluciones que integran todo lo que

necesitamos para trabajar, y además disponen de los llamados instaladores
automáticos, que nos dejan preparado y, lo mas importante, configurado de manera
homogénea el entorno de desarrollo que vamos a emplear en todo este curso.
De entre los instaladores disponibles, hemos elegido una solución probada y que cubre
varios sistemas operativos (Windows, GNU/Linux y Mac), esta se llama Xampp en su
version reducida (lite) y la versión 1.5. En el curso vamos a usar la versión para
Windows, que será la referente por facilidad de uso para los usuarios menos
avanzados, aunque veremos algunas pantallas de Linux como alternativa (99%
idénticas).
En Linux y otros sistemas, podemos usar Xampp o nos instalaremos

Apache+PHP+MySQL por nuesta cuenta. Esto último para usuarios avanzados, dado
que hay que configurar el sistema, aunque últimamente, en algunas distribuciones de
Linux es muy sencillo que el sistema nos instale y configure todo por si mismo bajo
demanda.

Xampp en la versión elegida instala las siguientes versiones de Apache, Php y Mysql:
• Apache: v2.0.54
• Php: 5.0.5
• MySQL: v4.1.14
Requerimientos:
• 64Mb de memoria RAM

• 58Mb de disco
• Windows 98, ME, XP Home.Windows NT,2000,XP
Professional,GNU/Linux,MacOS.
Hay que tener en cuenta que Xampp evoluciona muy rápidamente y que en el
momento de realizar el curso puede encontrarse en una versión posterior. De todas
formas es de esperar que la instalación siga siendo muy similar o igual.
Instalación paso a paso sobre Windows
1. Descargamos la versión deseada según el sistema operativo que tengamos desde

las direcciones siguientes:
• Windows:
http://prdownloads.sourceforge.net/xampp/xampp-win32-1.5.0-pl1-installer.exe?download
• Linux: http://www.apachefriends.org/en/xampp-linux.html
2. Ejecutamos el fichero. Nos aparecerá la siguiente ventana preguntándonos donde

instalará Xampp:

Eligiremos la ruta de instalación como por ejemplo: C:\CursoPHP y pulsaremos el botón

"Extract".
3. Una vez instalado, tendremos una carpeta llamada C:\CursoPhp\xampplite , dentro

de ella ejecutaremos el fichero setup_xampp.bat y nos saldrá una ventana similar a la
siguiente:
Pulsaremos una tecla cualquiera y se cerrará la ventana o la cerraremos con el ratón.
4. Ya está instalado y listo para arrancar el servidor Apache y MySQL, para ello hay
que ejecutar el ejecutable xampp_start.exe dentro de la carpeta C:\CursoPhp\xampplite
:

Mientras estemos utilizando PHP no debemos cerrar esta ventana. Cuando queramos
dejar de usar Xampp no se debe cerrar sin más la ventana, sino ejecutar el programa
xampp_stop.exe , que se encargará de cerrar de forma ordenada la aplicación.
5. Vamos a comprobar que Apache está funcionando, para ello vamos a ir a la

dirección http://localhost con nuestro navegador favorito y deberíamos ver la siguiente
página:

Esta página web esta siendo servida por Apache y PHP (mirar la dirección en el
navegador). Pulsaremos en el idioma español (Spanish ) para continuar.
6. Esta es la página principal de Xampp en español, desde ella podremos navegar por
las demostraciones de PHP (Algunas no funcionarán dado que usamos una versión de
Xampp reducida):

7. Pulsaremos en el enlace Estado para probar toda la instalación definitivamente:

Deberíamos tener todos los componentes con el estado Activado.

Módulo II. Conceptos básicos

U.D.1. Panorámica del lenguaje
En este módulo y en el siguiente se van a descirbir los elementos y estructuras del
lenguaje. Quien esté familliarizado con la programación estructurada encontrará que la
mayoría son familiares. Concretamente la sintaxis de PHP es heredada del lenguaje C,
Java y Perl. Si ya conocemos C o Java entonces tenemos el 90% del camino recorrido,
en lo que a sintaxis se refiere.
Las explicaciones vienen acompañadas por ejemplos para facilitar su comprensión.

Todos los ejemplos pueden ser probados tal y como se explica en la práctica del
módulo I. Para ello hay que crear un fichero con un editor de textos, como puede ser el
Bloc de Notas (ficheros planos), dándole un nombre y guardándolo con extensión .php
en la carpeta de publicación C:\CursoPHP\xampplite\htdocs\practicasPHP .
Los resultados de los programas que hagamos se visualizarán a través del navegador,
escribiendo en la barra de direcciones la URL de nuestra página en local.
• http://localhost/practicasPHP/miprograma.php
Vamos a pasar directamente a dar una visión general del lenguaje.
Bloques de código PHP
Una página web en PHP generalmente contiene dos tipos de código: el código HTML y
el código PHP. El código de PHP que va a procesar el interprete puede estar dentro de
una de las siguientes etiquetas:
<?php ... ?>

<script language="php"> ... </script>
<% ... %>
<? ... ?>
Nosotros vamos a usar la primera (es la más usual), las dos últimas hay que activarlas
exprésamente en la configuración de PHP.
Ejemplo 2.1.1. Aquí podemos ver una página muy sencilla. Tiene tres bloques de
código: al comienzo la cabecera HTML, después un fragmento en PHP y finalmente el

cierre de la página otra vez en HTML.
<html> Bloque HTML

<head>
<title>Hola Mundo</title>
</head>
<body>
<p>
<?php Bloque PHP

echo "Hola Mundo";
?>
</p> Bloque HTML
</body>
</html>
En un fichero PHP pueden alternarse tantos bloques HTML con bloques PHP como se
quiera, siempre que estos últimos estén abiertos y cerrados por las etiquetas
adecuadas.
Sentencias en PHP
Una sentencia es una instrucción básica que realiza alguna acción. También se les
llama a veces línea de código, aunque estrictamente hablando no tienen porqué ocupar
exactamente una línea en el fichero.
Es imprescindible que las sentencias estén bien diferenciadas. Para ello en PHP toda
sentencia debe ser terminada con un punto y coma " ; ". La única excepción a esto es
la última sentencia antes del fin de un bloque de código PHP, indicado por "?> ".
Ejemplo 2.1.2. Los siguientes bloques de código están bien formados, ya que todas las
sentencias, salvo la última, terminan con un punto y coma:
<?php echo "Esto es un bloque ";echo "de código correcto";

?>
<?php echo "Esto es un bloque ";echo "de código correcto"

?>
<?php echo "Esto es un bloque de código correcto" ?>
Las instrucciónes echo y print()

Una de las instrucciones básicas de PHP es la instrucción echo . Se limita a interpretar

el texto que se pone a continuación e insertarlo en la página web. Una forma alternativa
de conseguir esto es haciendo uso de la etiqueta:
<?= ... ?>
La función print() también es equivalente a echo .
Ejemplo 2.1.3. Los siguientes bloques de código PHP son equivalentes y por lo tanto
producen el mismo resultado:
<?php echo "Este texto se mostrará en la página web." ?>
<?= "Este texto se mostrará en la página web." ?>
<?php print("Este texto se mostrará en la página web.") ?>
Ejemplo 2.1.4. En muchas ocasiones querremos insertar un salto de línea en la página

de salida. En HTML el salto de línea se marca con la etiqueta <br> , por lo que para
conseguir este resultado lo haremos de forma similar a como se hace a continuación:
<?php echo "Esta es la primera línea.";

echo "<br>" //Salto de línea HTMLecho "Esta es la segunda
línea."
?>
Funciones en PHP
En PHP hay dos tipos de funciones, las que están definidas por el propio lenguaje y las
que puede crear a medida el programador. Estas últimas las veremos en la U.D.3. del
módulo III.
Pero en los trozos de código que vienen a continuación nos encontraremos que para
hacer acciones complejas deberemos usar las funciones predefinidas del lenguaje
PHP. Estas se caracterizan por un identificador seguido por un parentesis,dentro del
cual ponemos los parámetros que tenemos que pasarle a la función.
A medida que las vayamos usando iremos describiendo las funciones definidas. Un
ejemplo de este tipo de funciones que hemos visto ya es la instrucción print() .

Comentarios en PHP
Los cometarios son ignorados por el interprete a la hora de generar la página. De todas
formas cumplen una función esencial, aumentar la legibilidad del código, para su
posterior mantenimiento por nosotros o por otra persona. Con los comentarios
describiremos la función de determinados fragmentos de código.
En PHP hay tres formas de poner comentarios:
<?php
// Este es un comentario de una sola línea
/*Este es un comentario
que ocupa varias líneas*/
# Esta forma de poner comentarios de una línea se usa menos?>
Hay que tener en cuenta que si bien los comentarios ayudan a comprender el código y
por lo tanto facilitan el mantenimiento del código por nuestra parte o por la de otras
personas, un abuso de los mismos puede hacer difícil distinguir a primera vista el
propósito del código. Lo ideal es escribir un código limpio que resulte lo más legible
posible y limitar el uso de comentarios a aquellas ocasiones en los que haya que hacer
una aclaración imprescindible.
También es habitual insertar anotaciones en el código a medida que se está

construyendo, cuando aún no ha tomado su forma final. Este tipo de comentarios es
conveniente eliminarlo en cuanto dejan de ser necesarios.
Hay dos palabras que se usan habitualmente en los comentarios durante el desarrollo.
<?php
//FIXME: Marca un trozo de código que habría que mejorar
//DOME: Marca una característica sin programar?>
No está de más recordar que los comentarios son parte del código PHP, por lo que han
de estar en bloques de código PHP (es decir, abiertos por la etiqueta "<¿php " y
cerrados por la etiqueta "?> ".
Errores en PHP
Sin lugar a dudas, cuando programemos, cometeremos errores, como olvidar poner un
punto y coma al final de una instrucción, o no cerrar adecuadamente unas comillas.
Cuando vayamos a intentar ver el resultado en el navegador aparecerá un mensaje de
error (o varios) similar a este.

El mensaje está en inglés y es muy probable que no nos oriente de qué es lo que está
fallando. Pero lo importante es que si que nos muestra donde (en qué línea) está
fallando, por lo que podremos dirigirnos a ella y arreglar el fallo.
Inhibir errores
En ocasiones no querremos que el error se vea por pantalla. Para conseguir esto
pondremos el símbolo arroba "@" antes de la sentencia en la que se produce el fallo.
Ejemplo 2.1.5. El primer trozo de código muestra un mensaje de error al intentar abrir
un archivo que no existe. En cambio en el segundo fragmento se hace uso del símbolo
@ para evitar que dicho error se muestre por pantalla.
<?php
$archivo = fopen("noexiste.txt", "r");
?>
<?php
@$archivo = fopen("noexiste.txt", "r");
?>
U.D.2. Variables
Datos en PHP
En PHP definimos los datos con los que vamos a trabajar como variables. Una variable
no es más que una estructura de datos cuyo valor puede cambiar con el tiempo. PHP
trabaja con tres tipos de datos sencillos: integer (número entero), double (número con

decimales) y string (cadena de texto).
El separador de decimales en PHP es el punto, como en la mayoría de los lenguajes de

programación.
Ejemplo 2.2.1. En los dos ejemplos anteriores el dato es de tipo cadena, aunque la
última cadena contenga un número. Como se puede observar, los datos de tipo string
se escriben entre comillas, que pueden ser simples o dobles.
11 //esto es un dato de tipo integer 43.95 //esto

es un dato de tipo double "Código postal" //esto es un dato de tipo string
"08080" //esto también es un dato de tipo string
Ejemplo 2.2.2. Si queremos escribir un dato que contenga comillas dobles lo

escribiremos encerrado entre comillas simples. Y si queremos escribir un dato que
contenga comillas simples lo encerraremos en comillas dobles.
'Leopoldo Alas "Clarin" fué un gran escritor...'
Nombre de variables
Todas las variables en PHP se distinguen por comenzar con el símbolo del dolar, "$",
seguido del nombre de la variable. El nombre de una variable ha de empezar
necesariamente por una letra o el símbolo guión bajo "_" seguido por cualquier
combinación de números, letras o guiones bajos.
Ejemplo 2.2.3. Diferentes ejemplos de nombres de variables, válidos y no válidos.
<?php $apellido1; //nombre de variable válido

$_tfno; //nombre de variable válido
$1apellido; //no válido, empieza por un número
$email@; //no válido, contiene el símbolo @?>
Es importante tener en cuenta que en lo nombres de variables se distingue entre

mayúsculas y minúsculas.
Ejemplo 2.2.4. Mediante este ejemplo se puede ver que PHP distingue entre
mayúsculas y minúsculas en los nombres de variables.
<?php $precio = 33;

$Precio = 55;
echo "La variable precio contiene el valor";
echo $precio;
echo "<br>";
echo "La variable Precio contiene el valor";
echo $Precio;
?>
A pesar de que tenemos gran libertad a la hora de poner nombres a las variables es
recomendable seguir los siguientes consejos para que el código resulte más legible:
• Usar nombres de variable que tengan significado.

• No usar nombres de variable demasiado largos (12-16 caracteres deberían
ser suficientes en la mayoría de los casos).
• No usar como nombre de variable palabras clave de PHP.
Ejemplo 2.2.5. Los siguientes nombres de variable no son recomendables.
<?php $x37; //no tiene significado

$preciodelproductoconiva //demasiado largo
$echo //echo es una palabra clave de PHP
?>
Asignación de datos a variables
Como se ha ido viendo en los ejemplos, a las variables se les asigna un dato mediante
el símbolo igual "=".
Ejemplo 2.2.6. Asignación de un dato de tipo cadena a una variable.
<?php $telefono = "918903220";

?>
Hay que tener en cuenta que PHP es un lenguaje poco tipado, Las variables no tienen
un tipo de datos predefinido, el tipo vendrá dado según el contenido de la variable o el
contexto donde se trate. Este es el punto mas debil del lenguaje, aunque le aporta una
sencillez y flexibilidad propias.
Constantes

Las constantes son una manera de asignar a un identificador valores simples que no
van a variar. La declaración de una constante se realiza mediante la función define() .
El nombre de la constante debe seguir las mismas reglas que las variables, solo que no
lleva delante el símbolo del dolar, "$", ya que no es una variable. Una práctica habitual
es poner los nombres de las constantes en mayúsculas.
Ejemplo 2.2.7. Sabemos a ciencia cierta que el número PI no va a cambiar. En lugar

de tener que teclearlo varias veces a lo largo del código podemos definir una constante
con el identificador PI.
<?php $define("PI", 3.1416);

echo PI; //No se pone el símbolo dolar
?>
U.D.3. Operadores
Los operadores son utilizados para realizar cálculos y manipular datos en el ámbito de
una expresión. Las expresiones más comunes que conocemos, como la multiplicación,
implican la participación de dos operandos (los datos) y un operador (el símbolo de
la multiplicación). En PHP puede haber:
• Operadores unarios: La expresión manipula un único dato.

• Operadores binarios: La expresión manipula dos datos.
• Operadores ternarios: La expresión manipula tres datos.
Ejemplo 2.3.1. Los datos pueden ser introducidos directamente o estar almacenados
en variables. El resultado de la operación se suele asignar a una variable, aunque
puede formar parte de una expresión mayor. Esta variable a la que se asigna el
resultado puede ser parte de la expresión.
<?php echo "La variable z vale ";

$z = 1 + 5; //Los datos se introducen directamente
echo $z;echo "<br>";
echo "La variable z vale ";

$x = 2;
$y = 3;
$z = $x + $y; //Los datos están almacenados en variablesecho $z;echo
"<br>";
echo "La variable z vale ";

$z = $x + $z; //La variable $z aparece en la expresiónecho $z; ?>

Lo habitual es clasificar a los operadores según el tipo de cálculo o manipulación que

realizan.
Operadores aritméticos
En PHP hay cinco operadores que realizan operaciones matemáticas entre dos datos y
un operador unario, el signo de negación.
Operador Denominación Descripción Ejemplo Resultado
+ Suma Devuelve 2+2 1

la
suma
de
dos
operandos.
- Resta Devuelve 5-3 1
la
diferencia
entre
dos
operandos.
* Producto Devuelve la 2*3 1
multiplicación entre
dos
operandos.
/ Cociente Devuelve 8/2 1
el
cociente
de
la
división
entre
dos
operandos.
% Módulo Devuelve 7%4 3
el
resto
de
la
división
entre

dos
operandos.
- Cambio Devuelve $x=6 $y
de el $y=-x vale
signo valor -6
del
operando
con
el
signo
cambiado.
Ejemplo 2.3.2. Aquí se experimenta con varias operaciones aritméticas.
<?php echo "El resultado de sumar 5 y 3 es ";

$z = 5 + 3;echo $z;
echo "<br>";
echo "El resultado de restar 3 a 5 es ";
$z = 5 - 3;echo $z;
echo "<br>";echo "El resultado de multiplicar 5 y 3 es ";
$z = 5 * 3;echo $z;
echo "<br>";echo "El resultado de dividir 5 entre 3 es ";
$z = 5 / 3;echo $z;
echo "<br>";echo "El resultado de calcular 5 módulo 3 es ";
$z = 5 % 3;echo $z;
echo "<br>";echo "El resultado de cambiar el signo a la variable $z es ";
$z = -$z;echo $z;
?>
Operadores de comparación
En el siguiente módulo se tratará de las sentencias de control. Estas utilizan el

resultado de unas expresiones especiales para decidir cual sera la instrucción que
ejecutarán luego. Las expresiones básicas que utilizan son el resultado de una
condición. Este resultado solo puede tomar dos valores: verdadero o falso.
PHP tiene dos constantes predefinidas para designar los valores verdadero y falso, que
son, como cabía esperar, TRUE y FALSE. Se pueden usar también en minúsculas,
aunque conviene recordar que la práctica habitual en programación es usar las
constantes en mayúsculas.

Cuando el resultado es verdadero la expresión de comparación devolverá TRUE, si la

evaluación de la expresión de comparación es falsa PHP devolverá como resultado
FALSE.
== Es Devuelve verdadero
2==2 TRUE
igual si 2==5 FALSE
los
dos
operandos
son
iguales.
!= No Devuelve verdadero
2!=2 FALSE
<> es si 2!=5 TRUE
igual los
dos
operandos
son
diferentes.
< Es Devuelve verdadero
2<5 TRUE
menor si 5<2 FALSE
el
primer
operando
es
menor
que
el
segundo.
> Es Devuelve verdadero
2>5 FALSE
mayor si 5>2 TRUE
el
primer
operando
es mayor
que
el
segundo.
<= Es Devuelve verdadero
2<=5 TRUE
menor si 2<=2 TRUE
o el
igual primer

operando
es
menor
o
igual que
el
segundo.
>= Es Devuelve verdadero
5>=2 TRUE
mayor si 2>=2 TRUE
o el
igual primer
operando
es
mayor
o
igual que
el
segundo.
A nivel interno PHP no almacena TRUE o FALSE, snio que interpreta el valor 0 como
falso y el 1como verdadero (realmente interpreta como verdadero cualquier valor que
sea diferente de 0. Por ejemplo, en PHP el valor 5 es interpretado como verdadero ).
Ejemplo 2.3.3. En este ejemplo aparece la construcción if ... else que se verá en la
proxima unidad didáctica.
<?php echo "¿Es 5 igual a 3? ";

if (5 == 3) { echo "TRUE";
} else {
echo "FALSE";
}
echo "<br>";echo "¿Es 5 diferente a 3? ";
if (5 != 3) { echo "TRUE";
} else {
echo "FALSE";
}
echo "<br>";
echo "¿Es 5 menor que 3? ";
if (5 < 3) { echo "TRUE";
} else {
echo "FALSE";
}
echo "<br>";
echo "¿Es 5 mayor que 3? ";

if (5 > 3) { echo "TRUE";

} else {
echo "FALSE";
}
?>
Operadores lógicos
Los operadores lógicos sirven para relacionar los resultados de condiciones, es decir,
combinan los resultados de valores TRUE y FALSE. Son útiles para representar
expresiones del tipo ¿Es cierto que Madrid es la capital de España y que a la vez
Madrid es la ciudad más poblada de España?
&& AND Devuelve verdadero

TRUE TRUE
and ( si && FALSE
y ambos TRUE
) operandos TRUE
son &&
verdaderos. FALSE
|| OR Devuelve verdadero
TRUE TRUE
or ( si && TRUE
o al TRUE
) menos TRUE
uno &&
de FALSE
los
operandos
es
verdadero.
xor XOR Devuelve verdadero
TRUE FALSE
( si && TRUE
o uno TRUE
exclusivo de TRUE
) los &&
operandos FALSE
es
verdadero
pero

no
ambos.
! NOT Devuelve TRUE FALSE
( verdadero FALSE TRUE
negación si
) el
operando
es
falso
y
falso
si
es
verdadero
Ejemplo 2.3.4. Al conjunto de combinaciones de valores que pueden tomar los

operandos y el resultado de la operación se le conoce en lógica como tabla de verdad.
En el siguiente ejemplo construiremos la tabla de verdad del operador AND. De forma
similar se podría construir la tabla de verdad del resto de los operadores.
<pre>
<?php echo "Tabla de verdad del operador AND ";
echo "<br>";
echo "<br>";echo "opdo1 | opdo2 |opdo1 AND opdo2";
echo "<br>";echo "------+-------+----------------";
echo "<br>";
echo "TRUE | TRUE | ";
if (TRUE && TRUE) { echo "TRUE ";
} else {
echo "FALSE";
}echo "<br>";echo "TRUE | FALSE | ";
if (TRUE && FALSE) { echo "TRUE ";
} else {
echo "FALSE";
}
echo "<br>";echo "FALSE | TRUE | ";
if (FALSE && TRUE) { echo "TRUE ";
} else {
echo "FALSE";
}
echo "<br>";echo "FALSE | FALSE | ";
if (FALSE && FALSE) { echo "TRUE ";
} else {

echo "FALSE";
}
?>
</pre>
Operador de unión de cadenas
En la mayoría de ejemplos anteriores, cuando hemos querido imprimir un texto por

pantalla que estaba formado por varios fragmentos hemos tenido que usar
una instrucción echo por cada uno de los fragmentos. El operador de unión de cadenas
nos permite unir los fragmentos para, por ejemplo, usar una sola instrucción echo.
. Concatenar Une "Hola"."Mundo" "Hola

dos Mundo"
cadenas
de
texto
Ejemplo 2.3.5. Se pueden concatenar directamente cadenas de texto con datos de tipo
entero. Los datos que se concatenan se pueden introducir directamente o extraer de
variables.
<?php
$x = 2;
$y = 3;
$z = $x + $y; echo "El resultado de sumar 2 y 3 es " . 5 . "<br>";
echo "El resultado de sumar 2 y 3 es " . (2 + 3) . "<br>";
echo "El resultado de sumar 2 y 3 es " . $z . "<br>";
?>
Operadores de asignación
En la unidad didáctica sobre variables hemos visto el operador básico de asignación,

que es el símbolo igual "=". Pero hay otros operadores que permiten hacer una
operación y una asignación a la vez y por lo tanto producen un código má comprimido.
El uso de estos operadores es desaconsejable para el programador principiante ya que
puede llevar a un código poco legible y como consecuencia a asignaciones erroneas.

Los operadores de asignación comprimidos y sus equivalencias son:
Operador Ejemplo Equivalencia
= $x = 4 $x = 4
+= $x += 4 $x = $x + 4
-= $x -= 4 $x = $x - 4
*= $x *= 4 $x = $x * 4
/= $x /= 4 $x = $x / 4
%= $x %= 4 $x = $x % 4
.= $x .= "mundo" $x = $x .
"mundo"
++ $x++ $x = $x + 1
-- $x-- $x = $x - 1
Precedencia de operadores
Un último aspecto que conviene mencionar es, ¿qué pasa cuando en una expresión
compleja aparece más de un operando? En ese caso, ¿qué operaciones se evaluan
antes?.
Cuando hay expresiones complejas con más de un operando hay unos que se evaluan
antes de otros siguiendo el siguiente orden, teniendo en cuenta que los de arriba se
evalúan antes que los de abajo y que los de la misma fila tienen igual precedencia (se
evalúan de izquierda a derecha):
Operador lógico de negación !
Operadores multiplicativos */%

Operadores aditivos +-.
Operadores de comparación < <= > >=
Operadores de comparación == !=
(igualdad)
Operadores lógicos (salvo la && || xor

negación)
Operadores de asignación = (y operadores

comprimidos)
En cualquier caso podemos alterar la precedencia mediante la inclusión de partentesis

alrededor de las expresiones. De hecho es muy recomendable hacerlo incluso aunque
exista una regla de precedencia que produzca el mismo resultado, para dar mayor
claridad al código.
Ejemplo 2.3.6. La multiplicación tiene precedencia sobre la suma por lo que, sin
paréntesis, en la expresión 2 + 5 * 4 se evalúa primero 5 * 4 y luego se le suma dos.
<?php echo "El resultado de (2 + 5) * 4 es " . ((2 + 5) * 4);

echo "<br>";
echo "El resultado de 2 + 5 * 4 es " . (2 + 5 * 4);//El último caso resulta más
legible si ponemos
echo "El resultado de 2 + 5 * 4 es " . (2 + (5 * 4));?>
U.D.4. Sentencias de control

Hasta ahora solo hemos visto instrucciones muy sencillas. Además la único que
podíamos hacer con ellas es ejecutarlas secuencialmente. Pero, ¿tenemos
herramientas para elegir una alternativa entre dos? ¿O para escribir 5 veces un texto
por pantalla? Para hacer frente a estas situaciones se incluyen en cualquier lenguaje
de programación las sentencias de control.
Estructuras condicionales.
Instrucción if

Las instrucciones condicionales permiten ejecutar diferentes fragmentos de código en

función del resultado de una expresión condicional. La instrucción básica es if . La
sintaxis es:
if (condición ) {
Código a ejecutar si la condición es cierta
}
Cuando el código a ejecutar si la condición es cierta es una sola sentencia se

pueden omitir las llaves "{" "}". En cualquier caso es preferible no omitirlos ya que dan
mayor claridad a cuales son exáctamente las sentencias que se ejecutan en el caso de
cumplirse la condición.
Ejemplo 2.4.1. Las dos construcciones siguientes son equivalentes, aunque es

preferible siempre usar la primera por claridad:
<?php
$hora = 8; // La hora en formato de 24 horasif ($hora == 8) {
echo "Suena el despertador.";}echo "<br>";if ($hora == 8)
echo "Suena el despertador.";?>
Ejemplo 2.4.2. Veamos la diferencia entre poner llaves para encuadrar un bloque de
texto entre llaves y no hacerlo:
<?php
echo "Suena el despertador. ";
echo "Es la hora de levantarse.";
}
echo "<br>";if ($hora == 8) echo "Suena el despertador. ";
echo "Es la hora de levantarse.";
?>
Instrucción else
En muchos casos no nos bastará con ejecutar un código si ese cumple la condición
sino que querremos elegir entre dos opciones alternativas y mutuamente excluyentes.
En estos casos la sentencia if se completa con un bloque de código que se ejecuta solo
si es falsa la condición:
if (condición ) {

Código a ejecutar si la condición es cierta

} else {
Código a ejecutar si la condición es falsa }
Ejemplo 2.4.3.
<?php
$hora = 17; // La hora en formato de 24 horasif ($hora <= 12) {
echo "Son las " . $hora . " de la mañana";
} else {
echo "Son las " . ($hora - 12) . " de la tarde";}?>
Instrucción else if
También puede suceder que queramos encadenar diferentes condiciones. Para ello se
puede encadenar una sentencia else con un nuevo condicional. A su vez la nueva
sentencia if puede ser completada por un else.
if (condición1 ) {
Código a ejecutar si la condición1 es cierta
} else if (condición2 ) {
Código a ejecutar si la condición1 es falsa y la 2 cierta } else {
Código a ejecutar si ambas condiciones son falsas
}
Ejemplo 2.4.4. Se pueden encadenar varias sentencias else if como se ve en el

siguiente programa:
<?php
echo "Es la hora de desayunar.";
} else if ($hora == 14) {
echo "Es la hora de la comida.";} else if ($hora == 21) {
echo "Es la hora de la cena.";} else {
echo "Ahora no toca comer.";}?>
Instrucción switch
En el caso anterior se elegía entre varias opciones alternativas y excluyentes. PHP nos
ofrece una instrucción que nos facilita la tarea, siempre que haya que elegir entre

varias posibles. A diferencia de con la instrucción if , si queremos que se ejecuten

varias instrucciones no será necesario englobarlas entre llaves "{" "}". La ejecución
seguirá hasta que encuentre el siguiente break.
switch (expresion ) { case etiqueta1 : Código a ejecutar

si expresión == etiqueta1 break; case etiqueta2 : Código
a ejecutar si expresión == etiqueta1 break; case default :
Código a ejecutar si no se verifica ninguna etiqueta break; }
El bloque de código detras del default se ejecuta en el caso de que no se haya

verificado ninguno de los casos anteriores. Terminar el bloque de instrucciones default
con una instrucción break es opcional, pero es recomendable ya que mejora la
legibilidad.
Ejemplo 2.4.5. Puede haber tantas sentencias case como sea necesario.
<?php
$hora = 14; // La hora en formato de 24 horasswitch ($hora) {
case 9: echo "Es la hora de desayunar.";
break; case 14: echo "Es la hora de comer.";
break; case 21: echo "Es la hora de merendar.";
break; default: echo "Ahora no toca comer.";
break;}
?>
Ejemplo 2.4.6. Aquí se puede observar dos estrategias que nos pueden ser útiles en
algunos casos. La primera es formar un grupo de alternativas que producen un
resultado. La segunda en omitir intencionadamente la instrucción break al final de un
bloque.
<?php
$hora = 19; // La hora en formato de 24 horasswitch($hora) {
case 24: case 23: case 22: echo "Ya he cenado.";
case 21: case 20: case 19: case 18: case 17: case 16: case
15: echo "Ya he comido.";
case 14: case 13: case 12: case 11: case 10: echo "Ya
he desayunado."; break;
default:
echo "Tengo hambre";
break;}?>

Estructuras iterativas
En muchas ocasiones, al programar, hay una acción que se repite varias veces.
Podríamos poner varios bloques de código iguales seguidos para conseguir este
efecto, pero esto nos conduciría a un código redundante y muy largo. Además, ¿que
sucede si no conocemos las veces que queremos repetir el código a priori?
Instrucción while
Es la estructura más sencilla. Repite indefinidamente la ejecución de un bloque de

código mientras la evaluación de la condición sea cierta. La forma que tenemos de
controlar cuantas veces se repite el bucle while es a través de la condición. Por lo tanto
en el cuerpo del bucle se han de modificar las variables que intervienen en la condición
de tal forma que en algún momento sea falsa.
while (condición ) { Código a ejecutar mientras la condición sea cierta

}
Ejemplo 2.4.7. El ejemplo más tipo de ejecución de un bucle es contar. Es importante

observar dos cosas:
1. La variable $i se inicializa fuera del bucle.

2. La variable $i se modifica en la última instrucción del cuerpo del
bucle. De esta forma cada vez que se evalúa la condición ha cambiado.
Cuando $i llega a valer 11 la condición es falsa y el bucle termina.
<?php
$i = 1;while ($i <= 10) { echo "Línea " . $i;
echo"<br>";
$i++;
}
?>
Ejemplo 2.4.8. Un ejemplo un poco más complejo. En la expresión condición del bucle
se hace uso de una constante por primera vez en los ejemplos.
<?php
define(HORA_DE_CENAR, 21); //Constante
$hora = 12; // La hora en formato de 24 horaswhile ($hora <
HORA_DE_CENAR) {
echo "Son las " . $hora . ". ";

echo "Faltan " . (HORA_DE_CENAR - $hora) . " horas ";

echo "para la cena."; echo"<br>";
$hora++;
}
echo "Son las " . $hora . ". Es la hora de la cena.";
?>
Instrucción do ... while
En PHP se dispone también de la estructura do ... while, que a diferencia de la anterior

evalúa la condición al final en lugar de al principio del bucle. De esta forma el bucle se
ejecuta siempre al menos una vez y a partir de ese momento se repite mientras la
condición sea cierta.
do { Código a ejecutar } while (condición );
Ejemplo 2.4.9. Uno de los casos en los que se usa esta estructura es cuando se está
esperando recibir un dato en concreto y hay que realizar varias veces una lectura de un
dato hasta que se recibe el dato esperado. Como aún no conocemos ninguna forma de
recibir datos todavía se ha optado por generarlos aleatoriamente. En este ejemplo se
simula el lanzamiento de un dado de parchis.
<?phpdo { $dado = rand(1,6); //rand() devuelve un valor aleatorio

echo "Tirando el dado... ";
echo "ha salido un " . $dado . ".";
echo "<br>";
} while ($dado != 5);
echo "¡Bien! Saco una ficha de casa.";
?>
Instrucción for
La instrucción for es probablemente la más fácil de comprender para las personas que
están aprendiendo a programar, dado que, en la mayoría de los casos se conoce el
número de veces que se va a ejecutar el bucle antes de entrar al mismo. La sintaxis
que tiene en PHP es:
for (inicialización ; condición ; incremento ) { Código a ejecutar }
El bucle se ejecutará mientras la condición sea TRUE.

Ejemplo 2.4.10. Aquí se puede ver un bucle for sencillo que, al igual que el bucle while
del ejemplo 2.4.7., imprime 10 líneas numeradas. Como se puede observar es habitual
utilizar la variable $i en el cuerpo del bucle. A esta variable se le llama a veces índice.
<?php
for ($i = 1; $i <= 10; $i++) { echo "Línea " . $i;
echo"<br>";
}
?>
Ejemplo 2.4.11. La instrucción de incremento no tiene porqué hacer aumentar el valor,

también lo puede hacer retroceder. En este ejemplo se imprime una cuenta atrás.
<?php
echo "Cuenta atrás.";
echo "<br>";for ($i = 10; $i >= 0; $i--) { echo $i . " ... ";
echo"<br>";
}
echo "Ignición!";
?>
Ejemplo 2.4.12. También se puede hacer que la instrucción incremento aumente el

valor en cada paso un número distinto de 1. El siguiente programa cuenta los números
del 3 al 15 de 3 en 3.
<?phpfor ($i = 3; $i <= 15; $i = $i + 3) { echo $i;

echo"<br>";
}?>
Ejemplo 2.4.13. La condición no tiene por qué ser necesariamente sobre la variable
declarada como índice . En este ejemplo se puede observar esto. El resultado es el
mismo que con el ejercicio anterior.
<?php$j = 3for ($i = 1 ; $j <= 15 ; $i = $i++) {

$j = $i * 3; echo $j;
echo"<br>";
}?>
De todas formas es muy recomendable que la condición sea sobre el índice. También
hay que evitar alterar el contenido del índice en el cuerpo del bucle, pues puede llevar a

comportamientos impredecibles si no se tiene cuidado.

Anidamiento de bloques de código
Hasta ahora hemos visto a las sentencias de control actuar de forma aislada. Pero en
la mayoría de las situaciones nos encontraremos con que para obtener el resultado
esperado hemos de hacer que trabajen juntas. Esto no supone ningún problema. Un
bloque de código dentro de una sentencia de control puede contener varias sentencias
condicionales, y a su vez los bloques de código de estas, nuevas sentencias
condicionales.
Ejemplo 2.4.14. Aquí se puede ver un caso típico del uso de sentencias de control
anidadas.
<?php
for ($i = 1; $i <= 10; $i++) { if (($i % 2) == 1) {
echo "El " . $i . " es un número impar.";
echo "<br>"; } else {
echo "El " . $i . " es un número par.";
echo "<br>"; }
}?>
El principal problema con el que nos podemos encontrar es tener un código poco
legible. Para evitarlo es recomendable poner espacios delante de cada bloque de
código de tal forma que el comienzo de las instrucciones comience a diferentes
distancias del margen dependiendo del bloque en el que se está. A esta técnica se le
llama indentado (sangrado).
El indentado más habitual es de 4 espacios en blanco por cada nivel de anidamiento.

Todos los fragmentos de código que se han incluido hasta ahora se han puesto con
este estilo de indentado con el que es más frecuente encontrárselos.
Ejemplo 2.4.15. Este código es idéntico al anterior pero sin indentado. Es obvio que
este es mucho más dificil de comprender el flujo que sigue el programa.
<?php
for ($i = 1; $i <= 10; $i++) {if (($i % 2) == 1) {
echo "El " . $i . " es un número impar.";
echo "<br>";} else {
echo "El " . $i . " es un número par.";
echo "<br>";}
}?>

Indentar no es obligatorio, el código funcionaría igual sin hacerlo, pero como se ha visto
en este ejemplo los programas se vuelven prácticamente ilegibles.
Ejemplo 2.4.16. Mediante el anidamiento se pueden conseguir resultados interesantes

con muy poco código. En el siguiente ejemplo se va a dibujar una tabla de multiplicar.
<table>
<?php
for ($i = 1; $i <= 10; $i++) {
echo "<tr align='right'>";
for ($j = 1; $j <= 10; $j++) {
echo "<td width='25'>" . ($i*$j) . "</td>";
}
echo "</tr>";
}
?>
</table>
Terminación de los bucles
Si no controlamos bien la condición del bucle esta nunca se evaluará a falso y el bucle
se evaluará indefinidamente, dando lugar a un bucle infinito. Este es uno de los errores
más habituales, en bucles complejos puede ser fácil perder de vista cuales son las
variables que intervienen en la evaluación de la condición.
Ejemplo 2.4.17. Este es un bucle infinito que escribirá indefinidamente una frase por
pantalla. El bucle no se detiene hasta que no paremos la descarga desde el navegador
o nos quedemos sin memoria.
<?phpwhile (TRUE) {
echo "Hasta el infinito ";
echo "y más allá...";
echo "<br>";
}?>
break
La ejecución natural de los bucles se puede interrumpir mediante la sentencia break .

En el cuerpo de cualquiera de los tipos de bucle que hemos visto, una sentencia break
causa la finalización del mismo sin ejecutarse ninguna sentencia más del cuerpo del
bucle. En otras palabras, en cuanto se encuentra una sentencia break se interrumpe la

ejecución del bucle y se pasa a la siguiente línea de código después del bucle.
Ejemplo 2.4.18. Bucle que se interrumpe mediante un break.
<?php
while (TRUE) {
echo "Hasta el infinito";
break;
echo " y más allá..."; echo "<br>";
}?>
Ejemplo 2.4.19. En ocasiones se pone intencionadamente un bucle infinito que se

pretende romper con una sentencia break en su cuerpo.
<?php
define(ALERTA_MISION, 5);
$nivel_alerta = 1;
while (TRUE) {
echo "Hasta el infinito";
if ($nivel_alerta == ALERTA_MISION) {
break;
} echo " y más allá...";
echo "<br>";
$nivel_alerta++; // Se incrementa en uno}
echo "Parece que hay alguien en apuros.";?>
continue
La sentencia continue tiene cierta similitud con la sentencia break .
Su funcionamiento es el siguiente. En cuanto se encuentra una sentencia continue se

ignoran el resto de las instrucciones del cuerpo del bucle pero no se sale del mismo,
sino que se salta a la sentencia de evaluación de la condición . Obviamente si en ese
momento la condición del bucle es verdadera el bucle comenzara una nueva ejecución.
Ejemplo2.4.20. Este programa lista los números del 1 al diez, indica los que
son múltiplos por 3 y si son divisibles por 3 nos muestra el resultado de esta división.
<?phpfor ($i = 1; $i <= 10; $i++) {

echo "El número " . $i;
if (($i % 3) != 0) {
echo " no es multiplo de 3.";

echo "<br>";
continue;
}
echo " es multiplo de 3. ";
echo "Por lo tanto ";
echo $i . " dividido entre 3 es igual a " . ($i / 3); echo "<br>";
}?>
Las sentencias break y continue dan lugar por lo general a un código más complejo y
propenso a errores, por lo que no se recomienda su uso por parte del programador
principiante.

Módulo III. Conceptos avanzados

U.D.1. Cadenas
El manejo de cadenas en PHP es de vital importancia, ya que la única forma que
tenemos de comunicarnos con el cliente es a través de texto. Hay que tener en cuenta
que el producto de un programa en PHP es una página web con formato HTML.
Combinar código HTML con código PHP
Como en una página web dinámica programada en PHP hay código de dos tipos lo
mejor es mantenerlos bien diferenciados. Hay que ser especialmente cuidadoso
procurando que el código sea muy legible. Esto facilitará el mantenimiento de la página
y hará mucho más sencillo dotarla de elementos de diseño.
El objetivo ideal sería que un diseñador web pudiera aplicar diseño a una página PHP
sin tener que preocuparse de la programación que contiene. En el módulo V veremos
una breve introducción a las plantillas que nos facilitan notablemente la tarea de
separar el código HTML del PHP.
Variables dentro de cadenas
Hasta ahora, siempre que hemos necesitado mostrar un texto compuesto por una
cadena y el valor de una variable los hemos tenido que unir usando el operador
concatenar " . ". Pero PHP ofrece una sintaxis alternativa que resulta más compacta y
puede ser de utilidad en muchos casos.
Ejemplo 3.1.1. Si ponemos una variable en el interior de una cadena entre comillas,
PHP la interpreta y en vez del nombre de la variable escribe su valor. Lo podemos
comprobar a continuación, donde los dos fragmentos de código producen los mismos
resultados.
<?php
$edad = 46;
echo "Belinda tiene " . $edad . " años.";
?>
<?php
$edad = 46;

echo "Belinda tiene $edad años.";

?>
Uso de la sentencia echo
Es recomendable usar esta forma de conseguir salida cuando es predominante la

cantidad de código PHP sobre la cantidad de código HTML. Lo mismo se aplica al uso
de la función print() que produce los mismos resultados. Hay partidarios de usar una
forma y partidarios de usar la otra, lo que no es muy recomendable es mezclarlas
dentro del mismo programa.
Ejemplo 3.1.2. En este pequeño programa predomina el código PHP sobre el código
HTML.
<html>
<head>
<title>Números primos</title>
</head>
<body><?php
define(LIMITE, 100);
echo "Los números primos del 1 al " . LIMITE . " son:";
echo "<br>";
for ($i = 1; $i <= LIMITE; $i++) {
$es_primo = TRUE; //Hipótesis inicial, es primo
for ($j =2; $j < $i; $j++) {
if(($i % $j) == 0) { //Tiene un divisor
$es_primo = FALSE; //Luego no es primo
break;
}
}
if ($es_primo) {
echo "$i";
echo "<br>";
}
}
?></body>
</head>
Uso de la sintaxis <?= ... ?>
A la inversa, cuando predomina el código HTML sobre el código PHP es interesante

mostrar la salida usando esta sintaxis.

Ejemplo 3.1.3. En este pequeño programa predomina el código HTML sobre el código
PHP.
<html>
<head>
<title>El hombre del tiempo</title>
</head>
<body bgcolor="#cccccc">
<table border="1">
<tr>
<td align="center" colspan="2">
Hola, soy el hombre del tiempo.<br>
Mi método para adivinar el clima es infalible.
</td>
</tr>
<tr>
<td align="center">
Temperatura mínima prevista
</td>
<td align="center">
Temperatura máxima prevista
</td>
</tr>
<tr>
<td align="center">
<font size="+2"><?= rand(0, 15)?></font> grados.
</td>
<td align="center">
<font size="+2"><?= rand(15, 30)?></font> grados.
</td>
</tr>
</table>
</html>
Fragmentos de HTML dentro de estructuras condicionales
Cuando tenemos que mostrar trozos de código HTML muy grandes y este se encuentra
dentro de una estructura condicional, puede ser muy pesado construirlos a base de
sentencias echo . En este caso es preferible volver a cerrar el bloque de código PHP
con la etiqueta ?>, escribir el código HTML que se ejecuta condicionalmente, y abrir
otra vez el código PHP con la etiqueta <?php para terminar la estructura condicional.
Este sistema, combinado con el uso de la sintaxis <=? ... ?> produce un código

compacto y fácil de leer.
Ejemplo 3.1.4. Aquí se ven las dos estrategias. La segunda es más compacta y clara.
<?php
$autorizado = FALSE;
if (!$autorizado) {
echo ?<center>?;
echo ?<table bgcolor="#cccccc">?;
echo ?<tr>?;
echo ?<td align="center">?;
echo ?<font color="#ff0000" size="+2">?;
echo ?No está autorizado a ver esta página.?;
echo ?<br>?;
echo ?Contacte con el administrador del sistema.?;
echo ?</font>?;
echo ?</td>?;
echo ?</tr>?;
echo ?</table>?;
echo ?</center>?;
}
?>
<?php
$autorizado = FALSE;
if (!$autorizado) {
?>
<center>
<table bgcolor="#cccccc">
<tr>
<td align="center">
<font color="#ff0000">
No está autorizado a ver esta página.<br>
Contacte con el administrador del sistema.
</font>
</td>
</tr>
</table>
</center> <?php
}
?>

Distribución del código
La última cuestión que nos queda por resolver es donde situar el código. Salvo el
código que muestra resultados por pantalla, que tiene que aparecer en el lugar
apropiado de la página, el código PHP se puede situar en cualquier lugar. La mejor
opción es separarar en la medida de lo posible el código encargado de:
• Inicializar las constantes y variables.

• Leer datos de entrada.
• Realizar operaciones.
Este código es conveniente ponerlo al principio de la página. Los resultados de las

operaciones que se quieran mostrar se almacenan entonces en variables auxiliares y
se muestran en el cuerpo de la página HTML donde corresponda haciendo uso de las
etiquetas <?= ... ?>.
Ejemplo 3.1.5. Esta es una página web en PHP bien construida. Usa un algoritmo para
hallar el máximo común divisor de dos números generados aleatoriamente.
<?php
//Inicialización
DEFINE(LIMITE, 100);
//Lectura de datos
$i = rand(1, LIMITE); //Simulamos la lectura
$j = rand(1, LIMITE);
//Operaciones con los datos

if ($i > $j) {
$mayor = $i;
$menor = $j;
} else {
$mayor = $j;
$menor = $i;
}
while (($mayor % $menor) != 0) {
$auxiliar = $menor;
$menor = $mayor % $menor;
$mayor = $auxiliar;
}
$mcd = $menor;
?>
<html>
<head>
<title>Máximo comun divisor</title>

</head>
<body>
El máximo común divisor de <?= $i ?>y <?= $j ?>es <?= $mcd ?>.
</body>
</html>
Esto no es posible siempre. Por ejemplo, si tenemos que mostrar una lista de 11
resultados el bucle que los recorre deberá estar mezclado con el código HMTL. De
todas formas con la experiencia iremos aprendiendo poco a poco a extraer la mayor
parte del código PHP al comienzo de la página.
Manipulación de cadenas
PHP dispone de funciones predefinidas en el núcleo que nos permiten hacer

operaciones con los textos almacenados en cadenas. Ya hemos visto las función echo
y printf() pero hay unas cuantas más.
Acceder a los caracteres de una cadena
Se puede acceder a los caracteres de las cadenas indicando la posición del caracter
que queremos extraer. Las posiciones van desde 0 hasta el número de caracteres
(longitud) menos uno. Si intentamos acceder a una posición más allá del final de la
cadena nos devolverá la cadena vacía (cadena sin ningún caracter = "").
Ejemplo 3.1.6. Varias pruebas extrayendo caracteresde una cadena.
<?php
$cadena = "Pernambuco";
echo "Cadena a analizar: '$cadena'<br>";
//Caracter en la primera posición

echo "Caracter en la posición 0: '$cadena[0]'<br>";
//Caracteres de posiciones intermedias

//La cadena tiene longitud 10, la última posición es la 9

//La cadena tiene longitud 10, en la posición 12 no hay nada

echo "Caracter en la posición 12: '$cadena[12]'<br>";?>

strlen()
Por lo general no conceremos la longitud de la cadena a priori. Esta función nos

permite obtenerla.
strlen(cadena )
strpos()
En ocasiones nos interesará conocer la posición de la primera aparición de un caracter

en una cadena. Si no se encuentra el caracter devuelve FALSE.
strpos(cadena , caracter )
Alternativamente podemos indicarle la posición a partir de la cual queremos que

empiece a buscar.
strpos(caracter, posición inicial )
substr()
Habrá muchos casos en los que nos interesará extraer un trozo del texto de una
cadena. Para hacerlo disponemos de esta función.
substr(caracter, posición inicial, posición final )
Ejemplo 3.1.7. El funcionamiento de las funciones se va a explicar con un ejemplo

típico, la comprobación de que un mail es correcto y la extracción de datos del mismo.
<?php
$email = "maurodosantos@pernambuco.com ";
echo "Email a analizar: ?$email?<br>";

echo "<br>";
echo "Tiene " . strlen($email) . " letras.<br>";
//Indica la posición del caracter "@" o FALSE si no está

$posicion_arroba = strpos($email, "@");
//Busca la aparición de un punto (.) partir de la arroba

$posicion_punto = strpos($email, ".", $posicion_arroba);

if ($posicion_arroba && $posicion_punto) {

echo "Es una dirección de email válida<br>";
$usuario = substr($email, 0, $posicion_arroba);
$dominio = substr($email, $posicion_arroba + 1);
echo "El nombre de usuario es: $usuario<br>";
echo "El dominio es: $dominio<br>";
} else {
echo "No es una dirección de email válida<br>";
if (!$posicion_arroba) {
echo "Le falta el caracter arroba<br>";
}
if (!$posicion_punto) {
echo "El dominio no es válido<br>";
}
}
?>
trim()
Elimina los espacios en blanco al principio y final de una cadena.
trim(cadena )
str_replace()
En un texto, reemplaza las apariciones de una cadena por otra.
str_replace(cadena original, cadena a buscar, cadena reemplazar )
Ejemplo 3.1.8. En este ejemplo se supone que podemos recibir emails con erroneos, y
los intentamos arreglar. El primer error que eliminamos es la aparición de espacios en
blanco al principio y al final de la dirección. El segundo cuando los usuarios escriben el
dominio pernambuco.es cuando el correcto es pernambuco.com .
<?php
$email = " maurodosantos@pernambuco.es ";
echo "Dirección recibida: ?$email?.<br>";
//Eliminamos los espacios en blanco
$email = trim($email);
//Reemplazamos pernambuco.es por pernambuco.com
$email = str_replace($email, "pernambuco.es", "pernambuco.com");

echo "Dirección corregida: ?$email?.";

?>
strtoupper() y strtolower()
La función strtoupper() convierte los textos a mayúsculas, y strtolower() a minúsculas.
strtoupper(cadena )
strtolower(cadena )
Ejemplo 3.1.9. En este ejemplo vamos a pasar la dirección de correo a minúsculas.
<?php
$email = " MAUROSOSANTOS@PERNAMBUCO.ES ";
echo "Dirección recibida: ?$email?.<br>";
//Convertimos a minúsculas
$email = strtolower($email);
echo "Dirección corregida: ?$email?.";
?>
Ejemplo 3.1.10. Un uso muy habitual de estas funciones es para comparar cadenas.
Para PHP la cadena "MADRID" es diferente a la cadena "Madrid", pero mediante estas
funciones se pueden comparar como iguales.
<?phpecho "Comparación de cadenas directamente: ";

if ("MADRID" == "Madrid") {
echo "MADRID es igual a Madrid<br>";
} else {
echo "MADRID no es igual a Madrid<br>";
}
echo "<br>";
echo "Antes de compararar pasamos ambas a minúsculas: ";
if (strtolower("MADRID") == strtolower("Madrid")) {
echo "MADRID es igual a Madrid<br>";
} else {
echo "MADRID no es igual a Madrid<br>";
}
?>

number_format()
Esta función es útil cuando hay que mostrar datos de tipo double, es decir, números
con decimales. Permite especificar el número de decimales que queremos que se
muestren, en lugar de los diez decimales que se muestran habitualmente.
number_format(número, decimales )
Ejemplo 3.1.11. Esta función ya apareció en una práctica del módulo anterior.
<?php
$precio_kg = 1.29;
$peso = 2.17;
$a_pagar = $precio_kg * $peso;
//Saca el dato $a_pagar ocn 2 decimales
echo "A pagar " . number_format($a_pagar, 2) . " euros.";?>
U.D.2. Arrays
Hasta ahora hemos trabajado en nuestros programas con una pequeña cantidad de
datos, y la cantidad de los mismos no variaba a lo largo del programa. Pero la mayoría
de los programas que hacen algo útil requieren tratar gran cantidad de datos. En este
caso sería muy incomodo tener una variable para cada dato.
Afortunadamente cuando se tratan muchos datos estos suelen ser de unos tipos muy
similares entre sí. Para tratarlos en grupos PHP ofrece tipos de datos compuestos, es
decir, tipos de datos que permiten almacenar varios datos en una misma variable.
El tipo de datos compuesto más sencillo es el array . Es una estructura muy potente,
flexible y de uso muy intuitivo. Un array está compuesto por varios elementos. Cada
elemento almacena un valor diferente. Y para poder localizar un elemento hay
disponemos del índice (algo así como una dirección).
Arrays indexados numéricamente
El tipo más sencillo de arrays son los indexados numéricamente, en los que el índice
de cada elemento corresponde con su posición. Hay que tener en cuenta qué, al igual
que sucedía con las cadenas, el primer elemento de un array tiene índice 0 (y no 1
como cabría esperar).

Inicializaciar un array
Los arrays se suelen almacenar en variables, como cualquier otro tipo de datos.
La forma más sencilla de crear un array es asignando los valores de sus elementos a la
vez que se crea. Para ello primero declaramos el nombre de la variable y usamos la
función array() , a la que le pasamos como parámetros un grupo de valores separados
por comas.
Ejemplo 3.2.1. Creación de un array por asignación directa mediante la función array()
:
<?php $edades = array(28, 43, 32, 55);

$formas = array("triángulo", "cuadrado", "círculo");
?>
La segunda forma de crear un array es añadiéndole elementos al final del array. Para
añadir un elemento a un array se usa su identificador seguido de corchetes "[ ]", sin el
índice, y se le asigna un valor.
Ejemplo 3.2.2. Aquí se puede ver como se crea un array mediante la adición de
elementos.
<?php $paises[] = "Italia"; //Añade el elemento con índice 0

$paises[] = "Francia"; //Añade el elemento con índice 1$paises[] =
"Portugal"; //Añade el elemento con índice 2
?>
Ejemplo 3.2.3. Se pueden combinar ambas formas, primero declarar un array

directamente y cuando sea necesario ir añadiendo elementos.
<?php $frutas = array("melón", "sandía", "naranja");

$frutas[] = "manzana";
$frutas[] = "melocoton";?>
Acceder a un elemento de un array

Necesitaremos acceder a los elementos de un array para asignarles valores o para leer
su contenido. Esto es muy sencillo, basta poner el índice del elemento al que queremos
acceder entre corchetes "[ ... ]".
Ejemplo 3.2.4. Aquí se leen los valores de los elementos de un array para sacarlos
por pantalla. Luego se asigna un nuevo valor al primer elemento (recordamos, con
índice 0).

echo "La primera fruta de la lista es $frutas[0].<br>";
echo "La segunda fruta de la lista es $frutas[1].<br>";
echo "La tercera fruta de la lista es $frutas[2].<br>";
$frutas[0] = "limón"; //Asigna un nuevo valor al elemento 1
echo "La primera fruta de la lista es $frutas[0].";?>
Recorrer un array
Los arrays se suelen utilizar para almacenar listas de valores. Por ello una de las
acciones más habituales que se hacen con ellos es recorrerlos de principio a fin para
leer o modificar uno o varios de ellos.
Las estucturas iterativas (bucles) que se vieron en la unidad didáctica 4 del módulo II
son idóneas para recorrer arrays. Lo único que hay que hacer es limitar el número de
iteraciones al número de elementos del array. Para esto disponemos de la función
count().
count(array )
Ejemplo 3.2.5. La función count() nos dice cuantos elementos contiene un array.

echo "La lista contiene " . count($frutas) . " frutas.";?>
Ejemplo 3.2.6. Recorriendo un array para mostrarlo por pantalla.
<?php $frutas = array("melón", "sandía", "naranja");for ($i = 0; $i <

count($frutas); $i++) {
echo "Elemento $i: $frutas[$i]<br>";
}
?>

Ejemplo 3.2.7. Recorriendo un array para modificar todos sus elementos. Aquí se usan
dos arrays que están relacionados por sus posiciones.
<?php
$nombres = array(Juan, Inés, Andrea, Roberto); $edades = array(33, 28, 45,
52);for ($i = 0; $i < count($edades); $i++) {
echo "$nombres[$i] tiene $edades[$i] años.<br>";
}
echo "<br>";for ($i = 0; $i < count($edades); $i++) {
$edades[$i]++;
}
echo "Ha pasado un año...<br>";
for ($i = 0; $i < count($edades); $i++) {
echo "$nombres[$i] tiene $edades[$i] años. <br>";
}
?>
Ejemplo 3.2.8. Recorriendo un array para buscar un elemento. Se vuelve a hacer uso
de dos arrays relacionados por las posiciones de sus índices. En este código se da por
supuesto que se va a encontrar el valor buscado. No es seguro, fallaría si
preguntaramos por la edad de una persona cuyo nombre estuviera en el array
nombres.
<?php $nombres = array(Juan, Inés, Andrea, Roberto);

$edades = array(33, 28, 45, 52);
echo "¿Cuantos años tiene Andrea?<br>";
for ($i = 0; $i < count($nombres); $i++) {
if ($nombres[$i] == "Andrea") {
echo "$edades[$i] años"; }}?>
Ordenar un array
La función sort() ordena los elementos de un array. Si el array está formado por
cadenas de texto considera menores las minúsculas que las mayúsculas.
sort(array )
Ejemplo 3.2.9. En esta ejemplo se ordena una lista de nombres, primero por el
procedimiento normal. Luego se muestra la forma de ordenar el mismo array sin hacer
distinción entre mayúsculas y minúsculas.

<?php
$astros = array("planeta", "cometa", "Venus", "Jupiter");
echo "Ordenación distinguiendo mayúsculas y minúsculas:<br>";

sort($astros);
for ($i = 0; $i < count($astros); $i++) {

echo "$astros[$i]<br>";
}
echo "<br>";
echo "Ordenación sin distinguir mayúsculas y minúsculas:<br>";

$astros_minusculas = array_map("strtolower", $astros);
array_multisort($astros_minusculas, SORT_ASC, SORT_STRING, $astros);
for ($i = 0; $i < count($astros); $i++) {

echo "$astros[$i]<br>";
}
?>
Arrays no secuenciales
Hasta ahora lo arrays que hemos visto tenían como índices la sucesión 0 (1er elemnto),
1 (2o elemento), 2 (3er elemento) ...En PHP los índices de un array no tiene por qué
ser consecutivos, pueden incluso estar desordenados.
El índice de los arrays asociativos no tiene por qué ser necesariamente un entero,
puede ser también un numero decimal o una cadena. Este tipo de arrays es más difícil
de usar y aunque permite una mayor flexibilidad pueden ser fuente de muchos errores
difíciles de detectar si no se usan con cuidado.
Arrays asociativos
Estos son un caso específico de arrays no secuenciales en los que el índice es una
cadena de texto. Pueden resultar útiles para guardar listas en las cuales se asocia un

valor a una palabra clave.
La creación de este tipo de arrays se puede hacer de dos formas. La primera es

mediante la función array() de forma parecida a como lo hacíamos antes, solo que
ahora deberemos especificar un valor para el índice.
Ejemplo 3.2.10. Cuando se declaran explícitamente los índices se escribe el valor del
indice seguido por "=>" y el valor del elemento que contiene.
<?php
$capitales = array("Italia" => "Roma",
"Francia" => "Paris",
"Portugal" => "Lisboa");
echo "La capital de Francia es {$capitales["Francia"]}";

?>
Como se puede observar en el ejemplo, si queremos hacer referencia a un elemento de

un array indexado por una cadena dentro de un texto entre comillas lo tendremos que
encerrar entre llaves "{ }". Si no nos dará un error al interpretar la comilla de apertura
del índice del array como la comilla final de la cedena.
Ejemplo 3.2.11. En la siguiente sentencia PHP considera como texto la parte en verde
y como código la parte en rojo. Como no puede entender la palabra Francia dará un
error.
<?phpecho "La capital de Francia es $capitales["Francia"]";

?>
La segunda forma de crear un array asociativo es añadiendo elementos al array y

asignándoles de forma explícita cual es su índice.
Ejemplo 3.2.12. Veamos esta segunda forma de inicializar arrays declarando

explícitamente sus índices.
<?php $alturas["Aneto"] = 3404;

$alturas["Teide"] = 3718;

$alturas["Mulhacen"] = 3748;
echo "El Aneto mide {$alturas["Aneto"]} metros";
?>
Hay que tener cuidado con este sistema de creación pues se usa indistintamente para
crear un elemento y para acceder a su valor.
Ejemplo 3.2.13. En este ejemplo primero se relaciona un array con otro a través de
índices de tipo cadena. Los valores del primer array sirven a su vez como índices del
segundo.
<?php
$nombres = array("Eva", "Antonio", "Felipe", "Rosa");
$edades = array("Eva" => 28,
"Antonio" => 43,
"Felipe" => 32,
"Rosa" => 55);
for ($i = 0; $i < count($nombres); $i++) {

echo "$nombres[$i] tiene {$edades[$nombres[$i]]} años.<br>";
}
?>
Aún así, al igual que ocurría con los arrays no secuenciales, su uso no es
recomendable si no se tiene dominio sobre el lenguaje de programación PHP.
Arrays no homogéneos.
Como estamos viendo PHP establece muy pocas limitaciones a las estructuras de los
arrays. Aunque hasta el momento todos los arrays que hemos visto los hemos usado
para manipular datos del mismo tipo (arrays de enteros, arrays de cadenas...) esta es
una restricción que no era necesaria.
PHP permite mezclar en los elementos de los array valores de diferentes tipos. Incluso
permite que los índices de los elementos de un mismo array sean de diferentes tipos.

Pero una vez más esta es una estrategia peligrosa a seguir y a la que en la mayoría de
los casos no será necesario recurrir.
Arrays multidimensionales
El contenido de un elemento de un array puede, a su vez, ser un array. De esta forma

se pueden construir arrays multidimensionales.
Ejemplo 3.2.14. Aquí se muestra como almacenar una matriz (array de dos
dimensiones) que contiene una sopa de letras generada aleatoriamente (la función
chr() devuelve un caracter dado su número ascii).
<font >
<?php
DEFINE(ALTO,10);
DEFINE(ANCHO,20);
$sopa_letras = array();
for ($i = 0; $i < ALTO; $i++) {

for ($j = 0; $j <ANCHO; $j++) {
$sopa_letras[$i][$j] = chr(rand(65, 90));
}
}
echo "SOPA DE LETRAS<br>";

echo "<br>";
for ($i = 0; $i < ALTO; $i++) {
for ($j = 0; $j <ANCHO; $j++) {
echo $sopa_letras[$i][$j];
}
echo "<br>";
}
?>
</font>
Mostrar el contenido de un array
Ejemplo 3.2.15. PHP dispone de la función print_r() a la que se le pasa como

argumento un array y imprime por pantalla su contenido. Para poderlo ver bien se usa
la etiqueta HTML <pre>... </pre> que sirve para mostrar el texto y los saltos de línea
como tal cual.

<pre>
<?php$edades = array("Eva" => 28,
"Antonio" => 43,
"Felipe" => 32,
"Rosa" => 55);
print_r($edades);
?>
</pre>
Desbordamiento de arrays
Si se intenta acceder a un elemento que no existe en un array PHP nos devolvera la

cadena vacía (""). Esta es una causa de error muy habitual, sobre todo si luego vamos
a hacer operaciones con ese dato.
Ejemplo 3.2.16. Aquí se accede al quinto elemento del array, que no existe.
<?php $formas = array("triángulo", "cuadrado", "círculo");

echo $formas[4];
?>
U.D.3. Funciones
PHP es un lenguaje estructurado y como tal dispone de funciones. Las funciones no
son más que fragmentos de código (programitas) a los que se puede llamar desde
cualquier parte del código. Gracias a esto permiten:
• Reutilizar código que se usa frecuentemente.

• Estructurar lógicamente el código para que sea más comprensible.
• Separar el código en diferentes ficheros para poder compartirlo en diferentes

páginas PHP.
Funciones definidas por el usuario
Declaración de una función
Antes de poder utilizar una función ésta ha de ser escrita. Por lo tanto el lugar en el que
se suelen situar las funciones es al comienzo del archivo, de tal forma que estén
disponibles a partir de ese momento. Situarlas al comienzo también ayuda a una
estructuración del código más lógica.
Las funciones se declaran, como las variables, con un nombre , precedido de la palabra
function , unos paréntesis (para albergar los datos de entrada, llamados argumentos o
parámetros) y unas llaves que incluyen el cuerpo de la función. Dentro del cuerpo de la
función podemos declarar variables, llamadas a otras funciones y demás sentencias.
function nombre_funcion (arg1, arg2, arg3, ...) {

bloque de código
return valor ; //Opcional
}
Llamada a una función
Para utilizar una función se escribe su nombre, seguido de paréntesis y dentro de estos
se escriben los datos que se quieren pasar a la función (o variables que contienen
dichos datos).
nombre_funcion (arg1, arg2, arg3, ...);
Si la función devuelve un dato este se puede asignar a una variable o usar

directamente como parte de una expresión.
Ejemplo 3.3.1. A continuación se muestra una función muy sencilla, que no tiene
argumentos.
<?phpfunction hola_mundo() {
echo "¡Hola Mundo!";
}
hola_mundo();
?>

Devolución de un valor
Las funciones son mucho más útiles si pueden devolver un dato. Para ello usan la
sentencia return . Una vez que se llega a esta instrucción no se ejecuta el código que
se pueda encontrar a continuación.
Ejemplo 3.3.2. La siguiente función devuelve aleatoriamente un día de la semana.
<?php
function dia_semana() {
$semana = array("lunes", "martes", "miércoles", "jueves",
"viernes", "sabado", "domingo");
$dia = $semana[rand(0, 6)];
return $dia;
}
$dia_cine = dia_semana();
echo "El próximo $dia_cine voy al cine.";
?>
Argumentos
Aún así, estas funciones que hemos visto son muy sencillas y no permiten hacer
grandes cosas. Lo más habitual es que a las funciones se les pasen datos, que
luego operen con estos y que al terminar la función devuelva el resultado. A los datos
que recibe una función se les llama argumentos o parámetros.
En la declaración de la función, tras la palabra clave function , va el nombre de la

función seguido por una lista de argumentos entre paréntesis y separados por comas.
Dentro del cuerpo de la función estos datos se pueden utilizar como una variable
cualquiera.
Ejemplo 3.3.3. Función sencilla que recibe un parámetro y devuelve un resultado.

Luego es llamada dentro de un bucle para mostrar el cuadrado de los números de 1 a
10;
<?php
function cuadrado($numero) {
return $numero * $numero;}for ($i = 1; $i <= 10; $i++) {
echo "$i al cuadrado es igual a " . cuadrado($i) . ".<br>";
}?>

Paso de argumentos por valor
Cuando se pasan valores a las funciones hay varias formas de pasarlos. El

comportamiento predefinido es lo que se conoce como paso por valor. Esto quiere decir
que la variable que recibe el valor hace una copia del mismo y a partir de ese momento
actúa como una variable independiente de manera que si cambias el valor del
argumento dentro de la función, no se ve modificado fuera de ella.
Paso de argumentos por referencia
En ocasiones es preferible no hacer la copia del dato que se pasa. Esto puede
interesar cuando se trabaje con arrays (el copiado de muchos datos puede perjudicar el
tiempo de ejecución del programa) o más comunmente cuando se quiere alterar el
valor de la variable para obtener algún efecto. A esto se le llama paso de parámetros
por referencia. Para indicar que un parámetro se pasa por referencia se le antepone el
símbolo ampersand, "&".
Una función puede emplear argumentos pasados por valor y por referencia.
Ejemplo 3.3.4. Comparación entre el paso por valor y por referencia.
<?php
function duplicar_por_valor($argumento) {
$argumento = $argumento * 2;
echo "Dentro de la función vale $argumento.<br>";
}
function duplicar_por_referencia(&$argumento) {
$argumento = $argumento * 2;
echo "Dentro de la función vale $argumento.<br>";
}
$numero1 = 5;
echo "Antes de llamar a la función vale $numero1.<br>";
duplicar_por_valor($numero1);
echo "Después de llamar a la función vale $numero1.<br>";
echo "<br>";
$numero2 = 7;
echo "Antes de llamar a la función vale $numero2.<br>";
duplicar_por_referencia($numero2);
echo "Después de llamar a la función vale $numero2.<br>";
?>

Ejemplo 3.3.5. No se puede hacer que una función devuelva dos valores. Pero en su
lugar es posible pasar por referencia las variables a devolver y modificar su contenido
en el cuerpo de la función. Aquí se emplea esta estratagema para intercambiar el
contenido de dos variables.
<?php
function intercambiar(&$argumento1, &$argumento2) {
$auxiliar = $argumento1;
$argumento1 = $argumento2;
$argumento2 = $auxiliar;
}
$numero1 = 5;
$numero2 = 8;
echo "($numero1, $numero2)<br>";
intercambiar($numero1, $numero2);
echo "($numero1, $numero2)"
?>
Alcance de las variables
Dentro de las funciones también podemos declarar nuevas variables, pero, ¿que pasa
si hay una variable dentro de una función que se llama igual que una variable que se
encuetra fuera de la función? La respuesta es que la variable de dentro de la función es
diferente de la que está fuera y por lo tanto su valor es independiente.
A esto se le llama alcance de una variable. Las variables que se declaran dentro de
una función solo existen en el cuerpo de la función.
Ejemplo 3.3.6. Este código muestra el alcance de una variable dentro de una función.
No hay que confundir este ejemplo con el ejemplo 3.3.4. En este caso no hay ningún
argumento.
<?php
function mi_ciudad() {
$ciudad = "Madrid";
echo "Dentro de la función vale $ciudad.<br>";
}
$ciudad = "Barcelona";
echo "Antes de llamar a la función vale $ciudad.<br>";
mi_ciudad();

echo "Después de llamar a la función vale $ciudad.<br>"

?>
Ejemplo 3.3.7. Puede darse el caso de que queramos acceder a una variable global
dentro del cuerpo de la función. Para conseguirlo le antepondremos la palabra clave
global a la primera referncia de la variable, con lo que el interprete PHP sabe que
estamos llamando a la variable externa.
<?php
function mi_ciudad() {
global $ciudad;
$ciudad = "Madrid";
echo "Dentro de la función vale $ciudad.<br>";}
$ciudad = "Barcelona";
echo "Antes de llamar a la función vale $ciudad.<br>";
mi_ciudad();
echo "Después de llamar a la función vale $ciudad.<br>" ?>
No obstante es altamente recomendable usar en las funciones nombres de variables

diferentes a los de las variables del programa principal para evitar confusiones.
Tampoco es conveniente usar variables globales dentro de las funciones. Siempre que
se pueda es mejor pasar estas variables como parámetro, mejora notablemente la
fiabilidad y claridad del código.
Creación de bibliotecas
Para conseguir un código lo más claro posible es deseable que este sea breve. Una
forma de conseguirlo es extraer las funciones que se declaran a un
archivo independiente con extensión .php . Una ventaja de esta estrategia es que se
pueden hacer accesibles estas funciones a más de una página en PHP.
Ejemplo 3.3.8. Una biblioteca de funciones guardada en el archivo utils.php . Se ha

optado por poner un breve comentario antes de cada función explicando su cometido
para contribuir a la legibilidad y mantenibilidad del código.
<?php
// Biblioteca de funciones de usuario
// Archivo utils.php
// Devuelve el argumento elevado al cuadrado

function cuadrado($numero) {

return $numero * $numero;}// Devuelve la raíz cuadrada del argumento

function raiz($numero) {
return sqrt($numero);
}
// Devuelve verdadero si el número es igual o mayor que cero
function es_positivo($numero) {
return ($numero >= 0);
}?>
Ejemplo 3.3.9. En los ficheros de biblioteca se puede incluir cualquier tipo de código.
También se pueden poner archivos de configuración, de constantes predefinidas, etc.
En este caso se guarda en el archivo config.php.
<?php
// Fichero de configuración
// Archivo config.php
DEFINE(PI, 3.1416);DEFINE(NUMERO_E, 2.7183);

DEFINE(EULER, 0.5772);
?>
Las instrucciónes include() y require()
Para tener disponibles las funciones de un fichero externo hay que indicarle al código
PHP que las ha de incorporar al script actual. Mediante estas instrucciones se incluye
un fichero en el punto en el que se importa. La diferencia es que require() lanza un
error fatal en el caso de no encontrar el fichero mientras que include() no lo hace.
Ejempo 3.3.10. La inclusión de bibliotecas se suele poner al principio para que estén
disponibles en el resto del código.
<?php
include("config.php");
include("utils.php");
$radio = 5;
$circunferencia = 2 * radio * PI;
$area = PI * cuadrado($radio);
echo "Un círculo de rádio $radio tiene circunferencia ";
echo "$circunferencia y área $area.<br>";
$area = -8;
if (es_positivo($area)) {
$radio = raiz(area / PI);

echo "Un círculo de área $area tiene un rádio $radio";

} else {
echo "No se puede calcular, área negativa.";
}
?>
Hay que tener en cuenta el orden en el que se cargan los archivos externos, sobre todo
si unos hacen uso de código de otros.
Otros tipos de funciones
Hasta ahora hemos visto las funciones que nosotros definimos. Pero a lo largo de
muchos ejemplos hemos ido usando funciones como rand() o number_format() que ya
estaban disponibles en el lenguaje. Estas son funciones del núcleo de PHP y por lo
tanto no hace falta hacer un include() para poder usarlas.
Extensiones de PHP
Las funciones que incorpora de forma predefinida PHP están agrupadas en

extensiones.
Ejemplo 3.3.11. Para saber que extensiones están instaladas en nuestro interprete de
PHP tenemos una opción muy útil, la función phpinfo() que genera una página con la
información del intérprete que tenemos instalado.
<?php
phpinfo();?>
Debe aparecernos una pantalla similar a la siguiente:

Referencia sobre funciones
Toda la referencia sobre funciones se puede encontrar en la página oficial sobre PHP:
http://es.php.net/manual/es/funcref.php
Hay una gran multitud de funciones en PHP de las cuales probablemente usaremos

unas pocas. Las extensiones más útiles son:
• Funciones matemáticas - http://es.php.net/manual/es/ref.math.php

• Funciones de cadenas - http://es.php.net/manual/es/ref.strings.php
• Funciones de mysql - http://es.php.net/manual/es/ref.mysql.php
• Funciones de fecha y hora - http://es.php.net/manual/es/ref.datetime.php
La página dispone también de un buscador que resulta bastante útil.
U.D.4. Formularios
Hasta este momento todas las páginas que hemos visto a través de ejemplos tenían un
defecto, no eran interactivas. Hacían operaciones en función de los datos de los que ya
disponían pero eran incapaces de recibir datos del navegador.
Una de las formas más habituales de recibir datos por parte de una página web
dinámica es a través de formularios web. Estrictamente hablando los formularios no
son parte del lenguaje PHP sino del lenguaje HTML. Pero para recibir los datos de un
formulario en HTML hace falta por lo general una página dinámica que los procese.
Hay que tener en cuenta que además de formularios HTML hay otras tecnologías que
permiten el envío de datos a páginas web, com Flash u otras páginas web dinámicas.
Formularios HTML
Los formularios pueden llegar a ser muy complejos, con una gran cantidad de campos
de entrada, validación de datos por Javascript, campos ocultos... Pero el objetivo del
curso no es explicar su funcionamiento, así que se hará un repaso muy superficial.
Un formulario está formado por tres tipos de elementos: Etiquetas de comienzo y final,
campos de entrada de datos y botones para realizar acciones.
Declaración del formulario
Un formulario se distingue por estar encuadrado entre una etiqueta de comienzo de

formulario <form ...> y una de final de formulario </form>. La etiqueta de comienzo de
formulario ha de tener al menos tres atributos.
• name - No es obligatorio pero si muy recomendable darle un nombre al

formulario para que sea fácil de identificar.
• method - Este parámetro puede tomar dos valores según la forma de enviar
los datos:
• • get - Los datos se envían codificados en la URL (dirección de la
página destino).

• post - Los datos se envían ocultos.

• action - Indica la página destino que se encargara de procesar los datos que
envía el formulario.
<form name="formulario" method="get" action="procesar.php">

Campos de entrada de datos
Botones de acciones
</form>
Campos
Una vez declarado el formulario hemos de poner un campo para cada uno de los datos
que queremos recibir. Hay 6 tipos de campos:
• Texto - Se usa para recibir una línea de texto.
<input type="text" name="nombre">
• Selección única - Se usa para elegir una opción entre varias. Las opciones
que son excluyentes entre sí han de tener el mismo nombre.
<input type="radio" name="sexo" value="hombre">

<input type="radio" name="sexo" value="mujer">
• Selección múltiple - Se usa para elegir opciones de forma independiente.

Esto es, se pueden elegir todas, algunas o ninguna.
<input type="checkbox" name="cine">

<input type="checkbox" name="musica">
<input type="checkbox" name="lectura"><br>
• Lista de selección - Es un sistema alternativo al campo de selección

única para elegir una opción entre varias, esta vez con formato de lista
desplegable.
<select name="sexo">
<option>hombre</option>
<option>mujer</option>
</select>

• Área de texto - Sirve para poder recibir textos largos compuestos por varias
líneas.
<textarea name="opinion"></textarea>
• Campo oculto - En ocasiones queremos pasar un dato a la página PHP que

procesará el formulario pero no queremos que esté se muestre en un campo
visible. Puede ser útil para pasar información entre páginas PHP
independientes.
<input type="hidden" name="referencia">
En todos ellos es importante poner el atributo name que es el nombre de variable con
el cual vamos a recibir los datos. El atributo value es opcional e indica el valor
predefinido que se les da.
Botones
Todos los formularios han de tener un botón para enviar los datos una vez que se han
rellenado.
<input type="submit" name="Enviar">
También se suele incluir un botón para limpiar los campos del formulario.
<input type="reset" name="Borrar todo">
Ejemplo 3.4.1. A continuación se muestra un formulario formado por algunos de los

tipos de campo descritos con anterioridad y se guarda en un archivo llamado
encuesta.html .
<html>
<head>
<title></title>
</head>
<body>
<form name="encuesta" method="get" action="verificar.php">
NOMBRE <input type="text" name="nombre" size="43"><br>
<br>
NIVEL DE INTERNET<br>

bajo <input type="radio" name="nivel" value="bajo" checked>

medio <input type="radio" name="nivel" value="medio">
alto <input type="radio" name="nivel" value="alto"><br>
<br>
EXPERIENCIA PREVIA EN PROGRAMACIÓN<br>
Visual Basic <input type="checkbox" name="basic">
C/C++ <input type="checkbox" name="c_cplus">
Java <input type="checkbox" name="java"><br>
<br>
TU OPINIÓN SOBRE ESTE CURSO<br>
<textarea name="opinion" cols="40" rows="5"></textarea><br>
<br>
<input type="submit" value="Enviar">
<input type="reset" value="Borrar todo">
</form>
</body>
</html>
Deberíamos ver un formulario similar a este:

Recepción de datos de formularios
Recibir los datos no puede ser más sencillo. El script de destino tendrá definida un
variable por cada campo con el mismo nombre que se le haya dado en el formulario. Y
esta variable contendrá el valor que se haya introducido en el campo. Esta variable ya
está disponible desde el comienzo del script, no hay que hacer nada especial, sólo leer
su contenido.
Ejemplo 3.4.2. Esta página PHP recibe los datos de la encuesta y los muestra. Para
que funcione hay que guardarla con el nombre verificar.php , que es el que aparecía en
el atributo action del formulario.
<?php
echo "Comprueba si tus datos son correctos.<br>";
echo "<br>";
echo "$nombre.<br>";
echo "Nivel de internet $nivel.<br>";

if (($basic == "on") || ($c_cplus == "on") || ($java == "on")) {

echo "Con experiencia en ";
if ($basic == "on") {
echo "Visual Basic";
if ($c_cplus == "on") {
echo ", C/C++";
}
if ($java == "on") {
echo ", Java";
}
} else if ($c_cplus == "on"){
echo "C/C++";
echo ", Java";
}
} else {
echo "Java";
}
}
echo ".<br>";
} else {
echo "Sin experiencia previa en programación.<br>";
}echo "<br>";
echo "OPINIÓN SOBRE EL CURSO:<br>";
echo nl2br($opinion); //convierte saltos de línea en <br>
?>
Ejemplo 3.4.3. Los parametros que nos han llegado se encuentran almacenados en un
array asociativo con nombre de variable $_REQUEST. Podemos ver su contenido
usando la función print_r() que se vió en la unidad didáctica anterior. Esto nos ofrece
otra forma de acceder a los datos recibidos, que es más explícita y por lo tanto hace el
código más legible.
<pre>
<?phpprint_r($_REQUEST);
?>
</pre>
Ejemplo 3.4.4. El ejemplo 3.4.3. Podría haber sido escrito también de la siguiente
forma (se muestran sólo las primeras líneas, un buen ejercicio sería completarlas).

<?php
echo "Comprueba si tus datos son correctos.<br>";
echo "<br>";
echo "{$_REQUEST["nombre"]}.<br>";
echo "Nivel de internet {$_REQUEST["nivel"]}.<br>";//...
?>
Páginas que envían, reciben y procesan datos
Ejemplo 3.4.5. Esta página web une el formulario de entrada de datos y la recepción
de los mismos. El atributo action de la etiqueta form ha de ser el mismo que el nombre
de la página. Para ello usamos la variable predefinida $PHP_SELF que contiene el
nombre de archivo de la misma página. Podemos guardar este archivo con el nombre
juegoppt.php.
<?php
$opciones = array("piedra", "papel", "tijeras");
if ($jugada != "") {
$mijugada = $opciones[rand(0, 2)];
if ($jugada == $mijugada) {
$resultado = "Empates.";
} else if (($jugada == "piedra" && $mijugada == "tijeras")
|| ($jugada == "tijeras" && $mijugada == "papel")
|| ($jugada == "papel" && $mijugada == "piedra")) {
$resultado = "Tu ganas.";
} else {
$resultado = "Gano yo.";
}
}
?>
<html>
<head>
<title>Piedra, papel o tijera</title>
</head>
<body>
<?php
if ($jugada != "") {
?>
Has elegido <?= $jugada ?>, yo he elegido <?= $mijugada ?>.
<?= $resultado ?><br>
¿Quieres jugar otra vez?<br>

<?php
}
?>
<form "juego" method="post" action="<?= $PHP_SELF ?>">
Piedra<input type="radio" name="jugada" value="piedra">
Papel<input type="radio" name="jugada" value="papel">
Tijera<input type="radio" name="jugada" value="tijeras">
<input type="submit" value="Jugar">
</form>
</body>
</head>
El código que se incluye al principio solo se ejecuta si el dato $jugada no llega vació, es
decir, cuando se le ha dado al menos una vez al botón de enviar.
Redirección de páginas web
En ocasiones se necesita que un programa PHP reciba datos y haga una operación
"silenciosa" con los mismos. Es decir, que no sea necesario que se muestre una página
al navegador sino que se vuelva a la inicial. Esto se puede hacer con un formulario que
envía recibe y procesa datos.
Una alternativa es hacer una página que procese los datos y que al terminar se redirija
automáticamente a otra. Para poder hacerlo PHP nos ofrece la función header(), que
se usa de la siguiente forma.
header("location:url ")
La dirección de destino url puede ser una ruta absoluta o relativa.
Es imprescindible que la página no contenga al principio código HTML. También hay

que tener en cuenta que una vez que se llega a la función header no se sigue
ejecutando el resto de la página, por lo que las operaciones que queramos hacer las
habremos de ejecutar antes.
Ejemplo 3.4.6. Este es un ejemplo típico de recepción de datos. En primer lugar se

incluye una sencilla página web con un formulario que pide el nombre y un
comentario para almacenarlo en un registro de visitas. En el script insertar.php se
almacena en la base de datos y se redirecciona a una página para dar las gracias.
• visita.html

<html>
<head> <title>Libro de visitas</title>
</head>
<body><form name="visita" method="post" action="insertar.php">
Nombre: <input type="text" name="nombre" size="44"><br>
Comentario:<br>
<textarea name="comentario" cols="40" rows="5"></textarea><br>
</form></body>
</html>
• insertar.php
<?php
// Aquí vendría el código para guardar en la base de
datosheader("location:gracias.html"); //Redirección
?>
• gracias.html
<html>
<head> <title>Gracias</title>
</head>
<body>
Su comentario ha sido registrado en el libro de visitas.<br>
Gracias por su participación.
</body>
</html>
Ejemplo 3.4.7. Un uso habitual de la redirección es para redirigir hacia una página de
error en el caso de que haya fallos en los datos. En este ejemplo se pide una dirección
de correo electrónico, se valida y si es incorrecta se reenvía a una página de error.
• suscripcion.html
<html>
<head> <title>Suscripción al boletín electrónico</title>
</head>
<body>
Bienvenido al servicio de suscripción.<br>
Por favor, introduzca una dirección de email válida.<br><form

name="suscripcion" method="post" action="guardar.php">

Email: <input type="text" name="email" size="40"><br>
</form></body>
</html>
• guardar.php
<?php//Indica la posición del caracter "@" o FALSE si no está

$posicion_arroba = strpos($email, "@");
//Busca la aparición de un punto (.) a partir de la arroba

$posicion_punto = strpos($email, ".", $posicion_arroba);
if ($posicion_arroba && $posicion_punto) {

// Aquí vendría el código para guardar en la base de datos
header("location:confirmacion.html"); //Redirección
} else {
// Aquí vendría el código para guardar en la base de datos
header("location:error.html"); //Redirección
}?>
• confirmacion.html
<html>
<head> <title>Confirmacion</title>
</head>
<body>
Su suscripción ha sido registrada.</br>
Gracias por su interés.
</body>
</html>
• error.html
<html>
<head> <title>Error</title>
</head>
<body>
Introdujo una dirección de correo no válida.<br>
Por favor vuelva a solicitar la suscripción.

<a href="suscripcion.html"> Volver </a></body>

</html>
U.D.5. Manejo de ficheros

Mediante los formularios hemos conseguido aportar interactividad a nuestra páginas
web. Pero otra de las limitaciones fundamentales de lo que podemos hacer con lo que
sabemos hasta el momento es que una vez que se cierra una página web los datos que
contiene se pierden.
En el próximo módulo veremos como guardar la información en una base de datos.

Esto es útil para grandes cantidades de información muy estructurada pero hay casos
en los que la información que queremos guardar es pequeña. En esta unidad didáctica
veremos como podemos usar PHP para acceder al sistema de archivos del servidor
para poder leer o guardar datos.
Manejo de ficheros
Abrir
Para acceder a un archivo primero es necesario abrirlo. Para ello usaremos la función
fopen() que tiene dos argumentos, el nombre del archivo a acceder y el modo de
acceder a este.
fopen(ruta al archivo, modo de acceso )
PHP ofrece los siguientes modos de acceso:
Modo Descripción
r Apertura para sólo lectura;

ubica el apuntador de archivo
al comienzo del mismo.
r+ Apertura para lectura y
escritura; ubica el apuntador
de archivo al comienzo del
mismo.
a Apertura para sólo escritura;
ubica el apuntador de archivo

al final del mismo. Si el

archivo no existe, intenta
crearlo.
a+ Apertura para lectura y
escritura; ubica el apuntador
de archivo al final del mismo.
Si el archivo no existe,
intenta crearlo.
w Apertura para sólo escritura.
Cualquier contenido del
archivo será borrado. Si el
archivo no existe, intenta
crearlo.
w+ Apertura para lectura y
escritura.Cualquier contenido
del archivo será borrado. Si
el archivo no existe, intenta
crearlo.
El apuntador es la posición del archivo en la que leemos o escribimos. Como podemos

ver lo más habitual es que lo situemos al principio para leer todo su contenido o al final
para ir añadiendo datos.
La función devuelve un manejador que usaremos posteriormente para manipular el

archivo (y que guardaremos en una variable), o devuelve FALSE si no ha podido
acceder por alguna causa (permisos, ruta, memoria,etc.).
Cerrar
Mientras hacemos operaciones con el archivo este lo hemos de mantener abierto pero
al terminar de trabajar con él hay que cerrarlo para que el sistema operativo pueda
disponer de él (mientras está abierto el sistema operativo lo bloquea para que no
puedan escribir en él dos programas y destruir mutuamente lo que escriben).
Para cerrar un archivo abierto se usa la función fclose() pasándole como parámetro la
variable que contiene el manejador del archivo.
fclose(archivo )
Ejemplo 3.5.1. En este código se abre un fichero en modo de lectura. En función de si

se ha conseguido se muestra un mensaje de confirmación o de error. Finalmente el
archivo se cierra.

<?php$ruta = "utils.php";
$archivo = fopen($ruta, "r");
if ($archivo) {
print "Archivo $ruta abierto para lectura.";
} else {
print "No se pudo abrir el archivo: $ruta.";
}
fclose($archivo);
?>
Ejemplo 3.5.2. El fichero que abrimos lo podemos localizar mediante una ruta absoluta
o relativa. Aunque en Windows las rutas se construyan usando la contrabarra " \ " PHP
admite que se separen los directorios con la barra normal " / " como en Linux. Esta es
la forma que elegiremos ya que las rutas relativas que contruyamos de esta forma
serán válidas tanto si instalamos nuestra aplicación en Linux como en Windows.
<?php
$ruta_absoluta = "c:/CursoPHP/xampplite/htdocs/index.php";
$ruta_relativa = "../practicasPHP/config.php";
$archivo1 = fopen($ruta_absoluta, "r");
$archivo2 = fopen($ruta_relativa, "r");
fclose($archivo1);
fclose($archivo2);
?>
Ejemplo 3.5.3. Es incluso posible abrir archivos que estén alojados en otros servidores,
aunque lo más habitual es que solo tengamos permisos de lectura.
<?php$url = "http://www.google.es/index.html ";

$archivo = fopen($url, "r");fclose($archivo);
?>
Leer
Lo más habitual es que queramos leer el archivo. PHP ofrece muchas formas de
hacerlo. Una de las más sencillas es mediante la función fread() que lee un número de
caracteres de un archivo. En conjunción con la función filesize() que nos devuelve el
tamaño del archivo en bytes se puede usar para leer todo el archivo.
fread(archivo, tamaño )

Ejemplo 3.5.4. Lectura del archivo prueba.txt . Para que el archivo funcione tendremos
que haberlo creado antes y copiado en la misma carpeta que este script.
<pre>
<?php
$archivo = fopen("prueba.txt", "r");
$tamano = filesize("prueba.txt");$texto = fread($archivo, $tamano);
echo $texto;fclose($archivo);
?>
</pre>
Escribir
Otra acción que querremos hacer habitualmente es añadir datos a un archivo. Para ello
se usa una función muy sencilla, fwrite() que escribe en la posición en la que está el
apuntador (normalmente, si hemos abierto el archivo en modo "a" escribiremos al final
del archivo).
La función fwrite() usa dos parámetros. El primero el manejador del archivo y el

segundo la cadena que queremos escribir.
fwrite(archivo, cadena de texto )
Ejemplo 3.5.5. En este ejemplo se usa esta función dos veces para escribir dos
frases en el archivo.
<?php
$archivo = fopen("refranes.txt", "a");fwrite($archivo, "Si las barbas de tu
vecino ves cortar ...\r\n");
fwrite($archivo, "...pon las tuyas a remojar \r\n");fclose($archivo);
?>
La cadena " \r\n " sirve para insertar un salto de línea en el archivo en el sistema
operativo Windows. En Linux se usa solo la cadena " \n ".
Si lo que queremos es sobreescribirlo abriremos el archivo en modo "w", de tal forma

que se borre el contenido al abrirlo y dispondremos de un fichero vacío.
Crear un fichero
Si queremos crear un archivo bastará que lo abramos con el modo "a" o "w". Al abrirlo,

si el archivo no existe lo creará.
Eliminar un fichero
La función unlink() que recibe como parámetro una ruta a un fichero lo borra. En el
caso de que no lo haya conseguido (por no tener permisos o sencillamente porque no
existe el archivo) devuelve FALSE.
unlink(archivo )
Ejemplo 3.5.6. Este programa intenta borrar un archivo y en el caso de no conseguirlo

muestra un mensaje de error.
<?phpif (!unlink("prueba.txt")) {
echo "No se ha podido borrar el archivo.";
}?>
Atributos de un fichero
Para manejar de forma segura es conveniente que conozcamos sus atributos. Por
ejemplo, antes de abrir un archivo para escritura convendría comprobar si tenemos
permisos de lectura. Las siguientes funciones nos ayudarán en esta tarea.
file_exists()
Devuelve TRUE si el archivo por el que preguntamos existe.
file_size()
Ya ha aparecido al hablar de la lectura de un archivo. Devuelve el tamaño en bytes del

mismo.
is_file()
Devuelve TRUE si el archivo es un fichero.
is_dir()
Devuelve TRUE si el archivo es un directorio.
is_readable()

Devuelve TRUE si el archivo se puede abrir para lectura.
is_writeable()
Devuelve TRUE si el archivo se puede abrir para escritura.
Ejemplo 3.5.7. Mediante este programa se muestran las propiedades del archivo
prueba.txt.
<?php
$ruta = "prueba.txt";if (file_exists($ruta)) {
echo "$ruta tiene un tamaño de ";
echofilesize($ruta) . " bytes.<br>";
if (is_file($ruta)) { echo "$ruta es un fichero.<br>";
}
if (is_dir($ruta)) {
echo "$ruta es un directorio.<br>";
} if (is_readable($ruta)) {
echo "$ruta se puede abrir para lectura.<br>";
}
if (is_writable($ruta)) {
echo "$ruta se puede abrir para escritura.<br>";
}} else {
echo "$ruta no existe.";}?>
Manejo de directorios
PHP ofrece muchas funciones para manejar directorios, pero lo más probable es que
en la mayoría de los casos lo único que nos interese de un directorio es conocer los
archivos que tiene. Una vez que conozcamos este dato podremos construir rutas
relativas a sus subdirectorios y a su vez listarlos y así de forma sucesiva.
Abrir un directorio
De forma similar a com sucedía con los archivos, antes de trabajar con un directorio lo
tendremos que abrir. Nos serviremos de la función opendir() que devuelve un
manejador del directorio.
opendir(ruta al directorio )
Listar los archivos de un directorio

Para conocer los ficheros y subdirectorios que contiene un directorio se usa la función
readdir() . Por cada vez que llamemos a esta función nos devolverá el nombre de cada
archivo encontrado o FALSE si no quedan más archivos en el directorio.
readdir(directorio )
Ejemplo 3.5.8. Aquí se puede ver como listar todos los contenidos del directorio actual
(referenciado mediante la ruta relativa " . ") indicando a su vez si son ficheros o
directorios.
<?php
$directorio = opendir(".");
while ($archivo = readdir($directorio)) {
if (is_file($archivo)) {
echo "$archivo es un fichero.<br>";
}
if (is_dir($archivo)) {
echo "$archivo es un directorio.<br>";
}
}?>
Subir archivos al servidor
El envío de archivos desde el cliente, es una de las posibilidades más atractivas para
una aplicación web. Se subir de esta forma fotos, un curriculum, un documento PDF,
etc..
Ejemplo 3.5.9. Se va a explicar como subir un archivo a través de un ejemplo. En

primer luga necesitamos un formulario especial, que llamaremos subir.html .
• subir.html
<html>
<head>
<title>Elija el archivo a subir</title>
</head>
<body>
<form name="subir" method="post" action="guardar.php"
enctype="multipart/form-data">
Archivo a subir <input type="file" name="miarchivo"><br>
<input type="submit" value="Subir el archivo">

</form>
</body>
</html>
Además de este formulario necesitaremos una página dinámica en PHP que reciba el
archivo y lo guarde en el disco duro. Esto se hace en 3 pasos:
• El servidor guarda el archivo en un fichero temporal.

• Movemos el archivo en la posición definitiva usando la función
move_uploaded_file(). Esto es imprescindible ya que pasado cierto tiempo el
servidor web eliminará automáticamente el fichero temporal.
• Si la operación de mover el archivo falla mostramos un mensaje de error.
El código que se ha escrito en este caso, en el script guardar.php es:
• guardar.php
<?php
$temporal = $_FILES["miarchivo"]["tmp_name"];
$destino = "uploads/" . $_FILES["miarchivo"]["name"];
if (move_uploaded_file($temporal, $destino)) {
echo "Archivo subido con éxito";
} else {
echo "Ocurrió un error, no se ha podido subir el archivo";
}?>
Hay que tener cuidado, en este script se supone que el directorio uploads ya existe. Si
no es así la operación fallaría.

Módulo IV. PHP y las bases de datos

U.D.1. Estructura de una aplicación web con bases de datos
Según una definición muy acertada de Niklaus Wirth un programa está compuesto por
algoritmos y estructuras de datos.
En lo que llevamos de curso hemos estudiado a fondo la primera parte, los algoritmos
para resolver problemas. Pero conocemos poco sobre la segunda parte, los datos.
Internet se basa principalmente en el tráfico de datos, no en vano se le llama la

autopista de la información. Por lo tanto cualquier lenguaje de programación web que
se precie estará orientado a recibir, procesar y enviar información.
Pero para hacerlo necesita un respaldo potente como almacen de información. Hasta
ahora el único mecanismo que hemos visto para guardar datos de forma permanente
es escribir y leer en ficheros alojados en el servidor. Esto, para grandes cantidades de
información es inviable. Es preferible delegar esta función a software especializado, los
sistemas de gestión de bases de datos (o sencillamente, bases de datos).
Al añadir bases de datos a una aplicación web se amplía el esquema que interviene en
la generación de una página web con un nuevo elemento.

A esta disposición se la denomina arquitectura web de tres capas:
• Capa primera: cliente web (navegador).

• Capa segunda: servidor web con interprete de PHP.
• Capa tercera: sistema gestor de bases de datos.
El sistema gestor de bases de datos puede estar instalado en el mismo equipo que el
servidor web o en uno diferente. En nuestro entorno (suponiendo que estemos usando
Xampp), tenemos el servidor Apache y la base de datos MySQL en el mismo
ordenador.
PHP es el encargado de la comunicación entre la segunda y la tercera capa. Esto lo

puede hacer de dos formas.
• Mediante el API específico de la base de datos.

• Mediante ODBC, el estandar de comunicación con bases de datos.
Nosotros usaremos la primera forma ya que es más sencilla y eficiente.
U.D.2. ¿Qué es MySQL?

Bases de datos relacionales
El tipo de bases de datos más generalizado es el de las bases de datos relacionales.

Es el modelo más adecuado para modelar problemas reales y resulta sencillo de usar y
administrar. El usuario se puede desentender de donde y como se almacenan los
datos. La información puede ser recuperada o almacenada mediante "consultas" que
ofrecen una amplia flexibilidad y poder para administrar la información.
Las bases de datos relacionales guardan la información en tablas formadas por

registros (las filas de la tabla) que están formados por campos (las columnas de un
tabla).
MySQL
MySQL es un producto desarrollado por la compañía MySQL AB. Es el sistema gestor

de bases de datos más utilizado en las aplicaciones web de Internet. En sus comienzos
carecía de muchas funcionalidades habituales en este tipo de bases de datos como
integridad referencial o soporte para transacciones pero incluso con
estos inconvenientes se volvió muy popular. La versión actual ha evolucionado
notablemente y es mucho más completa.
MySQL es una base de datos relacional y destaca por las siguientes características.
• Es sencilla de usar y administrar.

• Es segura.
• Es eficiente.
• Es sofware libre y por lo tanto gratuita.
• Soporta el lenguaje de consultas SQL.
• Está disponible para casi todos los sitemas operativos.
• Ofrece posibilidades avanzadas de administración
• Su sencillez no es un inconveniente, la versión actual incluye muchas de las
características avanzadas que ofrecen otras bases de datos de pago.
MySQL es la pareja perfecta para las aplicaciones programadas en PHP.
U.D.3. El lenguaje SQL

¿Qué es SQL?
SQL es el acrónimo del término inglés Structured Query Language , lenguaje de

consultas estructurado. Es un lenguaje que se usa para comunicarnos con el sistema

gestor de bases de datos. Es a la vez potente y sencillo a la hora de recuperar

información de forma estructurada.
Trabajar con MySQL
El lenguaje de consultas SQL se va a explicar a través de ejemplos sobre MySQL. Uno

de los inconvenientes que tiene MySQL es que para administrar esta base de datos se
ha de hacer a través de una consola en modo texto (no tiene un interfaz en modo
gráfico amigable). No obstante, con un poco de práctica encontraremos que la consola
es un medio rápido para conseguir nuestros objetivos.
Para poder acceder a la consola de MySQL es necesario seguir los siguientes pasos,
suponiendo que hayamos instalado el paquete Xampp en Windows.
1. Xampp debe estar iniciciado. De no ser así iremos a la carpeta

C:\CursoPhp\xampplite (el directorio donde hemos instalado Xampp) y ejecutaremos
xampp_start.exe.
2. Una vez arrancado Xampp ejecutaremos el comando mysql -u root . Esto se puede
hacer en Windows desde Inicio --> Ejecutar o desde MS-DOS (símbolo de sistema).

La consola es igual tanto en Windows como en Linux, por lo que una vez dentro no se
apreciarán diferencias.
Sintaxis de SQL
A diferencia de PHP MySQL no distingue entre mayúsculas y minúsculas y las

instrucciones se pueden escribir tanto en una como en la otra forma. Pero para hacer
más legible lo que leemos lo habitual es escribir las palabras clave del lenguaje en
mayúsculas y el resto del código en minúsculas. Esta es la convención que se sigue en
este texto.
Otra característica de MySQL es que las sentencias se terminan siempre en punto y

coma, como en PHP.
Crear la estructura de la base de datos
Antes de poder almacenar datos hemos de crear una estructura que los pueda
contener.
Creación de una base de datos
MySQL es un sistema gestor de bases de datos, que puede gestionarmás de una base
de datos independiente. Por lo tanto lo primero que debemos hacer es crear nuestra
base de datos personal que utilizaremos durante las pruebas. Para ello se usa la

sentencia SQL CREATE DATABASE.
CREATE DATABASE nombre_base_datos;
Ejemplo 4.3.1. Creamos nuestra base de datos que llamaremos curso_php.
Selección de una base de datos
Antes de poder trabajar con la base de datos hemos de seleccionarla. Para ello
usaremos el comando USE.
USE nombre_base_datos ;
Ejemplo 4.3.2. A partir de ahora todas las sentencias SQL se harán sobre la base de
datos curso_php .
Creación de tablas
Las bases de datos almacenan la información en tablas, que son el pilar fundamental
de las bases de datos relacionales. La instrucción SQL que se utiliza para crear una
tabla es CREATE TABLE.
CREATE TABLE nombre_tabla ( definicion_tabla );
La definción de la tabla está compuesta por una lista de sus campos (columnas). Los
campos
CREATE TABLE nombre_tabla (

nombre_campo1 tipo_campo1 atributos_campo1,
nombre_campo2 tipo_campo2 atributos_campo2 ,
...
);

La definición de cada campo, salvo del último, debe termninar en coma. Cada campo
solo puede almacenar un tipo de datos, de momento nos bastará con conocer los
siguientes:
• INT - Almacena números enteros.

• CHAR(longitud ) - Almacena cadenas de texto de un máximo de longitud
caracteres.
• DATE - Almacena fechas
• DATETIME - Almacena fechas con la hora
Los atributos de un campo estarán vacíos en la mayoría de los casos. Aunque hay una
excepción. en casi todas las tablas se suele poner un campo id que contenga un
identificador único de cada registro. A este campo se le dan los atributos:
• PRIMARY KEY - Indica que el campo identifica de forma única el registro

(fila).
• AUTO_ INCREMENT - El campo se rellena automáticamente
incrementándose su valor en 1 cada vez que se añade un registro.
Ejemplo 4.3.3. En este ejemplo se ve la creación de una tabla con datos sobre los
empleados de una empresa.
CREATE TABLE empleados (

id INT PRIMARY KEY AUTO_INCREMENT,
nombre CHAR(50),
puesto CHAR(20),
fecha_nacimiento DATE,
salario INT
);
Los campos que se han definido en la tabla tiene las siguientes características:
• id - Campo de tipo entero que identifica de forma única un registro. Cada vez
que se añade un registro se incrementa automáticamente.
• nombre - Campo que puede almacenar una cadena de hasta 50 caracteres,
destinado a guardar el nombre. No tiene atributos.
• puesto - Campo que puede almacenar una cadena de hasta 20 caracteres,
destinado a guardar el puesto que desempeña. No tiene atributos.
• fecha_nacimiento - Almacena la fecha de nacimiento en formato
YYYY-MM-DD (4 cifras para el año, guión, 2 cifras para el mes, guión, 2
cifras apra el día). No tiene atributos.
• salario - Campo de tipo entero que guarda el sueldo en euros del empleado.
No tiene atributos.

Para ejecutar esta sentencia SQL podemos copiarla y pegarla en la consola de MySQL.
Listar tablas
Para ver todas las tablas que hay disponibles en una base de datos se usa la
instrucción SHOW TABLES.
SHOW TABLES;
Ejemplo 4.3.4. Al listar las tablas de la base de datos comprobamos que solo hay una,
la que acabamos de crear.
Mostrar la definición de una tabla
Esto se hace mediante la sentencia SQL DESCRIBE.
DESCRIBE nombre_tabla ;
Ejemplo 4.3.5. Al mostrar la descripción de la tabla empleados se puede

comporbar que coincide con la definición que hemos puesto al crearla.

Borrar tablas
Para borrar una tabla se usa la sentencia SQL DROP DATABASE. Hay que tener
mucho cuidado ya que al borrar una tabla borramos de forma irrecuperable todos los
datos que hubieramos introducido.
DROP TABLE nombre_tabla ;
Ejemplo 4.3.6. Vamos a eliminar la tabla empleados . Todos los datos que contenga se
borrarán.
Creación de tablas mediante un script
La definición de una base de datos es costosa de escribir y de introducir manualmente

como hemos visto en las ultimas consultas de creación de tablas. Un pequeño error
nos obligará a volver a introducir la consulta.
Para solventar este inconveniente, y dado que SQL es un lenguaje textual,

almacenaremos todas estas consultas en un fichero de texto de extensión .sql , para
distinguirlo de otros ficheros. De esta manera podremos editarlo fácilmente con
cualquier editor de texto plano (sin formato).
Este fichero contendrá (para MySQL) la selección de la base de datos y tantas

consultas de creación (e incialización mediante inserción de datos, para así tener
contenido inicial) como se desee.
Ejemplo 4.3.7. Nuestra base de datos curso_php quedará definida así en el fichero
curso_php.sql .
CREATE DATABASE IF NOT EXISTS curso_php;

USE curso_php;
CREATE TABLE IF NOT EXISTS empleados (
nombre CHAR(50),
puesto CHAR(20),
fecha_nacimiento DATE,
salario INT
);
Nótese que se ha aplicado el modificador IF NOT EXISTS. Su efecto es que crea la

tabla en el caso de que no exista y si existe no muestra ningún mensaje de error.
Este código, como hemos observado, lo guardaremos en un archivo llamado

curso_php.sql . Un buen sitio es la carpeta
C:\CursoPHP\xampplite\htdocs\practicasPHP\sql (que tendremos que crear).
Una vez guardado el script, para ejecutarlo lo haremos con el comando SOURCE:
Operaciones con datos
Ya tenemos la estructura que va a dar soporte a los datos, ahora nos falta saber como
podemos añadirlos, consultarlos, modificarlos y eliminarlos.
Introducir datos en una tabla
Las tablas que hemos creado están vacías, y así sirven de poco. Son como un
armazón, pero para que la base de datos sea útil hemos de introducir datos.
Para insertar un registro en una tabla se usa la sentencia SQL INSERT.
INSERT INTO tabla (campo1, campo2, ...)

VALUES (dato1, dato2, ...);
Ejemplo 4.3.8. Vamos a insertar un primer dato en la tabla empleados. Al igual que en
PHP los datos que son cadenas de texto los ponemos entre comillas, al igual que la
fecha. El campo id no hace falta insertarlo ya que lo hemos definido como
autoincremental.
Ejemplo 4.3.9. Se pueden insertar varios registros (filas) en una tabla con una
sentencia insert, separando los conjuntos de valores entre paréntesis por comas.

Leyendo datos de una tabla
Aquí es donde se despliega la potencia de SQL, que además tiene una sintaxis muy
fácil de comprender. Los datos se leen de la tabla a través de consultas, que son como
preguntas que le hacemos a la base de datos.
La sentencia básica para hacer consultas es SELECT.
SELECT campo1, campo2, ... FROM tabla ;
Ejemplo 4.3.10. Una consulta sobre la tabla empleados.
Ejemplo 4.3.11. En muchos casos querremos seleccionar todos los campos de la

tabla. Para ello se usa el comodín asterísco " * ", de tal forma que esta consulta
muestra exáctamente el mismo resultado que la anterior.
SELECT * FROM tabla ;
Ejemplo 4.3.12. En este caso restringimos el rango de la consulta al campo nombre.

Filtrando datos de una tabla
La clausula WHERE en una consulta SELECT permite poner condiciones de manera

que se nos muestren solo los registros que la cumplen. Esta es la sintaxis de la
sentencia SELECT ampliada con esta cláusula.
SELECT campos FROM tabla WHERE condiciones ;
Ejemplo 4.3.13. Esta consulta devuelve todos los datos de los empleados cuyo salario
es mayor de 1400 euros.
Se pueden unir varias condiciones mediante los operadores lógicos AND, OR y NOT
(cuyo funcionamiento es muy similar a PHP). Se pueden usar paréntesis si se tienen
dudas sobre las reglas de precedencia.
Ejemplo 4.3.14. Empleados que cobran más de 1400 euros y que nacieron antes de
1975.
Ejemplo 4.3.15. Empleados que tabajan de comerciales o programadores.

Ejemplo 4.3.16. Búsqueda textual. En ocasiones se quiere buscar los registros cuyo
texto contiene otro. Para ello, en lugar de comparar con el operador igual " = " se usa el
operdor LIKE y la cadena son la que se compara se pone entre comillas y signos de
porcentaje "%cadena %". Esta consulta muestra los registros cuyo nombre contiene la
cadena "an".
Ordenar datos de una consulta
En muchas ocasiones querremos que los datos devueltos nos lleguen devueltos. Para
ello usaremos con el SELECT la clausula ORDER BY a la que le acompaña el campo
por el que queremos ordenar. En el caso de que haya una clausula WHERE, ORDER
BY ha de ir detras necesariamente. La sintaxis nueva queda de la siguiente forma.
SELECT campos FROM tabla WHERE condiciones ORDER BY campo;
Ejemplo 4.3.17. Aquí se muestran todos los registros de la tabla ordenados por el
nombre del empleado en orden alfabético.
Ejemplo 4.3.18. Mediante el modificador DESC se pueden devolver los resultados en

orden inverso.

Actualizar datos
Además de añadir datos necesitaremos saber como modificar los existentes. La

sentencia UPDATE se encarga de esto. Se suele usar en combinación con una
condición (similar a las que se usan en los SELECT) que filtra los registros a cambiar.
UPDATE tabla SET campo = valor WHERE condiciones;
Ejemplo 4.3.19. Vamos a usar la sentencia UPDATE para subir el sueldo al empleado
Ana. Como la tabla tien un campo id es por este por el que filtraremos. Al final se hace
un SELECT para comprobar que la tabla se ha actualizado.
Ejemplo 4.3.20. Si no filtramos la actuallización se verán afectados todos los registros

de la tabla.

En una sentencia UPDATE se pueden sustituir varios campos a la vez separandolos

por comas.
UPDATE tabla SET campo1 = valor1, campo2 = valor2, ...
Borrado de registros de una tabla
Para el borrado de datos de una tabla se usa la sentencia DELETE. Se suele usar en
combinación con una condición que filtra los datos a borrar, si se usara sola borraría
todos los datos de la tabla. Su uso tiene cierta similitud con el de SELECT, con la
diferencia de que no hay que indicar campos ya que se borra toda la fila.
DELETE FROM tabla WHERE condiciones;
Ejemplo 4.3.21. Borrado del empleado Juan. Una vez más se selecciona por el id .
Ejemplo 4.3.22. Al usar la sentencia DELETE sin filtrar se están borrando todos los
datos de la tabla (pero no su definición). Luego al hacer el SELECT el mensaje Empty
set nos indica que la tabla está vacía.
U.d.4. Funciones de PHP con MySQL

Una vez que conocemos las características básicas de MySQL y las sentencias SQL
que se pueden ejecuar vamos a ver como se integra MySQL con PHP.
Las definiciones de bases de datos y tablas las haremos desde la consola de MySQL
(preferiblemente a través de un script SQL con las sentencias de creación e
inicialización de tablas). La manipulación de datos en cambio se hará desde PHP. Las
operaciones que nos interesan son, por lo tanto:

• Leer datos.
• Añadir datos.
• Modificar datos.
• Eliminar datos.
PHP accede a MySQL a través del API. Dispone de una extensión (biblioteca de
funciones) con muchas funciones para acceder a la base de datos.
Conectar con la base de datos
Antes de empezar a consultar información tenemos que conectar con el sistema gestor
de bases de datos y declarar la base de datos que vamos a usar. Esto se deberá hacer
en cualquier script que posteriormente quiera leer, añadir, modificar o eliminar datos.
mysql_connect()
Esta función conecta el script a un sistema gestor de bases de datos.
mysql_connect(servidor, usuario, contraseña )
Los parámetros que recibe son:
• servidor - Nombre o dirección IP del servidor donde está alojada la base de

datos. Si está instalado en la misma máquina que el servidor web lo normal
es que sea localhost . Se puede elegir un número de puerto diferente del que
se usa por defecto poniendo detras del servidor dos puntos " : " y el número
del puerto. P.ej.: localhost:3340 .
• usuario - Nombre de usuario con privilegios para acceder a la base de datos.
• contraseña - Contraseña del usuario.
Esta función devuelve una referencia a la base de datos que guardaremos en una
variable para usarla en posteriores funciones de PHP con MySQL.
mysql_select_db()
Usa como parámetros la base de datos que queremos seleccionar y la variable en la

que tengamos la referencia a la base de datos. Es equivalente en MySQL a la
sentencia USE.
mysql_select_db(nombre_base_datos , referencia_bd )
Ejemplo 4.4.1. Los ejemplos de esta unidad didáctica usaran la base de datos creada

en la unidad didáctica anterior llamada curso_php con la tabla empleados y con los
cuatro registros creados.
<?php//Conecta a la BD, guarda en la variable $con la referencia a la BD

$con = mysql_connect("localhost", "root", "");
//Selecciona la BD que se va a usar a partir de este
momento.mysql_select_db("curso_php", $conn);
?>
Ejemplo 4.4.2. Una buena idea es guardar el proceso de conexión a la base de datos y
luego utilizarlo en nuestros scripts mediante un include() . Aquí se ha creado el fichero
conectar_bd.php.
<?php
DEFINE(DB_HOST, "localhost");
DEFINE(DB_USER, "root");
DEFINE(DB_PASSWORD, "");
DEFINE(DB_NAME, "curso_php");$con = @mysql_connect(DB_HOST,
DB_USER, DB_PASSWORD);
if (!$con || !mysql_select_db("curso_php", $con)) {
die("Error conectando a la BD: " . mysql_error());
}?>
La función mysql_error() devuelve un texto con el error que se produjo en nuestra

última operación sobre la base de datos. Se ha utilizado la función de PHP die() que
termina la ejecución del script sacando un mensaje por pantalla. También se ha usado
el operador de supresión de errores "@ ".
Al incluir este fichero de configuración en el siguiente script se comporta igual que en

ejemplo 4.4.1., solo que mejorado para emitir mensajes de error.
<?php
include("conectar_bd.php");
echo "Establecida la conexión a la base de datos";
?>
Leer datos
Aquí nos encontramos con la función clave de este capítulo. Se trata de la función
mysql_query() . Su potencia es enorme ya que permite enviar una instrucción SQL,

como las vistas en el capítulo anterior, a la base de datos. Para leer datos la sentencia
que usaremos será obviamente un SELECT.
mysql_query()
La sintaxis de esta función es muy sencilla. La sentencia SQL es la misma que

pondríamos en la consola de MySQL, aunque no es necesario poner el punto y coma
final de la sentencia SQL (que sí al final de la instrucción PHP).
mysql_query(sentencia_SQL , referencia_bd )
Hay que tener en cuenta que esta función solo ejecuta la sentencia, no muestra ningún
dato. Por ello devuelve un identificador del resultado que se usa en otras funciones
para visualizar los valores devueltos por la consulta.
Ejemplo 4.4.3. Aquí se muestra como se ejecuta una sentencia SQL.
<?php
include("conectar_bd.php");$res = mysql_query("SELECT * FROM
empleados", $con);
?>
Ejemplo 4.4.4. Mejoraremos la claridad del código si guardamos la sentencia SQL en

una variable.
<?php
include("conectar_bd.php");$sql = "SELECT * FROM empleados";
$res = mysql_query($sql, $con);
?>
mysql_num_rows()
Antes de acceder al resultado nos interesa saber cuantos registros se han obtenido.
Concretamente una consulta podría no devolver ningún resultado y esto podría causar
un error en nuestro código.
Esta función nos dará el número de filas que tiene un resultado obtenido de una
consulta de tipo select (y sólamente de este tipo, las consultas de
inserción/borrado/actualización tienen otra función, mysql_affected_rows).
mysql_num_rows(identificador_de_resultado )

mysql_result()
De acuerdo, ya hemos ejecutado la sentencia SQL, pero ¿como accedemos al

resultado?. Para ello nos sirve la función mysql_result() .
mysql_result(identificador_de_resultado, fila, nombre_campo )
El campo se puede seleccionar también mediante un número, que es su posición entre

los campos devueltos.
Ejemplo 4.4.5. mysql_result() se suele usar en conjunción con la función

mysql_num_rows() para controlar las filas que se están recuperando. La estructura
ideal es un bucle for . En este ejemplo se muestra una consulta limitada en el rango
(solo se recupera el campo nombre ).
<?php
include("conectar_bd.php");$sql = "SELECT nombre FROM empleados";
$filas = mysql_num_rows($res);
for ($i = 0; $i < $filas; $i++) {
$nombre = mysql_result($res, $i, "nombre");
echo "$nombre<br>";
}?>
Ejemplo 4.4.6. Aquí se pone junto todo lo que hemos visto hasta ahora y se muestra
la tabla empleados dentro de una tabla HTML.
<?php
?>
<table border="1">
<tr>
<td>id</td>
<td>nombre</td>
<td>puesto</td>
<td>fecha_nacimiento</td>
<td>salario</td>
</tr>
<?php include("conectar_bd.php");
$sql = "SELECT * FROM empleados";


for ($i = 0; $i < $filas; $i++) {
echo "<tr>"; $id = mysql_result($res, $i, "id");
echo "<td>$id</td>";
$nombre = mysql_result($res, $i, "nombre");
echo "<td>$nombre</td>";
$puesto = mysql_result($res, $i, "puesto");
echo "<td>$puesto</td>";
$f_nacimiento = mysql_result($res, $i, "fecha_nacimiento");
echo "<td>$f_nacimiento</td>";
$salario = mysql_result($res, $i, "salario");
echo "<td>$salario</td>";
echo "</tr>";
}
?></table>
Ejemplo 4.4.7. Con un pequeño cambio en la sentencia SQL mostraremos las filas
ordenadas por el nombre.
$sql = "SELECT * FROM empleados ORDER BY nombre";
Ejemplo 4.4.8. Y con solo otro pequeño cambio obtenemos un resultado filtrado.
$sql = "SELECT * FROM empleados WHERE salario > 1400";
Ejemplo 4.4.9. Con el sistema que hemos seguido que consiste en separar la
sentencia SQL veamos lo fácil que resulta parametrizar un parámetro de búsqueda.
$salario = 1250;
$sql = "SELECT * FROM empleados WHERE salario > $salario";
mysql_fetch_array()
Es una alternativa a usar mysql_result() a la hora de recuperar los datos. La diferencia

es que en lugar de extraerse las celdas de la tabla de una en una se recupera un array
asociativo por cada fila que tiene como índices los nombres de los campos.
Cada vez que se llama a esta función recupera una de las filas resultado de la consulta,
hasta que no queda ninguna. entonces devuelve FALSE.

mysql_fetch_array(identificador_de_resultado )
Ejemplo 4.4.10. Mediante esta función se puede conseguir un código más compacto, y
que para algunos será más legible. Como cada llamada a la función recupera una fila y
pasa a la siguiente no es necesario recuperar mediante mysql_num_rows() el número
de filas que contiene el resultado. Este código es equivalente al del ejercicio 4.4.6.
<?php
?>
<table border="1">
<tr>
<td>id</td>
<td>nombre</td>
<td>puesto</td>
<td>fecha_nacimiento</td>
<td>salario</td>
</tr>
<?php
$sql = "SELECT * FROM empleados";
$fila = mysql_fetch_array($res);
while($fila) {
echo "<tr>";
echo "<td>{$fila["id"]}</td>";
echo "<td>{$fila["nombre"]}</td>";
echo "<td>{$fila["puesto"]}</td>";
echo "<td>{$fila["fecha_nacimiento"]}</td>";
echo "<td>{$fila["salario"]}</td>";
echo "</tr>";
$fila = mysql_fetch_array($res);
}
?>
</table>
Añadir datos
Para añadir datos no necesitamos conocer nada nuevo. Se usa la función

mysql_query() pero en esta ocasión se encapsula una sentencia SQL INSERT, que

añada datos.
Ejemplo 4.4.11. Vamos a añadir un nuevo empleado. Para ello se usará la sentencia
SQL "parametrizada", como si se hubiesen recibido los datos de un formulario y se
quisieran guardar en la base de datos. Como la consulta es muy larga se ha troceado
en varias líneas usando el operador concatenar cadena " . ".
<?php
$nombre = "Paola";
$puesto = "Programador";
$fecha_nacimiento = "1958-01-23";
$salario = 1800;
$sql = "INSERT INTO empleados "

. "(nombre, puesto, fecha_nacimiento, salario) "
. "VALUES "
. "('$nombre', '$puesto', '$fecha_nacimiento', $salario)";

?>
Podemos comprobar que se ha realizado la inserción tecleando SELECT * FROM

empleados desde la consola de MySQL o ejecutando el código del ejercicio 4.4.6. (o
del 4.4.10.)
Modificar datos
Una vez más usamos la función mysql_query() , con una sentencia SQL del tipo
UPDATE.
Ejemplo 4.4.12. Vamoa a modificar los datos del empleado que ñadimos en la
consulta anterior.
<?php
$id = 5; //id del registro a modificar

$nuevo_salario = 2100;$sql = "UPDATE empleados SET salario =
$nuevo_salario "
. "WHERE id = $id";$res = mysql_query($sql, $con);
?>

Eliminar datos
En esta ocasión usamos la función mysql_query() , con una sentencia SQL del tipo
DELETE.
Ejemplo 4.4.13. Vamos a modificar los datos del empleado que ñadimos en la
consulta anterior.
<?php
$id = 5; //Id del registro a borrar$sql = "DELETE
FROM empleados WHERE id = $id";$res = mysql_query($sql, $con);
?>

Módulo V. Aplicaciones comunes en

PHP
U.D.1. Fecha y hora
Timestamp
El concepto de timestamp procede del mundo Unix/Linux. A nivel interno, PHP guarda
las fechas como un número entero que corresponde con el nº de segundos que han
pasado desde una fecha de referencia, concretamente el 1 de enero de 1970. A este
formato para almacenar una fecha se le llama timestamp .
Ejemplo 5.1.1. Las dos fechas que se muestran a continuación son la misma, solo que
la segunda está en formato timestamp .
Ejemplo 5.1.2. El timestamp tiene la ventaja para PHP de que, al ser un número
entero, es fácil operar con él. Es sencillo sumar, restar o comparar dos fechas. Siempre
que queramos hacer este tipo de operaciones las hemos de hacer en formato
timestamp .

La fecha en formato timestamp tiene la desventaja de que su significado no es obvio.

Afortunadamente PHP ofrece múltiples funciones que sirven para convertir fechas en
formatos timestamp en fechas reconocibles, similares a "12 de octubre de 2005" o
"12/02/2005".
Funciones de fecha y hora
mktime()
Esta función permite crear una marca timestamp para una fecha y hora dados.
mktime(hora, min, seg, mes, día, año )
Es muy importante observar el orden de los argumentos, que no es al que estamos

acostumbrados. Concretamente el mes se encuentra antes del día.
Ejemplo 5.1.3. En este ejemplo se usa la función strftime() para ver la fecha en modo
texto. Su funcionamiento se explica más adelante.
<?php
$fecha = mktime(14, 30, 0, 12, 25, 2005);
strftime("%c", $fecha);
?>
Ejemplo 5.1.4. Nos encontraremos con multitud de ocasiones en las que

necesitaremos conocer la fecha actual. mktime() también se puede usar sin
argumentos para obtener el timestamp del momento actual.
<?php

$fecha = mktime();
strftime("%d/%m/%Y %H:%M:%S", $fecha);
?>
getDate()
Esta función recibe una fecha en formato timestamp y devuelve un array asociativo con
todos los datos de esa fecha.
getDate(timestamp )
Ejemplo 5.1.5. Como es un array asociativo podemos ver su contenido usando la

función print_r() .
<pre>
<?php
$fecha = mktime(); //timestamp del momento actual
$datos_fecha = getDate($fecha);print_r($datos_fecha);
?>
</pre>
Ejemplo 5.1.6. Podemos concatenar los campos de un array asociativo para dar
formato a una fecha.
<?php
$datos_fecha = getDate($fecha);
echo "Hoy es ";
echo$datos_fecha["mday"] . "/" . $datos_fecha["mon"] . "/"
. $datos_fecha["year"] . ".<br>";
echo "Son las ";
echo $datos_fecha["hours"] . ":" . $datos_fecha["minutes"] . ":"
. $datos_fecha["seconds"] . ".<br>";?>
strftime()
Esta función se usa para dar formato a las fechas de forma sencilla.
strftime(formato, timestamp )

La cadena de texto formato está formada por texto corriente mezclado

con especificadores de conversión. Cada especificador de conversión empieza con el
símbolo porcentaje "%". Esta es la lista de los especificadores de los que disponemos.
• %a - nombre del día de la semana abreviado

• %A - nombre del día de la semana completo
• %b - nombre del mes abreviado
• %B - nombre del mes completo
• %c - representación de fecha y hora preferidas en el idioma actual
• %d - día del mes en número (de 00 a 31)
• %H - hora como un número de 00 a 23
• %I - hora como un número de 01 a 12
• %j - día del año como un número de 001 a 366
• %m - mes como un número de 01 a 12
• %M - minuto en número
• %p - `am' o `pm', según la hora dada, o las cadenas correspondientes en el
idioma actual
• %S - segundos en número
• %U - número de la semana en el año, empezando con el primer domingo
como el primer día de la primera semana
• %W - número de la semana en el año, empezando con el primer lunes como
el primer día de la primera semana
• %w - día de la semana en número (el domingo es el 0)
• %x - representación preferida de la fecha sin la hora
• %X - representación preferida de la hora sin la fecha
• %y - año en número de 00 a 99
• %Y - año en número de cuatro cifras
• %Z - nombre o abreviatura de la zona horaria
• %% - carácter "%"
Ejemplo 5.1.7. Este código produce el mismo resultado que el del ejemplo 5.1.6. pero
es mucho más conciso y legible.
<?php
echo strftime("Hoy es %d/%m/%Y", $fecha) . ".<br>";
echo strftime("Son las %H:%M:%S", $fecha) . ".<br>";
?>
Ejemplo 5.1.8. Formateo de una fecha usando diferentes patrones.
<?php
$fecha = mktime(); //timestamp del momento actualecho
strftime("%d/%m/%Y %H:%M:%S", $fecha) . ".<br>";

echo strftime("%A %d de %B de %Y", $fecha) . ".<br>";

echo strftime("%Hh, %Mm y %Ss", $fecha) . ".<br>";
echo strftime("%I:%M %p", $fecha) . ".<br>";
?>
Esta función tiene la ventaja adicional de que nos puede dar la fecha en castellano
(lunes en lugar de monday). Para ello antes hay que informar al servidor de cual es el
idioma que deseamos.
setlocale()
Si se incluye esta función antes de llamar a strftime() se establece que todas las fechas
se darán ahora en el idioma elegido.
strftime(LC_TIME, idioma )
Ejemplo 5.1.9. Vamos a usar esta función para mostrar los resultados del ejemplo
anterior pero esta vez en castellano. La cadena que identifica al idioma castellano es
"esp" en Windows.
<?php
setlocale(LC_TIME ,"esp");
echo strftime("%d/%m/%Y %H:%M:%S", $fecha) . ".<br>";

echo strftime("%A %d de %B de %Y", $fecha) . ".<br>";
echo strftime("%Hh, %Mm y %Ss", $fecha) . ".<br>";
echo strftime("%I:%M %p", $fecha) . ".<br>";
?>
Validación de fechas
checkdate()
En ocasiones, por ejemplo cuando recibamos datos de un formulario, nos interesará

comprobar que la fecha realmente existe. La función checkdate() comprueba que una
fecha es correcta, devolviendo TRUE o FALSE según su validez. Las fechas anteriores
al año 1 no son válidas.

checkdate(mes, día, año )
Una vez más, el orden en el que se introducen los parámetros no es el tradicional. El

més se pone antes que el día.
Ejemplo 5.1.10. No hay un 31 de abril. Y 29 de febrero solo en los años que son
bisiestos.
<?php
$dia = 31;
$mes = 4;$anyo = 2005;
if (checkdate($mes, $dia, $anyo)) { echo "El $dia/$mes/$anyo es una
fecha válida.<br>";
} else { echo "El $dia/$mes/$anyo no existe.<br>";
}$dia = 29;
$mes = 2;
$anyo = 2005;if (checkdate($mes, $dia, $anyo)) {
echo "El $dia/$mes/$anyo es una fecha válida.<br>";
}
$dia = 29;
$mes = 2;
$anyo = 2004;
if (checkdate($mes, $dia, $anyo)) {
echo "El $dia/$mes/$anyo es una fecha válida.<br>";
}?>
U.D.2. Envío de emails

Consideraciones preliminares
El envío de emails no se puede hacer directamente desde PHP. PHP se limita a

encargar a un servidor de correo SMTP que envíe el mail y es este quien pone el
correo en la red. Por lo tanto para poder enviar emails necesitaremos, además del
servidor web un servidor SMTP al que tengamos acceso.
Esto puede resultar complicado ya que podemos no disponer de un servidor SMTP.

También puede suceder que aunque dispongamos de un servidor de SMTP no poder
usarlo de forma remota por motivos de seguridad.

Desafortunadamente el paquete Xampp, en la versión Lite que hemos elegido para

este curso no dispone de un servidor de correo SMTP, así que para poder probar los
ejemplos de este curso habrá que buscar uno.
Configuración del correo
Para configurar el correo tendremos que proporcionarle a la configuración de PHP el

nombre del servidor SMTP y una dirección de una cuenta de correo alojada en dicho
servidor. Para ello se usa la función init_set() con la que hay que configurar dos
parámetros.
ini_set("SMTP", nombre_servidor_SMTP )
ini_set("sendmail_from", dirección_email )
Ejemplo 5.2.1. Los usuarios de Microsoft Outlook Express probablemente podrán

hacer uso de la cuenta de email que tengan configurada. Por un lado han de poner su
dirección de correo electrónico y por otro el nombre del servidor SMTP. Este último se
puede encontrar en Menú Herramientas --> Cuentas --> Botón Propiedades -->
Lengüeta Servidores.
<?php
ini_set("SMTP", "smtp.pernambuco.com");

ini_set("sendmail_from", "juanpalomo @pernambuco.com ");

?>
Esta configuración se puede guardar en un archivo de configuración específico para el

email llamado email_config.php o bien en un archivo de configuración de uso más
general. Será imprescindible importarla antes de usar la función mail() .
Envío de emails desde PHP
Si bien configurar el servidor de correo electrónico puede ser complicado, una vez
hecho el envío de emails no puede ser más sencillo.
mail()
La función mail() tiene sólo tres parámetros. La dirección de correo del destinatario, el
asunto del correo y el contenido del mismo.
mail(destinatario, asunto, mensaje);
Para crear saltos de línea en el cuerpo del mensaje se utiliza la cadena "\n\r" que
simboliza un salto de línea en Windows.
Ejemplo 5.2.2. Para probar este script se puede poner como dirección de destino la de
una cuenta a la que tengamos acceso. El mansaje, al ser muy largo, se ha escrito en
varias líneas usando el operador concatenar " . ".
<?php
include("email_config.php");
$destinatario = "pedro@madagascar.com ";

$asunto = "El sábado al cine.";
$mensaje = "Hemos quedado el sábado a las 9 en el cine Odeón.\r\n"
. "Avisa si no puedes venir.\r\n"
. "\r\n"
. " Juan";
if (mail($destinatario, $asunto, $mensaje)) {

echo "El mensaje se ha enviado con éxito.";
} else {
echo "No se ha podido enviar el mensaje.";
}

?>
Ejemplo 5.2.3. En la forma anterior no nos resulta muy útil. Sería mejor si añadieramos
un formulario para elegir el destinatario, el asunto y redactar el correo.
• mail_form.html
<html>
<head>
<title>Enviar correo electrónico</title>
</head>
<body>
<form name="mail_form" method="post" action="enviar_mail.php">
Destinatario:<br>
<input type="text" name="destinatario" size="53"></br>
Asunto:<br>
<input type="text" name="asunto" size="53"></br>
Mensaje:<br>
<textarea name="mensaje" rows="5" cols="40"></textarea></br>
<input type="submit" value="Enviar correo"></br>
</form>
</body>
</html>
• enviar_mail.php
<?php
include("email_config.php");
//Las variables $destinatario, $asunto y mensaje se extraen

// directamente del formulario
if (mail($destinatario, $asunto, $mensaje)) {
echo "El mensaje se ha enviado con éxito.";
} else {
echo "No se ha podido enviar el mensaje.";
}
?>
El aspecto que tendrá el formulario es el siguiente.

U.D.3. Sesiones
Las sesiones se usan siempre que haya que dar servicios personalizados o de
identificación. El protocolo HTTP es un protocolo sin estado. Esto significa que no hay
manera de que un servidor web sepa qué estámos haciendo mientras navegamos por
un sitio web, a no ser que pueda identificar/marcar al cliente (el navegante) de algún
modo, para que, posteriores peticiones de este nos digan quién es.
Por supuesto, con una página dinámica en PHP podemos guardar información en algún
sitio (un fichero, una base de datos), pero las aplicaciones web no se componen de una
sola página sino de varias, así que necesitaremos de algún mecanismo que nos facilite
el almacenaje de datos temporales relativos a una navegación (llamada sesión).
PHP incorpora el manejo de las sesiones de serie, y de manera muy simple,

escondiendo la complejidad que tiene el proceso tras el protocolo HTTP. Para el
manejo de sesiones PHP incorpora una serie de funciones que permiten iniciar/terminar
una sesión así como funciones de escritura/lectura en la sesión.
Funciones para manejar sesiones
El uso de sesiónes en PHP se define en tres sencillos pasos:
1. Inicio de sesión. La primera página crea la sesión.

2. Uso de la sesión. Las páginas que forman parte de la aplicación

hacen uso de la sesión. Durante este transcurso se pueden escribir y
leer datos en la sesión.
3. Finalización de la sesión. La página de salida destruye la sesión.
session_start()
Esta función se usa para iniciar una sesión. Basta con incluirla al principio
de cada página que vaya a usar sesiones. Eso sí, debe ir antes de cualquier código
HTML, si no es así dará error.
Ejemplo 5.3.1. El primer código es correcto mientras que si probamos el segundo nos
dará un error. Este es un motivo adicional por el que es recomendable acostumbrarse a
poner el código PHP al principio de la página web.
<?php
//Lo primero que se hace es crear la sesión
session_start();
?>
<html>
<head>
<title>Esta página es correcta</title>
</head>
//...
<html>
<head>
<title>Esta página da error</title>
</head>
<?php
//Esto dará error ya que hay código HTML antessession_start();
?>
//...
session_id()
Todas las sesiones tienen un número que las identifica de forma única. En ocasiones
puede ser útil conocerlo y para eso se usa esta función.
session_destroy()
Mediante esta función se destruyen todos los datos que pudiera tener asociada la

sesión actual. En la página de salida es conveniente poner una llamada explícita a esta
función. Si se la llama se destruye la sesión y todos los datos asociada.
Ejemplo 5.3.2. Un caso básico. En iniciar_sesion.php se crea la sesión, en

sesion_activa.php se hace uso de ella mostrando su id y en finalizar_sesion.php se
destruye la sesión.
• iniciar_sesion.php
<?php
session_start();
?>
Sesión iniciada con id <?= session_id() ?>.<br>
<a href="sesion_activa.php">Seguir</a>
• sesion_activa.php
<?php
session_start();
?>
Sesión activa con id <?= session_id() ?>.<br>
<a href="finalizar_sesion.php">Salir</a>
• finalizar_sesion.php
<?php
session_start();
?>
Destruidos los datos asociados a la sesión <?= session_id() ?>.
<?php
session_destroy();
?>
Aunque es conveniente llamarla para destruir la sesión cuando haya dejado de ser útil
lo habitual es que los usuarios de Internet abandonen nuestra página web cerrando el
navegador y por lo tanto no tendremos ocasión de saber que la sesión ha dejado de ser
necesaria.
Afortunadamente el servidor web dispone de mecanismos para eliminar una sesión sin
nuestra intervención poniéndoles un tiempo de caducidad.

Variables de sesión
Una de las características que nos aportan las sesiónes es parala posibilidad de dar
persistencia a ciertos datos a través de diferentes páginas.
En las versiones actuales de PHP esto es muy sencillo ya que se usa el array global
$_SESSION. Este es un array asociativo (parejas de nombre -> valor), que está
disponible en todas las páginas a partir del momento que se haya iniciado la sesión con
session_start() . A este array le podemos añadir elementos o modificarlos de la forma
que ya conocemos.
Las variables que queremos que estén disponibles en todas las páginas las
guardaremos en este array.
Ejemplo 5.3.3. Aquí se modifica el ejemplo anterior para, al iniciar la sesión, añadirle la
fecha y hora de comienzo como parámetro. También se guarda un contador con las
páginas visitadas. Esta información se muestra luego en las páginas intermedias y en
la final se muestra la duración de la sesión junto con un mensaje de despedida.
• iniciar_sesion.php
<?php
session_start();
//Almaceno en la sesión el instante actual.

$comienzo = mktime();
$_SESSION["comienzo"] = $comienzo;
//Inicializo el contador de páginas vistas.

$_SESSION["contador"] = 1;
?>
Sesión iniciada el día

<?= strftime("%d/%m/%Y", $_SESSION["comienzo"]) ?>
a las
<?= strftime("%H:%M:%S", $_SESSION["comienzo"]) ?><br>
<a href="sesion_activa.php">Seguir</a>

• sesion_activa.php
<?php
session_start();
//Incremento el contador de páginas vistas

$_SESSION["contador"]++;
?>
Sesión activa desde el día

<?= strftime("%d/%m/%Y", $_SESSION["comienzo"]) ?>
a las
<?= strftime("%H:%M:%S", $_SESSION["comienzo"]) ?><br>
Páginas visitadas
<?= $_SESSION["contador"] ?>.<br>
<a href="sesion_activa.php">Seguir</a> - -
<a href="finalizar_sesion.php">Salir</a>
• finalizar_sesion.php
<?php
session_start();
//Incremento el contador de páginas vistas

$_SESSION["contador"]++;
//Calculo la duración en segundos de la sesión.

$ahora = mktime();
$duracion = $ahora - $_SESSION["comienzo"];
?>
La sesión ha durado
<?= floor($duracion / 3600) ?>h
<?= floor(($duracion % 3600) / 60) ?>m
<?= floor(($duracion % 60)) ?>s.<br>
En ese tiempo ha visitado
<?= $_SESSION["contador"] ?> páginas.<br>
<?php
session_destroy();
?>
En finalizar_sesion.php se han usado operaciones matemáticas básicas para convertir

una duración en segundos a un formato de horas, minutos y segundos.
Usos prácticos de las sesiones
La persistencia de datos hace posible programar en Internet aplicaciones complejas.

Algunas de las funciones populares que se programan haciendo uso de sesiones son
las siguientes.
• Control de acceso: Es uno de los usos principales, se piden unos

credenciales al usuario (p.ej: correo-e y contraseña en un formulario), estos
se comprueban con los existentes en la base de datos y si se autoriza el
acceso, se inicia una sesión. En dicha sesión se almacena un identificador
del usuario, de manera que no hay que autenticar al usuario en cada página.
Esta sesión caducará automáticamente por seguridad, o permitiremos que el
usuario salga de la aplicación.
• Personalización: Un usuario puede preferir ciertos
colores/propiedades/elementos en una aplicación web, y estos se mantienen
por todas las páginas de la aplicación.
• Comercio electrónico: Manteniendo las compras del usuario en un carrito

virtual, hasta que decida pagar. El carrito se almacena en la sesión y se

puede mostrar en cada página de una tienda virtual. En dicho carrito se
añaden/quitan productos, el usuario se puede marchar a ver otra página y
volver a la tienda y ahi está su carrito (mientras dure la sesión).
• Replicación de aplicaciones web: Los sitios web con muchas visitas
pueden necesitar de mas de un servidor web o base de datos por si falla
algo. Las sesiones se replican entre todos los servidores, de manera que el
usuario no pierde su información (p.ej: su compra) en caso de falla.
U.D.4. Control de acceso

De los usos habituales de las sesiones vamos a desarrollar más a fondo el control de
acceso ya que es seguro que habrá alguna página que queramos que tenga acceso
restringido .
Para ello lo habitual es disponer de un formulario en el que se pida el nombre de

usuario y la contraseña y una zona privada de páginas a las que solo se puede acceder
si se ha autentificado. Esto mismo se puede decir de forma más ortodoxa:
Ejemplo 5.4.1. Este sistema de control de acceso está compuesto por cuatro págionas.
acceso.html es un formulario web que solicita un nombre de usuario y contraseña.
Estos datos llegan a autenticar.php que comprueba si son válidos. Si es así añade a la
sesión una variable autorizado con el valor "si" y redirecciona a la página
zona_privada.php. Si la contraseña introducida es erronea redirecciona a la página
no_autorizado.php y muestra un error y ofrece un enlace para volver a registrarse.
No basta con redireccionar a la zona privada si la contraseña es correcta. Las páginas

de la zona privada han de tener un código al principio que comprueba que el usuario
está autorizado (mediantte la variable autorizado). De no ser así se podría acceder a
ellas escribiendo la URL en la barra de direcciones del navegador.
Si se intenta acceder a una página protegida de la zona privada y no es ha pasado por

el proceso de autenticarse se redirecciona a la página de error.
Este sistema es similar al que se usa en un parque de atracciones. Al entrar te ponen

una pulsera (autenticación ) y posteriormente, en cada atracción a la que se desea
entrar comprueban que llevas la pulsera (autorización ).
Se incluye también una página salir.php para destruir la sesión cuando se sale de la
zona privada.

• acceso.html
<html>
<head>
<title>Acceso a la zona privada</title>
</head>
<body>
Introduzca sus datos.
<table>
<form name="acceso" method="POST" action="autenticar.php">
<tr>
<td>Usuario: </td>
<td><input type="text" name="usuario" size="20"></td>
</tr>
<tr>
<td>Contraseña: </td>
<td><input type="text" name="contrasena" size="20"></td>
</tr>
<tr>
<td colspan="2" align="right">
<input type="submit" value="Entrar">
</td>
</tr>
</form>
</table>
</body>
</html>
• autenticar.php
<?php

session_start();if (($usuario == "alicia") && ($contrasena == "xanadu")) {

//Marco la sesión como autorizada
$_SESSION["autorizado"] = TRUE;
//Redirecciono a la zona privada

header("location:zona_privada.php");
} else {
session_destroy();
//Redirecciono a la página de acceso denegado

header("location:no_autorizado.html");
}
?>
• zona_privada.php
<?php
session_start();if (!$_SESSION["autorizado"]) {
}
?>
Bienvenido a la zona privada.<br>
<a href="salir.php">Salir</a>
• no_autorizado.php
<html>
<head>
<title>Acceso denegado</title>
</head>
<body>
<b>Acceso denegado.</b><br>
La página a la que intenta acceder requiere autenticación.<br>
<a href="acceso.html">Ir a la página de entrada.</a>
</body>
</html>
• salir.php
<?php

session_start();
session_destroy();
?>
Gracias por utilizar nuestros servicios.<br>
<a href="acceso.html">Ir a la página de entrada.</a>
Ejemplo 5.4.2. Una primera mejora obvia es extraer el código que comprueba si un
usuario está autorizado a una biblioteca (en este caso autorizar.php ) e incorporarlo a
cada página de la zona privada mediante un simple include() .
• autorizar.php
<?php
session_start();
if (!$_SESSION["autorizado"]) {
}
?>
• zona_privada.php
<?php
include("autorizar.php");
?>
Bienvenido a la zona privada.<br>
<a href="salir.php">Salir</a>
Ejemplo 5.4.3. Una segunda mejora obvia es crear un archivo externo que contenga
los datos de los usuarios del sistema. Hay que crear este archivo (usuarios.php ) y
modificar autenticar.php.
• usuarios.php
<?php
//Array asociativo que contiene los usuarios registrados
$contrasenas["alicia"] = "xanadu";
$contrasenas["alberto"] = "catai";
$contrasenas["marta"] = "bombay";
?>

• autenticar.php
<?php
include("usuarios.php");
session_start();
if (($contrasenas[$usuario] == $contrasena)) {

} else {
session_destroy();

}
?>
Ejemplo 5.4.4. Si se necesita una gestión un poco más avanzada de los usuarios se
puede hacer uso de la base de datos MySQL. En el script usuarios.sql se incluye una
definición de la tabla usuarios y su inicialización con unos pocos datos. En el código
PHP sólo hay que modificar el archivo autenticar.php . En este ejemplo se usa el
archivo importado conectar_bd.php mostrado en el ejemplo 4.4.2. para establecer la
conexión a la base de datos
• usuarios.sql

USE curso_php;
/* Definición de la tabla de usuarios */
CREATE TABLE IF NOT EXISTS usuarios(
usuario CHAR(20),
contrasena CHAR(20)
);/* Inicialización de la tabla de usuarios */INSERT INTO usuarios (usuario,
contrasena)
VALUES ("alicia", "xanadu"),
("alberto", "catai"),
("marta", "bombay");

• autenticar.php
<?php
session_start();
//Busco en la base de datos el usuario

$sql = "SELECT * FROM usuarios WHERE "
. "usuario = '$usuario' "
. "AND contrasena = '$contrasena'";
if ($filas != 0) {

} else {
session_destroy();

}
?>
Al confrontar con los bases de datos no es ni siquiera necesario ver el resultado de la

consulta, nos basta con saber el número de líneas devueltas. Si la consulta devuelve 0
registros (filas) es porque no ha tenido éxito al buscar al usuario cuyos datos han sido
introducidos en el formulario.
U.D.5. Registro de accesos

Apache tiene registros que miden el tráfico en nuestra página web y que,
en combinación con programas como AWStats procesan esta información sobre
accesos a nuestro sitio y la muestran en páginas web con gráficas explicativas.
Pero puede haber casos en los que queramos registrar determinados eventos y asociar
esta información a la persona que los está produciendo. El evento más típico en este
caso es un acceso a la zona privada de nuestra página web.

Registro de accesos en un fichero de texto
Esta es la forma más sencilla. Hay un fichero en el servidor que guarda en cada línea
un intento de acceso. Se va a optar por un diseño modular que, como se verá más
adelante, tiene muchas ventajas.
Ejemplo 5.5.1. Tomamos como base el ejemplo 5.4.4. de la unidad didáctica anterior.
Se supone que ya existe la tabla usuarios . En este caso le vamos a añadir una función
registrar_acceso() que recibe un id de usuario y graba un registro de su entrada. Si se
le pasa el valor -1 graba un intento fallido de entrada.
<?php// Función que registra la entrada de un usuario

//Si recibe una id de usuario -1 es que el acceso ha sido fallido
function registrar_acceso($id_usuario) {
$ahora = mktime();
$mensaje = strftime("%d-%m-%Y %H:%M:%S ", $ahora); if ($id_usuario
!= -1) {
$mensaje .= "El usuario con id $id_usuario "
. "ha entrado a la zona privada.";
} else {
$mensaje .= "Intento fallido de acceso a la zona privada.";
}
$archivo = fopen("accesos.txt", "a");
fwrite($archivo, "$mensaje\r\n");
fclose($archivo);
}?>
Este es el programa completo autenticar.php (se han eliminado algunos comentarios

para darle mayor claridad).
<?php
// Función que registra la entrada de un usuario

//Si recibe una id de usuario -1 es que el acceso ha sido fallido
$ahora = mktime();
$mensaje = strftime("%d-%m-%Y %H:%M:%S ", $ahora);
if ($id_usuario != -1) {
$mensaje .= "El usuario con id $id_usuario "
. "ha entrado a la zona privada.";

} else {
$mensaje .= "Intento fallido de acceso a la zona privada.";
}
$archivo = fopen("accesos.txt", "a");
fwrite($archivo, "$mensaje\r\n");
fclose($archivo);
}
session_start();

$res = mysql_query($sql, $con);if (mysql_num_rows($res) != 0) {
$_SESSION["autorizado"] = TRUE; $id = mysql_result($res, 0, "id");
registrar_acceso($id); header("location:zona_privada.php");
} else {
session_destroy(); registrar_acceso(-1);
}
?>
Tras varios accesos a esta página podemos ver el siguiente registro.
Registro de accesos en la base de datos
En lugar de guardar el acceso en un fichero de textos también se puede guardar en la

base de datos. Para ello necesitaremos una tabla que llamaremos accesos y cuya
definición es la siguiente.

USE curso_php;
/* Definición de la tabla de usuarios */
CREATE TABLE IF NOT EXISTS accesos(

id_usuario INT PRIMARY KEY AUTO_INCREMENT,

hora_acceso DATETIME);
Ejemplo 5.5.2. Para guardar en la base de datos solo ha sido necesario modificar la
función registrar_acceso.
<?phpinclude("conectar_bd.php");
// Función que registra la entrada de un usuario
// Si recibe una id de usuario -1 es que el acceso ha sido fallido
global $con; $ahora = mktime();
$fecha_mysql = strftime("%Y-%m-%d %H:%M:%S ", $ahora); $sql =
"INSERT INTO accesos (id_usuario, hora_acceso) "
. "VALUES ($id_usuario, '$fecha_mysql')";
mysql_query($sql, $con);
}?>
En esta ocasión los accesos se pueden ver mediante la consola de MySQL.
Registro de eventos asociados a un usuario
Para poder registrar otros eventos de un usuario, aparte del acceso, la aplicación web
tiene que conocer en todo momento qué usuario es el activo. Para ello, al autenticar a
un usuario, hay que guardar su identidad en una variable de sesión.
Ejemplo 5.5.3. Hemos modificado el código de autenticar.php para almacenar una

nueva variable de sesión con el id del usuario. Este id se puede usar más adelante
para personalizar los contenidos de las páginas que vea el usaurio, además de para
crear un registro de sus acciones.
<?php
session_start();


if (mysql_num_rows($res) != 0) {
$id = mysql_result($res, 0, "id");

$_SESSION["id_usuario"] = $id; registrar_acceso($id);
} else {
session_destroy();
registrar_acceso(-1); header("location:no_autorizado.html");
}
?>
U.D.6. Plantillas
Uno de los objetivos que hemos ido persiguiendo a lo largo del curso es la separación
del código HTML del PHP. Los sistemas plantillas suponen una contribución en este
sentido ya que separan en diferentes archivos la presentación (el código HTML con el
diseño) de la lógica (el código PHP que realiza operaciones con los datos.
DTemplate
PHP no incorpora ningún sistema de plantilas en la librería de funciones del núcleo por
lo que tendremos que hacer uso de una librería desarrollada por un tercero. En este
caso hemos elegido la librería DTemplate desarrollada por Peter Mallet por los
siguientes ventajas.
• Es muy fácil de instalar.

• Es fácil aprender su funcionamiento.
Otros sistemas de plantillas más avanzados y completos usan una sintaxis similar a
DTemplate, por lo que podremos aplicar lo que aprendamos a esos sistemas si
preferimos una versión más potente.
DTemplate se puede descargar desde este enlace.
http://prdownloads.sourceforge.net/dtemplate/dtemplate-120.zip

Instalación
DTemplate no requiere ninguna instalación especial. Lo único necesario es que el

archivo class.DTemplate.php se encuentre en el mismo directorio que las páginas PHP
que usan plantillas.
Esquema de funcionamiento
Para usar plantillas hay que seguir los siguientes pasos.
• Definir la plantilla y sus variables.

• Usar la plantilla dentro de la página PHP. Esto consta de:
• • Crear una instancia de la librería y asociarla a la plantilla que
queremos usar.
• Asignar valores a las variables.
• Interpretar la plantilla y mostrarla.
Definición de la plantilla
Una plantilla es un documento que contiene exclusivamente código HTML y variables.

Hay que crearla independientemente del código PHP. Algunas aplicaciones de diseño
web se pueden configurar para trabajar con plantillas.
Las plantillas las guardaremos con la extensión .tpl (del inglés template).
Es importante tener en cuenta que no se puede poner código PHP en las plantillas.
Variables de plantilla
Las variables en las plantilas las reconoceremos porque se escriben entre corchetes " {
... } " y contienen un identificador de la variable que normalmente escribiremos en
mayúsculas y sin espacios en blanco. No hay que confundir las variables de plantilla
con las variables de PHP.
{VARIABLE }
Ejemplo 5.6.1. La siguiente es una plantilla muy sencilla que tiene como variables el
título de la página y el mensaje dentro del cuerpo de la misma. La guardaremos con el
nombre plantilla_mensaje.tpl.
<html>
<head>

<title>{TITULO}</title>
</head>
<body>
{MENSAJE}
</body>
</html>
Uso de la plantilla dentro de la página PHP
Antes de hacer uso de la librería hay que importarla mediante la sentencia include() .
<?php
include("class.DTemplate.php");
//...
En primer lugar hay que crear una instancia de la librería y asignarla a una variable.
Esto se hace con la instrucción new de la siguiente forma.
$tpl = new DTemplate();
Una vez creada una instancia de la librería, para hacer uso de las funciones de la
librería lo haremos con la siguiente sintaxis.
$tpl -> funcion_de_DTemplate ();
define_template()
La primera función que usaremos nos servira para indicarle a la librería donde se
encuentran los archivos .tpl con definiciones de plantillas. Esta función asocia un
identificador a una plantilla.
$tpl -> define_template("identificador ", "plantilla.tpl ");
Si son varias las plantillas podemos definirlas sucesivamente llamando una vez a esta
función por cada plantilla.
assign()

Esta función asigna un valor a una variable que esté presente en una definición de
plantilla. Hay que asignar valores a todas las variables que aparezcan en la plantilla.
$tpl -> assign("VARIABLE ", valor );
process()
En este paso se interpretan las variables de la plantilla sustituyéndolas por los valores
que se les dieron al asignarlas.
$tpl -> process(identificador_plantilla );
DPrint()
Al final del script PHP hay que llamar a esta función para que pinte el resultado por
pantalla.
$tpl -> DPrint(identificador_plantilla );
Ejemplo 5.6.2. Parecen muchas funciones y su uso un tanto enrevesado. Pero

su aplicación es inmediata, solo hay que estar pendiente de cuales son las variables de
plantilla. Afortunadamente como las escribimos en mayúsculas resulta fácil
distinguirlas. Haremos uso de la definición de plantilla plantilla_mensaje.tpl que se creó
en el ejemplo anterior.
<?php
$titulo = "Prueba de plantillas";

$mensaje = "¡Hola Mundo!";

$tpl -> define_template("plantilla", "plantilla_mensaje.tpl");
$tpl -> assign("TITULO", "$titulo");
$tpl -> assign("MENSAJE", "$mensaje");
$tpl -> process("plantilla");
$tpl -> DPrint("plantilla");
?>
Plantillas anidadas

Al igual que se le puede asignar a una variable de plantilla un valor, se le puede asignar
también el resultado de procesar una plantilla. De esta forma se pueden componer
páginas con muchos elementos a partir de trozos de código sencillos.
fetch()
La función fetch() nos resultará útil para conocer el resultado de la plantilla ya

procesada. Este resultado se usará luego como contenido de otra plantilla.
$tpl -> fetch(identificador_plantilla );
Ejemplo 5.6.3. Aquí se usa una plantilla principal cuyas dos variables
{DATOS_COMERCIO} y {LISTA_PRECIOS} se rellenan haciendo uso de otras dos
plantillas, una con los datos de una frutería y otra con una lista de precios.
• Plantilla ficha.tpl
<html>
<head>
<title>Ficha del establecimiento</title>
</head>
<body>
{DATOS}<br>
<hr>
{LISTA_PRECIOS}</body>
</html>
• Plantilla datos.tpl
<b>{NOMBRE}</b><br>
{DIRECCION}<br>
{TELEFONO}<br>
<a href="mailto:{EMAIL}">{EMAIL}</a>
• Plantilla lista_precios.tpl
{PRECIOS}
El código PHP modificado que procesa las plantillas es el siguiente.

• ficha_comercio.php
<?php
$nombre_comercio = "Frutería Pernambuco";

$direccion_comercio = "c/ Don Juan Tenorio 17";
$tfno_comercio = "866 713 137";
$email_comercio = "maurodosantos@pernambuco.com ";
$productos = array("Limones", "Naranjas", "Peras", "Tomates");
$precioskg = array("Limones" => 3.50,
"Naranjas" => 1.80,
"Peras" => 1.20,
"Tomates" => 2.40);

$tpl -> define_template("ficha", "ficha.tpl");
$tpl -> define_template("datos", "datos.tpl");
$tpl -> define_template("lista_precios", "lista_precios.tpl");
//Asignamos primero valores a la plantilla datos

$tpl -> assign("NOMBRE", $nombre_comercio);
$tpl -> assign("DIRECCION", $direccion_comercio);
$tpl -> assign("TELEFONO", $tfno_comercio);
$tpl -> assign("EMAIL", $email_comercio);
$tpl -> process("datos");
//Asignamos los valores a la plantilla con la lista de precios

$precios = "";
for ($i = 0; $i < count($productos); $i++) {
$precios .= "$productos[$i] {$precioskg[$productos[$i]]} "
. "euros/kg<br>";
}
$tpl -> assign("PRECIOS", $precios);
$tpl -> process("lista_precios");
//Juntamos las dos plantillas procesadas dentro de la ficha

$tpl -> assign("DATOS", $tpl -> fetch("datos"));
$tpl -> assign("LISTA_PRECIOS", $tpl -> fetch("lista_precios"));
$tpl -> process("ficha");
$tpl -> DPrint("ficha");
?>

Plantillas anidadas en bucles
Esta estrategia se sigue en plantillas en las que hay un tipo de elemento que se repite
muchas veces, como pueden ser las filas de un listado.
Ejemplo 5.6.4. Sería mucho más práctico poner la lista de precios en una tabla. El
problema es que con los mecanismos que conocemos hasta ahora esto nos requeriría
guardar en una variable también las etiquetas de comienzo y final de fila y de comienzo
y final de celda <tr><td>...</td></tr> .
En lugar de esto vamos a hacer una nueva plantilla para cada fila.
• Plantilla producto.tpl
<tr>
<td>{NOMBRE_PRODUCTO}</td>
<td align="right">{PRECIO} euros el kg.</td>
</tr>
También hay que adaptar la plantilla lista_precios.tpl para que use una tabla.
• Plantilla lista_precios.tpl
<table border="1" width="300">

{PRODUCTO}
</table>
El código PHP modificado que procesa las plantillas es el siguiente.
• ficha_comercio.php
<?php
$titulo = "Ficha";
$nombre_comercio = "Frutería Pernambuco";
$direccion_comercio = "c/ Don Juan Tenorio 17";
$tfno_comercio = "866 713 137";
$email_comercio = "maurodosantos@pernambuco.com ";
$productos = array("Limones", "Naranjas", "Peras", "Tomates");
$precioskg = array("Limones" => 3.50,
"Naranjas" => 1.80,
"Peras" => 1.20,

"Tomates" => 2.40);

$tpl -> define_template("ficha", "ficha.tpl");
$tpl -> define_template("datos", "datos.tpl");
$tpl -> define_template("lista_precios", "lista_precios.tpl");
$tpl -> define_template("producto", "producto.tpl");
//Asignamos primero valores a la plantilla datos

$tpl -> assign("NOMBRE", $nombre_comercio);
$tpl -> assign("DIRECCION", $direccion_comercio);
$tpl -> assign("TELEFONO", $tfno_comercio);
$tpl -> assign("EMAIL", $email_comercio);
$tpl -> process("datos");
//Añadimos una a una las filas

for ($i = 0; $i < count($productos); $i++) {
$tpl -> assign("NOMBRE_PRODUCTO", $productos[$i]);
$tpl -> assign("PRECIO", $precioskg[$productos[$i]]);
//Es necesario procesar una vez por cada fila

$tpl -> process("producto");
}
//Asignamos este resultado a la plantilla lista_precios

$tpl -> assign("PRODUCTO", $tpl -> fetch("producto"));
$tpl -> process("lista_precios");
//Juntamos las dos plantillas procesadas dentro de la ficha

$tpl -> assign("TITULO", $titulo);
$tpl -> assign("DATOS", $tpl -> fetch("datos"));
$tpl -> assign("LISTA_PRECIOS", $tpl -> fetch("lista_precios"));
$tpl -> process("ficha");
$tpl -> DPrint("ficha");
?>
El resultado final es el siguiente.

La librería DTemplate tiene muchas otras funciones y otros modos de acceder a las
mismas que pueden servir para múltiples situaciones. Quien esté interesado puede
ampliar conocimientos con la documentación del producto.
Plataforma de Teleformación de IFES Página 143 de

143

Programacionen PHP

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Programacionen PHP

Încărcat de

Drepturi de autor:

Formate disponibile

Programación en PHP

Plataforma de Teleformación de IFES Página 1 de 143

U.D.3. Sesiones........................................................ 120

Página 2 de 143 Programación en PHP

Para compensar esta falta de interactividad aparecieron los lenguajes de programación

Con la llegada de los lenguajes de servidor aparecieron las primeras páginas

Generación de páginas web

Plataforma de Teleformación de IFES Página 3 de 143

Elementos del proceso:

a) Navegador - Aplicación que permite al usuario recibir y mostrar

El término servidor web se usa indistintamente para denominar tanto al ordenador

Página 4 de 143 Programación en PHP

Ahora hay un nuevo elemento, el servidor de aplicación.

f) Servidor de aplicación - Es el programa que colabora con el servidor

A diferencia de las páginas estáticas, en las que se guardaba en el disco duro el

Lenguajes de programación web

Pero el uso de lenguajes de uso general hacía complicado el proceso de construir

Plataforma de Teleformación de IFES Página 5 de 143

Afortunadamente hoy en día el panorama ha cambiado radicalmente. El éxito de

• Ser de fácil uso, para permitir una curva de aprendizaje sencilla.

ASP- Active Server Pages

Esta es una tecnología propietaria de Microsoft. Actualmente está engloba en su

JSP - Java Server Pages

PHP - PHP Hypertext Preprocessor

U.D.2. ¿Qué es PHP?

Página 6 de 143 Programación en PHP

En el año 1994 el programador danes-canadiense Rasmus Lerdorf lo creo para poder

En 1999 reescribieron el lenguaje y lo dotaron de mayor eficiencia mediante el motor

A nivel técnico se pueden destacar los siguientes aspectos:

• Es un lenguaje interpretado (también llamado de tipo script).

Plataforma de Teleformación de IFES Página 7 de 143

Postgres, Oracle, SQL Server...

Un uso común es dotar a una aplicación web de un servidor de base de datos, en el

¿Por qué PHP?

Hay muchas razones para aprender a usar PHP:

• Como ya se ha dicho con anterioridad el aprendizaje de este lenguaje es

Página 8 de 143 Programación en PHP

expertos arreglando errores y aportando mejoras, los usuarios testeando el

U.D.3. ¿Qué es apache?

Apache se ha ganado la confianza de los usuarios principalmente debido a las

• Es muy eficiente, robusto y seguro.

La mayor objeción que se le ha puesto a Apache es que no dispone de un modo gráfico

Durante este curso se propone la utilización de Apache como servidor al que se le

Otros servidores web

La principal alternativa a Apache es el servidor HTTP de Microsoft. Actualmente

Plataforma de Teleformación de IFES Página 9 de 143

• Hay que contratar un servicio de alojamiento, lo que puede resultar costoso.

Dependiendo de las habilidades de cada uno en el manejo e instalacion de

Afortunadamente existen en el mercado soluciones que integran todo lo que

En Linux y otros sistemas, podemos usar Xampp o nos instalaremos

Página 10 de 143 Programación en PHP

• 64Mb de memoria RAM

Instalación paso a paso sobre Windows

1. Descargamos la versión deseada según el sistema operativo que tengamos desde

2. Ejecutamos el fichero. Nos aparecerá la siguiente ventana preguntándonos donde

Plataforma de Teleformación de IFES Página 11 de 143

Eligiremos la ruta de instalación como por ejemplo: C:\CursoPHP y pulsaremos el botón

3. Una vez instalado, tendremos una carpeta llamada C:\CursoPhp\xampplite , dentro

Pulsaremos una tecla cualquiera y se cerrará la ventana o la cerraremos con el ratón.

Página 12 de 143 Programación en PHP

5. Vamos a comprobar que Apache está funcionando, para ello vamos a ir a la

Plataforma de Teleformación de IFES Página 13 de 143

Página 14 de 143 Programación en PHP