Introducción A PHP

6
Intoducción
a PHP
Para ver una copia completa de la licencia, acudir a la dirección
http://creativecommons.org/licenses/by-nc-sa/2.5/es/legalcode.es
(2)
índice
(6.1) servicios en la web________________________________________________ 7
(6.1.1) perspectiva histórica .............................................................................................................................. 7
(6.1.2) historia de la Web ................................................................................................................................. 8
(6.1.3) servicios web 1.0 .....................................................................................................................................11
(6.1.4) servicios web 2.0 ................................................................................................................................... 12
(6.1.5) aplicaciones en la nube. cloud computing .................................................................................. 16
(6.2) aplicaciones web_________________________________________________ 17

(6.2.1) servidores web ....................................................................................................................................... 17
(6.2.2) servidores de aplicaciones web ........................................................................................................ 17
(6.2.3) tecnologías para crear aplicaciones web ..................................................................................... 19
(6.2.4) servidores de aplicaciones web comerciales ............................................................................... 20
(6.3) instalación de Apache ____________________________________________21

(6.3.1) distribuciones ......................................................................................................................................... 21
(6.3.2) instalación binaria en Windows ...................................................................................................... 22
(6.3.3) instalación de código fuente en Linux .......................................................................................... 25
(6.3.4) instalación del paquete desde el sistema Linux .........................................................................26
(6.4) configuración de Apache ________________________________________ 27

(6.4.1) opciones de httpd................................................................................................................................ 27
(6.4.2) instalar Apache como servicio al arranque ................................................................................. 28
(6.4.3) archivos de configuración.................................................................................................................29
(6.5) Instalación de MySQL ___________________________________________ 30

(6.5.1) pasos previos ........................................................................................................................................ 30
(6.5.2) documentación .................................................................................................................................. 30
(6.5.3) instalación en Windows.................................................................................................................... 30
(6.5.4) instalación en Linux/Unix ................................................................................................................. 35
(6.5.5) asegurando la instalación ............................................................................................................... 40
(6.6) PHP ____________________________________________________________41

(6.6.1) ¿qué es PHP? ........................................................................................................................................41
(6.6.2) instalación en Windows .....................................................................................................................41
(6.6.3) instalar en Linux ................................................................................................................................. 42
(6.7) paquetes completos Apache/MySQL/PHP ________________________ 45
(3)
(6.7.1) XAMPP................................................................................................................................................... 45
(6.7.2) AppServ ............................................................................................................................................... 50
(6.8) ¿qué es PHP? ____________________________________________________51

(6.8.1) lenguajes de script de servidor ..........................................................................................................51
(6.8.2) PHP.........................................................................................................................................................51
(6.8.3) ventajas de PHP ................................................................................................................................. 52
(6.6) herramientas y software necesario _______________________________ 52
(6.10) bases de PHP _________________________________________________ 54

(6.10.1) etiqueta <? php?>...............................................................................................................................54
(6.10.2) HTML usa PHP y PHP usa HTML................................................................................................54
(6.10.3) comentarios ........................................................................................................................................ 55
(6.10.4) bases de escritura ............................................................................................................................. 55
(6.10.5) escribir en la salida ...........................................................................................................................56
(6.11) variables _______________________________________________________ 56

(6.11.1) introducción a las variables ..............................................................................................................56
(6.11.2) declarar ................................................................................................................................................ 57
(6.11.3) predefinidas ......................................................................................................................................... 57
(6.11.4) asignación de valores ........................................................................................................................ 57
(6.11.5) variables sin asignar valores ............................................................................................................ 58
(6.11.6) tipos de datos ......................................................................................................................................59
(6.11.7) referencias & ........................................................................................................................................ 61
(6.11.8) constantes............................................................................................................................................ 62
(6.11.9) operadores .......................................................................................................................................... 62
(6.12) estructuras de control __________________________________________ 65

(6.12.1) sentencia if ........................................................................................................................................................65
(6.12.2) sentencia switch ................................................................................................................................. 68
(6.12.3) bucles ................................................................................................................................................... 70
(6.13) uso de formularios HTML desde PHP ____________________________ 75

(6.13.1) repaso de los formularios HTML ..................................................................................................... 75
(6.13.2) controles de HTML 5 .......................................................................................................................... 81
(6.13.3) métodos de envío de datos del formulario ................................................................................. 85
(6.13.4) recepción de datos de un formulario desde una página PHP.............................................. 87
(6.13.5) usar la misma página para el formulario y la recepción........................................................ 87
(6.14) funciones ______________________________________________________ 89
(4)
(6.14.1) introducción ......................................................................................................................................... 89
(6.14.2) declaración y uso de funciones personales ................................................................................ 90
(6.14.3) alcance de las variables.................................................................................................................. 90
(6.14.4) paso de parámetros por referencia.............................................................................................. 91
(6.14.5) parámetros predefinidos ..................................................................................................................... 92
(6.14.6) variables globales ............................................................................................................................93
(6.14.7) variables estáticas ............................................................................................................................93
(6.14.8) recursividad ...................................................................................................................................... 94
(6.14.9) ámbito de las funciones ................................................................................................................. 97
(6.15) inclusión de ficheros ____________________________________________ 97
(6.16) arrays _________________________________________________________ 97

(6.16.1) introducción a los arrays ................................................................................................................ 97
(6.16.2) arrays escalares ................................................................................................................................ 98
(6.16.3) arrays asociativos ............................................................................................................................ 101
(6.16.4) bucle foreach ................................................................................................................................ 102
(6.16.5) arrays multidimensionales ........................................................................................................... 103
(6.16.6) inspección de arrays mediante funciones de recorrido ........................................................ 105
(6.16.7) funciones y arrays .......................................................................................................................... 106
(6.16.8) funciones estándar de uso con arrays ....................................................................................... 106
(6.16.9) uso de arrays en formularios........................................................................................................ 114
(6.17) strings _________________________________________________________ 115

(6.17.1) introducción ....................................................................................................................................... 115
(6.17.2) asignación de valores ..................................................................................................................... 116
(6.17.3) concatenación de textos ................................................................................................................ 116
(6.17.4) uso de variables en strings. uso de llaves................................................................................... 116
(6.17.5) manejo de strings como arrays de caracteres .......................................................................... 117
(6.17.6) cadenas heredoc ........................................................................................................................... 117
(6.17.7) cadenas nowdoc ............................................................................................................................ 117
(6.17.8) expresiones regulares ...................................................................................................................... 118
(6.17.9) funciones estándar de uso con strings ....................................................................................... 123
(6.18) funciones de fecha ____________________________________________ 130
(6.19) control de sesiones en PHP ____________________________________ 134

(6.19.1) limitaciones del protocolo http................................................................................................... 134
(6.19.2) sesiones.............................................................................................................................................. 134
(6.19.3) técnicas para almacenar el estado de una sesión ................................................................. 134
(6.19.4) uso de cookies ................................................................................................................................. 135
(6.19.5) uso de sesiones en PHP..................................................................................................................137
(5)
(6.20) bases de datos _______________________________________________ 140
(6.20.1) ventajas de las bases de datos ................................................................................................... 140
(6.20.2) instalación y configuración de MySQL ..................................................................................... 141
(6.20.3) conexión a MySQL desde PHP .................................................................................................. 141
(6.20.4) cerrar la conexión con la base de datos ................................................................................. 143
(6.20.5) captura de errores ........................................................................................................................ 143
(6.20.6) seleccionar base de datos ........................................................................................................... 144
(6.20.7) tipos de datos MySQL .................................................................................................................. 145
(6.20.8) ejecución de instrucciones SQL .................................................................................................. 146
(6)
(6)
servidores de
aplicaciones web
(6.1) servicios en la web
(6.1.1) perspectiva histórica
El éxito de Internet está absolutamente ligado a la web. Tanto que hoy en día
para la inmensa mayoría de las personas es indistinguible qué es la web y qué es
Internet. Todo se hace en la web. Dicho de otro modo (más coherente con esta
asignatura), desde la web es posible realizar la mayoría de tareas que un usuario
desea de Internet.
Esto no ha sido así siempre. Inicialmente Internet no tenía web. Tenía servicios
como el correo electrónico, la transmisión de ficheros, los grupos de noticias,…
Todos ellos se manejaban de forma tan incómoda que sólo los profesionales de la
informática podían utilizar Internet.
Así para leer el correo electrónico hacía falta un cliente de correo, la
transmisión de ficheros se realizaba mediante un cliente FTP, los foros de debate
se leían a través de gestores de news, para el chat hacía falta también un
programa especial,…
Todavía se puede utilizar hoy en día de esta forma Internet, de hecho yo
utilizo el programa ThunderBird para leer el correo en lugar de hacerlo a través de
un navegador web. Pero lo cierto es que casi todo el mundo con un ordenador
personal todas las tareas en Internet las realiza a través de un único servicio: la
web.
La cuestión es ¿por qué? Hay varias razones para el éxito absoluto de la web:
Su manejo es sencillo. Clics de ratón nos llevan de un punto a otro y eso
es muy fácil de entender.
Es muy visual. La web fue el primer servicio que permitió mostrar la
información de Internet acompañada de imágenes, sonidos y vídeos.
Sólo hace falta un programa para usar la web. El navegador. Hoy en día
presente en todo tipo de computadoras, hace que para acudir a un nuevo
servicio, simplemente se habrá el mismo programa que se utiliza
habitualmente para cualquier otro.
Inicialmente las páginas web estaban compuestas de texto y enlaces (a otras

páginas), pero en poco tiempo los usuarios y usuarias de las páginas web,
demandaban que estas ofrecieran más servicios: no sólo mostrar estáticamente un
texto fijo, sino que contuvieran vídeo, animaciones,… y poco a poco: acceso a
servidores de bases de datos, manejo del correo electrónico, transmisión de
Creación de Aplicaciones Web con PHP
ficheros, compra y venta de productos,…

Hoy en día desde la Web se puede hacer cualquier tarea, editar documentos,
leer el correo electrónico, enviar mensajes, retocar fotos, ver películas, escuchar
radio,…
La web parecía el servicio definitivo pero también tiene sus pegas, ya que a
medida que las páginas se hacen más complejas, se requiere en el navegador más
componentes para poder verlas bien (máquina virtual de Java, Flash, módulos
para interpretar lenguajes como JavaScript,…).
Actualmente sólo el mundo de las apps en los dispositivos móviles parece
arrojar alguna sombra sobre la web.
(6.1.2) historia de la Web

Se señalan algunos hechos importantes en la historia de la web:
1989. Tim Bernes Lee científico del CERN1 crea la World Wide Web
uniendo el lenguaje HTML y el protocolo HTTP.
1992.
• Se crea el navegador Mosaic que facilita el manejo de la web al
permitir leer páginas web desde un entorno gráfico con el ratón. A
partir de él se crearán todos los demás navegadores.
• Hay 50 servidores web a finales de año
1993.
• El CERN anuncia que la web será libre para todo el mundo, renuncia a
sus posibles patentes.
1994.
• Aparece Netscape Navigator, que en poco tiempo se convertiría en el
navegador más utilizado en el mundo
• A finales de año hay 10000 servidores web
• Se crea la web Yahoo! que se convertirá en el sitio web más popular
y el primer índice de la Web.
• Aparece CGI, Common Gateway Interface, Interfaz de Pasarela
Común que permite realizar programación en otros lenguajes y
asociar los programas a páginas web a fin de darlas más potencia.
1995.
• Aparece Windows 95, la informática de consumo llega a casi todos
los hogares del mundo desarrollado.
1
Conseil Européen pour la Recherche Nucléaire, es decir, Consejo Europeo para la
Investigación Nuclear), es un laboratorio de investigación en física de partículas situado
en Suiza.
(8)
autor: Jorge Sánchez – www.jorgesanchez.net
• Explosión de la web, Internet se empieza a hacer muy popular y la

web se empieza a convertir en el servicio más habitual para acceder
a Internet. Poco a poco aparecen miles y miles de sitios web en
Internet
• Microsoft crea Internet Explorer, su navegador para acceder a
Internet. Comienza la primera guerra de navegadores entre Explorer
y Navigator.
• Se crea el lenguaje Java que tiene una relación casi directa con Internet
• Aparece el lenguaje Javascript que permite insertar código dentro de
las páginas web.
• Aparece el sitio web Geocities, antecesor de las redes sociales, en el
que la gente publica páginas web y las agrupa por gustos en ciudades
virtuales.
• Se crea el lenguaje PHP que permite integrar código de servidor en
las páginas web a fin de crear webs más potentes.
1996.
• Se crea el lenguaje CSS que permite dar formato a las páginas web de
forma más avanzada.
• Se lanza Hotmail el sitio web que permite utilizar correo electrónico
desde la web. Se convierte en el correo electrónico más popular y
acaba siendo comprado por Microsoft.
1997.
• Escándalo Lewinsky. Los informes oficiales y detalles sobre el
escándalo aparecen antes en la web que en los medios digitales, el
público se acostumbra a leer noticias en la web lo que provoca una
crisis en los medios tradicionales.
1997.
• El organismo de estandarización W3C lanza la versión 4 de HTML.
Hasta este momento la última versión oficial de HTML. A su vez
Explorer y Navigator lanzan la versión 4, poco a poco Explorer le va
comiendo el mercado a Navigator.
• La empresa Macromedia crea Flash, que permite incrustar objetos
gráficos avanzados en las páginas web, por lo que las posibilidades
visuales de las mismas se disparan a cambio de que los navegadores
integren este famoso plugin.
1998.
• Microsoft crea el lenguaje script de servidor ASP, que se convierte en
un éxito inmediato a pesar de ser de código propietario.
• El W3C lanza la versión 2 de CSS, la última lanzada hasta la fecha.
1999.
• Sun crea el lenguaje de scripts de servidor basado en Java, JSP; para
competir con ASP y PHP que se han popularizado.
• Microsoft crea para Explorer 5 un objeto XML llamado
XMLHttpRequest que será copiado en los demás navegadores en los
años sucesivos. El acceso a este objeto desde JavaScript permite
(9)
crear páginas muy dinámicas y potentes (como Google Maps por

ejemplo). A este forma de programar se le llamará (en 2005) AJAX,
acrónimo asynchronous JavaScript and XML
2000.
• Aparece la Wikipedia, enciclopedia creada con la colaboración
desinteresada de miles de personas cuyos artículos crecen de manera
exponencial cada año.
• Google convierte a su buscador en el más rápido y poco a poco en el
más popular desplazando a Yahoo! y Altavista como los más
populares.
• La W3C define XHTML versión de HTML que sigue de manera estricta
las reglas de XML. Se considera actualmente la única versión válida
de HTML.
2001.
• Aparece Explorer 6 integrado en el popularísimo sistema Windows
XP. Con ello Microsoft gana la primera guerra de navegadores.
• Los sucesos del 11S provocan un colapso en Internet, los principales
periódicos digitales del planeta muestran sólo información muy
esquemática sobre los atentados para ahorrar ancho de banda y servir
al interés de los usuarios.
• Estallido punto com (Dot-com Buble), cientos de empresas que
habían tenido ganancias enormes pero especulativas comienzan a
desplomarse y desaparecer. Se habla de redefinir la web. Al año
siguiente ya se habla de la web 2.0
• Se populariza el uso de blogs (o weblogs) para publicar en Internet al
ser más fáciles de crear por todo tipo de usuarios
• Se crea Drupal, herramienta de gestión de contenidos (CMS) que
permite crear sitios colaborativos. Su éxito verdadero comienza a
partir del 2007 compitiendo con Joomla
2002.
• Aparece MySpace popular web social de éxito espectacular en esos años.
2003.
• Aparece la red social gráfica y virtual Second Life.
• Se crean las redes sociales profesionales Linkedin y Xing (llamada
inicialmente Open Social Club)
2004.
• Aparece Facebook verdadera red social digital cuyo éxito desborda
en los siguientes años hasta llegar a cientos de millones de usuarios.
• Aparece Gmail servicio de correo web de Google que poco a poco se
populariza por el tamaño de su buzón claramente superior a la
competencia y por sus grandes prestaciones y experiencia de usuario.
• Se comienza a trabajar en los borradores de HTML5 y CSS3
(10)
2005
• Tras liberar Netscape el código de su navegador, se crea el navegador
Mozilla Firefox basado en código abierto. Se inicia la segunda guerra
de navegadores que, por ahora, actualmente gana (por poco) Firefox.
• Aparece Google maps con mapas de Estados Unidos y Canadá que
poco a poco incluirán información de todo el planeta y le convierten
en el buscador de rutas más popular.
• Se crea Joomla, que se acaba convirtiendo en el CMS más popular.
• Aparece Youtube el servicio más popular para mostrar vídeos de todo tipo.
2006.
• Aparece el sitio de microblogging twitter. En poco tiempo se
convierte en uno de los más populares por su velocidad y número
espectacular de usuarios.
2007.
• Google lanza Street View como complemento a Google Maps desde el
que se ven fotografías de todas las calles de varias ciudades
estadounidenses. Poco a poco consigue fotografiar la mayoría de las
carreteras y calles de diversos países, entre ellos España-
2008.
• Google lanza su navegador Chrome. Actualmente está a punto de
pasar a Firefox como el navegador más popular de Internet.
2010.
• Explosión móvil. El crecimiento desorbitado del uso de smartphones
hace que cada vez más gente acceda a la web desde dispositivos
móviles. En China casi un 70% de los usuarios utiliza un móvil para
acceder a Internet.
2011.
• HTML5 y CSS3 empiezan a imponerse a pesar de seguir en estado de
borrador. Parece que el futuro pasa por ambas tecnologías.
• Las revueltas de la primavera árabe hacen un uso intenso de twitter y
facebook como medio de comunicación, expresión y convocación
ciudadana.
2012
• Los usuarios de Internet paralizan las leyes anti piratería en EEUU
(conocidas como SOPA y PIPA).
(6.1.3) servicios web 1.0

Hoy en día se llaman así a los servicios que ofrecían los sitios web clásicos. En
realidad la inmensa mayoría se sitios actuales siguen siendo web 1.0 puesto que
solo utilizan tecnologías clásicas.
La realidad es que web 1.0 se define como lo que no es web 2.0, una
definición vaga pero que en el punto siguiente se pretende aclarar mejor.
(11)
(6.1.4) servicios web 2.0

Se trata de la forma de denominar a las páginas web que ofrecen servicios
orientados al usuario. Las páginas web tradicionales ofrecían la misma información
para todos los usuarios, ahora varían para cada usuario, le permiten un manejo
más rico e incluso le hacen partícipe del contenido.
Inicialmente la web era simplemente textos e imágenes junto con los
hipervínculos que permiten saltar hacia otros contenidos. Ahora el tipo de
contenido es mucho más variado: animaciones, vídeo, sonido, juegos, aplicaciones
ofimáticas,… Este tipo de páginas empezaron a proliferar tras el estallido de la
burbuja punto com y es en el año 2004 cuando la empresa O’Reilly Media utiliza
el termino Web 2.0 en una conferencia (incluso llega a registrarlo) y lo hace
popular.
Hoy en día es difícil de definir, pero sin duda hace referencia a un tipo de
servicios web muy concretos. Podemos decir que hay tres pilares que conforman
las páginas web 2.0: Aplicaciones Ricas de Internet, SOA y Web social. Se
desglosan a continuación.
aplicaciones Ricas de Internet.
Es quizá el término más tecnológico relacionado con la web 2.0. Se llaman
Aplicaciones Ricas de Internet (también conocidas con las siglas RIA de Rich
Internet Applications) a aquellas páginas web que ofrecen servicios que las
asemejan con las aplicaciones de escritorio.
Inicialmente la web sólo disponía del lenguaje HTML para crear las páginas y
esto hacía que la interacción con el usuario fuera mínima, por los que las
aplicaciones que se creaban para la web tenían pocas capacidades comparadas
con las aplicaciones de escritorio como Word o Excel.
Por el contrario las aplicaciones creadas para ser ejecutadas en un ordenador
de forma local, exprimen la potencia de dicho ordenador.
Sin embargo, los navegadores han mejorado sus prestaciones hasta el punto de
ser capaces de traducir lenguajes (como JavaScript) y de poder añadir a sus
capacidades plugins capaces de manipular objetos complejos (como los creados
con Flash u otras herramientas complejas).
Y esto ha permitido que las aplicaciones web compitan con las locales, de
modo que aplicaciones que no están instaladas en el ordenador local, se utilicen
desde el navegador web con unas capacidades sorprendentes, como es el caso de
Google Docs que ya es de hecho un competidor del paquete Office de Microsoft.
Permiten en definitiva utilizar la web como si estuviéramos utilizando una
aplicación con toda su potencia en un ordenador local.
funcionamiento en el lado del cliente
En modo cliente, la página entregada por el servidor web que la alberga, contiene
(además del código HTML o XML) elementos pertenecientes a otros lenguajes y
tecnologías como pueden ser: Flash, Silverlight, Java, AJAX,…
El navegador deberá ser capaz de interpretar todas esas tecnologías y
traducirlas correctamente para que interaccionen con el usuario. Eso significa que
nuestro navegador deberá ser potente y en muchas ocasiones habrá que haberle
añadido plugins (componentes) capaces de entender las tecnologías que usen las
páginas. Por eso a casi todos los navegadores es necesario añadirles el plugin Flash
que permite visualizar páginas que contengan elementos fabricados con esta
tecnología.
(12)
Ilustración 1, Funcionamiento de las tecnologías ricas de Internet usandio tecnologías en el lado

del cliente
Es decir, todo el esfuerzo lo realiza el navegador (tecnología web de cliente pesado.

Esta forma de trabajo parecía que se iba quedando obsoleta por la dificultad de tener
un navegador con todos los componentes (que obligaba al usuario/a a descargar plugins
sin entender muy bien la razón), sin embargo en la actualidad (gracias al triunfo de
HTML 5) es la forma habitual de generar aplicaciones ricas, ya que la interactividad con
el usuario es más veloz en el lado del cliente.
funcionamiento en el lado del servidor
(13)
En este caso, se crean páginas que contienen componentes que pertenecen a

tecnologías que deben de ser interpretadas en el servidor. Es decir, cuando un
usuario o usuaria pide una página web, el servidor web se da cuenta que contiene
elementos especiales (o toda ella es de tipo especial) y pide a un servidor de
aplicaciones (como Internet Information Server o Apache) que traduzca esos
elementos.
El servidor de aplicaciones (si es compatible con esa tecnología), dará el
resultado al servidor web en un formato asumible por él (normalmente en el
propio HTML) y éste finalmente continua el proceso habitual entregando la página
al navegador.
La ventaja de este modo de trabajo es que el navegador puede ser más ligero
(se la llama tecnología de cliente ligero) y la parte dura o pesada se la lleva el
servidor web que es que tiene que tener a su disposición el servidor de
aplicaciones capaz de entender el código especial.
Hoy en día ambos métodos se juntan de modo que los desarrolladores web crean
páginas que contienen elementos en el lado del servidor y en el del cliente (por
ejemplo páginas PHP que devuelven código AJAX) y eso enriquece aún más las
aplicaciones web haciendo que sea posible realizar prácticamente cualquier tipo
de aplicación.
arquitectura orientada al servicio (SOA)
artículos usuarios
Servicio de Servicio de opiniones

Consulta de Compra de sobre artículos
Artículos Artículos
Tienda
On Line
Servicio de consumidores
Ilustración 3, Ejemplo de aplicaciones SOA

Otra de las claves, se trata de una tecnología que permite diseñar aplicaciones
basándose en peticiones a un determinado servicio. De esta forma se puede crear
pequeños elementos software muy reutilizables y además independientes del
lenguaje con el que fueron creados.
Es decir que podemos crear pequeños componentes que pueden ser entendidos
como servicios que se prestan. Cada servicio se crea en un lenguaje o tecnología
concreta; los otros servicios estará fabricados en otra tecnología (o no) y se
pueden recombinar entre sí para crear diferentes aplicaciones.
Esa orientación al servicio ha supuesto una auténtica revolución en Internet, ya
que si creamos un servicio por ejemplo que nos permita conocer las opiniones de
los usuarios sobre los artículos de una tienda, este servicio puede ser reutilizado
tanto por el de venta de artículos de la propia tienda, como por ejemplo por el
(14)
servicio que nos muestre información al consumidor sobre artículos en general

(ejemplo del dibujo).
Esto ha dado lugar a un nuevo tipo de programación que crea el llamado
Software as a Service (software como servicio o SaaS) y que ha supuesto una
enorme revolución. Se basa en que las aplicaciones no están pensadas para ser
instaladas en el ordenador del cliente (como ocurría y ocurre en la programación
de aplicaciones clásica), sino que se coloca en un servidor al que acceden los
clientes. De este modo se convierte en un servicio que está disponible desde
cualquier punto del planeta si la aplicación en el servidor está disponible desde
Internet.
web social
Es la parte más evidente y entendible de la web 2.0. El término se refiere a que el
usuario posee una interacción mucho mayor en la web siendo partícipe de lo que
en ella ocurre.
Es decir el usuario conecta con otros usuarios, participa de los contenidos
incluso creándoles o dando su opinión sobre ellos. Es decir, las páginas web 2.0
está muy vivas, tienen un enorme dinamismo, la creación ya no es solo de la
entidad que creo la página, sino
resumiendo la web 2.0
En definitiva las páginas web 2.0 tienen estas características:
El contenido no sólo es creado por los propietarios de las mismas, sino
que es creado y modificado por los propios usuarios.
Las páginas permiten controles más potentes de manejo por los usuarios
Los diferentes servicios ofrecidos por distintas páginas tienen facilidad
para interaccionar (podemos colocar un mapa de Google fácilmente o
acceder a Facebook para compartir un detalle de la página,…)
El contenido no está centralizado sino que residen en una maraña (nube)
de múltiples servidores colocados incluso en diferentes puntos
geográficos.
Es habitual comparar servicios ofrecidos por la web 1.0 con respecto a los de la
web 2.0, por ejemplo:
Web Web
1.0 2.0
Hotmail (clásico) Gmail
Doubleclick AdWords
Geocities Wordpress
Yahoo! Google
Enciclopedia Británica Wikipedia
Messenger Twitter, Facebook
Akamai Torrents
Ofoto Flickr, Instagram
mp3.com Spotify
… Delicio.us
… Google docs
… Aviary
(15)
(6.1.5) aplicaciones en la nube. cloud computing

Es otro de los términos fundamentales para definir los servicios ofrecidos por las
páginas actuales. Se basa en ofrecer al usuario servicios de modo que el usuario
pueda acceder a ellos desde cualquier dispositivo conectado a Internet,
ofreciendo una altísima disponibilidad del mismo.
Se basa en la programación distribuida de aplicaciones, pero a tal nivel que las
aplicaciones se distribuyen incluso por cientos de servidores de partes distintas del
planeta y así poder responder a una demanda ingente de peticiones de servicio y
además poseer una altísima capacidad de tolerar fallos.
De esta manera es la tecnología que permite utilizar el software como un
servicio (SaaS, Software as a Service), al igual que la web 2.0 (con la que está
íntimamente relacionada), al usuario le basta un navegador o una pequeña
aplicación (como una App de un dispositivo móvil) para acceder y utilizar el
servicio.
La computación en la nube apareció para responder tecnológicamente a los
retos de empresas como Google, Facebook o Amazon que tenían que responder a
gran velocidad a las peticiones de millones de usuario. Hoy en día el concepto
permite que se utilice Internet como la base de trabajo, sustituyendo así al
propio ordenador personal que puede ser un equipo de menor potencia al delegar
en la nube el proceso de las tareas y el almacenamiento de la información.
Ejemplos de servicios en la nube serían:
Discos duros virtuales. Como DropBox o SugarSync que sirven para
almacenar todo tipo de datos y que estos estén accesibles desde
cualquier dispositivo conectado.
Aplicaciones de ofimática web. Con capacidad para crear e incluso
compartir documentos de texto, hojas de cálculo,… Entre ellas están
Google Docs y Microsoft Web Apps.
Copias de seguridad en línea. Al estilo del disco virtual, pero pensado
para que las empresas tengan un respaldo en caso de pérdida de
información.
Calendarios. Permiten disponibilidad permanente de los datos de agenda
personal.
Sistemas operativos web. Permiten utilizan un ordenador virtual
disponible a través de Internet. El más famoso es EyeOS y en España
TribalOS.
Servicios VPN. Permiten a través de un navegador u otra aplicación
cliente ligera, controlar uno o más ordenadores remoto de modo que no
sea necesario acceder físicamente a él.
Redes sociales. Como Facebook, tuenti o
LinkedIn. Bibliotecas multimedia. Como
Youtube o Flickr. Marcadores en línea.
Como del.icio.us o Digg.
Existen detractores de este tipo de servicios, puesto que al final información

personal o empresarial crítica queda en poder de empresas privadas. E incluso hay
quien afirma (especialmente los movimientos a favor del software libre)
(16)
que supone un retroceso que asemeja el funcionamiento de los sistemas de los

años 70 en los que los trabajadores utilizaban un terminal muy ligero que se
conectaba a un ordenador central de cuya potencia y software dependían.
(6.2) aplicaciones web

(6.2.1) servidores web
Los servidores web son los encargados de recibir las peticiones referidas a páginas
o elementos de la web a través del protocolo http o https y de devolver el
resultado de la petición, que suele ser un recurso alojado en el servidor.
Normalmente es el navegador el que pide al servidor web el recurso que desea
el usuario, para finalmente recibir dicho recurso (si fue válida la petición) y
traducirle si es necesario a su forma legible por el usuario (es decir la traducción
de HTML la hace el navegador).
(6.2.2) servidores de aplicaciones web

Los servidores web sólo tienen la capacidad comentada: resolver peticiones de
elementos web. Pero no se molestan en descifrar el código de estos elementos.
Esa tarea la dejan en manos del cliente que hizo la petición (normalmente un
navegador web).
La cuestión es que cuando necesitamos crear elementos más complejos,
entonces las páginas y otros elementos que almacena el servidor, contendrán
código que debe de ser resuelto antes de entregarlo al cliente. Ahí es donde entra
el servidor de aplicaciones
Un servidor de aplicaciones es el elemento (software) que es capaz de traducir
las instrucciones y además comunicar con otros servidores (como por ejemplo los
servidores de bases de datos) para extraer información de la empresa que se
necesita para resolver la petición.
Los servidores de aplicaciones trabajan en conjunto con los servidores web
para que el proceso se haga de forma transparente al usuario; es decir el usuario
pide el servicio a través, normalmente, de su navegador y el servidor web atiende
la petición y pide al servidor de aplicaciones la traducción de la aplicación
contenida a fin mostrar al usuario el resultado de forma entendible por su
navegador (es decir en formato HTML).
A la forma de trabajar de un servidor de aplicaciones, se le conoce
normalmente como arquitectura de tres capas (a veces se habla de más capas).
Una primera capa es la del navegador que es capaz de traducir el llamado código
del lado del cliente (HTML, JavaScript, CSS, Flash,…). La segunda capa la forma el
servidor de aplicaciones en su labor de traducir código en el lado del servidor
(JSP, PHP, Ruby on Rails, Cold Fussion…) y convertirlo al formato entendible por el
navegador. La tercera capa son todos los servicios a los que accede el servidor de
aplicaciones que necesita para poder realizar la tarea encomendada a la
aplicación (por ejemplo el acceso a la base de datos).
La Ilustración 2 muestra una arquitectura de tres capas para resolver la
petición de una página PHP.
(17)
Sin embargo una visión más detallada de la arquitectura actual para construir
aplicaciones web sería:
Ilustración 4, Arquitectura de un sistema de aplicaciones web moderno
En la ilustración se muestra la comunicación entre el navegador (Chrome,

Explorer, Opera,…) y los servidores del sitio web. El navegador es capaz de
entender las tecnologías del lado del cliente. En la imagen se detalla el sitio web
que le llega como un conjunto de documentos HTML, CSS y JavaScript; aunque
realmente podría tener más componentes, como Flash por ejemplo.
En el lado del servidor hay tres capas a tener en cuenta:
La capa de presentación. Realizada por el servidor web y cuyo objetivo
es recibir las peticiones http y devolver la respuesta adecuada en formato
entendible por los navegadores.
La capa lógica. Es la capa que representa al servidor de aplicaciones. El
servidor de aplicaciones es invocado por el servidor web cuando le llega
una petición a un recurso que debe de ser tratado en el lado del servidor
como es un página PHP.
En esta capa lo que llegan son documentos escritos en un lenguaje que se
debe de interpretar en el lado del servidor y cuyo resultado se enviará al
servidor web para que este lo envíe al cliente que hizo la petición.
Hoy en día las aplicaciones de esta capa son un conjunto de documentos
que diferencian tres capas: el modelo, el controlador y la vista, conocido
como paradigma MVC.
La capa de negocio. Es la que contiene la información empresarial que
debe de estar absolutamente protegida de los usuarios. En esta capa
fundamentalmente se encuentra el sistema gestor de bases de datos
(SGBD) de la empresa, además de otros servidores que proporcionen otros
recursos empresariales (como servidores de vídeo, audio, certificados,…).
(18)
Los servidores de esta capa son invocados por los servidores de

aplicaciones cuando requieran estos recursos y con la información que
reciben pueden realizar su labor de manera correcta.
Todo este mecanismo de trabajo es el que involucra la creación de aplicaciones

web. En general los servidores web actuales actúan de servidores de aplicaciones
una vez que se les instala el software pertinente. Por ello cuando se habla de
servidores web, en realidad también hablamos de servidores de aplicaciones web.
(6.2.3) tecnologías para crear aplicaciones web

lenguajes de script de servidor
PHP (Personal Home Pages). Se trata de un lenguaje de scripts de
servidor; es decir código que se incrusta en las páginas HTML y que
requiere ser traducido por un servidor de aplicaciones que devolverá un
resultado en formato HTML.
ASP (Active Server Pages). Tecnología de Microsoft similar a la anterior,
sólo está pensada para utilizar en servidores de Windows, especialmente
en IIS.
JSP (Java Server Pages). Competidor de ASP que usa como base el
lenguaje Java.
Cold Fussion. Otro lenguaje de scripts, esta vez propiedad de Adobe. Es
el más sencillo de todos, pero es de uso más caro porque requiere
servidores especiales (Servidores de Cold Fussion).
plataformas de desarrollo de servicios web empresariales
J2EE (Java 2 Enterprise Edition). Nombre que se da a la plataforma de
creación de aplicaciones web empresariales de Java. Está formada
fundamentalmente por el propio lenguaje Java, EJB (Enterprise Java
Beans,
componentes reutilizables empresariales), servlets y JSP además de otros
componentes.
.NET. Plataforma de Microsoft que permite (entre otras muchas
posibilidades) crear aplicaciones y servicios web, haciendo especial
énfasis en el transporte de datos mediante XML.
frameworks MVC
En inglés framework se puede traducir como estructura; en el sentido que nos
ocupa un framework sería un marco de trabajo. MVC son las siglas del Modelo-
Vista-Controlador, comentado antes, un paradigma de programación de
aplicaciones que separa en tres niveles el trabajo:
El modelo. Especifica la forma de manipular los datos por parte de la
aplicación. Es decir especifica cómo son los datos (qué tipo tienen) y la
forma de manipularles. Este modelado de datos enlaza con la lógica de
negocio, es decir con la forma en la que los datos se almacenan en la
capa de negocio (en la base de datos en definitiva).
La vista. Hace referencia al aspecto visual de la aplicación de cara el
usuario, especifica la forma de interaccionar que tendrá la aplicación con
el usuario.
(19)
El controlador. Es la parte que controla las acciones del usuario y las

comunica a los dos niveles anteriores.
MVC es, en definitiva, un modelo de trabajo que facilita la creación de

aplicaciones web complejas. Hoy en día esta separación en tres capas de las
aplicaciones se realiza con marcos o plantillas de trabajo (más conocidas como
frameworks por su uso en inglés) que facilitan la creación de aplicaciones MVC
generando casi sin esfuerzo el núcleo de las aplicaciones. Las más populares son:
Ruby on Rails. Se trata de un marco de trabajo muy exitoso por la
facilidad que tiene de programar y sus buenos resultados visuales. Se
puede ejecutar en casi cualquier servidor web, basta con instalar el
componente correspondiente.
Apache Struts. El marco de trabajo más famoso para la creación de
aplicaciones J2EE. Muy preparado para utilizar con Apache.
Spring. Otro marco para trabajar en Java J2EE que tiene bastante éxito.
Tiene incluso una versión para las aplicaciones .NET
Django. Escrita en Python y pensada para utilizar en ese lenguaje que
facilita la creación de aplicaciones web.
Zend. Framework escrito para PHP. Uno de los más populares para este
lenguaje.
Yii. Otro framework PHP de reciente creación, pero de gran crecimiento
comercial.
(6.2.4) servidores de aplicaciones web comerciales

En realidad en muchas ocasiones es indistinguible un servidor web de un servidor
de aplicaciones web. La diferencia está en lo comentado antes, los servidores web
simplemente atienden a las peticiones http y los de aplicaciones sirven para
traducir código escrito en algún lenguaje.
Lo cierto es que casi todos los servidores web actuales permiten actuar de
servidores de aplicaciones gracias a la posibilidad de añadir componentes para poder
ejecutar tecnologías del lado del servidor. Por ello en la lista siguiente aparecen
tanto servidores web como servidores de aplicaciones web puros (sin capacidades de
servidores web).
Apache
Indudablemente Apache es el servidor web más popular de la actualidad. Abarca
el 65 % de todos los servidores web instalados, aunque es cierto que su cuota de
mercado va bajando poco a poco. Se trata de un software de código abierto que
utiliza una licencia de tipo Apache License que es una variante de la licencia GPL
de Linux. Eso significa que se puede distribuir libremente e incluso modificar el
código siempre y cuando el resultado mantenga la licencia original.
Dispone de multitud de módulos que convierten a Apache en un servidor capaz
de gestionar todo tipo de aplicaciones, lo que también le convierte en el servidor
de aplicaciones más popular de la actualidad; por ejemplo dispone de módulos
para:
Implementar SSL. Protocolo de seguridad en la transferencia de información
Enlace con el servidor Tomcat de aplicaciones, para implementar aplicaciones
Java de servidor.
(20)
Módulo para Perl

Módulo para PHP
Módulo para Python.
etc.
IIS
Abreviatura de Internet Information Server, es el servidor de aplicaciones de
Microsoft que está presente en las versiones profesionales de Windows y en todas
las de servidor. Viene con el propio sistema operativo y para instalarle basta con
agregarle como componente del sistema en la zona de instalación de aplicaciones
del panel de control de Windows (IIS sólo funciona bajo Windows).
El servidor incluye un servidor web (tanto http como https), servidor ftp,
webDAV y smtp. Además se comporta como servidor de aplicaciones web .NET y
admite extensiones para diversos tipos de aplicaciones (incluido PHP).
Es el segundo servidor web más popular tras Apache (17% del mercado).
nginx
Servidor web cada vez más popular. Muy ligero (con pocas funcionalidades) pero
presume de su alta velocidad especialmente con un número muy alto de sesiones
concurrentes. Tiene licencia de uso BSD, que permite su distribución y
modificación libre.
Ha subido enormemente su uso estando cerca de alcanzar a IIS con su 13% de
mercado.
Mediante FastCGI puede añadírsele numerosas funcionalidades, entre ellas la
capacidad de servir PHP, Ruby on Rails, Java,…
lighttpd
Servidor web que presume de muy poco consumo de CPU por su ligereza, pero de
una alta velocidad. Mediante FastCGI permite servir muchos lenguajes de servidor
(especialmente Ruby on Rails y PHP)
Apache Tomcat
Creado por la fundación Apache es un servidor web escrito en Java capaz de
interpretar servlets y páginas JSP escritas en Java, por lo que es un servidor de
aplicaciones web especialmente pensado para servir Java J2EE, la plataforma de
Java para crear aplicaciones.
Webrick
Servidor de aplicaciones popular para pruebas por su ligereza, pero que no es lo
suficientemente potente para usarlo a nivel comercial. Es el utilizado por los
desarrolladores en Ruby On Rails.
(6.3) instalación de Apache

(6.3.1) distribuciones
Apache es un software de código abierto bajo una licencia de tipo Apache License
que es una variante de la licencia GPL lo que significa que incluso se puede
modificar el código libremente y generar una nueva variante propia de Apache que
incluso puede cerrar el código, pero que en todo momento debe de mostrar un
(21)
aviso de que se trata de una variación hecha sobre el código original que era
perteneciente a una licencia Apache.
Por ello podemos instalar Apache compilando su código fuente (y así mantener
el espíritu del software libre), o bien descargar código ya compilado ejecutable e
instalar Apache de esa forma más sencilla. Las diferentes posibles instalaciones se
pueden descargar de http://httpd.apache.org
(6.3.2) instalación binaria en Windows

Hay dos posibilidades de binarios para Windows: con o sin servidor SSL. Si
optamos por la opción clásica (sin instalar el software Open SSL). Los pasos son:
(1) Descargar y ejecutar el archivo de instalación:
(2) Aceptar la licencia

(3) Indicar el nombre del dominio en el que se integra al servidor, nombre del
servidor, correo del administrador y si deseamos instalar el servidor para
todos los usuarios
(22)
(4) Elegir el tipo de instalación (es aconsejable elegir la personalizada,

Custom) y seleccionar los componentes de Apache a instalar
(recomendable todos)
(5) Finalmente realizar la instalación propiamente dicha

comprobar la instalación
Para comprobar que realmente está el servidor en funcionamiento, basta abrir un
navegador y navegar a la dirección http://localhost
Si todo va bien, aparecerá el siguiente mensaje:
It works! (funciona) es el texto de la página de inicio del servidor Apache.
(23)
modificar el PATH de Windows

Para poder utilizar las aplicaciones de Apache desde la línea de comandos de
Windows, es más cómodo que aparezca la ruta a los programas de apache dentro
del PATH de Windows.
Apache se instala normalmente en una ruta como:
C:\Program Files (x86)\Apache Software Foundation\Apache2.2
Con lo cual la ruta a añadir al PATH para llegar a los binarios es:
C:\Program Files (x86)\Apache Software Foundation\Apache2.2\bin
El PATH del sistema se modifica desde las propiedades del Sistema. Habrá que
añadir la ruta de Apache al final.
iniciar y parar el servicio

Apache se instala como servicio de Windows. El arranque y la parada por tanto se
pueden realizar desde la pantalla de servicios o bien desde un icono que Apache
instala en la barra de tareas al lado del reloj llamado Apache Monitor.
Desde la línea de comandos se pueden también hacer estas tareas (y otras)
mediante el programa que controla al servidor Apache que se puede llamar httpd
o simplemente Apache, con él se puede:
Instalar como servicio en Windows con httpd –k install o bien mediante
Apache -k install
Se inicia con net start apache2.2 o httpd –k start o Apache -k
start Se para con net stop apache2.2 o httpd –k stop o
Apache -k stop Se para también con httpd –k shutdown o
Apache -k shutdown
Se reinicia con httpd –k restart o Apache -k restart
Y se puede desinstalar como servicio con httpd –k uninstall, con Apache -
k uninstall o con sc delete apache
(24)
estructura de directorios de apache

En el directoio raíz de Apache en Windows, que estará en la carpeta en la que se
almacenan las aplicaciones de 32 bits (normalmente C:\Program Files
(x86)\Apache Software Foundation\Apache2.2) se pueden apreciar estas
carpetas
Carpeta Contenido
bin Archivos ejecutables
cgi-bin Scripts de servidor
config Archivos de configuración de Apache
error Archivos que contienen los mensajes de error del servidor (en varios
idiomas)
htdocs Directorio en el que se guardan las páginas web
icons Carpeta que contiene los iconos que usa el servidor para mostrar en
algunos de sus mensajes
logs Archivos de información sobre conexiones y errores acaecidos
manual Contiene el manual de Apache
modules Módulos y extensiones de Apache
(6.3.3) instalación de código fuente en Linux

En principio estos pasos valdrían para cualquier distribución Linux. La ventaja es
que conociendo esta instalación, no importará bajo qué distribución Linux
estemos; la desventaja es que es compleja y se puede fallar en alguno de los
pasos y además no nos ayudará ninguno de los asistentes.
(1) Se requiere que estén instaladas las herramientas de compilación C/C++
(gcc-c++ es el más popular) y de construcción. Lo habitual es que ya lo
estén, sino necesitamos instalar los paquetes correspondientes.
(2) Hay que ir a la dirección http://httpd.apache.org/download.cgi y
descargar uno de los archivos comprimidos (normalmente se usa el de
formato gz).
(3) Hay que descomprimir el archivo con el comando:
tar -vzxf nombrearchivo.tar.gz
o bien desde el entorno gráfico de Linux es fácil que pulsando el botón
derecho en el archivo dispongamos de posibilidades para descomprimir
(4) Configurar la instalación. Para ello dentro del directorio descomprimido de
Apache basta con ejecutar el archivo configure (mediante el comando
./configure si estamos en ese directorio en la línea de comandos). Usado
sin parámetros, ese comando instala (compilando el código fuente) Apache
en el directorio /usr/local/apache2 con las opciones de instalación por
defecto.
Pero el comando configure, admite parámetros que permiten configurar
toda la instalación. La opción más habitual es utilizar el parámetro --prefix
que permite indicar el directorio raíz en el que se instalará Apache, pero
hay muchas más posibilidades de configuración (visibles a través del
(25)
comando configure --help)

Un parámetro casi obligatorio de uso si se desea compilar con módulos de PHO es
--enable-so
Ejemplo de uso de --prefix (estando en el directorio descomprimido de Apache):
./configure --prefix=/sw/web/apache2 --enable-so
Usado con más parámetros permite decidir todos los aspectos de la
instalación. Para ver dichos parámetros basta con escribir configure --help
en la línea de comandos
(5) Compilar el código. Basta con ejecutar el comando make. Tardará unos
cuantos minutos la compilación. Después se ejecuta el comando make
install y así se produce ya la instalación en base a la configuración
indicada.
modificar el PATH de Linux
Es interesante cambiar el PATH de Linux al igual que el de Windows para que la
carpeta bin de Apache se encuentre en el PATH y así buscar los comandos de
Apache allí. Para ello basta encadenar la ruta a la carpeta bin de Apache en el
PATH, mediante:
export PATH=$PATH:/usr/local/apache2/bin
Suponiendo que /usr/local/apache2 es la ruta a la raíz de instalación de Apache.

Para que esos cambios sean permanentes y al iniciar sesión dispongamos siempre
de ellos, esa línea debería estar en el archivo .bash_profile o en el .bash_rc de
nuestro usuario.
Si el cambio es para todos los usuarios, se modifica el archivo /etc/profile
lanzar el servidor Apache
Una vez instalado podremos ejecutar el servidor Apache siempre que queramos
gracias al programa apachectl que se encuentra en la carpeta bin de la instalación
de Apache. Tiene estas posibilidades (se requieren permisos de administrador):
httpd -k start ó apachectl start. Inicia el proceso httpd; es decir ejecuta

el servidor Apache.
httpd -k stop ó apachectl stop. Para el proceso; detiene el servidor.
httpd -k restart ó apachectl restart. Reinicia el servidor.
apachectl help. Ayuda para ver todas las opciones del programa.
httpd sin parámetros, lanza el servidor
cat rutaACarpetalogsDeApache/httpd.pid | xargs kill. Elimina el
proceso cuyo identificador (pid) se encuentra en el archivo httpd.pid
(dentro de la carpeta log de Apache). Es decir elimina el proceso de
Apache. El archivo httpd.pid se crea cada vez que se ejecuta Apache
precisamente para grabar el identificador de proceso.
(6.3.4) instalación del paquete desde el sistema Linux

Otra posibilidad de instalación en Linux es instalar el paquete creado para esa
distribución. En las dos distribuciones más populares las de tipo Red Hat (como
Fedora) o apt-get y las Debian (como Ubuntu) se instala de forma distinta.
(26)
instalar paquete en sistemas Red Hat

Actualmente la utilidad más habitual para instalar un paquete es yum mediante:
yum install httpd
También podemos instalar el paquete desde el entorno gráfico del sistema.

En cualquier caso, tras la instalación todo estará configurado con las opciones
habituales. La instalación se realiza en /usr/local/apache2 y se puede desde ese
momento manejar como en el caso del código fuente.
instalar paquete en sistemas Debian
En el caso de Ubuntu y el resto de sistemas Debian, se usa actualmente el comando
apt-get desde la línea de comandos. Sería:
apt-get install apache2
Eso mismo se puede hacer desde el gestor gráfico de paquetes (por ejemplo Synaptic).
El problema es que la instalación es diferente:
/etc/apache2 es el directorio de instalación de Apache
apache2.conf es el archivo de configuración (que hará referencia a
httpd.conf)
/usr/sbin contiene los ejecutables
No hay archivo httpd, todo se maneja con apachectl
Aunque la gestión es sencilla (quizá más que en las otras instalaciones, sus tremendas
diferencias son una desventaja para el aprendizaje.
(6.4) configuración de Apache

(6.4.1) opciones de httpd
El programa que lanza apache es httpd (también se usa apachectl en Linux, pro
no tiene las mismas opciones, además apachectl acaba invocando a httpd). Al
ejecutar httpd se pueden utilizar estas opciones:
opción significado
-k start Lanza el servidor Apache
-k stop Para el servidor Apache
-k restart Reinicia el servidor Apache
-D nombre Define un nombre para las directivas
<IfDefine name>
-d directorio Permite indicar un directorio raíz
alternativo para Apache
-f rutaArchivo Permite indicar un archivo alternativo de
configuración
(27)
-C “directiva” Procesa la directiva indicada antes de leer

la configuración
-c “directiva” Procesa la directiva indicada después de
leer la configuración
-v Muestra la versión de Apache
-V Muestra las opciones de compilación
-h Ayuda para conocer las opciones de httpd.
-l Lista de módulos compilados
-L Lista de directivas
-t Ejecuta el analizador de sintaxis para los
archivos de configuración de Apache
-T Igual pero no comprueba la sintaxis
La ubicación de httpd depende de la instalación (como se ha comentado
anteriormente); lo más habitual es que se encuentre en la carpeta bin dentro de
la raíz de instalación de Apache.
(6.4.2) instalar Apache como servicio al arranque

Windows
Si la instalación se hace con el asistente, esa situación ya ocurre. Si no fuera así por
la forma de instalar o por cualquier otra razón. Bastaría con:
httpd -k install -n nombreDeServicio
Si no deseamos indicar un nombre de servicio, entonces no se usa el parámetro -n
y el nombre del servicio será Apache.
Linux
En ese caso hay que:
(1) Copiar httpd al directorio /etc/init.d. Por ejemplo:
cp /usr/local/apache2/bin/httpd /etc/init.d/apache
apache es el nombre que se da al servicio
(2) Ejecutar una de estas dos opciones:
• Versión Debian:
update-rc.d apache defaults
• Versión Red Hat

chkconfig apache on
• En otros casos habrá que manualmente copiar un enlaces simbólico

con el nombre adecuado a las carpetas rcX.d
En ese caso conviene conocer perfectamente cómo se
configurar manualmente las opciones de inicio del sistema.
(28)
(6.4.3) archivos de configuración

Para modificar el funcionamiento de Apache, se utilizan sus archivos de
configuración. El principal es httpd.conf (en algunas instalaciones es
apache2.conf) que se encuentra en el directorio conf de la instalación de
Apache. Puede haber otros, pero lo habitual es usar ese como principal. En
cualquier caso un archivo de configuración consta de:
Directivas. Se trata de una palabra clave a la que se sigue un valor. Por
ejemplo:
listener 80
Que usa el puerto 80 de comunicaciones. La lista de directivas se puede
mostrar con -L
Secciones. Se trata de las partes del documento, para así hacer que las
directivas sólo se apliquen a la sección a la que se refiere la sección. Usan
etiquetas estilo XML. Por ejemplo:
<Directory /usr/local/apache/htdocs/dir2>
Deny from all
Allow from 192.168.4.21
</Directory>
Comentarios. Comienzan por el signo #. Sirven para documentar el archivo.
ejemplos de directivas básicas
Listen. Permite modificar el puerto por el que se comunica el servidor
ServerName. Nombre del servidor (para probar se suele utilizar localhost)
ErrorLog. Ruta al archivo LOG de errores que permite examinar los problemas
acaecidos en el servidor Apache.
ErrorLog “logs/errorlog”
LogLevel. Permite indicar qué eventos se almacenan en el archivo

LOG de errores. Hay estas posibilidades (en orden decreciente de
significación crítica, mas alto menos evento se almacenan, sólo los ):
emerg. Sólo almacena eventos que impiden el desarrollo del servidor
alert. Si hay que tomar acciones inmediatamente.
crit. Si hay fallos críticos
error. Si ocurren condiciones de error
warn. Avisos, no significan errores, sólo advertencias de posibles errores.
notice. Cualquier evento que tenga cierta significancia. Si se elige
este nivel se almacena cualquier evento de los anteriores.
DocumentRoot. Indica una ruta que se entiende que será la raíz de los
documentos de Apache
DirectoryIndex. Indica el nombre del archivo que se mostrará cuando se
acceda a un directorio del servidor. Por ejemplo con
localhost/imágenes/. En ese caso se mostrará el contenido del directorio
si no existe el archivo índice del directorio (normalmente index.html).
(29)
Ejemplo:
DirectoryIndex index.html index.txt index.pl
archivos .htaccess
Tienen las mismas posibilidades que el archivo httpd.conf, pero sólo se aplica su
configuración al directorio en el que están colocados
(6.5) Instalación de MySQL

(6.5.1) pasos previos
Antes de instalar MySQL (al igual que otro software cuya instalación sea crítica)
se deben tomar estas decisiones:
Comprobar hardware mínimo necesario
Decidir la distribución. MySQL está disponible para numerosas
plataformas, hay que decidir para cuál nos interesa, en base al precio del
sistema, fiabilidad, buena integración, etc.
Decidir el formato de la distribución. Hay dos posibilidades:
Distribución binaria. Se trata de una forma más fácil y rápida de
instalar. Puede ser a través de un instalador preparado o bien a
través de binarios genéricos comprimidos. En el último caso,
simplemente con descomprimir y realizar unos cuantos ajustes,
tenemos la instalación finalizada
Código fuente. Se trata de que debemos compilar el código fuente
para que funcione el SGBD. Es más complicada de realizar pero
permite un mayor control de todos los componentes a instalar, así
como preparar un ejecutable óptimo para nuestro sistema o bien
incluso modificar el código (que es C y C++).
Obtener los archivos. De la dirección: http://dev.mysql.com/downloads.
(6.5.2) documentación
MySQL dispone de manuales tanto en línea como descargables (por ejemplo en
formato PDF) a través de la página http://dev.mysql.com/doc/
(6.5.3) instalación en Windows

Es la versión más descargada de MySQL. Hay dos opciones:
Distribución binaria, que permite iniciar el servidor inmediatamente. Es
un archivo msi, con las ventajas que eso tiene en un entorno de trabajo
Windows. Opciones:
Instalador msi
Instalación comprimida en formato ZIP
Distribución de código fuente para ser compilada con el compilador VC++ 6.0.
(30)
instalación con un paquete msi

instalación con el asistente
El asistente de MySQL es el programa que permite facilitar la instalación del
software. Los pasos a realizar con él son:
(1) Aceptar el cuadro con la información inicial
(2) Escoger el tipo de instalación. La opción personalizada (Custom) permite
elegir más a fondo los componentes a instalar.
(3) Confirmar la instalación
Tras finalizar estos pasos, automáticamente se modifica el registro de Windows,

se añade un grupo para MySQL en el menú de Inicio y una carpeta (por ejemplo
MySQL 5.5) dentro de la carpeta de los programas en el sistema de archivos de
Windows (por ejemplo con la ruta C:\Program Files\MySQL\MySQl 5.5).
instalar la instancia de MySQL
El sistema MySQL en sí funcionará en cuanto lancemos el asistente para gestionar
la instancia. La instancia es el proceso de base de datos que permite el acceso a
la base de datos. Eso puede hacerse en el último paso del asistente anterior o bien
lanzando el programa en la carpeta bin del directorio de MySQL,
MySQLInstanceConfig.
Una vez lanzado la primera pantalla es esta:
Ilustración 5, Imagen inicial del asistente de configuración de la

instancia del servidor MySQL
Con él los pasos a realizar son:
Elegir el tipo de instalación. La detallada permite más opciones de
configuración.
Elegir el tipo de servidor que deseamos:
• Developer Machine. Máquina de Desarrollo. Para uso personal
solamente, consumirá una cantidad mínima de recursos.
(31)
• Server machine. Servidor. Se entiende que comparte espacio con

otros servidores (web, de correo, ftp). Consume una cantidad
moderada de recursos.
• Dedicated Machine. Servidor dedicado. Se elige si sólo se utiliza
como servidor a MySQL.
Uso de la base de datos. En realidad gestiona qué motores de la base de
datos se usarán. MySQL dispone de dos opciones InnoDB (con buena
capacidad de manejo de transacciones, pero más lenta en añadir datos) y
MyISAM, más rápida pero con menos control de la integridad de los datos.
Las opciones del cuadro son:
• Multifuncional. Instala ambos motores y les da la misma potencia.
• Transacional. Instala ambos, pero da preferencia a InnoDB en los
recursos a fin de manejar correctamente las transacciones.
• No transacional. Desactiva InnoDB y activa sola MyISAM.
Elección del directorio donde instalar los datos. Lo que se conoce como la
ubicación del tablespace de datos. Sólo se usa con InnoDB y permite
colocar los datos en otra ubicación respecto a los del programa MySQL o
incluso en otra unidad de disco.
Elección del número de conexiones concurrentes. La primera opción es
para bases de datos con escaso número de conexiones concurrentes, la
segunda pensada para transacciones en línea (OLTP) y la tercera permite
editar a mano el número de conexiones concurrentes.
Selección del número de puerto (normalmente el 3306) y elegir si
deseamos el modo estricto de trabajo (es lo recomendable).
Elección del juego de caracteres que se utilizará para codificar el texto
de la base de datos.
Elección del modo de trabajo del servicio. Normalmente MySQL se instala
como un servicio de Windows más, pero podríamos no desearlo. Se puede
cambiar el nombre al servicio.
En este mismo paso se puede modificar el PATH de Windows para incluir
el directorio bin en el path y así desde la línea de comandos utilizar los
comandos mysql sin tener que modificar nuestra ruta.
El siguiente paso es muy importante. Se DEBE de cambiar la contraseña
del usuario root, del superadministrador, por seguridad. Además se puede
elegir si permitimos los accesos de este usuario de forma remota (desde
otro ordenador) y si activamos la cuenta anónima (acceso sin contraseña),
que no es recomendable.
Tras esos pasos comienza la instalación en sí. Si todo va bien aparece un
mensaje como éste:
(32)
Ilustración 6, Cuadro de diálogo que aparece cuando la

instalación ha concluido
En el cuadro último, se indica la ruta del archivo de configuración en el que se han

guardado los parámetros de instalación. Es el archivo my.ini situado en la carpeta
de instalación de MySQL. Examinar ese archivo es interesante y modificarle
permitiría cambiar el funcionamiento de MySQL independientemente de lo que se
haya especificado en la instalación.
comprobar funcionamiento de MySQL
Necesitamos probar la instalación. En Windows, MySQL crea las tablas de
privilegios y usuarios sin tener que configurar más. Además creará tres bases de
datos y diversas tablas en ellas como ejemplo.
MySQL será un servicio que se iniciará automáticamente en el arranque. De no
desearlo así debemos ir a la pantalla de Servicios de Windows (dentro de la
carpeta de herramientas administrativas) y parar el servicio además de indicar
que no deseamos su inicio automático (en las propiedades del servicio MySQL).
Para detener el servicio, basta ir a la línea de comandos e indicar el comando:
net stop MySQL
Si deseamos iniciar de nuevo el servicio:

net start MySQL
Si el servicio está funcionando, para probar el funcionamiento basta con conectar

con MySQL desde la línea de comandos, por ejemplo con:
mysql –u root –p
Después se nos solicitará la contraseña del administrador. Y entonces estaremos

viendo el Shell de MySQL (la pantalla que interpreta comandos MySQL). Por
ejemplo ejecutando el comando show databases, se nos mostrarán las bases de
datos ejemplo de MySQL.
En el caso de que el servidor no arranque con el comando net, podemos lanzar
MySQL invocando al programa (demonio) mysqld
desinstalar MySQL en el caso de instalación con el paquete msi
Para ello basta con ir al panel de control, localizar MySQL y desinstalar. Pero eso
elimina sólo los archivos de MySQL que se crearon en la instalación, los archivos de
configuración y datos permanecerán donde se crearon y eso puede causar
(33)
problemas en otra instalación. Para desinstalar completamente:

(1) Desinstalar desde el panel de control
(2) Eliminar el contenido de C:\Documents and Settings\All Users\Application
Data\MySQL, o bien en Windows 7 o Windows Server 2008
C:\ProgramData\MySQL (ProgramData es una carpeta oculta que
deberemos mostrar con la opción de mostrar carpetas y archivos ocultos de
Windows)
(3) Revisar la carpeta de instalación de MySQL y comprobar que no ha quedado
ningún archivo sin borrar
instalar MySQL desde un fichero ZIP
En ese caso tenemos un archivo comprimido que contiene la instalación de MySQL,
simplemente habrá que configurar la instalación. Los pasos son:
(1) Extraer el fichero ZIP en la ubicación deseada
(2) Crear un fichero de opciones con al menos las líneas donde colocar la
ubicación de MySQL y los datos. Aunque hay varias posibilidades de colocar
el archivo de configuración (como se describirá más adelante), lo habitual
es llamarle my.ini y colocarle en la carpeta de instalación de Windows (por
ejemplo C:\Windows).
Conviene copiar uno de los archivos de configuración que se encuentran en
la carpeta raíz de MySQL (por ejemplo my-medium.ini), cambiarle el
nombre a my.ini y modificar las líneas deseadas.
Ejemplo de ello es por ejemplo indicar cuál es el directorio raíz de MySQL y
la carpeta donde se almacenará la base de datos.
Para ello se añadirían las siguientes líneas a la sección mysqld:

[mysqld]
….. otros parámetros de configuración
# coloca en basedir el directorio de instalación
basedir=E:/mysql
# coloca en datadir el directorio de datos
datadir=E:/mydata/data
Como se ve en el ejemplo MySQL usa las barras de los directorios al estilo
Unix (/ en lugar de \). Para que la ruta cuadre con el archivo de opciones es
necesario asegurar que la raíz de los archivos de MySQL se encuentra donde
se ha marcado en el archivo de opciones.
Nota: Normalmente el directorio de datos (data), se encuentra debajo de la raíz de
instalación de MySQL, si deseamos utilizar la nueva ubicación deberemos copiar el
contenido de data a esa nueva ubicación.
(3) Colocar la ruta al directorio bin de MySQL dentro de la variable PATH de
Windows.
(4) Lanzar la instancia de la base de datos desde la línea de comandos escribiendo:
mysqld --console.
(34)
Tras este comando (si la configuración está bien), se quedará la consola

con el mensaje: Version: '5.5.16' socket: '' port: 3306 MySQL
Community Server (GPL) (suponiendo que disponemos de MySQL
Community Server versión 5.5.16).
El servidor MySQL está lanzado y escuchando por el puerto 3306
(5) Para el resto de veces bastará con lanzar el demonio de MySQL (mysqld),
simplemente escribiendo mysqld en la línea de comandos.
arrancar MySQL como un servicio
También es posible en este tipo de instalación arrancar MySQL como un servicio.
Basta con:
mysqld --install
Si no funcionara es posible que el servidor MySQL esté en funcionamiento.

Detener implica usar el comando:
mysqladmin -u root shutdown
Desde este instante tendremos MySQL colocado como servicio de Windows.

Disponemos de las opciones de comandos:
mysql --install-manual. Para instalar MySQL como servicio que debe iniciarse
manualmente.
mysql --remove. Para eliminar MySQL como servicio.
desinstalar si la instalación es desde un ZIP
(1) Desinstalar el servicio de MySQL si es tal. En todo caso detener la instancia
definitivamente de MySQL con sc delete mysql
(2) Si lo anterior no funciona (por ejemplo sino se configuró como servicio),
entonces: mysqladmin -u root shutdown
(3) Borrar el archivo de configuración my.ini
(4) Borrar los archivos de MySQL
En realidad en este tipo de instalación, todo es más sencillo porque no se instala

MySQL al estilo de las aplicaciones de Windows
El usuario administrador en este tipo de instalación no posee contraseña; habría que
cambiarla más tarde.
(6.5.4) instalación en Linux/Unix

instalación binaria genérica
La instalación binaria genérica en los sistemas de tipo Unix es similar a la de
Windows mediante archivo ZIP. Este tipo de instalación valdría para cualquier
versión de Linux. La ventaja es la comodidad y el hecho de que se maneje igual en
todo tipo de Unix/Linux. La desventaja es que esta instalación no está optimizada
para la versión de Linux concreta en la que instalamos MySQL.
(35)
La instalación creará una carpeta raíz desde la que colgarán todos los
directorios de MySQL, concretamente:
directorio uso
bin Ubicación de los programas MySQL
data Ubicación de los datos de las bases de datos
docs Manual en formato info de Linux
man Manual en formato del comando man de Unix
include Cabeceras de código fuente
lib Archivos de librería
scripts Contiene el script mysql_install_db
share Mensajes de error, juegos de caracteres, ejemplos,…
sql-bench Benchmarks
Los pasos son:
(1) Descargar el archivo comprimido con la instalación desde
http://dev.mysql.com/downloads/ Será algo así como Linux Generix
xxxx.tar.gz TAR Compressed donde las equis indican la versión del
sistema (por ejemplo versión 2.6 de 32 o 64 bits)
(2) Abrir la consola de comandos (el Shell) con privilegios administrativos y
ejecutar la orden:
groupadd mysql.
Esto añade un grupo para el usuario relacionado con MySQL
(3) Ejecutar la orden:
user add -g mysql mysql.
Esto crea un usuario llamado mysql que pertenece al grupo anterior.
(4) Colocarnos en el directorio que contendrá la instalación de MySQL. Lo
habitual es el comando: cd /usr/local.
(5) Descomprimir el archivo con:
tar zxvf rutaCompletaAlArchivoTAR .tar.gz.
Necesitamos indicar la ruta al archivo tar para descomprimirlo en la
carpeta en la que nos posicionamos en el punto 4. Es decir si hemos
descargado MySQL en la carpeta de descargas, podría ser: tar zxvf
$HOME/Downloads/MySQL-5.5.16- 1.Linux.2.6.x86_64.tar.gz. El resultado
es MySQL descomprimido en /usr/local (o en el directorio que hayamos
indicado en el punto 4.
(6) Crear un enlace simbólico al directorio de instalación MYSQL para tener un
acceso más sencillo. Por ejemplo:
cd $HOME
ln -s /usr/local/mysql-5.5.16-linux.2.6-x86_64 mysql
Desde ese momento el comando cd mysql, ejecutado desde la carpeta local
de usuario, entra en el directorio de instalación de MySQL.
(36)
(7) Ir al directorio raíz de MySQL (con cd mysql usando el enlace creado en el

punto anterior) desde ahí dar propiedad de los archivos de MySQL al
usuario root y grupo mysql creados anteriormente. Al usuario mysql se le
da la propiedad de la carpeta data donde se encuentran los datos:
chown -R root .
chown mysql data
chgrp -R mysql .
(8) Para el paso siguiente necesitamos la librería libaio1, si no disponemos de
ella hay que instalarla. En los Linux tipo Debian (como Ubuntu) con:
apt-get install libaio1 libaio-dev
En los Linux tipo Red Hat (como Fedora) con:

yum install libaio1
(9) Instalar las tablas iniciales mediante (suponiendo que seguimos en la raíz
de MySQL):
scripts/mysql_install_db --user=mysql
(10) Iniciar MySQL, pero teniendo cuidado de hacerlo sin ser el usuario root. La
forma de hacerlo (situados desde la raíz de MySQL):
bin/mysqld_safe --user=mysql &
Si sale bien el servidor estará funcionando correctamente. En la pantalla
de consola, se queda sin salir el prompt mientras el servidor siga
funcionando.
(11) Comprobar que realmente MySQL está funcionando con (situados desde la
raíz de MySQL):
bin/mysqladmin version
Si todo ha ido bien, el resultado sería algo como:
bin/mysqladmin Ver 8.42 Distrib 5.5.16, for linux2.6 on x86_64
Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its

affiliates. Other names may be trademarks of their respective
owners.
Server version 5.5.16

Protocol version 10
Connection Localhost via UNIX socket
UNIX socket /tmp/mysql.sock
Uptime: 1 min 27 sec
Threads: 1 Questions: 1 Slow queries: 0 Opens: 33 Flush tables: 1 Open tables:

26 Queries per second avg: 0.011
(12) Comprobar que podemos cortar MySQL (situados desde la raíz de MySQL):
(37)
bin/mysqladmin -u root shutdown

Si volvemos a comprobar si MySQL está en pie mediante el comando mysqladmin
versión, debería salir algo parecido a:
bin/mysqladmin: connect to server at 'localhost' failed
error: 'Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)'
Check that mysqld is running and that the socket: '/tmp/mysql.sock' exists!
(13) Lanzar de nuevo el servidor (situados desde la raíz de MySQL):

bin/mysqld_safe --user=mysql
(14) Entrar en MySQL (situados desde la raíz de MySQL):
bin/mysql
No hay contraseñas para ningún usuario, por lo que es conveniente hacerlo (se
explica más adelante
preparar MySQL para el inicio automático
Si se desea que MySQL se inicie automáticamente en cada encendido del
ordenador, bastará con copiar el script mysql.server que se encuentra en el
directorio support- files que, a su vez, está en la raíz de MySQL. La copia se
realiza al directorio que contiene los scripts de inicio del sistema, normalmente
/etc/init.d
El comando a ejecutar sería (estando en la raíz de MySQL):
cp support-files/mysql.server /etc/init.d/mysql
chmod +x /etc/init.d/mysql
Eso le coloca en los scripts de inicio con el nombre mysql y le da permiso de

ejecución. Desde ese momento el servicio mysql ya existe. Para lanzarle en cada
reinicio existen comandos en los diversos Linux. El más popular:
chkconfig --level 345 mysql on
Que iniciará el servidor en los niveles 3,4 y 5 del sistema, con el código de secuencia 50.
En el caso de Ubuntu (y de otros Linux tipo Debian), ese comando no existe y
actualmente se puede utilizar:
update-rc.d mysql defaults
que coloca el servicio mysql en los niveles 2,3,4 y 5 y le asigna el código de secuencia
20. Este otro comando es equivalente al chkconfig anterior:
update-rc.d mysql start 50 3 4 5 . stop 50 0 1 2 6
Ambos comandos tienen más opciones que serán fáciles de utilizar para quienes tengan
conocimientos sobre cómo funciona el arranque en Linux.
Para que estas opciones funciones, el archivo de configuración my.cnf situado
normalmente en /etc/my.cnf debería contener estas líneas al menos:
[mysqld]
datadir=/usr/local/mysql/data
basedir=/usr/local/mysql
La ruta /usr/local/mysql en el ejemplo es la que apunta a la raíz de MySQL.
(38)
desinstalar MySQL si la instalación es binaria ZIP
Si deseamos desinstalar MySQL del sistema; en este caso basta con parar el
servidor, eliminar los servicios relacionados con MySQL (si es necesario) que se
inician con el sistema y eliminar la carpeta raíz y todos los subdirectorios
(comando rm -R)
instalación mediante gestores de paquetes
Casi todos los Linux tienen predefinidos paquetes para instalar MySQL. Es el caso
de los paquetes rpm que se pueden instalar fácilmente en cualquier Linux de tipo
Red Hat (como Fedora).
Es la instalación recomendada desde el fabricante, la cuestión es que la
localización de los programas varía respecto a la instalación mediante binarios
genéricos. Por paquetes MySQL se organiza de la siguiente manera:
directorio uso
/usr/bin Ubicación de los programas MySQL y de sus scripts
/usr/sbin Ubicación del servidor mysqld
/var/lib/mysql Archivos log y bases de datos
/usr/share/info Manual en formato info de Linux
directorio uso
/usr/share/man Manual en formato del comando man de Unix
/usr/include/mysql Cabeceras de código fuente
/usr/lib/mysql Archivos de librería
/usr/share/mysql Raíz de MySQL. Mensajes de error, juegos de caracteres,
ejemplos,…
/usr/share/sql-bench Benchmarks
/etc/apache2 Archivos de configuración y soporte
instalación en Linux tipo RedHat (como Fedora)

Se suele usar la utilidad yum (o bien la utilidad gráfica de instalación de paquetes):
yum install mysql-server
Esto descarga los archivos necesarios y cambia la contraseña del administrador de

la base de datos (la pide por teclado).
Una vez instalado se usaría el comando:
service mysqld start
Lanza el servidor MySQL y lo coloca como servicio del sistema. Si deseamos
que sea un servicio que funcione desde el arranque del sistema, se haría:
chkconfig --levels 235 mysqld on
(39)
De esa forma en los niveles de ejecución 2,3 y 5; el demonio de MySQL (el proceso
servidor) se arranca desde el inicio. El código:
chkconfig --levels 235 mysqld off
Elimina del arranque al servicio.

instalación en Linux tipo Debian (como Ubuntu)
En los Linux derivados de Debian (como Ubuntu) pueden instalar el servidor MySQL con:
sudo apt-get install mysql-server
También se puede utilizar la herramienta gráfica Synaptic para instalar el

paquete de servidor de MySQL.
Se pedirá una contraseña administrativa y se habrá arreglado el PATH, se habrá
colocado el archivo de configuración en /etc/mysql/my.conf y se colocará como
servicio de arranque el script /etc/init.d/mysql que permite que el servidor puede
lanzarse automáticamente durante el arranque.
En todo momento podemos parar el servidor con:
service mysqld stop
y lanzar con:
service mysqld start
Además podremos colocar el servicio mysql para que se inicie automáticamente
mediante:
update-rc.d mysqld defaults
(6.5.5) asegurando la instalación

contraseñas de usuarios
Hay que intentar desde el primer momento que la instalación de MySQL no
permita que los usuarios puedan sobrepasar sus privilegios y dañar las bases de
datos. Por ello hay que asegurar que todos los usuarios (y en especial los
administrativos) tienen contraseña.
En las instalaciones en Windows ya existen las cuentas de usuario y se las pone
contraseña durante la instalación. Sin embargo algunas instalaciones en Windows
(las genéricas) no tienen los usuarios preconfigurados. Para configurar
inicialmente los usuarios se lanza el script (comentado anteriormente)
mysql_install_db. Con ello en la tabla mysql.user dispondremos de los usuarios
iniciales.
En Windows hay un usuario root (superusuario) que tienen privilegios totales
pero que solo puede acceder a la máquina local. Para permitir el acceso con esos
privilegios desde otra máquina, se crea otro usuario root (durante la instalación
de MySQL se pregunta esa posibilidad). En Linux los usuarios root permiten el
acceso local.
Hay cuentas anónimas (no tienen nombre de usuario) algunas para acceder de
forma local y otras no. Para asegurar el acceso se deben poner contraseñas a las
cuentas anónimas o bien eliminarlas.
Para examinar la lista de usuarios se usa:
SELECT user, host, password FROM mysql.user;
(40)
Para cambiar la contraseña, por ejemplo:

SET PASSWORD FOR 'root'@'localhost' = PASSWORD(‘Atrezzo’);
En el ejemplo se cambia la contraseña para el superadministrador root cuando

accede de forma local.
Otra forma (mejor puesto que modifica de golpe la contraseña de todos los root) es:
UPDATE mysql.user SET password=PASSWORD(‘Atrezzo’)
WHERE user=’root’;
FLUSH PRIVILEGES;
La última instrucción es la que hace que el cambio se lleve a cabo.

eliminación de la base de datos ejemplo
En muchas instalaciones de MySQL se dispone de una base de datos llamada test
que, en realidad, es para pruebas. Dejarla puede proporcionar un agujero de
seguridad, por lo que si no deseamos usarla para aprender se debe de eliminar
con:
DELETE FROM mysql.db WHERE Db LIKE 'test%';
FLUSH PRIVILEGES;
La última orden (FLUSH PRIVILEGES) confirma los cambios.
(6.6) PHP
(6.6.1) ¿qué es PHP?
Actualmente significa Hipertext Pre Processor y se trata del lenguaje de scripts
de servidor más popular.
Un lenguaje de scripts, en general, es un lenguaje cuyo código se incrusta
dentro de otro. Es el caso de JavaScript que es un lenguaje que va incrustado
dentro del código HTML de una página web. Pero, en el caso de JavaScript está en
el lado del cliente; es decir es el navegador de Internet el que tiene que tener la
capacidad de interpretar el código del lenguaje script, además del HTML.
Eso provoca una desventaja: los navegadores tienen que tener capacidades
añadidas y un nuevo lenguaje de ese tipo implica nuevos plugins para los
navegadores, con el riesgo de que algunos usuarios naveguen por las páginas web
sin poder verlas adecuadamente porque su navegador no tiene instalado el plugin.
Por ello los lenguajes de scripts de servidor han tenido mucho éxito. En ese
caso, es el servidor el que interpreta el lenguaje script y devuelve al navegador el
resultado de interpretar dicho lenguaje, que siempre es HTML.
PHP es gratuito y software de código abierto que tiene una relación excelente
con Apache, MySQL y Linux; aunque actualmente en Windows también se instala
muchísimo.
PHP se puede instalar también en servidores IIS de Microsoft y en otros
muchos; además puede utilizar sistemas de bases de datos como Oracle, Informix,
DB2,…
Los archivos de instalación de PHP están disponibles en
www.php.net/download.php. En cualquier caso las posibilidades de instalación
son las habituales:
(41)
Mediante archivos binarios. Que tienen estas dos posibilidades

• Un instalador msi (Windows) o instalación por paquetes (Linux)
• Binarios comprimidos (ZIPo TAR) Instalar por código fuente
(6.6.2) instalación en Windows

Desde el sitio http://windows.php.net/download/ se descarga el archivo msi (o
los archivos binarios ZIP) deseados. Es muy importarte leer la columna izquierda
para saber qué versión de PHP bajarse en función de nuestro servidor web.
Para Apache desde esa página (actualmente) habría que bajarse las versiones
VC6 que están optimizadas para él. Se comenta la instalación mediante binario
ZIP:
(1) Descomprimir los binarios en la ubicación deseada (por ejemplo C:\PHP)
(2) Añadir la ruta a la carpeta raíz de PHP y a la carpeta Ext (dentro de la
anterior, normalmente) como parte de la variable PATH del sistema.
(3) En la carpeta de instalación de PHP, copiar php.ini-recommended.ini a
php.ini. Eso usa un archivo de configuración preconstruido (podría ser
también el archivo php.ini-production en lugar de php.ini-recommended),
que después se puede modificar. php.ini es el archivo de configuración
principal de PHP.
(4) Buscar y modificar (o añadir si no se encuentran) estas líneas al archivo php.ini:
; Muestra errores
display_errors = On
;Especificar la ruta de las extensiones de PHP
extension_dir = "./ext"
;Habilitar el soporte de MySQL
extension=php_mysql.dll
extension=php_mysqli.dll
(5) Editar el archivo httpd.conf de Apache y añadir estas líneas (suponiendo
que PHP está instalado en c:\PHP):
PHPIniDir "C:/php"
LoadModule php5_module "c:/php/php5apache2_2.dll"2
AddType application/x-httpd-php .php
(6) Probamos el servicio (puede ser bueno incluso reiniciar el ordenador)
(7) Crear este archivo en la carpeta htdocs de Apache (si esa sigue siendo la
carpeta la que se almacenan las webs que sirve Apache) y llamarle
<?php
phpinfo();
?>
prueba.php:
(8) Arrancar Apache y navegar a http://localhost/prueba.php
(42)
(6.6.3) instalar en Linux

instalar con código fuente
(1) Descargar la instalación en forma de archivo tar.gz
(2) Descomprimir desde el sistema gráfico de Linux (normalmente usando la opción
Extraer aquí) o desde la línea de comandos usando el comando:
tar xzvf archivoPHP.gz.zip
(3) Crear el directorio en el que se instalará PHP (por ejemplo /usr/local/php)
(4) Puede ser necesario instalar el paquete libxml2-dev. En Linux tipo Debian
(como Ubuntu) se hace:
apt-get install libxml2-dev
En Linux
yum install libxml2-devel)
Para compatibilidad con MySQL habría que instalar los paquetes relacionados,
en especial mysql-client
(5) Entrar en la carpeta descomprimida anteriormente y ejecutar el comando

configure. Este comando sirve para configurar la instalación, en él hay que
indicar dónde está el directorio apxs. Normalmente está dentro del
directorio bin en la raíz de Apache (por ejemplo
/usr/local/apache2/bin/apxs).
La opción --with-mysql da soporte para MySQL y la opción --prefix permite elegir
dónde se realizará la instalación (si no se usa prefix, se instala en
/usr/local/php):
./configure --with-apxs2=raízApache/bin/apxs --with-mysql =raízMySQL
--prefix=raízPHPDeseada
(6) Compilar (desde dentro de la carpeta anterior):
make
make install
(7) Copiar el archivo php-development (que está en el directorio
descomprimido de instalación) a /usr/local/lib/php.ini para convertirlo en
el archivo de configuración php.ini. Dicho archivo podría estar en otra
ubicación si en el paso 5 (uso del comando ./config9 se hubiera hecho uso
de la opción:
./config …. --with-config-file-path=rutaDeseadaParaPHP.ini
La copia se haría con (suponiendo que seguimos dentro de la carpeta
descomprimida con la instalación de PHP):
cp php.ini-development /usr/local/lib/php.ini
2
Si usáramos Apache 2.0 el archivo sería php5apache.dll
Si usáramos Apache 2.3 sería php5apache2_3.dll (en todo caso conviene leer la
documentación de Apache y PHP disponible en ese momento)
(43)
(8) Añadir estas líneas al archivo general de configuración de Apache httpd.conf:

LoadModule php5_module modules/libphp5.so
AddType application/x-httpd-php .php
AddType application/x-httpd-php .phtml
La más importante es la primera; se supone que la orden make install,
coloca el módulo de PHP en el directorio modules de Apache, pero
conviene comprobarlo para asegurare que funcionan esas configuraciones.
(9) Reiniciar el servidor Apache
(10) Crear un documento php en el directorio de documentos de Apache
<?
phpinfo();
?>
(11) El resultado deberá ser algo como:
instalar con paquetes

Como en el caso de Apache y MySQL, es posible instalar PHP mediante gestores de
paquetes. Los nombres varían en cada sistema, por ejemplo en Debian sería:
apt-get install libapache2-mod-php5
(44)
(6.7) paquetes completos

Apache/MySQL/PHP
Hay varias posibilidades de instalar paquetes con Apache, MySQL y PHP ya
perfectamente configurado. La ventaja es la facilidad de instalación, la
desventaja es que suelen facilitar la instalación a cambio de hacerla más insegura.
(6.7.1) XAMPP
Se trata de la instalación más popular de estos servicios, es multiplataforma; pero
es sobre todo utilizada en Linux. Instala Apache, MySQL, PHP, phpMyAdmin,
Perl, e incluso un servidor FTPD (FileZilla) y oro de correo, además de otras
muchas herramientas (por ejemplo Open SSL), lo que la hace muy versátil. Se
descarga de
http://www.apachefriends.org/es/xampp.html
instalación en Windows
Hay tres posibilidades:
(1) Instalar mediante un programa ejecutable. Luego paso a paso elegimos la
carpeta raíz de la que colgarán todos los servicios. Después en el menú
Inicio- Programas-XAMPP, tendremos el panel de control para ejecutar los
servicios deseados (Apache, MySQL,…).
(2) Instalar desde un archivo comprimido ZIP. En ese caso bastará con
descomprimir en la carpeta que deseemos y después ejecutar el archivo
BAT setup_xampp.bat que se encontrará en dicha carpeta, ese instalador
prepara el entorno.
Ilustración 7, Resultado de lanzar setup_xampp.bat en la

instalación por USB
(45)
Después desde el panel de control (disponible en la raíz de xampp

mediante el archivo xampp_control.bat) podemos lanzar (start) y detener
los servidores deseados:
Ilustración 8, El Panel de Control de XAMPP con Apache y MySQL

en funcionamiento
Para probar que realmente está funcionando el servidor Apache desde un
navegador bastará ir a la dirección http://localhost, aparecerá esta
pantalla:
Ilustración 9, Splash page de XAMPP probando que el servidor

web está instalado
Navegando en el idioma deseado comprobaremos cómo está la configuración
(3) Instalar en una unidad USB. Esa opción instala un servidor más ligero que
instala sólo Apache, PHP, MySQL y OpenSSL para la seguridad. Es una
versión portable que se instala en la unidad y la podremos ejecutar (si
tenemos permisos suficientes) en cualquier sistema sin instalación previa.
El funcionamiento es como en el caso anterior
(46)
manejo de xampp
El Panel de Control está disponible mediante el archivo xampp-control en el
directorio raíz de xampp. Gracias a él podremos iniciar y detener los servidores
deseados.
También podemos utilizar estos otros archivos:
Archivo Uso
\xampp\xamp_start.exe Lanza Apache y MySQL
\xampp\xamp_start.exe Detiene Apache y MySQL
\xampp\apache_start.bat Lanza Apache
\xampp\apache_stop.bat Detiene Apache
\xampp\mysql_start.bat Lanza MySQL
\xampp\mysql_stop.bat Detiene MySQL
directorios
La organización de directorios es (partiendo de la carpeta de instalación de XAMPP):
Directorio Uso
\xampp\apache Carpeta raíz del servidor Apache
\mysql Carpeta raíz del servidor MySQL
\xampp\php Carpeta raíz de PHP
\xampp\htdocs Carpeta para almacenar las páginas
web del servidor
\xampp\cgi-bin Carpeta para almacenar los CGI
(programas ejecutables de servidor)
\xampp\mysql\data Carpeta de las bases de datos
MySQL
\xampp\apache\conf\httpd.conf Archivo de configuración de Apache
\xampp\php\php.ini Archivo de configuración de PHP
\mysql\bin\my.ini Archivo de configuración de MySQL
\xampp\phpMyAdmin\config.inc.php Configuración de PhpMyAdmin
\xampp\FileZillaFTP\FileZilla Server.xml Configuración del servidor FTP
FileZilla.
\xampp\apache\logs\error.log Archivo LOG de Apache (errores de
Apache)
\xampp\mysql\data\mysql.err Log de errores de MySQL
\xampp\anonymous Directorio de descarga de archivos
para el acceso anónimo del servidor
FTP
(47)
seguridad
En la instalación normal de XAMPP ocurren estos problemas (indicados por la propia
de descarga de XAMPP):
El usuario administrador de MySQL (root) no tiene
contraseña. El servicio MySQL es accesible por la red.
La página de demostración de XAMPP es accesible por la red
phpMyAdmin es accesible por la red
Los usuarios por defecto de los servidores de correo (Mercury) y de FTP son
conocidos.
Por ello no es un entorno seguro para producción salvo que se proceda a eliminar
estas inseguridades. Esto se realiza fácilmente una vez instalado XAMPP, desde la
página http://localhost/security/ (suponiendo que el servidor XAMPP sea
accesible desde http://localhost sino habrá que indicar correctamente la raíz del
sitio web de XAMPP) y allí podremos paliar estos problemas.
Por otro lado la instalación Lite (normalmente en un USB) al instalar menos
servidores consume menos recursos y reduce la inseguridad.
instalación en Linux
Una vez descargada los pasos para instalarla son:
(1) Extraer el archivo descargado al directorio /opt (con permisos de root). Por
ejemplo:
tar xvfz xampp-linux-1.7.7.tar.gz -C /opt
(2) Lanzar los servidores con:
/opt/lampp/lampp start
(3) Comprobar la instalación usando un navegador y escribiendo

http://localhost La página que aparece permite ver la documentación y
configurar la aplicación.
(48)
seguridad
La seguridad de la instalación es baja, de hecho ocurren estos
detalles: El administrador de MySQL no tiene contraseña
El servidor de MySQL es accesible por la red
El servidor FTP que viene con el paquete (ProFTP) tiene un usuario y
contraseña conocido: usuario nobody contraseña lampp
El gestor visual PhpMyAdmin es accesible por la
red Las páginas de ejemplo son accesibles.
Tanto MySQL como Apache usan el mismo usuario al ejecutarse (usuario
nobody)
El propio XAMPP tiene una opción que reduce el riesgo antes de que configuremos
adecuadamente la seguridad, es lanzarse de esta forma:
/opt/lampp/lampp security
Que protege más la instalación (usando contraseñas aleatorias y otros usuarios

creados para la ocasión).
otras opciones
El comando lampp dispone de estas opciones:
Opción del
Significado
comando
stop Detiene todo XAMPP
restart Detiene todo XAMPP y lo vuelve a lanzar
startapache Lanza sólo Apache
startssl Activa el protocolo seguro SSL para todas las ejecuciones futuras de
Apache
startmysql Lanza sólo MySQL
startftp Lanza el servidor FTPD que permite transmitir ficheros con el usuario
inicial nobody y la contraseña lampp
stopapache Detiene Apache
stopssl Desactiva el protocolo seguro SSL para todas las ejecuciones
posteriores del servidor Apache
stopmysql Detiene MySQL
stopftp Detiene FTPD. Si se lanza todo XAMPP con start, FTPD no se ejecutará
security Programa para probar el sitio web XAMPP con total seguridad
(49)
directorios
La organización de directorios es:
Directorio Uso
/opt/lampp/bin/ Raíz de los programas ejecutables de
las aplicaciones. Así:
/opt/lampp/bin/mysql lanza el
cliente de MySQL
/opt/lampp/htdocs/ Raíz de las páginas web alojadas en
Apache. Es decir DocumentRoot de
Apache.
/opt/lampp/etc/httpd.conf Configuración de Apache
/opt/lampp/etc/my.cnf Configuración de MySQL
/opt/lampp/etc/php.ini Configuración de PHP
/opt/lampp/etc/proftpd.conf Configuración de ProFTPD
/opt/lampp/phpmyadmin/config.inc.php Configuración de PhpMyAdmin
(6.7.2) AppServ
Es quizá la opción más potente instala Apache, PHP, MySQL y el gestor
phpMyAdmin para administrar MySQL con miras a PHP. Se descarga de:
http://www.appservnetwork.com/
Desde ahí se descarga un ejecutable que, al lanzarse, realiza paso a paso la instalación.
Ilustración 10, Pantalla inicial de AppServ
Tras breves preguntas sobre, el directorio de instalación (normalmente

C:\AppServ) la configuración de Apache (nombre del servidor y puerto) y la
configuración de MySQL (contraseña de root).
(50)
Todos los comandos de parada y encendido, así como la configuración de

httpd.conf, my.ini (para configurar MySQL) y php.ini (los archivos de
configuración de las tres aplicaciones) funcionan igual que en cualquier
instalación; pero además disponemos de un grupo de programas en el menú inicio
que nos facilita casi todas las tareas con los servidores.
directorios de AppServ
El problema de estas instalaciones en paquete a veces es entender la nueva
configuración de directorios. Pero en este caso es fácil, de la raíz de instalación
cuelgan:
Apache 2.2. Raíz de Apache
MySQL. Raíz de MySQL.
php5. Raíz del módulo de PHP
www. Todas las carpetas anteriores tienen la configuración habitual de
cada aplicación. Pero www es la carpeta (en lugar de la habitual htdocs
de Apache) que aloja las páginas a publicar. Es decir, es el
DocumentRoot de Apache.
(6.8) ¿qué es PHP?

(6.8.1) lenguajes de script de servidor
Las páginas web se crean mediante HTML, y este es un lenguaje muy limitado
para atender a los requerimientos que actualmente se exigen. Por ello han
aparecido numerosas extensiones al lenguaje que permiten enriquecer las
páginas web.
Muchas mejoras están orientadas al cliente, es decir que se trata de código
de otros lenguajes (llamados lenguajes de script) que se añaden al código
HTML y que el ordenador que recibe la página debe interpretar a través del
software apropiado. Por lo tanto el cliente de la página debe poseer el
software apropiado. Y esto es un problema.
Por ello aparecieron lenguajes y mejoras en el lado del servidor. De modo
que el programador añade al código HTML código de otro lenguaje script de la
misma manera que el párrafo anterior. La diferencia es que este código no se
le envía al cliente sino que es el servidor el que le interpreta. El cliente
recibirá una página HTML normal y será el servidor el que traduzca el código
script.
(6.8.2) PHP
Se trata indudablemente del lenguaje script de servidor más popular. Fue el
primero en aparecer aunque realmente empezó a imponerse en torno al año
2000 por encima de ASP que era la tecnología de servidor reinante.
Hoy en día se puede instalar módulos para interpretar PHP en casi todos los
servidores de aplicaciones web. En especial PHP tiene una gran relación con
Apache.
Es un lenguaje basado en C y en Perl, que se ha diseñado pensando en
darle la máxima versatilidad y facilidad de aprendizaje, por encima de la
rigidez y coherencia semántica.
(51)
(6.8.3) ventajas de PHP

(1) Multiplataforma. A diferencia de otros lenguajes (especialmente de
ASP y ColdFussion), se trata de un lenguaje que se puede lanzar en
casi todas las plataformas de trabajo (Windows, Linux, Mac,…)
(2) Abierto y gratuito. Pertenece al software licenciado como GNU, la
licencia del sistema Linux; lo que permite su distribución gratuita y que
la comunidad mejore el código.
(3) Gran comunidad de usuarios. La popularidad de PHP, junto con la gran
defensa que de él hacen los defensores del código abierto, permite
tener una comunidad amplia y muy dinámica a la que acudir en caso de
necesidad.
(4) Apache, MySQL. Apache es el servidor web y de aplicaciones más
utilizado en la actualidad. MySQL es el servidor de bases de datos
relacionales más popular en Internet para crear aplicaciones web.
Puesto que PHP tiene una gran relación y compatibilidad con ambos
productos (está de hecho muy pensado para hacer tándem con ellos),
esto se convierte en una enorme (y a veces determinante) ventaja.
(5) Extensiones. Dispone de un enorme número de extensiones que
permiten ampliar las capacidades del lenguaje, facilitando la creación
de aplicaciones web complejas.
(6) ¿Fácil? Es un punto muy controvertido. Los programadores PHP
entusiastas, defienden esta idea; es indudable además que fue uno de
los objetivos al crear este lenguaje. Sin embargo Microsoft defiende
con energía que ASP permite crear aplicaciones web complejas con
gran facilidad; y parece indudable que el lenguaje ColdFussion de
Macromedia (ahora de Adobe) es más sencillo de aprender.
Las características de PHP correspondientes a la libertad de creación y
asignación de valores a variables, tipos de datos poco restrictivos, y
otras ausencias de reglas rígidas suelen ser los puntos que defienden los
programadores de PHP para estimar su facilidad de aprendizaje. Sin
embargo los programadores de lenguajes formales como C y Java,
seguramente se encontrarán con más problemas que ventajas al
aprender este lenguaje.
(6.9) herramientas y software necesario

Para crear aplicaciones web en PHP necesitamos disponer de software
específico que complica los requisitos previos que tiene que tener la máquina
en la que deseemos aprender y probar el lenguaje. Lo imprescindible es:
Un servidor web compatible con PHP. La mayoría lo son, pero
parece que la opción de usar Apache es la más recomendable por la
buena relación que han tenido ambos productos. No obstante cada
vez es más habitual utilizar PHP en servidores como IIS o ngnx.
Motor PHP. Se trata del software que extiende al servidor web
anterior para conseguir que se convierta en un servidor de
aplicaciones web PHP. Necesitamos descargar e instalar dicho motor
correspondiente al módulo de PHP compatible con el servidor web con
(52)
el que trabajemos.
IDE para PHP. Un IDE es un entorno de desarrollo integrado; es decir,
un software que facilita la escritura de código en otro lenguaje. En
realidad se puede escribir código PHP en cualquier editor de texto
(como el Bloc de Notas de Windows por ejemplo); pero estos entornos
facilitan la edición de código (con coloreado especial de las palabras
de PHP, corrección del código en línea, abreviaturas de código,
plantillas,…) y su prueba y depuración.
Los IDEs más populares son:
• Basados en Eclipse. Eclipse es un entorno de programación de
aplicaciones pensado para Java pero que dispone de muchas
extensiones que permite programar para diferentes lenguajes,
convirtiéndose así en la plataforma de programación más popular
de la actualidad. Las extensiones de Eclipse más populares para
programar en PHP son:
 Aptana. Sea la versión sólo para PHP o la completa Studio Pro
con posibilidad de usar en varios lenguajes es una de las más
populares. Muy famosa para crear código Javascript, se ha
adaptado con grandes resultados para PHP ya que permite
casi todo lo necesario sobre este lenguaje.
 PHP Designer Toolkit (PDT). Considerada la extensión oficial
de Eclipse para programar en PHP, es quizá la más utilizada
en la actualidad.
 Zend Studio. Dispone de un framework (una plataforma) muy
famosa para crear PHP usando plantillas. Su entorno compite
con los anteriores en prestaciones.
• Netbeans. Se trata del entorno libre de programación competidor
con Eclipse. Ambos se crearon para programar en Java, pero han
extendido su uso a otros lenguajes. NetBeans dispone de una
extensión para PHP, incluso se puede descargar una versión ligera
de NetBeans sólo para PHP. Es una de las mejores opciones para
programar en PHP.
• Adobe Dreamweaver. Se trata del software comercial de
creación de páginas web más famoso del planeta. Tiene
capacidad para escribir código PHP e incluso facilidades gráficas
para hacerlo. Es inferior a los anteriores en cuanto a escritura de
código, pero muy superior cuando queremos concentrarnos en el
diseño del sitio.
• Microsoft Expression Web. Software comercial competidor del
anterior (aunque por ahora mucho menos popular) y con
capacidad de usar con PHP.
•
Depurador PHP. Se trata de un software que se añade al módulo PHP
para darle la capacidad de depurar el código. Los más utilizados por
su potencia son Zend Debugger y XDebug.
(53)
(6.10) bases de PHP

El código PHP se escribe en un documento de texto al que se debe indicar la extensión
.php. En realidad se trata de una página web HTML (o XHTML) normal a la que
se le añaden etiquetas especiales.
(6.10.1) etiqueta <? php?>

Cuando en un documento web queremos añadir código php se indica por esta etiqueta:
<?php
…código PHP
¿>
El código PHP se coloca en la zona de la página web donde más nos interese
hacerlo. Así un primer documento PHP podría ser (suponiendo que incrustamos
PHP en un documento de tipo XHTML 1.0 estricto):
<?php
echo '<?xml version="1.0" encoding="UTF-8"?>'
?>
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es" lang="es">
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>Título</title>
</head>
<body>
<?php
echo “Hola”;
?>
</body>
</html>
El primer código PHP es necesario porque actualmente se consideran las

páginas web XHTML como un documento XML más y por ello deben de llevar la
cabecera <?xml versión=”1.0” encoding=”utf-8”?> obligatoria en todo
documento XML. EL problema es que ese código en el servidor web daría
problemas porque podría entender que es código PHP (al empezar igual que la
etiqueta <?php) e intentaría traducirlo. Por ello es mejor escribirlo con la
función echo para explicar que es código del documento final HTML y no PHP.
(6.10.2) HTML usa PHP y PHP usa HTML

Como se ha visto anteriormente el código PHP se incrusta dentro del código
HTML. Lo interesante es que se puede incrustar código HTML en el PHP y
(54)
tendría sentido ya que las funciones de escritura (echo y print) en realidad

escriben hacia el resultado final, que en realidad es una página HTML por lo
que se puede hacer algo como:
<?php
echo “Mi nombre es <strong>Jorge</strong>”;
?>
(6.10.3) comentarios
Dentro del código PHP se pueden hacer tres tipos de comentario:
Comentarios de varias líneas. Al igual que en lenguaje C, comienzan
por /* y terminan por */. Ejemplo:
<?php
/*
Soy un comentario de
varias líneas
*/
$x=10;
?>
Comentarios de una línea estilo C++. Se ponen tras la barra doble //.
Ejemplo:
<?php
$x=10; //esto es un comentario
?>
Comentarios de una línea estilo ShellScript. Se ponen tras la almohadilla:

<?php
$x=10; #esto es un comentario
?>
(6.10.4) bases de escritura

Las normas básicas para escribir lenguaje PHP se basan en los lenguajes padres
de este, es decir C y Perl. Son:
Todas las líneas de código deben de finalizar con un punto
y coma Se puede agrupar el código en bloques que se
escriben entre llaves
Una línea de código se puede partir o sangrar (añadir espacios al
inicio) a voluntad con el fin de que sea más legible, siempre y cuando
no partamos una palabra o un valor.
PHP obliga a ser estricto con las mayúsculas y las minúsculas en
algunos casos como el nombre de las variables; sin embargo con las
palabras reservadas del lenguaje no es estricto. Es decir PHP
entiende que WHILE, while e incluso
wHiLe es lo mismo al ser una palabra reservada. Sin embargo $var y
(55)
$VAR no son iguales al ser el nombre de una variable.
(6.10.5) escribir en la salida

Aunque hay muchas funciones de escritura (para escribir en lo que será la
página final) las fundamentales son echo y print.
echo es la más utilizada y en realidad es un comando del lenguaje. Tras
echo se pasa uno o más textos (más adelante diremos expresiones de cadena)
que cuando son literales se escriben entre comillas. Si se usa más de un texto,
se separan con comas:
<?php
echo "Primer texto ", "segundo texto"
?>
El texto saldrá seguido en la página. Hay una forma abreviada de usar echo que es:
<?= “Primer texto “, “segundo texto”
?>
Se trata de no usar la etiqueta <?php para el código PHP. Si usamos <?=

estaremos indicando que dentro de esa etiqueta hay texto a sacar con echo.
No se puede colocar código de otro tipo dentro de <?= (porque entendería que
es texto a mostrar con echo).
print funciona casi igual, pero tiene dos importantes diferencias:
Devuelve un valor verdadero o falso dependiendo de si se pudo
escribir el texto o no (en código complejo es muy útil)
No admite varios textos, sólo uno. Aunque se le puede encadenar con
el operador punto (.):
print "Primer texto ", "segundo texto"; //error
print "Primer texto "."segundo texto"; //arreglado
(6.11) variables
(6.11.1) introducción a las variables
En todos los lenguajes de programación (y PHP no es una excepción) Las
variables son contenedores que sirven para almacenar los datos que utiliza un
programa. Dicho más sencillamente, son nombres que asociamos a
determinados datos. La realidad es que cada variable ocupa un espacio en la
memoria RAM del servidor que ejecute el código para almacenar el dato al que
se refiere. Es decir cuando utilizamos el nombre de la variable realmente
estamos haciendo referencia a un dato que está en memoria.
Las variables tienen un nombre (un identificador) que tiene que cumplir
estas reglas:
Tiene que empezar con el símbolo $. Ese símbolo es el que permite
distinguir a una variable de otro elemento del lenguaje PHP.
El segundo carácter puede ser el guion bajo (_) o bien una letra.
A partir del tercer carácter se pueden incluir números, además de
letras y el guión bajo
(56)
No hay límite de tamaño en el nombre

Por supuesto el nombre de la variable no puede tener espacios en
blanco (de ahí la posibilidad de utilizar el guión bajo)
Es conveniente que los nombres de las variables indiquen de la mejor forma

posible su función. Es decir: $saldo es un buen nombre, pero $x123 no lo es
aunque sea válido.
También es conveniente poner a nuestras variables un nombre en
(6.11.2) declarar
minúsculas. Si consta de varias palabras el nombre podemos separar las
palabras con un guión bajo en vez del espacio o empezar cada nueva palabra
con una mayúscula. Por ejemplo:$saldo_final o $saldoFinal.
La primera sorpresa para los programadores de lenguajes estructurados es que
en PHP no es necesario declarar una variable. Simplemente se utiliza y ya
está. Es decir si queremos que la variable $edad valga 15, haremos:
$edad=15:
Y no será necesario indicar de qué tipo es esa variable. Esto es

tremendamente cómodo pero también nos complica tremendamente la tarea
de depurar nuestros programas al no ser nada rígido el lenguaje y permitir casi
(6.11.3) predefinidas
todo.
El servidor web que aloje las páginas PHP pone a disposición del programador
variables de sistema ya definidas para su uso en el programa. La mayoría son
simplemente informativas. Todas suelen llevar el símbolo de subrayado en el
segundo carácter además de escribirse en mayúsculas. La mayoría son arrays
(se explican más adelante). Ejemplo:
echo $_SERVER["SERVER_PORT"];
Escribirá el número de puerto por el que se comunica el servidor web. Para

mostrar todas las variables predefinidas en el servidor podemos escribir este
código dentro de una página PHP
echo "<pre>";
print_r($_SERVER);
echo "</pre>";
Las etiquetas pre, permite que se muestra la información de una forma más
atractiva (porque respeta los cambios de línea y tabulaciones devueltos por
print_r). Por su parte print_r es una función para mostrar el contenido de los
(6.11.4) asignación de valores

arrays.
Esta operación consiste en dar valor a una variable y se realiza con el símbolo
=. Ejemplo:
$x=12;
(57)
Como se comentó anteriormente en PHP no es necesario declarar una variable

antes de su uso. En el caso de asignar números se escriben tal cual (como en el
ejemplo), los decimales se separan con el punto decimal. Los textos se
encierran entre comillas
(simples o dobles, aunque se aconseja usar las dobles salgo cuando nos venga
mejor las simples). Ejemplo:
$nombre=”Anselmo”;
Se pueden asignar resultados de aplicar fórmulas mediante operadores, como:

$beneficios=($gastos-$ingresos) * 0.6;
Otra cosa sorprendente es que una variable puede cambiar el tipo de datos
que almacena, por ejemplo es válido:
$x=18; //asignamos un número
$x=”Hola”; /asignamos un texto
(6.11.5) variables sin asignar valores

Un problema surge cuando queremos utilizar variables a las que no se les ha
asignado ningún valor. Como:
<?php
echo $x; //es la primera vez que se usa $x. Error
$y=$x+2; //error, aunque y valdrá 2
echo $y;
?>
Ocurrirá un error al hacer ese uso de la variable. Aunque en realidad la

directiva del archivo php.ini, error_reporting permite modificar los errores
de aviso que se lanzan. Si bajamos su nivel de aviso, no detectará estos fallos.
También podemos usar esa función al inicio de nuestro código para indicar
fallos. Sería:
error_reporting(E_ALL); //avisa de todos los errores
Si deseamos que no nos avise de estos fallos. Habría que pasar a

error_reporting otra constante; por ejemplo E_USER_ERROR avisa sólo si hay
errores de nivel usuario (o más graves) en el código
A las variables sin declarar se les da valores por defecto, que dependerán
del contexto en que se usen. Hay una función llamado isset a la que se le pasa
un variable e indica si la variable tenía asignado un valor; en cualquier otro
caso devuelve falso. Ejemplo:
<?php
echo isset($x); //escribe falso, o sea no escribe nada
$x=12;
echo isset($x); //devuelve verdadero, escribe 1
?>
(58)
(6.11.6) tipos de datos

enteros
A las variables se les puede asignar valores enteros. Los números enteros se
usan tal cual. Pueden ser positivos o negativos:
$n1=17;
$n2=-175;
Se puede usar sistema octal si se coloca un cero antes de la cifra entra:

$octal=071;
echo $octal; //escribe 56
Además pueden estar en sistema hexadecimal si a la cifra se la antecede de un

cero y una equis:
$hexa=0xA2BC;
echo $hexa; //escribe 41660
coma flotante
Los números decimales en PHP son de tipo coma flotante. Este es un formato
decimal para máquinas digitales que se manejan muy rápido por parte de un
ordenador, ocupan poco en memoria, pero desgraciadamente no son exactos.
Eso provoca que pueda haber algunos decimales que se pierdan.
Para asignar decimales hay que tener en cuenta en PHP que el formato es
el inglés, por lo que las cifras decimales se separan usando un punto como
separador decimal. Además es posible usar notación científica. Ejemplos:
$n1=234.12;
$n2=12.3e-4; //eso es 12,3·10-4, es decir 0,00123
Los números decimales en coma flotante de PHP son equivalentes al formato

double del lenguaje C.
cadenas
Se denomina así a los textos, que en programación se les denomina cadenas de
caracteres o Strings. Se asignan a las variables entrecomillando (en simples o
dobles) el texto a asignar. Ejemplo:
$nombre=”Jorge Sánchez”;
Si el propio texto lleva comillas, se puede utilizar combinaciones de las

comillas para evitar el problema. Por ejemplo:
$frase = ‘Antonio dijo “Hola” al llegar’;
Como queremos almacenar en $frase el texto con Hola entre comillas,

entonces englobamos todo el texto con comillas simples.
Otra opción es usar caracteres especiales, concretamente:
secuencia de escape significado

\t Tabulador
\n Nueva línea
(59)
secuencia de escape significado

\f Alimentación de página
\r Retorno de carro
\” Dobles comillas
\’ Comillas simples
\\ Barra inclinada (backslash)
\$ Símbolo dólar
Y así podremos:
$frase = “Antonio dijo \”Hola\” al llegar”;
Las secuencias de escape sólo funcionan si están encerradas entre comillas

dobles. Es decir, no funciona:
$frase = ‘Antonio dijo \”Hola\” al llegar’;
Las barras saldrán por pantalla también.

Un hecho de PHP muy interesante es que en un texto se puede incluir el
valor de una variable. Por ejemplo:
$días=15;
$texto=”Faltan $días días para el verano”;
echo $texto;//escribe: Faltan 15 días para el verano
Por lo que el símbolo $ sólo se puede asignar a un texto si se usa su secuencia de

escape
\$.
Los textos se pueden concatenar con ayuda del operador punto (.). Ejemplo:
$nombre="Jorge";
$apellidos="Sánchez Asenjo";
echo "Nombre completo: ".$nombre." ".$apellidos;
//escribe Nombre completo: Jorge Sánchez Asenjo
booleanos
Sólo pueden tomar como valores TRUE (verdadero) o FALSE (falso);
$verdadero=True;
echo $verdadero; //escribe 1
Sorprende que echo devuelva el valor uno; la explicación es que True está
asociado a valores positivos, mientras que False se asocia al cero. En concreto
hay una relación todos los tipos de datos:
Enteros: cero=False, resto=True
Coma flotante: 0.0=False,
resto=True Cadenas: False si
están vacías
Arrays: False si no posee ningún
elemento Recurso: False si el
recurso no es válido.
(60)
conversiones
En PHP como las variables pueden cambiar de tipo cuando se nos antoje,
resulta que tiene que intentar que todas las expresiones tengan sentido y
así, este código:
$v1=18;
$v2="3 de Diciembre";
echo $v1+$v2;
Escribe 21 (suma el 18 y el tres). Pero sin embargo:

$v1=18;
$v2="3 de Diciembre";
echo $v1.$v2;
Escribe 183 de Diciembre.

No obstante se pueden convertir de forma forzosa los valores al tipo
deseado; de esta forma elegiremos nosotros cómo realizar las conversiones. Se
trata del habitual operador de casting del lenguaje C. Ejemplo:
$x=2.5;
$y=4;
$z=(int)$x * $y;
$z vale 8 al convertir $x en un entero. Posibilidades:

(int) o (integer). Convierte a entero
(real), (double) o (flat). Convierte a coma flotante
(string). Convierte a forma de texto
(array). Convierte a forma de array.
(object). Convierte a un objeto-
(6.11.7) referencias &

Es una de las claves de la programación en cualquier lenguaje. Se trata de
variables que sirven para modificar otras variables existentes. Es decir, son
variables que en lugar de almacenar valores, almacenan la dirección de otra
variable. No es una copia de la otra variable, más bien es un sinónimo de la
otra variable. Su uso principal aparece cuando se utilizan funciones. Ejemplo
de uso:
$nombre="Antonio";
$ref=&$nombre; //ref es una referencia a la variable $nombre
echo $ref,"<br />"; //escribe Antonio
$ref="Marisa";
echo $nombre,"<br />" //escribe Marisa, a través de la referencia se ha
// cambiado el nombre
(61)
(6.11.8) constantes
Las constantes almacenan valores que no cambian en el tiempo. La forma de
definir constantes es gracias a la función define. Que funciona indicando el
nombre que tendrá la constante, entre comillas, y el valor que se le otorga.
Ejemplo:
define("PI",3.141592);
Las constantes no utilizan el signo $ de las variables, simplemente utilizan el

nombre. Es decir escribir el valor de la constante PI tras haberla declarado con
la instrucción anterior, sería:
echo PI;
Desde la versión 5.3 de PHP es posible definir una constante de una forma más
estructurada. Se trata de utilizar la palabra clave const habitual en la mayoría
de lenguajes de programación. Ejemplo de uso:
const PI=3.141592;
Aunque no es obligatorio, es conveniente usar mayúsculas para las constantes

para diferenciarlas de las variables (aunque en PHP el signo dólar $ ya hace
esa diferenciación) ya que se considera una norma de buen estilo de escritura
en cualquier lenguaje de programación.
(6.11.9) operadores
Lo habitual al programar en PHP es utilizar expresiones que permiten realizar
comprobaciones o cálculos. Las expresiones dan un resultado que puede ser de
cualquiera de los tipos de datos comentados anteriormente (enteros,
decimales, booleanos, strings,…)
aritméticos
Son:
operador significado
+ Suma
- Resta
* Producto
/ División
% Módulo (resto)
Ejemplo de uso:
(62)
$x=15.5;
$y=2;
echo $x+$y,"<br />"; //escribe 17.5
echo $x-$y,"<br />"; // escribe 13.5
echo $x*$y,"<br />"; // escribe 31
echo $x/$y,"<br />"; //escribe 7.75
echo $x%$y,"<br />"; //escribe 1, sólo coge la parte entera
operadores condicionales
Sirven para comparar valores. Siempre devuelven valores booleanos. Son:
< Menor
> Mayor
>= Mayor o igual
<= Menor o igual
== Igual, devuelve verdadero si las dos expresiones que
compara son iguales
=== Equivalente, devuelve verdadero si las dos expresiones
que compara son iguales y además del mismo tipo
!= Distinto
! No lógico (NOT)
&& “Y” lógico
AND “Y” lógico
|| “O” lógico
OR “O” lógico
XOR "OR" exclusivo
Los operadores lógicos (AND, OR y NOT), sirven para evaluar condiciones

complejas. NOT sirve para negar una condición. Ejemplo:
$edad = 21;
$mayorDeEdad = $edad >= 18; //mayorDeEdad será true
$menorDeEdad = !$mayorDeEdad; //menorDeEdad será false
echo $mayorDeEdad."\t".$menorDeEdad;
El operador && (AND) sirve para evaluar dos expresiones de modo que si
ambas son ciertas, el resultado será true sino el resultado será false.
Ejemplo:
$carnetConducir=TRUE;
$edad=20;
$puedeConducir= ($edad>=18) && $carnetConducir;
//puedeConducir es TRUE, puesto que edades mayor de 18
//y carnet es TRUE
(63)
El operador || (OR) sirve también para evaluar dos expresiones. El resultado será
true
si al menos uno de las expresiones es true. Ejemplo:
$nieva =TRUE;
$llueve=FALSE;
$graniza=FALSE;
$malTiempo= $nieva || $llueve || $graniza; //malTiempo es TRUE porque nieva
La diferencia entre la igualdad y la equivalencia se puede explicar con este ejemplo:

$resultado= (18 == 18.0); //resultado es verdadero
$resultado= (18 === 18.0); //resultado es falso
En el ejemplo 18===18.0 devuelve falso porque aunque es el mismo valor, no

es del mismo tipo.
operadores de asignación
Ya se ha comentado el operador de asignación que sirve para dar valor a una
variable. Ejemplo:
$x=$y+9.8;
Sin embargo existen operadores que permiten mezclar cálculos con la

asignación, ejemplo:
$x += 3;
En el ejemplo anterior lo que se hace es sumar 3 a la x (es lo mismo $x+=3, que

$x=$x+3). Eso se puede hacer también con todos estos operadores:
+= -= *= /=
&= |= ^= %=
>>= <<= .=
Otros operadores de asignación son “++” (incremento) y “--“ (decremento). Ejemplo:
$x++; //esto es $x=$x+1;

$x--; //esto es $x=$x-1;
Pero hay dos formas de utilizar el incremento y el decremento. Se puede usar

por ejemplo x++ o ++x
La diferencia estriba en el modo en el que se comporta la asignación. Ejemplo:
$x=5;
$y=5;
$z=$x++; //z vale 5, x vale 6
$z=++$y; //z vale 6, y vale 6
operadores de BIT
Manejan números, a los cuales se les pasa a formato binario y se opera con
ellos BIT a BIT.
(64)
Son:
& AND
| OR
~ NOT
^ XOR
>> Desplazamiento a la derecha
<< Desplazamiento a la izquierda
concatenación
El punto (.) es un operador que permite unir textos. Su uso es muy sencillo.
Ejemplo:
$x="Hola ";
$y="a todo el mundo";
$z=$x.$y; //$z vale "Hola a todo el mundo"
Hay operador de asignación y concatenación de texto, se trata del operador .=.

Ejemplo de uso:
$x="Hola ";
$x.="a todo el mundo";
echo $x; //escribe "Hola a todo el mundo
También es válido el uso de la concatenación en la asignación. Ejemplo:

$texto = "Hola ";
$texto.= "amigos y ";
$texto.="amigas"; //$texto es Hola amigos y amigas
(6.12) estructuras de control

Hasta ahora las instrucciones que hemos visto, son instrucciones que se
ejecutan secuencialmente; es decir, podemos saber lo que hace el programa
leyendo las líneas de izquierda a derecha y de arriba abajo.
Las instrucciones de control de flujo permiten alterar esta forma de
ejecución. A partir de ahora habrá líneas en el código que se ejecutarán o no
dependiendo de una condición.
Esa condición se construye utilizando lo que se conoce como expresión
lógica. Una expresión lógica es cualquier tipo de expresión que dé un
resultado verdadero o falso.
Las expresiones lógicas se construyen a través de los operadores relacionales
(==, >,
<,…) y lógicos (&&,||, !,…) vistos anteriormente.
(6.12.1) sentencia if
sentencia condicional simple
Se trata de una sentencia que, tras evaluar una expresión lógica, ejecuta una
(65)
serie de instrucciones en caso de que la expresión lógica sea verdadera. Si la

expresión tiene un resultado falso, no se ejecutará ninguna expresión. Su
sintaxis es:
if(expresión lógica) {
instrucciones
…
}
Las llaves se requieren sólo si va a haber varias instrucciones. En otro caso se

puede crear el if sin llaves:
if(expresión lógica) sentencia;
Ejemplo:
if($nota>=5){
echo "Aprobado";
$aprobados++;
}
Sólo se escribe Aprobado si la variable $nota es mayor o igual a cinco.
Hay otra posibilidad de sintaxis:
if(expresión lógica) :
instrucciones
…
endif;
En lugar de las llaves, cierra el bloque if con la palabra endif. Los dos puntos
tras el paréntesis son obligatorios. Se trata de una forma simplificada (que,
ciertamente, hay que usar con cuidado).
sentencia condicional compuesta
Es igual que la anterior, sólo que se añade un apartado else que contiene
instrucciones que se ejecutarán si la expresión evaluada por el if es falsa.
Sintaxis:
if(expresión lógica){
instrucciones a ejecutar si la expresión es verdadera
….
}
else {
instrucciones a ejecutar si la expresión es falsa
…
}
(66)
Como en el caso anterior, las llaves son necesarias sólo si se ejecuta más de
una sentencia en el bloque.
Ejemplo de sentencia if-else:
if($nota>=5){
echo "Aprobado";
$aprobados++;
}
else {
echo "Suspenso";
suspensos++;
}
La forma simplificada de esta sentencia sería:
if($nota>=5):
echo "Aprobado";
$aprobados++;
else :
echo "Suspenso";
$suspensos++;
endif;
No se usan las llaves, en su lugar se usan los dos puntos y el cierre con endif.
sentencia condicional múltiple
Permite unir varios if en un solo bloque. Ejemplo:
if($nota<5){
echo "suspenso";
$suspensos++;
}
elseif($nota<7){
echo "aprobado";
$aprobados++;
}
elseif($nota<9){
echo "notable";
$aprobados++;
}
else{
echo "sobresaliente";
$aprobados++;
}
(67)
Cada sentencia elseif permite añadir una condición que se examina si la

anterior no es verdadera. En cuanto se cumpla una de las expresiones, se
ejecuta el código del if o elseif correspondiente. EL bloque else se ejecuta si
no se cumple ninguna de las condiciones anteriores.
La versión simplificada sería:
if($nota<5):
echo "suspenso";
$suspensos++;
elseif($nota<7):
echo "aprobado";
$aprobados++;
elseif($nota<9):
echo "notable";
$aprobados++;
else:
echo "sobresaliente";
$aprobados++;
}
(6.12.2) sentencia switch

switch (expresión) {
case valor1:
instrucciones del valor 1
[break]
[case valor2:
instrucciones del valor 1
[break]
[
.
.
.]
[default:
instrucciones que se ejecutan si la expresión no toma
ninguno de los valores anteriores
..]
}
Los corchetes indican que su contenido es opcional. Es decir, los break son
opcionales y la cláusula default también.
Esta instrucción se usa cuando tenemos instrucciones que se ejecutan de
forma diferente según evaluemos el conjunto de valores posible de una
expresión. Cada case contiene un valor de la expresión; si efectivamente la
expresión equivale a ese valor, se ejecutan las instrucciones de ese case y de
los siguientes.
(68)
La instrucción break se utiliza para salir del switch. De tal modo que si
queremos que para un determinado valor se ejecuten las instrucciones de un
apartado case y sólo las de ese apartado, entonces habrá que finalizar ese
case con un break.
El bloque default sirve para ejecutar instrucciones para los casos en los
que la expresión no cumpla ninguno de los valores anteriores. Ejemplo:
srand(time());
$diaSemana=rand(1,7);
switch ($diaSemana) {
case 1:
$dia="Lunes";
break;
case 2:
$dia="Martes";
break;
case 3:
$dia="Miércoles";
break;
case 4:
$dia="Jueves";
break;
case 5:
$dia="Viernes";
break;
case 6:
$dia="Sábado";
break;
case 7:
$dia="Domingo";
break;
default:
$dia="?";
}
No usar break para salir del switch puede servir para cosas como:
(69)
srand(time());
$diaSemana=rand(1,7);
switch ($diaSemana) {
case 1:
case 2:
case 3:
case 4:
case 5:
echo "Laborable";
break;
case 6:
case 7:
echo "Festivo";
break;
default:
echo "?";
}
Hay una versión simplificada de switch que permite usar los dos puntos al final
de la línea del switch y sustituir la llave final del switch por el texto
(6.12.3) bucles
endswitch.
Un bucle es un conjunto de sentencias que se repiten mientras se cumpla una
determinada condición. Los bucles agrupan instrucciones las cuales se
ejecutan continuamente hasta que una determinada condición que se evalúa
sea falsa.
bucle while
Sintaxis:
while (expresión lógica) {

sentencias que se ejecutan si la condición es true
}
El programa se ejecuta siguiendo estos pasos:

(1) Se evalúa la expresión lógica
(2) Si la expresión es verdadera ejecuta las sentencias, sino el programa
abandona la sentencia while
(3) Tras ejecutar las sentencias, volvemos al paso 1
Ejemplo (escribir números del 1 al 100):
(70)
$i=1;
while ($i<=100){
echo $i."<br />";
$i++;
}
while tiene también una versión simplificada. El ejemplo anterior quedaría:

$i=1;
while ($i<=100):
echo $i."<br />";
$i++;
endwhile;
Este tipo de bucles son los fundamentales. Todas las demás instrucciones de
bucle se basan en el bucle while. Por ello se comentan con él los dos
principales tipos de bucle: de centinela y de contador.
Otra sintaxis posible es:
while (expresión lógica) :

sentencias que se ejecutan si la condición es true
endwhile;
bucles de contador
Se llaman así a los bucles que se repiten una serie determinada de veces.
Dichos bucles están controlados por un contador (o incluso más de uno). El
contador es una variable que va variando su valor (de uno en uno, de dos en
dos,… o como queramos) en cada vuelta del bucle. Cuando el contador alcanza
un límite determinado, entonces el bucle termina.
En todos los bucles de contador necesitamos saber:
(1) Lo que vale la variable contadora al principio. Antes de entrar en el bucle
(2) Lo que varía (lo que se incrementa o decrementa) el contador en cada
vuelta del bucle.
(3) Las acciones a realizar en cada vuelta del bucle
(4) El valor final del contador. En cuanto se rebase el bucle termina. Dicho
valor se pone como condición del bucle, pero a la inversa; es decir, la
condición mide el valor que tiene que tener el contador para que el
bucle se repita y no para que termine.
Ejemplo:
(71)
$i=10; /*Valor inicial del contador, empieza valiendo 10

(por supuesto i debería estar declarada como entera, int) */
while ($i<=200){ /* condición del bucle, mientras i sea menor de 200, el

bucle se repetirá, cuando i rebase este
valor, el bucle termina */
echo $i."<br />"; /*acciones que ocurren en cada vuelta del bucle en
este caso simplemente escribe el valor
del contador */
$i+=10; /* Variación del contador, en este caso cuenta de 10 en 10*/

}
/* Al final el bucle escribe:
10
20
30
…
y así hasta 200
*/
bucles de centinela
Es el segundo tipo de bucle básico. Una condición lógica llamada centinela,
que puede ser desde una simple variable booleana hasta una expresión lógica
más compleja, sirve para decidir si el bucle se repite o no. De modo que
cuando la condición lógica se incumpla, el bucle termina.
Esa expresión lógica a cumplir es lo que se conoce como centinela y
normalmente la suele realizar una variable booleana.
Ejemplo:
$salir=FALSE; /* En este caso el centinela es una variable

booleana que inicialmente vale falso */
while($salir==FALSE){ /* Condición de repetición: que salir siga

siendo
falso. Ese es el centinela.
También se podía haber escrito
simplemente: while(!salir)
*/
$n=rand(1,500); // Lo que se
repite en el
echo($n); /* bucle: calcular un
número
aletorio de 1 a 500 y escribirlo */
(72)
$salir=($n%7==0); /* El centinela vale verdadero si el número

es
múltiplo de 7
*/
}
Comparando los bucles de centinela con los de contador, podemos señalar estos
puntos:
Los bucles de contador se repiten un número concreto de veces, los
bucles de centinela no
Un bucle de contador podemos considerar que es seguro que finalice,
el de centinela puede no finalizar si el centinela jamás varía su valor
(aunque, si está bien programado, alguna vez lo alcanzará)
Un bucle de contador está relacionado con la programación de
algoritmos basados en series.
Un bucle podría ser incluso mixto: de centinela y de contador. Por ejemplo

imaginar un programa que escriba números de uno a 500 y se repita hasta que
llegue un múltiplo de 7, pero que como mucho se repite ocho veces.
Sería:
$salir = FALSE; //centinela

$i=1; //contador
while ($salir == false && $i<=8) {
$n = rand(1,500);
echo $n."<br />";
$i++;
$salir = ($n % 7 == 0);
}
do while
La única diferencia respecto a la anterior está en que la expresión lógica se
evalúa después de haber ejecutado las sentencias. Es decir el bucle al menos
se ejecuta una vez. Es decir los pasos son:
(1) Ejecutar sentencias
(2) Evaluar expresión lógica
(3) Si la expresión es verdadera volver al paso 1, sino continuar fuera del while
(73)
Sintaxis:
do {
instrucciones
} while (expresión lógica)
Ejemplo (contar de uno a 1000):
$i=0;
do {
$i++;
echo $i."<br />";
} while ($i<1000);
Se utiliza cuando sabemos al menos que las sentencias del bucle se van a
repetir una vez (en un bucle while puede que incluso no se ejecuten las
sentencias que hay dentro del bucle si la condición fuera falsa, ya desde un
inicio).
De hecho cualquier sentencia do..while se puede convertir en while. El
ejemplo anterior se puede escribir usando la instrucción while, así:
int i=0;
$i++;
echo $i."<br />";
while (i<1000) {
$i++;
echo $i."<br />";
}
for
Es un bucle más complejo especialmente pensado para rellenar arrays o para ejecutar
instrucciones controladas por un contador. Una vez más se ejecutan una serie de
instrucciones en el caso de que se cumpla una determinada condición. Sintaxis:
for(inicialización;condición;incremento){
sentencias
}
Segunda versión:
for(inicialización;condición;incremento):
sentencias
endfor;
(74)
Las sentencias se ejecutan mientras la condición sea verdadera. Además antes

de entrar en el bucle se ejecuta la instrucción de inicialización y en cada
vuelta se ejecuta el incremento. Es decir el funcionamiento es:
(1) Se ejecuta la instrucción de inicialización
(2) Se comprueba la condición
(3) Si la condición es cierta, entonces se ejecutan las sentencias. Si la
condición es falsa, abandonamos el bloque for
(4) Tras ejecutar las sentencias, se ejecuta la instrucción de incremento
y se vuelve al paso 2
Ejemplo (contar números del 1 al 1000):
for($i=1;$i<=1000;$i++){
echo $i."<br />";
}
La ventaja que tiene es que el código se reduce. La desventaja es que el

código es menos comprensible. El bucle anterior es equivalente al siguiente
bucle while:
$i=1; /*sentencia de inicialización*/

while($i<=1000) { /*condición*/
echo $i."<br />";
$i++; /*incremento*/
}
(6.13) uso de formularios HTML desde PHP

Los formularios son el elemento de las páginas web que permiten recoger
valores del usuario y enviarlos a una dirección URL para que se les procese. En
nuestro caso la URL será una página PHP que recogerá los valores introducidos
en el formulario y actuará en consecuencia.
(6.13.1) repaso de los formularios HTML

etiqueta form
Todo formulario HTML comienza con una etiqueta form, dentro de ella se
colocan todos los controles del formulario.
Fundamentalmente la etiqueta form posee dos atributos:
method. Que permite indicar qué instrucción http utilizaremos para
pasar la información al destino de nuestro formulario. Las opciones
habituales son GET y POST. No se distingue entre mayúsculas y
minúsculas.
action. Es el atributo que contiene la URL de la página web que
procesará el formulario.
(75)
Ejemplo:
<form action="control_form.php" method="GET">

…
</form>
cuadros de texto
Los cuadros de texto permiten recoger texto. Su sintaxis es:
<input type="text" name="nombre" />
Es saca en la página un cuadro en el que el usuario puede introducir texto.

Además podemos utilizar estos atributos:
value. Da un valor inicial al cuadro, se usa para indicar un texto de
ayuda al relleno.
id. Identificador del cuadro. La W3C (organismo que estandariza XML
y HTML) recomienda usar id en lugar de name, pero lo cierto es que
PHP recoge los valores gracias a name, no funciona con id. Por lo que
para más seguridad los diseñadores suelen utilizar ambos atributos.
Ejemplo:
<form action="control_form.php" method="get">
Escriba su nombre y apellidos<input type="text" name="nombre" />
</form>
Ese código da como resultado:
botón de envío
Sirve para llevar a cabo la comunicación entre el formulario y la página que
recoge sus datos. La sintaxis es:
<input type="submit" value="texto del botón" />
En cuanto se pulsa este botón, los datos del resto de controles se envían a la
página receptora del formulario (que se corresponde a la URL indicada en el
apartado action de la etiqueta form).
botón de restablecer
La sintaxis de este botón es:
<input type="reset" value="texto del botón" />
Este tipo de botones lo que hacen es anular los datos que se han introducidos
en los controles del formulario. Deja todos los controles en su estado inicial.
botón genérico
Un botón genérico se marca indicando type="button" en la etiqueta type. En
(76)
los formularios no se usa para enviar o configurar la inf0ormación, sino que se

utiliza normalmente para capturar su pulsación (mediante JavaScript es lo
más habitual) y responder en consecuencia.
cuadro de contraseñas
Funcionan como los cuadros de texto, sólo que el texto que se introduce se
oculta, mostrando sólo puntos o asteriscos. La sintaxis es:
<input type="password" name="nombre" />
Usa los mismos atributos que los cuadros de texto

botones de radio
Se trata de un control fácil de usar que permite elegir una de entre varias
opciones. Todas las opciones deben de tener el mismo nombre y sólo
cambia el valor. Ejemplo:
<p>Sexo:</p>
<input type="radio" name="sexo" value="hombre"/>Hombre<br />
<input type="radio" name="sexo"
value="mujer" checked="checked"/>Mujer<br />
</form>
El resultado es:
El atributo checked (que sólo admite el valor checked) hace que el botón en el
que se usa, aparezca chequeado por defecto
casillas de verificación
Se usan igual que los botones de radio, aunque no se recomienda agrupar
varios con el mismo nombre; no porque no se pueda, sino porque las casillas se
asocian a valores que se activan o desactivan.
La diferencia es que el tipo (type) es checkbox en lugar de radio. también
posee el atributo checked para que inicialmente la casilla aparezca pulsada.
(77)
Ejemplo:

<p>Sexo:</p>
<input type="checkbox" name="sexo" value="hombre"/>Hombre<br />
<input type="checkbox" name="sexo" value="mujer"
checked="checked"/>Mujer<br />
Estado civil: Casado <input type="checkbox" name="estadocivil"
value="casado" checked="checked"/>
<br />
<input type="submit" value="Enviar" />
</form>
El resultado:
cuadros combinados
Un cuadro combinado permite el uso de una lista de opciones en la que se
puede elegir la deseada. Todo cuadro comienza con una etiqueta select que
es la encargada de dar nombre (name) al control. Dentro cada opción del
cuadro se indica con una etiqueta option a la que se da valor mediante el
atributo value. Dentro de la etiqueta option se coloca el texto que verá el
usuario.
Ejemplo:
<select name="provincia">
<option value="av">Ávila</option>
<option value="bu">Burgos</option>
<option value="l">León</option>
<option value="p">Palencia</option>
<option value="sg">Segovia</option>
<option value="so">Soria</option>
<option value="sa">Salamanza</option>
<option value="va">Valladolid</option>
<option value="za">Zamora</option>
</select>
<input type="submit" value="enviar"/>
</form>
(78)
Resultado:
Se pueden agrupar opciones dentro del cuadro usando el elemento optgroup.

Ejemplo:

<select name="provincia">
<optgroup label="Cantabria">
<option value="s">Santander</option>
</optgroup>
<optgroup label="Castilla y León">
<option value="av">Ávila</option>
<option value="bu">Burgos</option>
<option value="l">León</option>
<option value="p">Palencia</option>
<option value="sg">Segovia</option>
<option value="so">Soria</option>
<option value="sa">Salamanza</option>
<option value="va">Valladolid</option>
<option value="za">Zamora</option>
</optgroup>
</select>
<input type="submit" value="enviar"/>
</form>
Da como resultado:
(79)
cuadro de selección de archivo

Cuando se usa type="file" en una etiqueta input, entonces aparece un botón
que al pulsarle hace aparecer un cuadro de selección de archivos mediante el
cual podremos elegir un archivo. La ruta local a dicho archivo es lo que se
guarda para ser enviado al sitio o página que recibe los valores del formulario.
Ejemplo:
<form action="recogida1.php" method="get"> Elija

el archivo
<input type="file" name="archivo" />
<input type="submit" value="enviar"/><br />
</form>
Resultado:
Al pulsar seleccionar archivo aparece un cuadro, cuando elijamos el archivo

aparece su nombre.
cuadro de texto multilínea
La etiqueta textarea permite coloca un cuadro de texto de varias líneas para
que el usuario puede introducir un texto largo. El atributo rows permite
indicar la altura en líneas de texto del cuadro y el atributo cols, la anchura en
caracteres. Ejemplo:
Escribe un texto descriptivo: <br />
<textarea rows="10" cols="40" name="texto"></textarea><br />
</form>
Resulta:
Entre la etiqueta textarea se puede colocar texto que aparecerá inicialmente

dentro del cuadro.
agrupación de controles
La etiqueta fieldset permite agrupar controles para que visualmente sea más
cómodo el relleno de los controles. Visualmente los controles aparecerán
recuadrados y se suele utilizar una etiqueta inmediatamente interior a
(80)
fieldset que es legend que contiene el texto que encabezará al grupo de

controles.
Ejemplo:

<fieldset >
<legend>Datos personales</legend>
<input type="radio" name="sexo" value="hombre"/>Hombre<br />
<input type="radio" name="sexo" value="mujer"
checked="checked"/>Mujer<br />
Estado civil: Casado <input type="checkbox" name="estadocivil"
value="casado" checked="checked"/>
<br />
</fieldset>
<input type="submit" value="Enviar" />
</form>
El resultado:
(6.13.2) controles de HTML 5

El nuevo estándar HTML ha mejorado notablemente los formularios gracias a
nuevos controles. La pega es que no todos los controles son soportados por los
navegadores; hay controles que algunos navegadores no permiten utilizar.
cunado un navegador no comprende un control HTML 5, suele traducirle como
un cuadro de texto normal.
cuadros de texto especializados
La diferencia entre ellos es el uso del atributo type. Los buenos navegadores
que reconocen estos cuadros, varían su uso para adaptarles a su función y así
facilitar al usuario la entrada de datos. De hecho los navegadores validan los
datos y no les dejan enviar hasta que sean correctos. Posibilidades:
input type="number". Acepta sólo números. El navegador se asegura
de no aceptar texto. El atributo maxlength permite indicar un valor
máximo para el cuadro. Si, por ejemplo, ponemos maxlength="5" y
entonces sólo se aceptarán cinco caracteres.
input type="email". Acepta sólo direcciones de correo electrónico
input type="url". Acepta sólo direcciones URL.
input type="date". Acepta sólo fechas válidas. Usa el formato de
(81)
fecha configurado en el sistema operativo del usuario que visita la

página. Los navegadores además proporcionan un cuadro visual más
sencillo para recoger la fecha.
input type="time". Acepta sólo horas válidas; funciona igual que el
cuadro anterior.
input type="datetime". Acepta fecha y hora.
input type="month". Acepta sólo números del 1 al 12, referidos a un mes.
input type="search". Presenta un cuadro de texto pensado para hacer
búsquedas.
input type="tel". Permite introducir números de teléfono.
input type="range". Presenta un control para elegir datos entre un
rango. Los atributos max y min establecen el rango máximo y mínimo
del control. El atributo step indica cuánto se mueve el control (si de
uno en uno, de dos en dos,…).
input type="color". Presenta un control de selección de colores. El
color se toma en formato #xxxxxx donde cada x es una cifra
hexadecimal. Es decir lo toma en el formato habitual de colores de
HTML.
etiquetado de controles
En lugar de poner la información de los controles poniendo texto
directamente, se recomienda usar la etiqueta label que utiliza un atributo for
que sirve para asociar el texto interno a la etiqueta label respecto al nombre
del control que se indica con el atributo for.
Esto permite una mejor usabilidad (los navegadores reconocen label y, por
ejemplo, al hacer clic en el texto de la etiqueta, el control asociado recibe el
foco).
El ejemplo anterior usando label sería:

<label for="texto">Escribe un texto descriptivo:</label>
<textarea rows="10" cols="40" name="texto" ></textarea><br />
</form>
datalist
No hay muchos navegadores que acepten esta etiqueta, pero es muy potente
permite añadir entradas a un control de cuadro de texto (y también a cuadros
especializados como los de email, url,….). La forma de usar consiste en usar el
atributo HTML5 list existente en la etiqueta input. Ese atributo asociará el
cuadro de texto a la lista de valores. Luego dentro de datalist se colocan
etiquetas option para cada opción en la lista.
(82)
Ejemplo:
<form action="recogida.php" method="get">
<label for="gustos">
Escribe en qué te gusta pasar tu tiempo de ocio
</label>
<input type="text" id="gustos" name="gustos" list="listaGustos" />
<datalist id="listaGustos">
<option label="deportes" value="Deportes" />
<option label="teatro" value="Teatro" />
<option label="cine" value="Cine" />
<option label="leer" value="Leer" />
</datalist>
</form>
No aparece un cuadro combinado, será un cuadro de texto que permitirá que

aparezca la lista de opciones. Pero podremos escribir lo que queramos.
Sin embargo esta forma no funciona en la mayoría de navegadores y por
ello se usa un truco que hace que los navegadores no compatibles con HTML5
vean la lista como un cuadro combinado y los compatibles como un cuadro de
texto en el que se podría escribir:
<form action="recogida.php" method="get">
<label for="gustos">
Escribe en qué te gusta pasar tu tiempo de ocio
</label>
<datalist id="listaGustos">
<select name="listaGustos">
<option value="deportes" >Deportes</option>
<option value="teatro" >Teatro</option>
<option value="cine" >Cine</option>
<option value="leer" >Leer</option>
</select>
</datalist>
<input id="gustos" name="gustos" list="listaGustos" />

</form>
El truco consiste en meter select dentro del datalist, los navegadores

modernos ignorarán la etiqueta select y los viejos el datalist.
atributo required
Este atributo obliga a rellenar con algún valor el control en el que se usa. Es
decir hace que un determinado control sea de obligado rellenado en un
formulario. Uso:
<input type="text" name="texto" id="texto" required />
(83)
O bien, usando una forma más compatible con XMNL:

<input type="text" name="texto" id="texto" required="required" />
atributo multiple
Permite en los cuadros de entrada de texto que el usuario pueda indicar varios
valores si les separa con comas.
atributo pattern
Permite colocar una expresión regular en un cuadro de texto que,
obligatoriamente, tendrá que cumplir el cuadro en el que se use el atributo.
Ejemplo (cuadro de texto que sólo acepta introducir 5 letras mayúsculas y tres
números):
<form action="recogida1.php" method="get">
<label for="texto">
Escribe el nº de serie (5 letras y tres números)
</label>
<input type="text" pattern="[A-Z]{5}[0-9]{3}" id="gustos" name="texto"
/>
</form>
atributo placeholder
Un placeholder es un texto que ayuda a rellenar un cuadro de un formulario
(está especialmente pensado para los cuadros de texto) colocando un texto
inicial en el cuadro que se va en cuanto el cuadro obtiene el foco del usuario
(porque, por ejemplo, el usuario le hace clic). Ejemplo:

<label for="texto">
Escribe el nº de serie
</label>
<input type="text" pattern="[A-Z]{5}[0-9]{3}" id="gustos" name="texto"
placeholder="5 letras y tres números" />
</form>
El resultado es:
atributo autocomplete
Permite activar (valor on) o desactivar (valor off) el autocompletado del
navegador. El autocompletado es la opción que permite a los usuarios cuando
rellenan un formulario ver entradas habituales que han escrito en el mismo u
otros formularios. a veces conviene desactivar cuando lo que se escribe son
datos sensibles (nombre de usuario, contraseñas).
atributos min,max yrange
Son atributos que se pueden utilizar en muchos tipos de cuadros (number,
date, time, range,..) que almacenan valores numéricos o similares. min y
max establecen los límites del cuadro. Por ejemplo si el cuadro es numérico y
(84)
ponemos min=1 y max=50 y eso impedirá poner valores en el cuadro fuera de

esos topes. El parámetro step indica el mínimo incremente de valor en el
cuadro; si en el ejemplo anterior ponemos step=3 del valor 1 saltaremos al 4.
Los controles del cuadro (en el caso de los cuadros numéricos, las flechitas)
(6.13.3) métodos de envío de datos del formulario

obedecen a esa configuración.
Como se ha comentado antes, un formulario puede enviar la información
usando el atributo method del formulario y eligiendo GET o POST.
paso de datos mediante GET
El método GET lo que hace es añadir a la URL destinataria del formulario
los datos recogidos del formulario. Ejemplo:

<label for="nombre">Escriba su nombre</label>
<input type="text" name="nombre" /> <br />
<label for="apellidos">Escriba sus apellidos</label>
<input type="text" name="apellidos" /> <br />
<label for="nombre">Escriba su dirección</label>
<input type="text" name="direccion" /> <br />
<label for="nombre">Escriba sus teléfonos:</label><br />
<input type="text" name="telefono1" maxlength="9" pattern="[0-0]{9}" /> <br />
<input type="text" name="telefono2" maxlength="9" pattern="[0-0]{9}" /> <br />
</form>
El resultado del código, rellenando los campos, sería:
Suponiendo que estamos probando el código en la página web

http://localhost/pruebas/form11.html, al pulsar enviar, se genera la URL:
http://localhost/pruebas/recogida1.php?nombre=Jorge&apellidos=S%C3%A1nchez
+Asenjo&direccion=C%2F+Los+Vientos&telefono1=666666666&telefono2=999999
999
El apellido Sánchez se convierte en S%C3%A1nchez por que se requiere

codificar en Unicode y en las URL es necesario utilizar el operador %, al que se
le pasa el código hexadecimal del carácter. En este caso hay dos, porque en
utf-8 el símbolo á usa dos bytes.
(85)
Dejando de lado la cuestión de la codificación, la forma de una URL tipo GET es:
http://urlpágina?var1=valor1&var2=valor2&.....
Es decir, usa pares entre el nombre de la variable (en el formulario asignada a

través del atributo name) y el valor que se le dio en el formulario. Cuando un
control del formulario se queda sin valor, entonces la variable se queda sin
definir y, por lo tanto, la página PHP receptora deberá comprobar si se rellenó
o no el control mediante la función isset.
En el ejemplo anterior, ei la página
receptora, http://localhost/pruebas/recogida1.php tiene este
código:
<!DOCTYPE HTML>
<html lang="es-ES">
<head>
<meta charset="utf-8" />
<title></title>
</head>
<body>
<pre>
<?php
print_r ($_GET);
?>
</pre>
</body>
</html>
El resultado:
Array
(
[nombre] => Jorge
[apellidos] =>
Sánchez Asenjo
[direccion] => C/ Los
Vientos [telefono1]
=> 666666666
[telefono2] => 999999999
)
El paso de datos de un formulario mediante GET tiene estas connotaciones:

La URL es visible, por lo que todo lo que el usuario ha escrito está ala
vista en la URL. Y eso incluye las contraseñas y nombres de usuario
que haya utilizado.
Las páginas generadas con GET pueden añadirse como marcador o
favorito a los navegadores y páginas de marcadores. Eso puede ser
interesante, pero puede ser un problema
No tenemos que pasar por el formulario para enviar valores a la
página receptora. Eso puede provocar problemas de seguridad, pero
(86)
también puede ser una ventaja para redireccionar páginas pasando

parámetros a las mismas.
La depuración de nuestros programas es más cómoda si usamos GET,
porque vemos lo que realmente llega del formulario en la propia URL.
paso de parámetros mediante POST
Los formularios se crean igual en ambos casos, pero ahora cambiamos el atributo
method de la etiqueta form para elegir POST.
Ahora la URL no añade los parámetros del formulario, quedan invisibles.
Realmente se pasan en el paquete http que comunica a ambas páginas, pero
no se ve en la URL con lo que habría que utilizar métodos más sofisticados
para poder recoger los datos que el usuario introdujo en el formulario.
(6.13.4) recepción de datos de un formulario desde una

página PHP
PHP permite recibir los datos pasados por los parámetros usando dos variables,
que son en realidad dos arrays que contendrán todos los valores del formulario.
Se trata de
$_GET y de $_POST cada una dedicada al método con su mismo nombre.
Puesto que son arrays (se estudian con profundidad más adelante) su
manejo es distinto al de una variable normal. Podemos entender que son
contenedores de todos los elementos del formulario.
Los controles del formulario que hayan recibido valores envían esos valores
asociados al nombre de control especificado en el atributo name. De modo
que si el método de paso era POST, la página PHP accederá al valor de ese
control mediante:
$_POST["name"]
donde name es el nombre del control.

Puede ser que el control no reciba ningún valor (porque el usuario no
rellena nada en él). En ese caso la invocación a $_POST (o a $_GET) usando
el nombre de ese control, provocará un error de variable indefinida, por lo
que debemos comprobar la existencia de la variable mediante la función isset.
Otras veces lo que ocurrirá es que se recibe como definida la variable pero
no contiene valores. En ese caso habría que utilizar la función empty para
comprobar que no está vacío el atributo.
(6.13.5) usar la misma página para el formulario y la

recepción
A veces se usa la misma página para recibir los datos del formulario. En ese
caso la página del formulario será PHP. Un uso habitual es para validar los
datos desde PHP. La página recibe los datos y les valida, si está bien entonces
les da por buenos sino, informa del error.
Actualmente las validaciones de los datos se realizan por JavaScript y
especialmente usando AJAX; esta técnica permite validar los datos de forma
más directa (sin tener que reenviarles). Pero implica usar otros lenguajes y
tampoco podrían hacer validaciones complejas.
(87)
En el siguiente ejemplo se expone una página que pide un nombre de

usuario y contraseña en un formulario. Si son correctos se indicará que lo son;
sino, un enlace nos volvería a llevar a la página para volver a empezar. La
cuestión es ¿cómo sabe la página web cuando mostrar el formulario y cuando
no? La forma es valorar la existencia de la variable superglobal $_POST (lo
mismo para $_GET). Cuando devuelve falso, es que no ha recogido valor
alguno, es decir habría que mostrar el formulario. Código:
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8" />
<title></title>
</head>
<body>
<?php
if(!$_POST) { //si no existe $_POST, el formulario se debe mostrar
?>
<form action="form1.php" method="post">
<label for="nombre">Escriba su usuario</label>
<input type="text" name="nombre" maxlength="20" /> <br />
<label for="contra">Escriba la contraseña</label>
<input type="password" name="contra" maxlength="20" /> <br />
</form>
<?php
}//cierre del if
else{
$nombre=$_POST["nombre"];
$contra=$_POST["contra"];
if($nombre!="Jorge" || $contra!="123456") {
echo "No es válido ese usuario y contraseÃ±a <br />";
echo "<a href='form1.php'>Volver al formulario</a>";
}
else {
echo "Entrada correcta";
}
}
?>
</body>
</html>
(88)
(6.14) funciones
(6.14.1) introducción
Uno de los problemas habituales del programador ocurre cuando los programas
alcanzan un tamaño considerable en cuanto a líneas de código. El problema se
puede volver tan complejo que acaba siendo inabordable.
Para mitigar este problema apareció la programación modular. En ella el
programa se divide en módulos de tamaño manejable. Cada módulo realiza
una función muy concreta y así el programador se concentra en cada módulo y
evita la complejidad de manejar el problema completo. Los módulos se
pueden programar de forma independiente. Se basa en concentrar los
esfuerzos en resolver problemas sencillos y una vez resueltos, el conjunto de
las soluciones a esos problemas soluciona el problema original.
En definitiva la programación modular implementa el paradigma divide y
vencerás, tan importante en la programación. El programa se descompone en
módulos. Los módulos se puede entender que son pequeños programas que
reciben datos y a partir de ellos realizan un cálculo o una determinada tarea.
Una vez el módulo es probado y validado se puede utilizar las veces que haga
falta en el programa sin necesidad de tener que volver a programa; incluso se
puede utilizar en diferentes programas ya que se pueden almacenar funciones
en un mismo archivo formando lo que se conoce como librería.
En PHP la programación modular se implementa mediante funciones. Las
funciones trabajan de esta manera:
(1) Las funciones poseen un nombre, un identificador que cumple las reglas
indicadas para los demás identificadores que conocemos (como los de
las variables). Pero, a diferencia de las variables, no utilizan el signo $.
Se aconseja que el nombre de las funciones se escriba en minúsculas.
(2) A las funciones se les indica, aunque no a todas, unos valores
(parámetros) que la función necesita para hacer su labor
(3) Las funciones pueden devolver un valor, resultado del trabajo de la misma.
(4) Las funciones contienen el código que permite realizar la tarea para la
que se creó la función.
(5) Lo más importante es que las funciones son fundamentales en la
programación de aplicaciones PHP porque permiten centrarse en un
problema concreto y pequeño.
De hecho PHP incorpora muchas funciones ya creadas para trabajar (como la propia
print o la muy utilizada echo). Por ejemplo este código:
echo rand(1,10);
Escribe un número aleatorio entre uno y diez. Los parámetros son el número
uno y el diez, el valor que se devuelve es el número aleatorio entre esos dos
números, el identificador es rand y al ser una función estándar de PHP, no
podemos ver su código.
(89)
(6.14.2) declaración y uso de funciones personales
Los programadores de PHP pueden crear sus propias funciones para trabajar.
La sintaxis es la siguiente:
function nombreDeLaFunción(listaDeParámetros){
código de la función
}
Entre el código de la función se puede encontrar la palabra return que sirve

para devolver el resultado.
function doble($valor){
return 2*$valor;
}
Este código se puede declarar en cualquier parte de una página PHP,

pero lo aconsejable es declarar las funciones en la cabecera.
Para utilizar una función simplemente hay que invocarla pasando los
parámetros que requiere, por ejemplo:
$x=9.75;
echo doble(8)."<br />"; //escribe 16
echo doble($x); //escribe 19.5
No siempre las funciones devuelven valores, por ejemplo:

function negrita($texto){
echo "<strong>".$texto."</strong>";
}
La función no tiene instrucción return, puesto que no devuelve valores sino

que lo que hace es escribir el texto en negrita. Ejemplo de uso:
negrita("Hola");
(6.14.3) alcance de las variables

Las variables definidas en una función, al finalizar la función se eliminan. Es
decir su ámbito es local a la función. Ejemplo:
function f1(){
$h=9;
}
echo $h;
La instrucción echo del ejemplo anterior, provoca un fallo de variable no

definida, porque PHP no reconoce a la variable $h, la única $h del código se
crea en la función y sólo se puede usar en la función; hacer referencia a $h
fuera dela función no tiene sentido; ya que tras el cierre de la llave en la que
(90)
se definió, la variable muere. La variable es, en definitiva, local a la función.

Este código:
$h=5;
function f1(){
$h=9;
}
echo $h; //escribe 5
queda claro que una variable no se puede usar fuera de la función. Para PHP
en el ejemplo anterior hay dos variables $h cuando se cierra la función la que
se ha definido dentro de la función desaparece y regresa la anterior que valía
(6.14.4) paso de parámetros por referencia

cinco.
Por defecto las funciones reciben los parámetros por valor, esto significa que
se recibe una copia del valor en la función. Por lo que examinando este
código:
function f1($x){
$x=9;
}
$x=7;
f1($x);
echo
$x;
En el ejemplo la función f1 simplemente cambia el valor del parámetro $x; al

salir de esa función $x muere. Por lo que al escribir lo que vale $x, se
mostrará el valor de 7, ya que el $x de fuera de la función es diferente al
parámetro.
Sin embargo a veces sí se desea que las funciones cambien el valor de las
variables que se pasan como parámetro. El ejemplo más claro es el de la
función swap. La función swap sirve para intercambiar los valores de dos
valores.
Se desea que está instrucción: swap($x,$y), sirva para intercambiar los valores de x e
y
por ello se programa de esta forma:
function swap($x,$y){
$aux=$x;
$x=$y;
$y=$aux;
}
$valor1=12;
$valor2=17;
swap($valor1,$valor2);
(91)
echo $valor1."
".$valor2;
En apariencia swap funciona, pero realmente no modifica los valores de las variables
$valor1 y $valor2 puesto que los parámetros ($x y $y) reciben una copia de
los valores. El problema es que esta función recibe los parámetros por valor,
luego no modifica las variables originales. Por ello, echo escribiría 12 17.
Cuando los parámetros se usan por referencia, entonces sí se cambian las
variables. Para ello basta con preceder el signo & a los parámetros que se
usarán por referencia. Así swap se programaría así:
function swap(&$x,&$y){
$aux=$x;
$x=$y;
$y=$aux;
}
$valor1=12;
$valor2=17;
swap($valor1,$valor2);
echo $valor1."
".$valor2;
Escribe 17 12, las variables originales han sido modificadas.

Cuando una función utiliza paso por referencia, entonces al invocarla debe
recibir nombres de variables y no expresiones o valores literales. Es decir este
código:
swap(9,8);
produce un error, porque la función espera variables y no expresiones.
(6.14.5) parámetros predefinidos

Se puede indicar un valor por defecto a los parámetros a fin de permitir que
dicho parámetro sea opcional; de modo que, si se pasa el parámetro se toma
el valor que se pasa y si no, se toma el valor por defecto.
(92)
Ejemplo:
function potencia($base,$exponente=2){
$valor=1;
for($i=1;$i<=$exponente;$i++){
$valor*=$base;
}
return $valor;
}
echo potencia(2,3); //Escribe 8, es decir 23
echo potencia(2); //Escribe 4, es decir 22
La segunda vez que se invoca a la función, el parámetro $exponente toma el

valor por defecto 2.
(6.14.6) variables globales

Las variables globales permiten ser utilizadas en todo el código, sin que las
funciones utilicen variables que se han definido fuera de la función. Ejemplo:
function encadenar($número,$carácterRelleno){
global $texto;
for($i=1;$i<=$número;$i++){
$texto.=$carácterRelleno;
}
}
$texto="Hola";
encadenar(12,"d")
;
echo $texto."<br />"; //Escribe: Holadddddddddddd
encadenar(9,"+-");
echo $texto."<br />"; //Escribe: Holadddddddddddd+-+-+-+-+-+-+-+-+-
La función encadenar utiliza la variable global $texto gracias al uso de la

palabra global. Sin embargo en realidad esto es una mala práctica ya que
impide modular bien un programa ya que las funciones deberían ser lo más
independientes posibles. La función del ejemplo no podría ser transportada a
otra página PHP, ya que las variables globales serían otras seguramente.
En resumen, es una posibilidad que ofrece PHP pero que es poco
recomendable porque con ella se adquieren malas mañas al programar.
(6.14.7) variables estáticas

Otro uso de variables especiales lo supone las variables estáticas. Se trata de
variables locales a la función (sólo se podrán utilizar dentro de la función),
pero son variables que recuerdan su valor entre llamadas.
(93)
Ejemplo:
function estatica(){
static $cuenta=0;
$cuenta++;
echo "Esta es la llamada número $cuenta<br />";
}
for($i=1;$i<=10;$i++){
estatica();
}
La salida del código anterior es:

Esta es la llamada número
1 Esta es la llamada
número 2 Esta es la
llamada número 3 Esta es
la llamada número 4 Esta
es la llamada número 5
Esta es la llamada número
6 Esta es la llamada
número 7 Esta es la
llamada número 8 Esta es
la llamada número 9
Esta es la llamada número 10
Luego en cada llamada la variable $cuenta incrementa su valor. Eso sólo es

posible gracias a la línea en la que se define la variable como estática (static
$cuenta=0) que solo se ejecuta en la primera llamada. Si en esa línea
eliminamos la palabra static, entonces la variable se crea en cada llamada y
las diez líneas anteriores escribiría lo mismo (Esta es la llamada número 1)
(6.14.8) recursividad
La recursividad es una técnica de creación de programas, pensada para
soluciones a problemas complejos. Se basa en que dentro del código de la
función se invoca a la propia función.
Esta técnica es peligrosa ya que se pueden generar fácilmente llamadas
infinitas (la función se llama a sí misma, tras la llamada se vuelve a llamar a sí
misma,…). Hay que ser muy cauteloso con ella (incluso evitarla si no es
necesario su uso); pero permite soluciones muy originales y abre la posibilidad
de solucionar problemas muy complejos. De hecho ciertos problemas serían
casi imposibles de resolver sin esta técnica.
La idea general es que en cada llamada a la función, ésta resuelva parte
del problema y se invoque a sí misma de nuevo para resolver la parte que
queda, y así sucesivamente. En cada llamada el problema debe ser cada vez
más sencillo hasta llegar a una llamada en la que la función devuelve un único
valor. Tras esa llamada los resultados se encadenan hasta llegar al código que
realizó la primera llamada y pasarle la solución.
(94)
Es fundamental tener en cuenta cuándo la función debe dejar de llamarse

a sí misma; es decir, es importante decidir cuándo acabar. Toda función
recursiva debe de tener una condición de fin de las llamadas. De otra forma se
corre el riesgo de generar infinitas llamadas. Un bucle infinito utilizando
recursividad puede causar graves inestabilidades en el ordenador de trabajo.
Como ejemplo vamos a ver la versión recursiva del factorial.
function factorial($n){
if($n<=1) return 1;
else return $n*factorial($n-1);
}
La última instrucción (return $n*factorial($n-1)) es la que realmente aplica

la recursividad. La idea (por otro lado más humana) es considerar que el
factorial de nueve es, nueve multiplicado por el factorial de ocho; a su vez el
de ocho es ocho por el factorial de siete y así sucesivamente hasta llegar al
factorial de uno, que devuelve uno.
Para la instrucción factorial(4); usando el ejemplo anterior, la ejecución
del programa generaría los siguientes pasos:
(1) Se llama a la función factorial usando como parámetro el número 4 que
será copiado en la variable-parámetro n
(2) Como n>1, entonces se devuelve 4 multiplicado por el resultado de la
llamada
factorial(3)
(3) La llamada anterior hace que el nuevo n (variable distinta de la
anterior) valga 3, por lo que esta llamada devolverá 3 multiplicado por
el resultado de la llamada factorial(2)
(4) La llamada anterior devuelve 2 multiplicado por el resultado de la llamada
factorial(1)
(5) Esa llamada devuelve 1
(6) Eso hace que la llamada factorial(2) devuelva 2*1, es decir 2
(7) Eso hace que la llamada factorial(3) devuelva 3*2, es decir 6
(8) Por lo que la llamada factorial(4) devuelve 4*6, es decir 24 Y ese es ya
el resultado final
4 * factorial(3)
3 * factorial(2)
2 * factorial(1)
4*3*2*1
(95)
3*2*1
2*1
Ciclo de llamadas recursivas

1
Devolución de valores
Ilustración 1, Pasos para realizar la recursividad
¿recursividad o iteración?
Hay otra versión de la función factorial resuelta mediante un bucle for
(solución iterativa) en lugar de utilizar la recursividad. En concreto es:
function factorial2($n){
$res=1;
for($i=1;$i<=$n;$i++){
$res*=$i;
}
return $res;
}
La cuestión es ¿cuál es mejor?
Ambas implican sentencias repetitivas hasta llegar a una determinada
condición. Por lo que ambas pueden generar programas que no finalizan si la
condición nunca se cumple. En el caso de la iteración es un contador o un
centinela el que permite determinar el final, la recursividad lo que hace es ir
simplificando el problema hasta generar una llamada a la función que
devuelva un único valor.
Para un ordenador es más costosa la recursividad ya que implica realizar
muchas llamadas a funciones en cada cual se genera una copia del código de la
misma, lo que sobrecarga la memoria del ordenador. Es decir, es más rápida y
menos voluminosa la solución iterativa de un problema recursivo.
¿Por qué elegir recursividad? De hecho si podemos resolver la función
mediante la solución iterativa, no deberíamos utilizar recursividad. La
recursividad se utiliza sólo si:
No encontramos la solución iterativa a un problema
El código es muchísimo más claro en su versión recursiva y no
implica un gran coste de procesamiento al ordenador
(96)
(6.14.9) ámbito de las funciones

Las funciones en PHP siempre son globales. Es decir, una función se puede
utilizar en cualquier parte del código PHP. Por supuesto esto prohíbe poner el
mismo nombre a dos funciones.
(6.15) inclusión de ficheros

Dentro del código PHP se puede hacer uso de las instrucciones include y/o
require para incluir el código de otro archivo. El archivo puede ser de
cualquier tipo: html, php u otras extensiones.
Por lo que permite la creación de archivos que contengan librerías de
funciones o código reutilizable en múltiples páginas.
Tanto include como require lo que hacen es simplemente copiar y pegar el
código del archivo tal cual. La diferencia es que si el archivo no existe (o no se
encuentra), include seguirá ejecutando el código (aunque normalmente
mostrará una advertencia del error), mientras que require generará un error
grave y parará la ejecución del código.
En la inclusión se entiende que el código que se incluye es código PHP, por
lo que se entenderá que lo que no esté encerrado en etiquetas <? y ?> es
código HTML.
Ejemplo de uso:
include("funciones.php");
(6.16) arrays
(6.16.1) introducción a los arrays
Los tipos de datos que conocemos hasta ahora no permiten solucionar
problemas que requieren gestionar muchos datos a la vez. Por ejemplo,
imaginemos que deseamos almacenar las notas de una clase de 25
alumnos, no habrá más remedio que declarar 25 variables.
Eso es tremendamente pesado de programar. Manejar esos datos
significaría estar continuamente manejando 25 variables. Por supuesto si
necesitamos 2000 notas, el problema se hace inmanejable.
Por ello en casi todos los lenguajes se pueden agrupar una serie de
variables del mismo tipo en una misma estructura que comúnmente se
conoce como array1. Esa estructura permite referirnos a todos los
elementos, pero también nos permite acceder individualmente a cada
elemento.
1
Otros nombres habituales además de arrays son: listas, matrices, arreglos,… Estimo que
array es el más aceptado en la actualidad, los otros términos son más ambiguos.
(97)
Los arrays son una colección de datos del mismo tipo al que se le pone
un nombre (por ejemplo nota). Para acceder a un dato individual de la
colección hay que utilizar su posición. La posición es un número entero
que se llama índice, así para acceder a(por ejemplo nota[4] es el
nombre que recibe el cuarto elemento de la sucesión de notas).
Hay que tener en cuenta que en los arrays el primer elemento tiene
como índice el número cero. El segundo el uno y así sucesivamente; es
decir nota[4] en realidad es el quinto elemento del array.
Ilustración 3-1, Ejemplo de array de notas
Esta definición de arrays es la común en todos los lenguajes clásicos. En el

caso de PHP, los arrays son elementos más complejos, puesto que admiten
datos de distinto tipo. La realidad es que los arrays de PHP son en realidad
elementos que asocian un valor y una clave (arrays asociativos) como se
(6.16.2) arrays escalares

explica más adelante.
Los arrays escalares cumplen la definición indicada anteriormente de
array: es un conjunto de valores a los que se accede a través de un índice
que es un número entero. Así, por ejemplo las notas se podrían almacenar
de esta forma:
$nota[0]=5;
$nota[1]=9;
$nota[2]=8;
$nota[3]=5;
$nota[4]=6;
$nota[5]=7;
(98)
Acceder a una nota cualquiera, requiere conocer su índice.

No hace falta declarar el array (siguiendo el estilo habitual de PHP),
simplemente se utiliza. Es posible incluso este código:
$valor[0] =18;
$valor[1]="Hola";
$valor [2]=true;
$valor[3]=3.4;
Es decir, los datos pueden ser heterogéneos. Sin indicar índice podemos:
$valor[] =18;
$valor[]="Hola";
$valor []=true;
$valor[]=3.4;
Código equivalente al anterior, ya que al no indicar índice se usa el

siguiente índice libre en el array.
recorrer arrays
La gracia de los arrays en todos los lenguajes es la facilidad de rellenar o
utilizar su contenido mediante bucles for. Imaginemos que necesitamos
almacenar 1000 números aleatorios del 1 al 10; evidentemente sería
terrible tener que escribir 1000 líneas de código para realizar esta labor:
$valor[0]=rand(1,10);
…//¡¡¡¡mucho trabajo!!!!
Lo lógico es utilizar este código:

for($i=0;$i<1000;$i++)
$valor[$i]=rand(1,10);
La variable $i sirve para recorrer cada elemento del array. Va cambiando

de 0 a 999 y así en dos líneas se rellena el array.
función count
La función count que posee PHP permite saber el tamaño de un array. Es
útil para utilizar un array del que previamente no sabemos su tamaño.
Por ejemplo si deseamos recorrer un array que ya tiene valores para,
por ejemplo, mostrar cada elemento en pantalla, el código sería:
for($i=0;$i<count($valor);$i++){
echo $valor[$i]."<br />";
}
(99)
elementos vacíos
En este código:
$nota[0]=5;
$nota[1]=9;
$nota[3]=5;
$nota[4]=6;
$nota[5]=7;
Deliberadamente se ha dejado sin rellenar el elemento nota[2]. De modo

que la cuestión es ¿qué sacaría por pantalla la instrucción echo $nota[2]?
Normalmente un servidor Apache en el que se ejecute este código
mostraría un mensaje parecido a este:
Notice: Undefined offset: 2 in E:\Mis

documentos\xampp\htdocs\arrays\arrayPrb1.php on line 18
Undefined offset se puede traducir como desplazamiento indefinido y

además indica que dicho desplazamiento es el número 2. Es decir, lo que
Apache indica es que al moverse al elemento 2 del array se encuentra con
que es una posición indefinida: dicho de otra forma, que es un índice de
array que no existe.
La función count devuelve el tamaño del array sin tener en cuenta los
elementos vacíos; es decir, sólo cuenta los elementos definidos. Por todo
ello el código anterior:
for($i=0;$i<count($valor);$i++){
echo $valor[$i]."<br />";
}
Puede fallar si el array $valor tiene elementos vacíos. Además los últimos
elementos no saldrían por que el contador no llega a ellos al contar
elementos y no los índices más altos.
Para evitar eso podemos utilizar la función isset que devuelve
verdadero cuando a la variable que se le pasa como parámetro se le
asignado ya un valor. El bucle quedaría entonces:
$tope=count($nota);
for($i=0;$i<$tope;$i++){
if(isset($nota[$i]))
echo $nota[$i]."<br />";
else
$tope++;
}
El código es más enrevesado. Ahora sólo se escribe cada elemento del

array si la función isset nos asegura que dicho elemento tiene valor; la
variable $tope va incrementando su valor a fin de alcanzar al último
elemento real del array
(100)
uso del constructor array()

Los arrays pueden definirse de forma cómoda mediante la función array().
Dentro de esa función se colocan los valores que tendrá el array; y así en
una sola línea podemos asignar todos los valores del array. Ejemplo:
$numero=array(17, 34, 45, 2, 9, -5, 7);
Esa línea asigna valores a cada elemento del array empezando por el cero.
Es decir, es equivalente a:
$numero[0]=17;
$numero[1]=34;
$numero[4]=9;
$numero[2]=45;
$numero[5]=-5;
$numero[3]=2;
$numero[6]=7;
Esta función tiene posibilidad de elegir índices concretos. Eso se hace

colocando el índice y después el símbolo => antes del valor. Ejemplo:
$numero=array(17, 34, 3=>45, 2, 7=>9, 10=>-5, 7);
Sería equivalente a:
$numero[0]=17;
$numero[1]=34;
$numero[3]=45;
$numero[4]=2;
$numero[7]=9;
$numero[10]=-5;
$numero[11]=7;
Los índices que no se indican siguen la serie natural
(6.16.3) arrays asociativos

En este caso el índice es un texto que se comporta como una especie de
clave que permite acceder al dato. Ejemplo:
$nota["Antonio"]=5;
$nota["Luis"]=9;
$nota["Ana"]=8;
$nota["Eloy"]=5;
$nota["Gabriela"]=6;
$nota["Berta"]=7;
La ventaja de estos arrays es que son más legibles, la desventaja es que

no permiten su manejo mediante los bucles clásicos.
Esos arrays también permiten el uso de la función array():
$nota=array("Antonio"=>5,"Luis"=>9,"Ana"=>8,"Eloy"=>5,
"Gabriela"=>6,"Berta"=>7);
(101)
Esta función incluso permite mezclar valores escalares y asociativos (aunque no es

muy recomendable), por ejemplo:
$nota=array("Antonio"=>5, 4, 7, 5=>6, "Luis"=>9, 2,"Berta"=>7);
El ejemplo anterior sería equivalente a:
$nota["Antonio"]=5;
$nota[0]=4;
$nota[1]=7;
$nota[5]=6;
$nota["Luis"]=9;
$nota[6]=2;
$nota["Berta"]=7;
Otra cosa es la utilidad de esa sintaxis, que al final complica en demasía el código.
(6.16.4) bucle foreach

Recorrer arrays asociativos o incluso escalar con elementos si inicializar
resulta muy complejo con los bucles while o for. Por ello PHP dispone de
un bucle muy potente que permite recorrer todos los elementos de un
array sin importar si hay saltos en la numeración o si se trata de un array
asociativo. Se trata del bucle foreach que tiene esta sintaxis:
foreach(array as índice=>valor ){
sentencias
}
array es el nombre del array que se va a recorrer; índice es la variable

que recogerá el índice de cada elemento a medida que se recorra el
array; y valor es la variable que irá recogiendo el valor de cada elemento
del array. Ejemplo:
$nota=array("Antonio"=>5, 4, 7, 5=>6, "Luis"=>9, 2,"Berta"=>7);

foreach ($nota as $i=>$v){
echo "La nota $i vale $v\n";
}
/* Escribe:
La nota Antonio vale 5
La nota 0 vale 4
La nota 5 vale 6
La nota Luis vale 9
La nota 6 vale 2
La nota Berta vale 7
*/
(102)
(6.16.5) arrays multidimensionales

Un array multidimensional sirve para representar datos agrupados en una
estructura que utiliza dos índices para representar cada elemento del array.
Ejemplos:
$nota[0][0]=9;
$nota[0][1]=7;
$nota[1][0]=9;
…
Por supuesto es posible utilizar cualquier tipo de valor tanto para los
índices como para el valor:
$poblacion["Alemania"]["Berlin"]=4000000;
$poblacion["Alemania"]["Hanover"]=1200000;
$poblacion["Francia"]["Paris"]=7400000;
$poblacion["Francia"]["Lyon"]=2300000;
$poblacion["España"]["Palencia"]=80000;
Y se pueden utilizar más de dos dimensiones:
$poblacion["España"]["Castilla y León"]["Palencia"]=80000;
$poblacion["España"]["Castilla y León"]["Valladolid"]=370000;
$poblacion["España"]["Asturias"]["Oviedo"]=115000;
$poblacion["Alemania"]["Brandemburgo"]["Berlin"]=4000000;
De esa forma podemos considerar a los arrays como una especie de

almacenes de datos que se parecen mucho a las tablas de las bases de
datos relacionales; ese detalle facilita mucho la comunicación entre PHP y
las bases de datos.
Otra forma posible:
$alemania=array("Berlin", "Hannover");
$francia=array("París", "Lyon");
$espania=array("Palencia");
$poblacion=array("alemania"=>$alemania,"francia"=>$francia,
"espania"=>$espania);
constructor array() en arrays multidimensionales
La función array() está pensada para arrays de una dimensión. Pero es
posible utilizarla en arrays multidimensionales considerando que un array
de dos dimensiones es un array de arrays. De esa forma:
$poblacion=array("España"=>array("Palencia"=>80000,"Valladolid"=>350000,
"Oviedo"=>120000),
"Francia"=>array("Paris"=>7000000,"Lyon"=>2100000)
);
(103)
Es equivalente a:
$poblacion["España"]["Palencia"]=80000;
$poblacion["España"]["Valladolid"]=350000;
$poblacion["España"]["Oviedo"]=120000;
$poblacion["Francia"]["Paris"]=7000000;
$poblacion["Francia"]["Lyon"]=2100000;
recorrido mediante foreach de arrays multidimensionales
Nuevamente se basa la idea en considerar que un array multidimensional es
un array de arrays. Así en el que caso de que con el array anterior
hiciéramos este recorrido:
"Oviedo"=>120000),
);
foreach($poblacion as $i=$valor){
echo "El índice $i vale $valor<br />";
}
El resultado es:
El índice España vale Array
El índice Francia vale Array
Lo que nos indica el resultado es que el valor de cada elemento es un

array, con lo cual el código que realmente nos permite examinar cada
valor sería:
"Oviedo"=>120000),
);
foreach ($poblacion as $pais => $ciudades) {
foreach ($ciudades as $ciudad => $valor) {
echo "<p>País: $pais, Ciudad: $ciudad, población = $valor</p>";
}
}
Que obtiene el resultado:
País: España, Ciudad: Palencia, población = 80000

País: España, Ciudad: Valladolid, población = 350000
País: España, Ciudad: Oviedo, población = 120000
País: Francia, Ciudad: Paris, población = 7000000
País: Francia, Ciudad: Lyon, población = 2100000
(104)
(6.16.6) inspección de arrays mediante funciones

de recorrido
Se trata de funciones basadas en el manejo de punteros de los lenguajes
tradicionales. Utilizan un puntero virtual, que sería un objeto que señala a
uno de los elementos del array y que al moverle permite acceder al resto
de elementos.
Esta técnica se basa en el manejo de las siguientes funciones:
función uso
current(array) Devuelve el valor del elemento al que actualmente
señala el puntero. Si no hay ningún elemento, devuelve
false.
key(array) Devuelve la clave a la que señala el puntero
next(array) Mueve el puntero al siguiente elemento del array y
devuelve su valor. Si el elemento actual es el último,
next devuelve false.
prev(array) Mueve el puntero al elemento anterior del array y
devuelve su valor. Si el elemento actual es el primero,
prev devuelve false.
reset(array) Coloca el puntero en el primer elemento del array y
devuelve su valor. Si no hay ningún elemento en el array,
devuelve false.
end(array) Coloca el puntero en el último elemento y devuelve su
valor.
Ejemplo de recorrido de un array mediante estas funciones:
$capital=array( "Castilla y León"=>"Valladolid","Asturias"=>"Oviedo",

"Aragón"=>"Zaragoza");
while(current($capital)){
echo "<strong>".current($capital)."</strong><br />";
next($capital);
}
Para recorrerle al revés:
$capital=array( "Castilla y León"=>"Valladolid","Asturias"=>"Oviedo",

"Aragón"=>"Zaragoza");
end($capital);
while(current($capital)){
echo "<strong>".current($capital)."</strong><br />";
prev($capital);
}
(105)
(6.16.7) funciones y arrays

Las funciones pueden recibir y devolver arrays al igual que cualquier otro
tipo de variables.
A diferencia de la mayoría de lenguajes estructurados, en PHP los
arrays se pasan por valor a las funciones. Es decir cuando se pasa un array
a una función, ésta recibe una copia del mismo. Así las modificaciones al
array que se hagan dentro de la función, no afectan al array original.
function prueba($a){
$a[0]=18;
}
$array=array(1,2,3,4,5,6,7);
prueba($array);
echo $array[0];
Ejemplo:
La función prueba modifica el elemento con índice cero en el array para darle el valor
18. Sin embargo al ejecutar el código PHP anterior, veremos el número 1
en pantalla. La modificación de la función prueba se ha hecho con el
array $a que es una copia en realidad del original $array.
Si deseáramos que realmente la función modifique el array,
necesitamos pasar el array por referencia, como ya se ha visto en PHP
basta con indicar el símbolo & delante del parámetro (o parámetros) que
deseamos pasar por referencia:
function prueba(&$a){
$a[0]=18;
}
$a=array(1,2,3,4,5,6,7);
prueba($a);
echo $a[0];
Ahora sí escribe 18.
(6.16.8) funciones estándar de uso con arrays

funciones básicas
función significado
count($array) número de elementos del array
print_r($array) Escribe el contenido del array (tanto valores como índices)
is_array(array) Devuelve verdadero si el parámetro que recibe es un array
(106)
ordenación de arrays
Ordena el array indicado. Si no se indica el segundo
parámetro, ordena de forma normal sin convertir los tipos de
datos.
El segundo parámetro permite establecer la forma de
ordenación pudiendo indicar estas posibilidades:
• SORT_REGULAR. Ordenación normal (utilizada por
defecto), se adapta según el valor sea numérico o
String y no usa ordenación basado en alfabetos
distintos del inglés.
• SORT_NUMERIC. Ordena entendiendo que el array
contiene valores numéricos
• SORT_STRING. Ordena entendiendo que el array
contiene valores String (texto)
• SORT_LOCALE_STRING. Ordena basándose en la
configuración regional establecida con la función
setlocale. De modo que setlocale(LC_ALL,"es_ES")
sort(array, [flags]) establecería como configuración regional, español de
España.
• SORT_NATURAL. Ordena el array considerando sus
valores como lo haría un ser humano (es decir el texto
"texto2" iría delante de "texto10" porque entendería
el diez como un número superior al dos, y no ordenaría
como si fueran textos alfabéticos.
El funcionamiento es el mismo que la función natsort
• SORT_FLAG_CASE Permite combinar (usando el
operador OR (|) a nivel de bits) con SORT_STRING o
SORT_NATURAL para ordenar cadenas de forma
insensible a mayúsculas/minúsculas. Por ejemplo:
sort($array,SORT_STRING | SORT_NATURAL)
Al ordenar de esta forma, los índices desaparecen, el array

final es un array escalar (el primer índice será el cero, luego
el uno, etc.)
rsort(array, [flags]) Igual que la anterior, pero ordena en orden descendente.
Idéntica a sort, pero los índices no se desprecian y se
asort(array, [flags]) respetan. Es decir se ordenan los valores y los índices se
recolocan junto a la posición de su valor correspondiente
arsort(array, [flags]) Como la anterior pero el orden es descendente
Idéntica a sort, pero se ordenan las claves. La relación de la
ksort(array, [flags]) clave junto con su valor correspondiente se respeta.
krsort(array, [flags]) Como la anterior pero el orden es descendente
(107)
Ordena el array utilizando una función de usuario. Dicha
función se debe crear de forma que reciba dos parámetros y
devuelva un número mayor de cero cuando el primer
parámetro sea mayor que cero, cero cuando sean iguales y un
número menor que cero cuando el segundo parámetro sea
mayor que el primero.
usort recibe el nombre de la función entre comillas. Ejemplo:

usort(array, funcionUsuario)
usort($array,"funcion1")
Se supone que la funcion1 ha sido creada previamente y

cumple los requisitos indicados anteriormente
Esto permite crear ordenaciones personales con los arrays.
Las claves se pierden (al igual que ocurre con la función sort)
y sólo se ordenan los valores, resultando un array escalar.
Igual que la anterior, pero se respeta la relación de las claves
uasort(array, funcionUsuario) con sus valores.
Igual que la anterior, pero lo que ordena son las claves en
uksort(array, funcionUsuario) lugar de los valores.
Permite ordenar varios arrays al mismo tiempo, indicando
cada array y (opcionalmente) la forma de ordenar.
La forma de ordenar se indica mediante las palabras

SORT_ASC (orden ascendente), SORT_DESC (orden descen-
dente), SORT_REGULAR (orden normal), SORT_NUMERIC
array_multisort( (ordenación numérica), SORT_STRING (ordenación para
array1, arg1 ó array2,… texto). Ejemplo:
)
array_multisort($a,SORT_DES, SORT_NUMERIC,
$b,SORT_STRING)
En el ejemplo, el primer array ($a) se ordena en descendente

y de forma numérica, mientras que el segundo ($b) se ordena
de forma textual.
Ordena el array de modo que se ordena en la forma en la que
lo haría un ser humando. Es decir el texto imagen2 iría antes
natsort(array) que imagen10. Se respeta la relación entre clave y valor, por
lo que no se pierden las claves.
Igual que la anterior, pero no distingue entre mayúsculas y
natcasesort(array) minúsculas.
(108)
búsquedas y filtros en los arrays
Busca el valor indicado en el array y devuelve la clave del
array_search( valor en el array o false si no lo encuentra. El tercer
parámetro (stricto) es opcional y en caso de valer
valorBusq,array [,estricto]
verdadero (por defecto vale falso), sólo encuentra el valor
) si tiene el mismo valor en el array y además es del mismo
tipo.
in_array( Busca el valor indicado en el array, de forma estricta o no
valorBusq,array [,estricto] (ver función anterior) y devuelve true si lo encuentra o
false en caso contrario.
)
array_key_exists(array, clave) Devuelve verdadero si en el array existe la clave indicada.
Devuelve un array que contiene los valores del array que
cumplen la expresión regular. En el apartado (3.2.8),
preg_prep( página 26, se explican las expresiones regulares.
expresionRegular,array[,flag]
) Si se usa el tercer parámetro con la constante
PREG_GREP_INVERT, el array resultado contiene los
elementos que no cumplen la expresión regular.
El segundo parámetro es el nombre de una función
existente indicada entre comillas. Dicha función se creará
de modo que tenga un solo parámetro y devuelva
verdadero o falso en base a una condición que se valorará
en el parámetro.
array_filter(array,función)
array_filter aplica dicha función a cada elemento del array
y devuelve un nuevo array que contiene los elementos del
primer array a los que, pasándolos como parámetro a la
función, ésta devuelva falso. Es decir elimina todos los
elementos que no cumplan la condición establecida por la
función.
funciones para manejo aleatorio

shuffle(array) Reordena de forma aleatoria el array
array_rand(array) Devuelve un índice aleatorio del array
(109)
funciones de manipulación del contenido del array
Devuelve un array escalar que contiene todas las claves del
array_keys($array) array
Devuelve un array escalar en el que están los valores del
array_values($array) array (los índices se retiran y se cambian por escalares)
Intercambia las claves por los valore en el array. Es decir:
array_flip($array) las claves pasan a ser valores y los valores las claves de
dichos valores.
Toma los valores de ambos arrays y devuelve un nuevo
array donde las claves son los valores del primer array y
los valores son los del segundo array.
array_combine(array1, array2)
Ambos arrays deben de tener el mismo número de valores
(de
otro modo ocurrirá un error). Las claves de ambos arrays
se ignoran en el resultado final.
Devuelve un array que contiene n elementos, todos ellos
con el valor indicado. El parámetro inicio indica cuál
array_fill(inicio,n,valor) será el primer índice del array (es numérico); los
siguientes índices serán los números consecutivos al
inicial.
Devuelve un array a partir de otro (parámetro claves)
array cuyos valores se considerarán las claves del nuevo.
array_fill_keys(claves,valor)
Todos los elementos del nuevo array valdrán el valor
indicado.
Elimina los valores duplicados en el array. El segundo
parámetro sirve para indicar la forma de comparar los
array_unique(array, [flags])
valores y utiliza las mismas posibilidades que las
indicadas en la función sort.
Devuelve un nuevo array copia del primero, pero en el
que se rellena del valor indicado hasta alcanzar el
tamaño indicado por n. Si n es un número positivo el
relleno se hace hacia la derecha y si no, hacia la
izquierda. Ejemplo:
array_pad(array,n,valor)
$a=array("a","b","c);
$b=array_pad($a, 5, "x)
El array b será: a, b, c, x, x
(110)
Devuelve una porción del array que se indica de modo

que se toman los elementos desde la posición inicial
indicada, hasta la posición final indicada. Si el parámetro
posFin se omite, entonces se toma desde la posición
inicial hasta el último elemento del array.
array_slice(array,posInicio[,posFin])
Las posiciones indicadas se toman de forma escalar, es
decir el primer elemento tiene la posición cero, el
segundo uno,… El array original no cambia, pero en el
resultante los índices nuevos será escalares; es decir,
comienzan a numerar los índices desde el cero.
Elimina los elementos del array usado como primer

parámetro de la función desde la posición marcada
mediante el parámetro posInicio hasta el final. Este
parámetro puede ser negativo y entonces la posición
(posInicio) desde la que eliminar se cuenta desde el final.
A la hora de indicar la posInicio, se maneja el array como

array_splice( si fuera escalar. Es decir el primer elemento es el cero, el
array,posInicio[,tamaño segundo es el uno,…
[,arraySubst]]
)
Devuelve un array con los elementos eliminados.
Si se usa el parámetro tamaño entonces se recorta el

número indicado por ese parámetro (en lugar de llegar
hasta el final).
El parámetro arraySubst sirve para indicar un array que

contiene los elementos con los que se sustituirán los
eliminados.
Genera un nuevo array en el que los índices son los valores
array_count_values(array) anteriores y el valor es el número de veces que cada valor
antiguo aparecía en el array original
array_sum(array) Suma todos los valores del array y retorna el resultado
array_product(array) Multiplica todos los valores del array y retorna el resultado
Retira el primer elemento del array, desplazando a todos
los demás elementos en el mismo. Es decir, no deja el
array_shift(array) hueco del eliminado. Los índices se ponen de forma
escalar, es decir comienzan a numerarse desde el número
cero.
array_unshift(array,valor1,valor2,… Coloca al principio del array los valores indicados
)
Retira del array a su elemento y lo devuelve como
array_pop(array)
resultado
Coloca los valores indicados (al menos uno) al final del
array_push(array,valor1, valor2,…) array original. Combinado con array_pop permite simular
(111)
pilas
Indica una función existente (pero entrecomillada) y

devuelve un array resultado de aplicar la función indicada
array_map(función, array) a cada elemento del array. La función se debe definir
usando un solo parámetro, ese parámetro representa a
cada elemento del array.
Indica una función existente (pero entrecomillada) y la
aplica a cada elemento del array. La función al definirla
usará un solo parámetro que representa a cada elemento
del array. Dicho elemento se define por referencia al crear
la función (es decir utiliza el operador &) de ese modo la
función realmente podrá modificar el valor de cada
elemento..
Ejemplo:
array_walk(array, función) function doble(&$x){

$x*=
2;
}
$array=array(1,2,3,4,5);
array_walk($array,”doble
”); print_r($array);
Escribiría: 2,4,6,8,10
Indica una función existente (pero entrecomillada) y la
aplica a cada elemento del array. La función al definirla
usará un solo parámetro que representa a cada elemento
array_walk_recursive(array,
función)
del array.
En el caso de que los valores del array sean otros arrays, se

ejecutará la función para dichos arrays.
Devuelve un array multidimensional, resultado de dividir el
array que se pasa como parámetro en trozos del tamaño
indicado.
array_chunk(
array,tamaño [,respetarClaves] El parámetro opcional respetarClaves, si vale true (por
) defecto es false) respeta las claves originales; de otro modo
las claves se pierden y cada array se renumera de forma
escalar.
(112)
combinación de arrays
Une los dos arrays que se le pasan los valores del segundo
van a continuación de los del primero. Si el array es
asociativo, en caso de repetir claves, sólo se queda con las
últimas.
$a=array("uno"=>"Pedro","dos"=>"Antonio","tres"=>"Santiago");
$b=array("dos"=>"Sara","tres"=>"Antonio","cuatro"=>"Santiago");
$c=array_merge($a,$b);
print_r($c);
/* obtiene:
Ar
array_merge($array1,$array2,…)
ra
y(
[uno] =>
Pedro [dos]
=> Sara [tres]
=> Antonio
[cuatro] => Santiago
)
Si el array es escalar se renumeran de nuevo todas las
claves y sí aparecen las claves con índices repetidos.
Igual que el anterior, sólo que ahora si hay índices
array_merge_recursive($a1,$a2,.. repetidos, en el array resultante se convertirán en un array
.)
que combina todos los valores de ese índice.
Genera un nuevo array, intersección de los indicados. En el
array_intersect($array1,$array2,… array resultante sólo aparecen los valores duplicados en
) todos los arrays. Se mantienen los índices, pero toma los
primeros índices que parezcan en la lista de arrays.
array_intersect_key( Genera un nuevo array en el que aparecen las claves
$array1,$array2,… presentes en todos los arrays indicados como parámetros.
)
Genera un nuevo array en el que aparecen los valores del
array_diff($array1,$array2,…) primer array que no están en el segundo (array de
diferencia). La relación entre clave y valor se mantiene.
Genera un nuevo array en el que aparecen las claves del
array_diff_key($array1,$array2,…) primer array que no están en el segundo. La relación entre
clave y valor se mantiene.
(113)
conversión de matrices a partir de variables comunes y viceversa
Se le pasa una lista de variables. La lista es en realidad una
compact(lista de variables) lista de textos (strings) que contienen el nombre de las
variables. La función devuelve un array con esos valores
list no es una función, realmente permite asociar valores de
un array a una lista de variables. Ejemplo:
$a=array(979797979,"Manuel",1250.45);
list(listaDeVariables)=array
list($tlfno,$nombre,$salario)=$a;
Las variables $tlfno, $nombre y $salario tomarán cada una
el valor que les corresponda del array.
(6.16.9) uso de arrays en formularios

Una de las virtudes de un array, es su capacidad de recoger en una sola
variable, valores procedentes de diferentes controles en un formulario. La
forma es muy sencilla, basta con indicar un nombre de array como
atributo name en los elementos del formulario; para indicar que ese
nombre es de un array, se añaden la apertura y cierre de corchetes [ y ].
Ejemplo:
<!DOCTYPE html>
<html lang="es-ES">
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<form action="formArrayget.php" method="GET">
Elige estas opciones:<br />
<input type="checkbox" name="opciones[]" value="menor" />
Menor de edad <br />
<input type="checkbox" name="opciones[]" value="minusvalia" />
Minusvalía<br />
<input type="checkbox" name="opciones[]" value="numerosa" />
Familia numerosa <br />
<input type="checkbox" name="opciones[]" value="minima" />
Renta mínima<br />
<input type="submit" values="Enviar" />
</form>
</body>
</html>
La página resultante es (suponiendo que hemos marcado después algunas opciones):
(114)
En esta página, todos los checkbox están asociados a un array llamado

opciones. Dicho array contendrá un valor por cada elemento al que le
hayamos hecho clic. Los índices se indican de forma escalar, es decir el
primer valor (en el orden de escritura de la página web) será el cero,
luego el uno,…
De modo que si el código de la página que recoge el array (formArrayget.php)
<!DOCTYPE html>
<html lang="es-ES">
<head>
<title></title>
</head>
<body>
<?php
print_r($_GET["opciones"]);
?>
</body>
</html>
es:
La salida de dicha página tras recoger los valores del formulario

anteriormente comentados es:
Array ( [0] => menor [1] => numerosa )
Indicando que el array opciones (presente en el array de recogida del

formulario
$_GET) tiene dos elementos (con índices 0 y 1) con las valores menor y
numerosa
(correspondientes a los valores de los controles checkbox del formulario).
(6.17) strings
(6.17.1) introducción
La palabra String en inglés significa cadena y por eso es muy habitual en
muchos libros de informática referirse así a este tipo de dato. Sin embargo
en realidad por String se entiende a una serie de caracteres, lo que
normalmente llamamos simplemente texto.
¿Por qué no llamarlas simplemente textos? Porque no todos los strings
son textos. Es decir, hay series de caracteres que no representan
necesariamente textos. Esto por ejemplo: !"·$%&/()=? es un String en
cuanto a qué es una serie de caracteres, pero no diríamos que es un texto
al no ser entendible.
En toda aplicación informática los strings son el tipo de dato
fundamental. Tanto es así que en realidad ya hemos usado strings en los
apartados anteriores. Sin embargo en este punto vamos a desglosar todo
el manejo de strings que permite PHP.
(115)
(6.17.2) asignación de valores

Para asignar valores a un string basta con utilizar el operador =.
A continuación se indica el texto entre comillas dobles o simples:
$string1="Soy un texto";
$string2='Yo también';
En el caso de los caracteres especiales, éstos sólo se pueden indicar dentro

de comillas dobles.
(6.17.3) concatenación de textos

Como se ha comentado en apartados anteriores, el operador de
concatenación de textos es el símbolo del punto (.).
Ejemplos:
$texto1="Hola";
$texto2="a todos y todas";
$texto3=$texto1." ".$texto2;
echo $texto3;
Por pantalla saldría Hola a todos y todas. Como se observa en el ejemplo

se pueden concatenar tanto variables de tipo strings como textos literales
(se encadena el contenido de la variable $texto se añade un espacio en
blanco y se concatena con el contenido de la variable texto2).
Podemos usar la concatenación y asignación:
$texto1="Hola ";
$texto1.="a todos y todas";
echo $texto1;
El resultado es como en el texto anterior ya que el símbolo .= permite

añadir al final de la variable el String que se indique.
(6.17.4) uso de variables en strings. uso de llaves

Una de las grandes capacidades PHP es la de poder traducir contenidos de
variables por su valor dentro de un texto. Ejemplo:
$libre="free";
echo "En inglés libre se dice $libre"; //muestra: En inglés libre se dice free
Sin embargo, este código daría error:
echo "<br />Me gusta patinar en $librestyle";
ya que no existe la variable $librestyle (ya que no entiende que haya que
considerar
$libre y luego style.
Sin embargo sí funciona mediante:
echo "<br />Me gusta patinar en {$libre}style";

//Sale: Me gusta patinar en freestyle
(116)
las llaves son además imprescindibles para utilizar con arrays

multidimensionales; aunque, en cualquier caso el operador de
concatenación de texto puede ayudarnos con expresiones más complejas.
echo "El doble de x es".x*2."<br />";
(6.17.5) manejo de strings como arrays de caracteres

Se puede….. Ejemplo:
$string1="Este es el texto de prueba";

$string1[6]="X";
echo $string1; //Sale: Este eX el texto de prueba
Aunque realmente no se considera un array; de hecho no se admite el uso de

foreach en strings.
(6.17.6) cadenas heredoc

Permiten asignar valores de texto sin usar comillas. Ejemplo:
$nombre="Jorge";
$texto=<<<fin
Mi querida amiga <br />
escribo estas líneas esperando que me leas. <br />
Firmado: $nombre <br />
fin;
echo $texto;
En el ejemplo se ha coloreado de color rojo el texto que se almacena en la

variable
$texto. El texto a asignar es el que sigue al símbolo de inserción de documento
(<<<) y al marcador de texto, que es un grupo de caracteres concreto (en este
caso se ha usado la palabra fin como marcador de texto). El marcador se indica
inmediatamente después del símbolo <<< y vuelve a aparecer en la primera columna
tras el último carácter que se almacenará en la variable. Es decir, escribe:
Mi querida amiga
escribo estas líneas esperando que me leas.
Firmado: Jorge
(6.17.7) cadenas nowdoc

Funciona igual que el anterior, sólo que entiende que el texto está
encerrado entre comillas, por lo que no se interpretan los nombres de
variable ni los códigos de escape. Para diferenciar las dos notaciones, en
ésta el marcador de línea va entre comillas simples (en la declaración, no
en el cierre):
(117)
$nombre="Jorge";
$texto=<<<'fin'
Mi querida amiga <br />
escribo estas líneas esperando que me leas. <br />
Firmado: $nombre <br />
fin;
echo $texto;
Resultado:
Mi querida amiga
escribo estas líneas esperando que me leas.
Firmado: $nombre
No se ha interpretado la variable $nombre, se ha entendido que es un texto normal.
(6.17.8) expresiones regulares

Uno de los usos más habituales en la mayoría de lenguajes de programación, tiene
que ver con expresiones regulares.
Se utilizan, sobre todo, para establecer un patrón que sirva para conseguir que
ciertos textos le cumplan. Ese patrón permite búsquedas avanzadas, criterios
avanzados de verificación de claves o códigos (por ejemplo números de serie de
productos que cumplen unas reglas muy concretas), etc.
PHP permite el uso de dos tipos de expresiones regulares:
POSIX (Portable Operating System Interface) 1003.2
correspondientes a un estándar aceptado por el organismo IEEE
(The Institute of Electrical and Electronics Engineers) muy
influyente en normas electrónicas y que se basa en la sintaxis del
sistema Unix. Las funciones compatibles con este formato
comienzan por la palabra ereg.
PCRE (Perl Compatible Regular Expressions). Parte de PHP
desde la versión 4.2, procedente del lenguaje Perl (precisamente
famoso por su uso de las expresiones regulares). Es el formato
que más se usa, de hecho se recomienda no utilizar el anterior.
Las funciones que utilizan este formato de expresión regulares
comienzan por la palabra preg. Por otro lado este formato es
compatible con Unicode, por lo que también es más recomendable
para lenguas que usan símbolos fuera del ASCII original como el
castellano.
formato de las expresiones regulares PCRE
Las expresiones regulares utilizan símbolos especiales para indicar el
patrón correspondiente. Las expresiones regulares de tipo Perl deben ir
delimitadas por la barra de dividir /. Los símbolos y patrones que se
pueden utilizar son:
(118)
símbolo significado
Si c es un carácter cualquiera (por ejemplo a, H, ñ, etc.) indica,
c donde aparezca dentro de la expresión, que en esa posición
debe aparecer dicho carácter para que la expresión sea válida.
Siendo c, d, y e caracteres, indica que esos caracteres deben
cde aparecer de esa manera en la expresión.
Permite indicar un subpatrón dentro del paréntesis. Ayuda a
(x) formar expresiones regulares complejas.
Cualquier carácter. El punto indica que en esa posición puede ir
. cualquier carácter
^x Comenzar por. Indica el String debe empezar por la expresión x.
Finalizar por. Indica que el String debe terminar con la
x$ expresión x.
La expresión a la izquierda de este símbolo se puede repetir una
x+ o más veces
la expresión a la izquierda de este símbolo se puede repetir
x* cero o más veces
El carácter a la izquierda de este símbolo se puede repetir cero
x? o una veces
Significa que la expresión x aparecerá n veces, siendo n un
x{n} número entero positivo.
x{n,} Significa que la expresión x aparecerá n o más veces
x{m,n} Significa que la expresión x aparecerá de m a n veces.
La barra indica que las expresiones x e y son opcionales, se
x|y puede cumplir una u otra.
Cumplen esa expresión los caracteres que, en orden ASCII,
c-d vayan del carácter c al carácter d. Por ejemplo a-z repsenta
todas las letras minúsculas del alfabeto inglés.
[cde] Opción, son válidos uno de estos caracteres: c, d ó e
No es válido ninguno de los caracteres que cumplan la expresión
[^x] x. Por ejemplo [^dft] indica que no son válidos las caracteres
d, f ó t.
\d Dígito, vale cualquier dígito numérico
\D Todo menos dígito
\s Espacio en blanco
\S Cualquier carácter salvo el espacio en blanco
Word, carácter válido dentro de los que PHP considera para
\w identificar variables. Es decir, letras, números o el guion bajo.
(119)
\W Todo lo que no sea un carácter de tipo Word.

\n Nueva línea
\t Tabulador
Permite representar el carácter c cuando este sea un carácter
que de otra manera no sea representable (como [, ], /, \,…).
\c Por ejemplo \\ es la forma de representar la propia barra
invertida.
Permite indicar un carácter Unicode mediante su código
\xff hexadecimal.
Indica un carácter que cumpla la propiedad Unicode indicada
con los símbolos xx que pueden ser:
Código Significado
Cc Control
Cf Formato
Cn Sin asignar
Co Uso privado
Cs Sustituto
L Letra
Ll Letra minúscula
Lm Letra modificadora
Lo Otra letra
Lt Letra de título
Lu Letra mayúscula
M Marca
Mc Marca de espacio
\p{xx} Me Marca de cierre
Mn Marca de no-espacio
N Número
Nd Número decimal
Nl Número letra
No Otro número
P Puntuación
Pc Puntuación de conexión
Pd Puntuación guión
Pe Puntuación de cierre
Pf Puntuación final
Pi Puntuación inicial
Po Otra puntuación
Ps Puntuación de apertura
S Símbolo
Sc Símbolo de moneda
Sk Símbolo modificador
(120)
Código Significado
Sm Símbolo matemático
So Otro símbolo
Z Separador
Zl Separador de línea
Zp Separador de párrafo
Zs Separador de espacio
La letra i al final de los delimitadores permite ignorar
i mayúsculas y minúsculas.
funciones de expresiones regulares
Indica una expresión regular (apartado patrón) y la comprueba
en el String que se pasa a la función. Devuelve verdadero en el
caso de que el texto cumpla la expresión regular.
arrayResult es un array que se puede indicar para almacenar en

él el texto dentro del String que cumple el patrón. De modo que
el elemento cero del array será el texto completo que cumpla
preg_match( todo el patrón, el elemento 1 será el texto que cumpla el
patrón, string primer subpatrón que se haya definido (los subpatrones se
indican entre paréntesis), etc.
[, arrayResult]
[, flag] [,despl]
El parámetro flags permite utilizar la constante
) PREG_OFFSET_CAPTURE para que el array anterior almacene
además de cada texto que cumpla la condición, la posición en la
que se estaba ese texto dentro del array original (lo coloca en el
array detrás de cada texto que cumpla la condición)
despl permite indicar el índice dentro del String por el que se

empezará a buscar el patrón (si no se indica este parámetro
comenzamos a buscar por el principio.
preg_match_all( Igual que la anterior, sólo que cuando encuentra el patrón,
patrón, string sigue buscando en el resto del texto para buscar la siguiente
aparición. >Esto la hace más útil para usar arrays de resultados.
[, arrayResult]
[, flag] [,despl]
)
(121)
Busca el patrón en el string indicado y cuando le encuentra,
devuelve un nuevo string resultado de sustituir el patrón
encontrado por el texto de reemplazo indicado. Ejemplo:
$s="Este es un documento Java, y no de la isla de Java";

echo preg_replace("/java/i", "PHP",$s);
Escribe Este es un documento PHP, y no de la isla de PHP

preg_replace(
patrón, El patrón puede incluso ser un array con varios patrones: si es
así, se sustituye cada patrón del array en el string por el texto
reemplazo, de reemplazo indicado.
string
[, límite] Es posible que incluso el reemplazo sea un array de textos de
[, cuenta] reemplazo. Si es así: cada elemento del array de patrones se
) reemplaza por el elemento del array de reemplazo
correspondiente.
El parámetro opcional límite pone un tope al número de

reemplazos efectuados. Por ejemplo si vale 1, sólo se
reemplaza la primera aparición del patrón. Por defecto vale -1
(es decir, no hay límite).
La variable cuenta, si se utiliza, sirve para almacenar el número

de reemplazos efectuados.
Divide el string indicado según el patrón de expresión regular
indicado y devuelve un array que contiene cada trozo obtenido
del string. Ejemplo:
$s="texto a dividir, ole y ole";

print_r (preg_split("/[\s,]+/", $s));
preg_split( Sale:
patrón, Array
string (
[, límite [0] => texto
[, flags]] [1] => a
[2] => dividir
)
[3] => ole
[4] => y
[5] => ole
)
El parámetro opcional límite indica el máximo de trozos a

obtener.
(122)
(6.17.9) funciones estándar de uso con strings

funciones básicas
strlen(string) Devuelve el tamaño del String
mayúsculas y minúsculas
strtolower(texto) Convierte el texto a minúsculas
strtoupper(texto) Convierte el texto a mayúsculas
Retorna un string resultado de poner en minúsculas el primer
lcfirst(texto)
carácter del texto (suponiendo que sea una letra).
Retorna un string resultado de poner en mayúsculas el primer
ucfirst(texto)
carácter del texto (suponiendo que sea una letra).
funciones de comparación
Compara los dos textos (strings) y devuelve cero si son
iguales, uno si el primero es mayor en orden alfabético
strcmp(texto1, texto2)
(usando el código ASCII) y -1 si es mayor el segundo string.
Igual que la anterior pero no tiene en cuenta las mayúsculas

strccasemp(texto1, texto2) (sólo en inglés)
Igual que las anteriores, pero la comparación que hace tiene

en cuenta la forma natural humana de ordenar. Así por
strnatcmp(texto1,texto2) ejemplo el texto imagen2 sería considerado menor que
imagen11 (en orden alfabético es mayor).
Igual que la anterior pero sin considerar mayúsculas ni

strcasenatcmp(texto1,texto2) minúsculas.
Devuelve un número entero conocido como distancia

Levenshtein que simboliza el número de modificaciones al
primer texto que nos permitirían conseguir el segundo
levenshtein(texto1, texto2)
texto. De modo que si esa distancia es pequeña, los dos
textos son parecidos.
Devuelve un código que indica la forma de pronunciar una

metaphone( palabra (usando el inglés), de modo que dos palabras con
pronunciación similar tendrían el mismo código.
texto [,fonemas]
) El parámetro fonemas indica el número máximo de fonemas
a tener en cuenta (menos, más palabras parecidas habrá)
similar_text( Devuelve el número de caracteres parecidos entre el texto1
(123)
texto1, y el texto2. En realidad lo interesante es usar el tercer

parámetro porcentaje. Este parámetro se pasa por
texto2 referencia por lo que tiene que ser una variable. Dicha
[,porcentaje] variable recibe un porcentaje de similitud entre ambas
) cadenas de texto.
funciones de búsqueda y reemplazo
Devuelve la posición del segundo texto dentro del primero
(empieza a contar la posición desde el número cero). Si el
texto buscado no se encuentra, devuelve false. Ejemplo:
strpos(texto, textoBusq) $a="Esta es la comunidad de Castilla y León";

echo strpos($a," Castilla");
Escribiría 24, ya que Castilla empieza a aparecer en la

posición 24 del String $a.
Igual que la anterior pero no tiene en cuenta mayúsculas ni
stripos(texto, textoBusq) minúsculas. Sólo es válida con textos que no usen caracteres
fuera del alfabeto inglés.
listaCars es un string que contiene todos los caracteres que
deseamos buscar en el texto de modo que busca cualquiera
de esos caracteres dentro del texto.
La función si encuentra cualquiera de esos caracteres,

devuelve el resto de caracteres desde la posición del primer
strpbrk(texto, listaCars) carácter que encuentre en el texto. Ejemplo:
echo strpbrk("este año no voy a la montaña","ñyn");
Escribe (puesto que encuentra primero a la eñe):
ño no voy a la montaña
str_replace( Localiza todas las apariciones del textoBuscado en el texto
textoBuscado, que se pasa como tercer parámetro y las cambia por el texto
indicado en textoReemplazo.
textoReemplazo,
texto El cuarto parámetro (opcional), veces, se envía por
[,veces] referencia y almacenará el número de reemplazos realizados
)
str_ireplace( Idéntica a la anterior, pero no distingue entre mayúsculas y
textoBuscado, minúsculas.
textoReemplazo,
texto
[,veces]
)
(124)
substr_replace( Coloca en el texto original, el texto indicado como
texto, textoReemplazo, de modo que sustituya a todos los
caracteres desde la posición indicada como posInicial, hasta
textoReemplazo,
el final o hasta el número indicado con el parámetro
posInicial posFinal.
[,posFinal]
)
Hace reemplazos múltiples de caracteres en el texto y
devuelve el texto resultante de realizar esos reemplazos.
El array que se usa como segundo parámetro, contiene datos

de forma que cada índice se buscará en el texto y se
reemplazará por su valor. Ejemplo:
strtr(texto,arrayTraducción)
$array=array("a"=>"á","e"=>"é","i"=>"í","o"=>"ó");
echo strtr("este texto tiene", $array)
Escribe:
ésté téxtó tíéné

Elimina en el texto todos los caracteres backslash (\). Es
stripslash(texto) muy útil para texto procedente de lenguajes de
programación.
Retira del texto todas las etiquetas de tipo HTML o PHP que
haya contenidas, excepto las que se indiquen en el
strip_tags( parámetro noRetirables, que es un string que contendrá las
texto etiquetas que no queremos retirar seguidas. Ejemplo:
[,noRetirables] strip_tags(texto,”<p><strong”)
)
Elimina del texto todas las etiquetas que haya excepto p y
strong.
funciones de extracción de texto
Busca un string dentro de otro y devuelve los caracteres
desde su primera aparición hasta el final. En la respuesta
incluye el texto buscado. Ejemplo:
strstr(texto, textoBusq) $a="Esta es la comunidad de Castilla y León";
echo strstr($a," Castilla");
Escribiría Castilla y León

Igual que la anterior pero no tiene en cuenta mayúsculas ni
minúsculas. Sólo es válida con textos que no usen caracteres
stristr(texto, textoBusq)
fuera del alfabeto inglés.
(125)
Permite extraer un texto en base a una serie de caracteres
de modo que primer coge el primer texto dentro del string
original (primer token) y en las siguientes llamadas irá
devolviendo el resto de tokens (en las siguientes llamadas no
se usa el primer parámetro) hasta que tras devolver el último
retorna el valor falso.
Ejemplo:
$s="este es el texto, le vamos a partir";

$tok=strtok($s," ,");
while($tok!=false){
echo $tok."\n";
strtok(string [,token]) $tok=strtok(" ,");
}
Escribe:
este
es
el
texto
le
vamos
a
partir
Devuelve un array donde cada elemento del mismo es una
subcadena que procede de separar el texto indicado en base
a su delimitador.
El parámetro límite indica el máximo número de cadenas a

extraer.
Ejemplo:
explode( $s=”soy una frase, con unas, cuantas, comas”;

delimitador, $a=explode(“,”,$s);
texto print_r($a);
[,límite])
Escribirá:
Array()
([0]=>soy una frase
[1]=>con unas
[2]=>cuantas
[3]=>comas
)
(126)
Une todos los elementos del array para formar un texto que
implode(array) contiene el valor de cada elemento.
Devuelve un string que contiene el texto indicado repetido

str_repeat(texto, veces) las veces que se indiquen en el segundo parámetro.
Devuelve una copia del texto donde cada carácter se ha

str_shuffle(texto) movido aleatoriamente. Es decir, forma un anagrama.
Devuelve un string que contiene el texto original al revés.

strrev(texto)
Devuelve un array en el que en cada elemento hay un trozo

del texto original. El texto se trocea por tamaño de
caracteres; si no se indica tamaño se divide carácter a
str_split(texto [,tamaño])
carácter; si, por ejemplo, tamaño vale 3, se divide de tres en
tres caracteres.
Sin indicar segundo ni tercer parámetro, devuelve el número

de palabras encontradas en el texto.
El parámetro formato puede tomar los valores:

1 La función devuelve el número de palabras
encontradas
str_word_count(
texto 2 Devuelve un array escalar con todas las
palabras encontradas
[,formato
[,listaCaracteres]] 3 Devuelve un array asociativo donde cada valor
es cada palabra encontrada y su índice la
) posición en el texto original.
listaCaracteres es un string que contiene caracteres que en
esta función se deben de considerar como parte de la
palabra y no como separadores de caracteres. Es muy útil
para texto escrito en cualquier lengua distinta del inglés y
así considerar a la eñe como parte normal del texto.
funciones para extraer subcadenas de texto
Extrae del string que se pasa como primer parámetro, el
substr(texto, posInicial texto que va desde la posición indicada (empezando a contar
[,tamaño]) por cero) hasta el final. O bien, extrae desde dicha posición
el número de caracteres indicados por el parámetro tamaño.
(127)
funciones de limpieza de texto
Sin usar el segundo parámetro, elimina del texto los espacios
en blanco del principio y el final. Elimina también saltos de
línea, retornos de carro, tabuladores, nulos y caracteres de
salto vertical.
trim(texto, [caracteres])
El segundo parámetro permite indicar una lista de caracteres
entrecomillada que serán los que se eliminen si se
encuentran al final y al principio del texto (en lugar de
eliminar los espacios).
ltrim(texto, [caracteres]) Igual que el anterior, pero sólo elimina los caracteres al
inicio del texto.
rtrim(texto, [caracteres]) Igual que el anterior, pero sólo elimina los caracteres al final
del texto.
obtener códigos ASCII
chr(códigoASCII) Devuelve el carácter correspondiente al código ASCII

indicado.
ord(carácter) Inversa a la anterior. Devuelve el código ASCII del carácter

indicado.
funciones de formato de datos
Devuelve un string que contiene al número que se indica
formateado de modo que aparece el separador de miles.
number_format( El segundo parámetro (opcional) permite indicar cuántos

número decimales vamos a utilizar para mostrar el número. Los otros
dos parámetros se utilizan para indicar cuál es el carácter de
[,decimales
separador de decimales y el de miles.
[,caracterDecimal
[,caracterDeMiles]]] Ejemplo:
)
echo number_format(1234567.892,2,",",".");
Muestra: 1.234.567,89
(128)
Devuelve un string resultante de aplicar al número que se
recibe como segundo parámetro el formato de moneda
indicado mediante el primer parámetro.
Sólo funciona en entornos compatibles con la función
strfmon de lenguaje C (Windows no lo es).
El parámetro formato es, a su vez, un string que contiene
símbolos especiales para dar formato. Esa expresión está
precedida por el símbolo % al que le pueden seguir uno o más
de estos caracteres
i Formatea el número usando los símbolos y

separadores pertinentes según lo especificado por
la función setlocale basándose en el sistema
monetario internacional. Por ejemplo si antes
hemos usado setlocale(“LC_ALL”,”es-ES”), el
money_format( formato del número será el correspondiente al
formato, formato monetario español.
número n Idéntica al anterior pero usa el sistema nacional de
moneda, según la configuración regional
)
especificada por setlocale.
=f Mediante el símbolo =, se especifica un carácter de
relleno para el número (por defecto se usa el
espacio en blanco).
^ Deshabilita las opciones de agrupamiento (el
separador de miles)
+ Indica signo para el número
( Muestra los números negativos entre paréntesis
! Elimina el símbolo de moneda
#n Caracteres de anchura que se usarán para la parte
entera del número.
.p Número de decimales que se utilizarán
- Alineación izquierda del número (normalmente la
alineación es derecha)
cifrado
Devuelve hash correspondiente al texto indicado usando el

md5(texto [,raw_input]) algoritmo MD5. Si el parámetro raw_input se indica con
valor true (por defecto vale false), codifica en binario crudo
con tamaño 16.
sha1(texto [,raw_input]) Igual que el anterior pero utilizando el algoritmo SHA1
(129)
Genera el hash correspondiente a aplicar sobre el texto el

hash( algoritmo que se indique en el parámetro algoritmo (puede
algoritmo, texto ser “sha256” , “md5”.
[,raw_input] La lista completa de posibles algoritmos se puede consultar
) con la función hash_algos que devuelve un array con todos
los nombres posibles a utilizar.
Genera el polinomio CRC32 de comprobación sobre el string
crc32(texto) indicado. Mediante ese polinomio podemos comprobar la
validez de los datos.
crypt(texto, salt) Función completa para cifrar el texto indicado. Su

funcionamiento es complejo.
str_rot13(texto) Codifica el texto utilizando la rotación ROT13 de cifrado.
(6.18) funciones de fecha

Como en todos los lenguajes el manejo de fechas y horas en complejo. Pero
PHP proporciona numerosas funcionas que facilitan su manejo.
PHP utiliza el formato de fecha y hora de Unix, por lo que muchas
funciones requieren pasar las fechas en este formato. Por ello hay otras
muchas funciones que nos ayudan a crear fechas en ese formato a partir
de un texto que represente a una fecha.
(130)
(131)
(132)
array asociativo en lugar de escalar.
Analiza el texto y devuelve la fecha correspondiente.
Ejemplos de uso2:
<?php
echo strtotime("now"), "\n";
echo strtotime("10 September 2000"), "\n";
strtotime(texto) echo strtotime("+1 day"), "\n";
echo strtotime("+1 week"), "\n";
echo strtotime("+1 week 2 days 4 hours 2 seconds"), "\n";
echo strtotime("next Thursday"), "\n";
echo strtotime("last Monday"), "\n";
?>
checkdate(mes, dia, año) Devuelve verdadero si la fecha indicada de esta forma es

válida.
Devuelve la zona horaria en uso (por ejemplo
date_default_timezone_get()
Europe/Berlin)
date_default_timezone_set( Establece la nueva zona horaria. EL texto debe ser
zona estándar, por ejemplo (Europe/Berlin).
)
2
Ejemplo #1 de la documentación de php.net
(133)
(6.19) control de sesiones en PHP

(6.19.1) limitaciones del protocolo http
El protocolo que se utiliza para navegar por la web es http. Se dice que http
es un protocolo sin estado (o sin memoria). La razón es que no almacena
información alguna sobre la petición o la respuesta, lo que provoca que cada
petición sea independiente de la anterior, no se tiene en cuenta lo realizado
en la petición anterior.
Al principio, los desarrollos web no estaban preocupados por esta
circunstancia ya que, esencialmente, servían páginas estáticas que contenía
información simple. Sin embargo en la actualidad necesitamos otorgar
memoria a nuestros desarrollos para adaptar nuestras páginas web al usuario
concreto o a las acciones que este realiza. Eso permite una experiencia más
(6.19.2) sesiones
rica al usuario o usuaria.
Una sesión es la navegación que hace un determinado usuario o usuario por
un sitio web. La sesión se refiere a todas las peticiones que realiza el usuario
referidas al mismo sitio web. Una sesión se inicia cuando el usuario acude a
una página del sitio web y finaliza cuando el usuario abandona el sitio.
Durante toda la sesión el usuario puede haber establecido preferencias y
elegido opciones que nos interese recordar. Eso es lo que se denomina el
estado de una sesión. Deberemos conseguir que esa información no se
pierda para utilizarla tanto en beneficio del usuario como en el nuestro
propio como propietarios del sitio.
(6.19.3) técnicas para almacenar el estado de una sesión

Uso de la dirección IP. El array $_SERVER proporciona este dato del
usuario entre otros (se puede usar $_SERVER["REMOTE_HOST"] o
$_SERVER["REMOTE_ADDR"]. Eso en principio permite
identificarle; pero no es un método seguro ya que el usuario/a
puede acceder desde servidores proxy o utilizando otras tecnologías
que no nos permitan identificar con seguridad su dirección IP.
Uso de variables ocultas de formulario. Cada vez que el usuario
realice acciones que supongan datos a almacenar (los productos que
va comprando, el usuario y contraseña con el que se identifica,…)
los podemos pasar mediante campos de formulario oculto o bien
añadiéndoles a la cadena URL de cada enlace por el sitio. Es posible
usarlo siempre que tengamos la capacidad de identificar de forma
única la sesión y de ser pasar los datos de enlace en enlace. El
problema es que el paso por GET (el más cómo de mantener
mediante esta técnica) muestra los parámetros y eso es
tremendamente inseguro.
Además, por mucha pericia que tengamos con esta técnica, es muy
pesada de utilizar y lastra el desarrollo del conjunto del sitio web.
Almacenar datos de sesión en bases de datos o ficheros en el
servidor. Permite incluso que el usuario abandone el sitio web y
puede, sin embargo, mantener la sesión que abandonó. Lo malo es
(134)
que si tenemos una enorme cantidad de usuarios en nuestro sitio

web, se convierte en un imposible mantener el sitio con esta
técnica.
Uso de cookies. La idea es la misma que en la anterior, sólo que la
información no se guarda en el servidor sino en un archivo en el
cliente. Ese archivo es lo que se conoce como una cookie. El usuario
no será ni siquiera consciente el almacenamiento de la cookie, pero
en ella almacenaremos los datos de la sesión y podremos mantener
esa información sobre el usuario.
Lo malo es que la usuario o el usuario pueden bloquear las cookies o
borrarlas y eso está fuera de nuestro control por lo que es una
técnica que tiene también sus riesgos.
(6.19.4) uso de cookies

Son indudablemente la opción más habitual para almacenar la información
del usuario. Lo malo es lo ya comentado, el cliente de un sitio web puede
prohibir o borrar las cookies almacenadas.
Las cookies son un archivo de texto que almacenan información sobre el
usuario y que se guardan en el propio ordenador del usuario. Contiene
esencialmente nombres de variables y valores (de tipo string) de las mismas.
Esas variables son las que se usan para guardar la información sobre el
usuario.
Las cookies se pasan en la cabecera de la petición http por lo que su
información viaja en el mismo paquete. En el momento que el servidor
decide grabar los datos de la cookie, esta viaja con el paquete en todas las
peticiones y respuestas de esa sesión.
Los datos de la cookie viajan en la cabecera, por lo que el servidor debe
almacenar dichos datos antes de hacer uso de cualquier instrucción en
pantalla.
Ilustración 1, Funcionamiento de las cookies
(135)
setcookie
La función setcookie es la encargada de añadir (o borrar) una nueva cookie.
setcookie(nombre [,valor [,expiración [,ruta [,dominio [, segura [sóloHttp ]]]]] )

Sintaxis:
Los parámetros son:
nombre. Es el nombre que le damos a la cookie. Después podremos
consultarle para poder saber su valor.
valor. Valor que le damos a la cookie. Si no indicamos valor alguno,
entonces estaremos borrando la cookie.
expiración. Por defecto toma el valor cero, que significa que la
cookie caduca en cuanto se cierre el navegador con el que se creó.
Otra posibilidad es indicar una fecha en formato Unix. Por ejemplo
time()+600 indicaría que la cookie expira dentro de 10 minutos
dominio. Si no se indica nada toma como dominio en el que se
aplica la cookie el dominio actual, pero se puede indicar otro.
segura. Por defecto vale false, si indicamos true; entonces indica
que la cookie sólo se almacena si estamos comunicándonos mediante
un protocolo seguro.
soloHttp. Disponible desde la versión 5.2 de PHP. Indica que la
cookie sólo está disponible mediante el protocolo http y no, por
ejemplo, desde JavaScript. Se supone que evita inseguridades al
utilizar cookies; pero es un tanto discutible.
Ejemplos:
setcookie("visitas",1);
//graba la cookie visitas con valor 1 y que caduca con esta sesión
setcookie("usuario","andrei",time()+60*60*24)
//graba la cookie con nombre usuario que caducará al día siguiente
acceder a los datos de las cookies
El array global $_COOKIES contiene las cookies almacenadas en el equipo del
cliente, de modo que para acceder al valor de una cookie se indicará el
nombre de la cookie como índice de este array. Por ejemplo
$_COOKIE["visitas"] devolvería el valor de la cookie con nombre visitas
(suponiendo que esté definida dicha cookie). Ejemplo de lectura de una
cookie:
if(isset($_COOKIE["visitas"])){
echo "esta es tu visita número".$_COOKIE["visitas"];
}
borrar cookies
Cuando se vuelve a utilizar la función setcookie indicando el nombre de una
cookie ya existente y un nuevo valor, el nuevo valor sobrescribe el anterior
valor que tuviera dicha cookie.
Bajo la misma idea si usamos setcookie indicando un nombre de cookie
existente y el valor cero o false, entonces se eliminará la cookie con ese
nombre.
(136)
Ejemplo:
setcookie("visitas",false); //elimina la cookie de nombre visitas

Podemos también eliminar cookies más antiguas indica una fecha de
caducidad anterior a la actual, por ejemplo:
setcookie("visitas",false,time()-60*60*24);
//elimina la cookie de nombre visitas con fecha de caducidad de un día
//hasta este momento
almacenar datos binarios
En la cookies no se pueden almacenare datos binarios, sólo strings. Es decir
no es válido el código:
setcookie("notas",array(9,7,6,5)); //inválido: datos binarios
Por ello todos los programadores para almacenar datos binarios (como los
arrays), crean mecanismos para convertir lo binario en texto. En general al
proceso de convertir los datos en un formato almacenable se le conoce como
serializar (traducción excesivamente literal del inglés serialize).
De hecho PHP incorpora una función que realiza automáticamente este
proceso, que se llama precisamente serialize. A esta función se le pasa un
dato binario y le convierte en texto. De ese modo el array puede ser
almacenado mediante la instrucción:
setcookie("notas",serialize(array(9,7,6,5))); //inválido: datos binarios
El problema ahora es que cuando lo queramos leer, tenemos el problema

contrario: es decir convertir el texto en el binario correspondiente. Ese
proceso es incluso más difícil; pero PHP lo facilita mediante la función
contraria: unserialize. Para extraer el array del ejemplo usaríamos:
$variableArray=unserialize($_COOKIE["notas"]));
(6.19.5) uso de sesiones en PHP

ventajas y desventajas
Comparadas con las cookies ofrecen estas ventajas
Pueden funcionar aunque el usuario/a desactive la posibilidad de
cookies (podrían pasar el identificador de sesión mediante GET).
Almacenan más información que una cookie y además son capaces
de almacenar datos binarios.
Son más seguras puesto que los datos que se almacenan de la sesión
lo hacen en el servidor y no en el cliente. En principio la seguridad
de los servidores es mayor que la de los ordenadores de los usuarios
Desventajas:
Son susceptibles al ataque conocido como secuestro de sesión
(session hijacking), mediante el cual un usuario se puede hacer con
el identificador de sesión de otro usuario y hacerse pasar por él.
El identificador de sesión se almacena mediante cookies, por lo que
(137)
si no nos damos cuenta podríamos tener la misma dependencia con

al configuración que tenga el usuario en el navegador.
funcionamiento
El manejo de sesiones parte de asignar un identificador a cada sesión. PHP
dispone de la posibilidad de calcular dicho número de sesión para que sea
único en cada sesión de usuario. Tras lo cual podemos identificar de formas
unívoca a cada sesión. Ese identificador es el que se relacionará con los
datos del usuario.
Los pasos son los siguientes:
(1) Se genera un id aleatorio. Para ello se invoca a la función session_start().
(2) Se almacena cada dato de la sesión. Se asigna un nombre y un valor a
cada dato de la sesión que deseemos almacenar. Para ello
disponemos del array
$_SESSION, cuyos índices son los nombres de las variables de sesión a
las cuales asignamos valores. Los índices son strings, pero (a
diferencia de lo que ocurre con las cookies), los valores pueden ser
binarios (incluso podemos almacenar arrays directamente)
(3) En una página en la que deseemos recoger los datos almacenados de
las sesiones, bastará con llamar a session_start() para poder recoger
los valores de la sesión.
(4) Mediante el array $_SESSION podremos leer o escribir nuevos datos
en la sesión En realidad las sesiones son más sencillas de manejar que las
cookies.
Ilustración 2, Funcionamiento de las sesiones PHP
La cuestión es ¿Cómo se pasa el identificador de sesión de petición en

petición? Disponemos de dos posibilidades:
Mediante una cookie. Se crea una cookie cuyo nombre es el nombre
de la sesión y cuyo valor es el identificador de la sesión. En PHP es
la opción por defecto. Lo malo es que el usuario puede prohibir
(138)
utilizar cookies; lo bueno es que es más difícil obtener el

identificador de sesión.
Para que esta opción sea la que funcione (si no fuera así) hay que
modificar el archivo de configuración php.ini y colocar estos
valores:
• session.use_cookies 1
• session.use_trans_id 0
Mediate GET. En este caso se pasa el identificador de la sesión
acompañando a cada petición mediante el uso de una cadena de
consulta GET. Es decir que si nuestra sesión tiene el nombre de
PHPID y el identificador fuera el 8FR45237A89 y estamos con la
sesión ya iniciada y en la URL http://prueba.com/pog1.php la URL
que tendremos será:
http://prueba.com/pog1.php?PHPID=8FR45237A89
Para que sea esta la opción que está funcionando, deberemos
modificar el archivo php.ini y hacer estos cambios:
• session.use_cookies 0
• session.use_trans_id 1
Normalmente la sesión caduque en cuanto el usuario abandona el navegador.

Se puede hacer (sobre todo si el identificador es una cookie) que dure más,
pero no es lo recomendable. Las sesiones deben caducar cuando el usuario
cierra la sesión, de otro modo hay más posibilidad de inseguridad y además
es la forma habitual de usar sesiones. Si necesitamos esa perdurabilidad de la
sesión, lo lógico es usar cookies o bases de datos.
iniciar sesión
Una sesión comienza en la primera página PHP que invoque a la función
session_start. Esta función no tiene argumentos, simplemente inicia la
sesión (si no ha sido iniciada ya) lo cual implica:
(1) Crear un identificador aleatorio de sesión
(2) Crear el archivo en el que se almacenarán los datos de la sesión en el
servidor
(3) Crear la variable global $_SESSION, array en el que se almacenarán
los datos de la sesión.
Si la sesión ya había sido iniciada cuando se invocó a sessión_start, entonces

no se crea una nueva sesión sino que:
(1) Se sigue utilizando la sesión anterior
(2) Permite el uso del array $_SESSION que contendrá los datos de la sesión
Con lo cual todas las páginas que quieran utilizar la sesión iniciada tienen que
invocar a session_start.
obtener datos de la sesión
Dos funciones permiten obtener (y cambiar) los datos de la sesión
(139)
session_id. Si la invocamos sin parámetros, devuelve el

identificador de sesión actual. Admite que le pasemos un
identificador de sesión nosotros, con lo que ese se convierte en el
identificador de la sesión actual. Poner nosotros números de sesión
propios es peligroso en cuanto a que si no tenemos un buen
algoritmo de cálculo del identificador podríamos tener dos sesiones
session_name. Si la invocamos sin parámetros, devuelve el nombre
de sesión actual (por defecto PHPID). Admite que le pasemos un
nombre de sesión nosotros. Esto es útil para que no sea tan claro
que estamos usando sesiones PHP ya que el nombre PHPID es
conocido por todos los programadores PHP.
La directiva session.name en el archivo de configuración php.ini
permite asignar otro nombre por defecto para las sesiones.
usar variables de sesión
Para almacenar un dato de sesión basta usar esta sintaxis:
$_SESSION["clave"]=valor
Para recoger un valor almacenado se utiliza la misma clave en el array. Como

hemos comentado es posible incluso almacenar datos binarios con lo que las
sesiones son bastante más versátiles que las cookies.
borrar datos de sesión
Si deseamos eliminar un dato de la sesión basta con usar la función PHP de
eliminación de variables unset. De modo que si deseamos eliminar una
variable de sesión llamada visitas, haremos:
unset($_SESSION["visitas"])
Para eliminar todos los datos, hay que hacer esta secuencia:
unset($_SESSION);
$_SESSION=array();//imprescindible, sino la sesión queda inutilizable
eliminar la sesión entera
Eliminar la sesión en sí consiste en:
session_start(); //si no la hubieramos llamado ya
unset($_SESSION); //elimina el array, sino queda gastando memoria
session_destroy();//función de eliminación en sí de la sesión
(6.20) bases de datos

(6.20.1) ventajas de las bases de datos
El uso de bases de datos es imprescindible en cualquier aplicación web de
hoy en día. Algunas razones para utilizarlas son:
Proporcionan almacenamiento permanente. Es decir, los datos que
se almacenan resisten entre sesiones con lo cual son un método
ideal cuando la información no se desea eliminar en ningún
momento.
(140)
Añaden una capa más de seguridad. Los datos están fuera del
alcance directo del usuario ya que no se almacenan en las peticiones
http. Los datos se encuentran en un servidor de base de datos con el
que se comunica el servidor web. En esta comunicación no
interviene el usuario. Aunque hay técnicas para intentar acceder a
la base de datos usando trucos, lo cierto es que las bases de datos
son un software más preparado para la seguridad que si nosotros
gestionáramos directamente la información
Proporcionan herramientas avanzadas de gestión de datos y
usuarios. Los Sistemas Gestores de Bases de Datos son un software
especializado en la gestión de datos, permite hacer consultas
avanzadas, crear diferentes vistas y permitir su uso a ciertos
usuarios, copias de seguridad, transacciones,…
Uso del lenguaje SQL. El lenguaje más conocido para el manejo de
datos en bases de datos relacionales, está disponible y esto significa
que podremos usar toda su potencia en nuestras páginas web.
Ilustración 3, Funcionamiento de las bases de datos en PHP
(6.20.2) instalación y configuración de MySQL

MySQL es la base de datos idónea para trabajar con PHP. Normalmente
los paquetes como xampp la traen incorporada y ya preparada para
instalar.
En estos apuntes no se explica la instalación de MySQL (los pasos
detallados sobre su instalación están disponibles en
www.jorgesanchez.net/bd/abd.html en los apuntes Instalación y
configuración de bases de datos).
Desde xampp podemos gestionar íntegramente la creación de bases de
datos a través de PHPMyAdmin, un gestor web de MySQL integrado en el
servidor xampp.
Este proceso no se describe en estos apuntes, pero es sencillo.
(6.20.3) conexión a MySQL desde PHP

La conexión entre PHP y MySQL requiere de la creación de un enlace o
conector entre el servidor de aplicaciones PHP. El funcionamiento del enlace
a la base de datos depende de que esté instalado correctamente el paquete
en PHP que permite la conexión, en este caso, a MySQL.
(141)
La función PHP que se encarga de establecer el enlace es

mysql_connect. La sintaxis es:
mysql_connect([servidor [,usuario [,contraseña [,nuevoEnlace [,flags]]]])
Los parámetros son todos opcionales. Se explican a continuación:

servidor. Nombre y puerto de la máquina a la que nos conectamos
(es decir el servidor MySQL). Se indica su nombre o IP y
(opcionalmente el puerto). Si no se indica su valor se recoge de la
directiva PHP (presente en el archivo de configuración php.ini)
mysql.default_host que, normalmente, vale localhost_3306 (es
decir, conexión a servidor local MySQL mediante el puerto 3306, el
puerto habitual de comunicación de MySQL).
usuario. Nombre del usuario de la base de datos con el que nos
conectamos (y que, por lo tanto, al menos tendrá permiso de
conexión). De no indicarlo, se recoge de la directiva PHP
mysql.default_user.
contraseña. Contraseña del usuario con el que nos conectamos. Si
no se indica se recoge de la directiva mysql.default_password (por
defecto vale nulo).
nuevoEnlace. No se suele usar mucho este parámetro. De no hacerlo
si volvemos a invocar a esta función utilizando los mismos
parámetros (mismo servidor, usuario, contraseña) que ya se
utilizaron en la llamada previa; entonces no se crea un nuevo
enlace, se devuelve el mismo enlace anterior.
Para evitarlo y que sí podamos obtener un enlace nuevo, a este
parámetro se le indica el valor true.
flags. Permite utilizar constantes predefinidas para variar diversos
aspectos con el enlace a la base de datos:
• MYSQL_CLIENT_COMPRESS. Utiliza protocolo de
compresión en la
comunicación con la base de datos.
• MYSQL_CLIENT_IGNORE_SPACE. Ignora los espacios posteriores
en los nombres de las funciones.
• MYSQL_CLIENT_INTERACTIVE. Permite que la conexión siga
activa aunque el usuario lleve unos segundos sin actividad.
MYSQL_CLIENT_SSL. La comunicación se realiza utilizando
encriptación SSL (si está disponible).
Ejemplo:
$con=mysql_connection(localhost,'prueba','12345');
En el ejemplo conectamos con el servidor local de MySQL utilizando el usuario prueba
con contraseña 12345.
Si la conexión es correcta, la función devuelve los valores de la conexión
(el enlace a datos) que se suele asignar a una variable (en el ejemplo
anterior se los queda $con). En el caso de que falle (por que el usuario no
tiene esa contraseña, o el servidor no está funcionando , etc. etc.), entonces
la función devuelve falso.
(142)
(6.20.4) cerrar la conexión con la base de datos

La función mysql_close es la encargada de esta labor. Recibe un parámetro
que será el enlace a la base de datos (si no se pasa ninguna tomará el último
enlace creado mediante mysql_connect). Siempre es conveniente cerrar las
conexiones, de no hacerlo estaremos malgastando recursos; aunque MySQL
con el tiempo cerrará todas las conexiones que se hayan abierto y no se
utilicen, si dejamos que lo haga MySQL podría ocurrir que no tuviera tiempo
de cerrar si abrimos demasiadas conexiones ( y no cerramos ninguna).
(6.20.5) captura de errores

error_reporting
Al utilizar bases de datos hay muchos posibles errores que pueden ocurrir. De
hecho si no funciona la conexión, todo lo demás que nuestra aplicación
quisiera realizar, no sería posible.
La configuración de PHP (mediante el archivo php.ini) permite especificar
qué tipo de errores se mostrarán al usuario. Esto ya se ha comentado en la
primera unidad de estos apuntes. La directiva error_reporting es la
encargada de decidir qué errores se muestran y cuáles se ignoran.
Inicialmente cuando estamos en proceso de depuración de nuestro
código, nos interesa mostrar todo lo que ocurre, pero cuando pasamos a
producción, sólo lo más grave debería mostrarse. Por ello debemos calibrar
bien la directiva error_reporting a nuestras necesidades. Sus posibles
valores son:
E_ERROR: Sólo se mostrarán los errores fatales (errores
irrecuperables, graves).
E_WARNING. Se muestran las advertencias(warnings) que son
errores más leves.
E_NOTICE. Avisos en tiempo de ejecución (más leves que las anteriores).
E_CORE_ERROR. Igual que E_ERROR pero sólo muestra los errores
procedentes del núcleo de PHP
E_CORE_WARNING. Igual que E_WARNING pero sólo muestra los
errores procedentes del núcleo de PHP
E_COMPILE_WARNING. Avisos de compilación de motores como Zend.
E_USER_ERROR. Errores generados por el propio programador.
E_USER_WARNING. Advertencia generados por el propio programador.
E_USER_NOTICE. Avisos generados por el propio programador.
E_STRICT. Avisa del código utilizado por el programador que, aunque
funciona, no es correcto (porque podría tener problemas en versiones
futuras de PHP).
E_RECOVERABLE_ERROR. Error fatal, pero que no impidió la
ejecución del motor PHP al no considerarse inestable tras el
fallo.
E_ DEPRECATED. Avisos sobre código obsoleto.
E_ USER_DEPRECATED. Avisos sobre código obsoleto lanzados por el propio
programador.
(143)
E_ALL. Muestra todos los errores (salvo los E_STRICT hasta la

versión 5.4 de PHP).
Inicialmente el valor de error_reporting en el archivo php.ini está

establecido de esta forma:
error_reporting = E_ALL | E_STRICT
significa que se muestran todos los errores, incluidos aquellos sobre cómo
mejorar el código.
Si usamos:
error_reporting = E_ERROR
Sólo se muestran los errores fatales.

No obstante podemos no cambiar el archivo php.ini y utilizar la función
error_reporting que permite modificar el nivel de errores que se muestran,
pero en tiempo de ejecución. Es decir desde el momento en el que se invoca
a la función decidiremos que errores se mostrarán independientemente de la
configuración de php.ini.
Ejemplo:
error_reporting(E_ERROR);
mysql_error y mysql_errno
Muchas veces nos conviene capturar los errores que proceden de la base de
datos MySQL para desde el programa decidir lo que hacer dependiendo del
error. Para ello disponemos de do dos funciones:
mysql_error. Devuelve el texto del último error detectado por MySQL.
mysql_errno. Devuelve el número de error.
A ambas funciones se les pasa el enlace de conexión (si no reciben ningún

parámetro utilizarán el último enlace con la base de datos que se haya
creado.
Ejemplo:
$con=mysql_connect("localhost","prueba","12345");
if($con){
….
mysql_close($con);
}
else{
echo "Error: conexión no realizada, respuesta del servidor: ".
mysql_error($con)."Nº de error".mysql_errno($con);
}
(6.20.6) seleccionar base de datos

En MySQL las tablas pertenecen a una base de datos, por lo que lo habitual
es seleccionar la base de datos para de ese modo trabajar de forma cómoda
con las tablas y vistas de dicha base de datos.
(144)
PHP permite seleccionar la base de datos mediante la función

mysql_select_db a la que se le pasa el nombre de la base de datos (entre
comillas, es decir como string) y, opcionalmente, el nombre del enlace de
base de datos (si no se indica este parámetro se usa el último enlace a base
de datos realizado con mysql_connect).
(6.20.7) tipos de datos MySQL
Las tablas (y las vistas) son el objeto de trabajo con una base de datos. En el
caso de MySQL los datos que contiene cada columna de una tabla pueden ser
de tipo:
Enteros: A todos ellos se les puede añadir el texto UNSIGNED para
indicar que sólo valen números positivos (además doblan el rango
posible de números positivos). En los enteros se puede, además,
indicar AUTO_INCREMENT significaría que el número se calcula sólo
para cada nueva fila, es muy útil para columnas que queremos sean
clave, pero que no queremos rellenar su valor.
• INT o INTEGER. Números enteros de -2147483647 a 2147483648.
Son números de que ocupan 32 bits
• SMALLINT. Números enteros de 16 bits. De 32168 a -32167
• TINYINT. Números enteros de un byte (8 bits), de -128 a 127
• BIGINT. Para números enteros enormes (de 64 bits).
• FLOAT. Números de coma flotante (16 bits). Con precisión simple
• DOUBLE. Números de coma flotante (32 bits) de precisión doble
• DEC o DECIMAL. Se le indica el número de cifras y el número de
decimales (por ejemplo decimal(9,2)). Sirve para indicar
números decimales de coma fija (exactos).
• NUMERIC. Prácticamente equivalente al anterior.
Texto: Son los mismos tipos que posee SQL estándar:
• CHAR. Texto de longitud fija (como un dni)
• VARCHAR. Texto de longitud variable
Fecha y hora:
• DATE. Para fechas
• TIMESTAMP. Para instantes concretos de tiempo (fecha y hora)
• YEAR. Para
representar años.
Elementos especiales
• TINYTEXT, TEXT, MEDIUMTEXT y LONGTEXT. Almacenan textos
pensados para información que no es clave. La diferencia está
entre los cuatro tipos está en el tamaño del texto que pueden
almacenar. El texto almacenado no puede ser parte de un índice
no clave principal o secundaria
• TINYBLOB, BLOB, MEDIUMBLOB y LONGBLOB. Almacenan datos
binarios. La diferencia entre los cuatro está en el tamaño
máximo de datos que permiten.
(145)
• ENUM. Permite almacenar valores enumerados. Estos es un

valor que está en una lista de valores posibles.
• SET. Similar al anterior, lista de cadenas de caracteres.
(6.20.8) ejecución de instrucciones SQL

SQL genérico de MySQL
La función más versátil de PHP para utilizar bases de datos es la función
mysql_query dicha función admite dos parámetros, el primero es una
instrucción SQL compatible con MySQL y el segundo (opcional) la variable de
enlace a la base de datos. Ejemplo:
mysql_query("CREATE TABLE personas(id_persona INTEGER,".
"nombre VARCHAR(25))", $con);
Esta instrucción crea (si el usuario con el que se ha conectado tiene
permisos) una tabla en la base de datos seleccionada de MySQL. Para
comunicar con MySQL usa la variable
$con que debe tener asociado un enlace correcto a MySQL.
Si la instrucción no funciona, entonces mysql_query devuelve false. En
otro caso devuelve true (excepto para las instrucciones, como SELECT, que
devuelven una vista de los datos).
problemas de seguridad
Puesto que muchas veces los datos que se envían a través de SQL al servidor
utilizan formularios que rellenan los usuarios, los hackers podrían tener un
resquicio de acceso a la base de datos mediante técnicas de inyección SQL,
en la cual en lugar de responder a lo que pide el formulario, se añaden
manera camuflada otras sentencias.
Para evitar este problema podemos pasar primero la instrucción por la
función mysql_real_escape_string que lo que hará es que los caracteres
peligros (como las comillas, saltos de línea, etc.) se pasan a su forma
escapada (es decir ' se convierte en
\'), con lo cual no se pueden delimitar nuevas instrucciones y tendremos
protección frente al ataque por inyección de SQL.
Es decir, debería ser obligatorio llamar a mysql_query usando esta forma:
mysql_query(mysql_real_escape_string($instruccionSQL),$con);
recuento de filas afectadas
Podemos necesitar, sobre todo en instrucciones DML (INSERT, DELETE o
UPDATE) de SQL, saber cuántas filas de las tablas estamos modificando. Para
ello basta utilizar la función mysql_affected_rows la cual (a la que enviamos
el enlace de conexión) que devolverá el número de filas modificadas por la
última instrucción DML que se haya enviado a MySQL.
SQL con instrucciones SELECT
En el caso de querer ejecutar instrucciones de tipo SELECT (también
DESCRIBE, SHOW o EXPLAIN, propias de MySQL), como en éstas su resultado
en una vista de los datos; entonces la función mysql_query en la que se
ejecute alguna de estas instrucciones, devuelve un conjunto de resultados
(un result set).
(146)
Un conjunto de resultados es un elemento capaz de recoger el resultado

de una consulta SQL. De modo que a través de él podemos mostrar el
resultado de dicha consulta mediante PHP. Ejemplo:
$res=mysql_query("SELECT nombre,apellido1,telefono FROM clientes");
$res es la variable que recogerá el conjunto de resultados (o false, si falla la
instrucción SQL).
Los conjuntos de resultados pueden ser pasados como parámetro a otras
funciones. La más interesante para poder analizar los resultados es
mysql_fetch_assoc. Esta función permite recorrer fila a fila los resultados de
un conjunto de resultados.
Es decir la forma de recorrer los resultados de un SELECT desde PHP es:
(1) Usar mysql_query para lanzar la instrucción SQL. Su resultado será un result
set
que será recogido por una variable
(2) La variable se le pasa a mysql_fetch_assoc, ésta devuelve un array
asociativo que contiene los valores de la primera fila de la consulta
(cada índice será el nombre de una columna y el valor el
correspondiente a esa columna en esa fila).
Si no hay resultados, devuelve false
(3) Se siguen mirando el resto de filas de la misma forma hasta
que
mysql_fetch_assoc devuelve false.
Hay una función llamada mysql_fetch_array que funciona como

mysql_fetch_assoc pero el array devuelto no tiene por qué ser asociativo.
Que lo sea o no depende de un segundo parámetro que puede ser
MYSQL_ASSOC (devolverá lo mismo que mysql_fetch_assoc), MYSQL_NUM
(devuelve un array escalar) y MYSQL_BOTH (devuelve ambos).
No obstante lo lógico es usar siempre mysql_fetch_assoc ya que es más
coherente con el funcionamiento de las bases de datos relacionales.
En la pagina siguiente tenemos un ejemplo completo de conexión (página

que muestra los resultados de una vista sobre una tabla de la base de datos
en una página web):
(147)
<!doctype html>
<html lang="es">
<head>
<title>Lista de usuarios</title>
</head>
<body>
<table>
<?php
//establecimiento de la conexión
$con=mysql_connect("localhost","web","12345");
if($con){
//selección de la base de datos
mysql_select_db("web",$con);
//realización de una consulta
$res=mysql_query("SELECT nombre,contra FROM usuarios2;",$con);
$array=mysql_fetch_assoc($res); //tomamos la primera fila
echo "<tr><th>Usuario</th><th>Contraseña</th></tr>";
while($array){//se repite hasta que deje de haber datos
echo "<tr><td>".$array["nombre"].
"</td><td>".$array["contra"]."</td></tr>";
$array=mysql_fetch_assoc($res); //leemos la siguiente fila
}
mysql_close($con);//cerramos el enlace de datos
}
else{
die("Error al conectar con la base de datos ".mysql_error());
}
?>
</table>
</body>
</html>
(148)

Introducción A PHP

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Introducción A PHP

Enviado por

Direitos autorais:

Formatos disponíveis

6

(6.2) aplicaciones web_________________________________________________ 17

(6.3) instalación de Apache ____________________________________________21

(6.4) configuración de Apache ________________________________________ 27

(6.5) Instalación de MySQL ___________________________________________ 30

(6.6) PHP ____________________________________________________________41

(6.7) paquetes completos Apache/MySQL/PHP ________________________ 45

(6.8) ¿qué es PHP? ____________________________________________________51

(6.6) herramientas y software necesario _______________________________ 52

(6.10) bases de PHP _________________________________________________ 54

(6.11) variables _______________________________________________________ 56

(6.12) estructuras de control __________________________________________ 65

(6.13) uso de formularios HTML desde PHP ____________________________ 75

(6.14) funciones ______________________________________________________ 89

(6.15) inclusión de ficheros ____________________________________________ 97

(6.16) arrays _________________________________________________________ 97

(6.17) strings _________________________________________________________ 115

(6.18) funciones de fecha ____________________________________________ 130

(6.19) control de sesiones en PHP ____________________________________ 134

Inicialmente las páginas web estaban compuestas de texto y enlaces (a otras

ficheros, compra y venta de productos,…

(6.1.2) historia de la Web

• Explosión de la web, Internet se empieza a hacer muy popular y la

crear páginas muy dinámicas y potentes (como Google Maps por

• Se comienza a trabajar en los borradores de HTML5 y CSS3

(6.1.3) servicios web 1.0

(6.1.4) servicios web 2.0

Ilustración 1, Funcionamiento de las tecnologías ricas de Internet usandio tecnologías en el lado

Es decir, todo el esfuerzo lo realiza el navegador (tecnología web de cliente pesado.

En este caso, se crean páginas que contienen componentes que pertenecen a

Servicio de Servicio de opiniones

Ilustración 3, Ejemplo de aplicaciones SOA

servicio que nos muestre información al consumidor sobre artículos en general

(6.1.5) aplicaciones en la nube. cloud computing

Existen detractores de este tipo de servicios, puesto que al final información

que supone un retroceso que asemeja el funcionamiento de los sistemas de los

(6.2) aplicaciones web

(6.2.2) servidores de aplicaciones web

Ilustración 4, Arquitectura de un sistema de aplicaciones web moderno

En la ilustración se muestra la comunicación entre el navegador (Chrome,

Los servidores de esta capa son invocados por los servidores de

Todo este mecanismo de trabajo es el que involucra la creación de aplicaciones

(6.2.3) tecnologías para crear aplicaciones web

El controlador. Es la parte que controla las acciones del usuario y las

MVC es, en definitiva, un modelo de trabajo que facilita la creación de

(6.2.4) servidores de aplicaciones web comerciales

Módulo para Perl

(6.3) instalación de Apache

(6.3.2) instalación binaria en Windows

(2) Aceptar la licencia

(4) Elegir el tipo de instalación (es aconsejable elegir la personalizada,

(5) Finalmente realizar la instalación propiamente dicha

It works! (funciona) es el texto de la página de inicio del servidor Apache.

modificar el PATH de Windows

iniciar y parar el servicio

estructura de directorios de apache

(6.3.3) instalación de código fuente en Linux

comando configure --help)

Suponiendo que /usr/local/apache2 es la ruta a la raíz de instalación de Apache.

httpd -k start ó apachectl start. Inicia el proceso httpd; es decir ejecuta

(6.3.4) instalación del paquete desde el sistema Linux

instalar paquete en sistemas Red Hat

yum install httpd