Guia de Estudio de PHP

PHP & MYSQL I & II
Guía de PHP & MYSQL I
Introducción y Generalidades
Requisitos
Gracias a PHP se pueden elaborar completos sitios dinámicos, y su complemento ideal siempre
resulta ser MySQL para gestionar las bases de datos que utilizamos en nuestros desarrollos,
por esta razón es importante aprender a utilizar tanto el uno como el otro y saber de qué
manera enlazarlos para una programación web más completa. PHP es uno de los lenguajes
más usados en Internet y existen muchos sitios importantes programados con él.
MOS. David Ortega Mazzini 2

Contenido
INTRODUCCIÓN Y GENERALIDADES ....................................................................................................... 2
REQUISITOS ................................................................................................................................................. 2
DATOS DEL AUTOR ................................................................................................................................ 9
MOS DAVID ORTEGA MAZZINI ............................................................................................................... 9
PRÓLOGO ............................................................................................................................................ 10
INTRODUCCIÓN.- ................................................................................................................................. 11
QUÉ ES PHP .......................................................................................................................................... 11
QUÉ SE PUEDE HACER CON PHP ........................................................................................................... 11
EL MODELO CLIENTE – SERVIDOR ........................................................................................................ 13
PÁGINAS ESTÁTICAS ............................................................................................................................ 14
PÁGINAS DINÁMICAS........................................................................................................................... 14
SERVIDOR WEB APACHE ...................................................................................................................... 15
POR QUÉ PHP....................................................................................................................................... 16
VENTAJAS ............................................................................................................................................ 17
DESVENTAJAS ...................................................................................................................................... 17
INSTALACIÓN ....................................................................................................................................... 17
ENTORNO DE TRABAJO ........................................................................................................................ 23
XAMPP................................................................................................................................................. 24
APPSERV .............................................................................................................................................. 25
COMPROBACIÓN DE LA INSTALACIÓN ................................................................................................. 25
PHP: LENGUAJE DE PROGRAMACIÓN................................................................................................... 25
SINTAXIS .............................................................................................................................................. 25
ETIQUETAS DE PHP .............................................................................................................................. 26
COMENTARIOS EN PHP ........................................................................................................................ 27
VARIABLES ........................................................................................................................................... 27
TIPOS DE DATOS .................................................................................................................................. 30
ÁMBITOS DE LAS VARIABLES ............................................................................................................... 31
OPERADORES ....................................................................................................................................... 33
OPERADORES ARITMÉTICOS ................................................................................................................ 33
EL OPERADOR DE DIVISIÓN ("/") DEVUELVE UN VALOR FLOTANTE A MENOS QUE LOS DOS
OPERANDOS SEAN INTEGERS (O STRINGS QUE SE CONVIERTAN A INTEGERS) Y LOS NÚMEROS SEAN
DIVISIBLES, EN CUYO CASO SERÁ DEVUELTO UN VALOR INTEGER. ...................................................... 33
LOS OPERANDOS DEL MÓDULO SE CONVIERTEN EN INTEGERS (POR EXTRACCIÓN DE LA PARTE

DECIMAL) ANTES DEL PROCESAMIENTO. ............................................................................................. 33

EL RESULTADO DEL OPERADOR MÓDULO % TIENE EL MISMO SIGNO QUE EL DIVIDENDO — ES DECIR,
EL RESULTADO DE $A % $B TENDRÁ EL MISMO SIGNO QUE $A. POR EJEMPLO: .................................. 33
OPERADORES DE ASIGNACIÓN ............................................................................................................ 34
PASO DE VARIABLES POR URL .............................................................................................................. 34
$HTTP_GET_VARS .................................................................................................................................. 35
$_GET ..................................................................................................................................................... 35
CARACTERES ESPECIALES EN URL Y SU CODIFICACIÓN CON PHP .......................................................... 35
EJEMPLOS DE CASOS DE PÁGINAS CON PARÁMETROS ........................................................................ 36
LABORATORIOS ................................................................................................................................... 36
LAB: PRACTICA CON PARÁMETROS GET 1 ............................................................................................ 36
LAB: PRACTICAL CON FORM ................................................................................................................. 36
LAB: PRACTICA CON PARÁMETROS GET 2 (OPCIONAL) ........................................................................ 36
LAB: PARÁMETROS GET Y USO DE VARIABLES LOCALES (OPCIONAL) ................................................... 36
ESTRUCTURAS DE CONTROL ................................................................................................................ 36
TODO SCRIPT PHP ESTÁ CONSTRUIDO EN BASE A UNA SERIE DE SENTENCIAS. UNA SENTENCIA PUEDE
SER UNA ASIGNACIÓN, UNA LLAMADA DE FUNCIÓN, UN CICLO, UNA SENTENCIA CONDICIONAL O
INCLUSO UNA SENTENCIA QUE NO HACE NADA (UNA SENTENCIA VACÍA). LAS SENTENCIAS
GENERALMENTE FINALIZAN CON UN PUNTO Y COMA. ADICIONALMENTE, LAS SENTENCIAS PUEDEN
AGRUPARSE EN UN CONJUNTO DE SENTENCIAS, ENCAPSULÁNDOLAS ENTRE CORCHETES. UN GRUPO
DE SENTENCIAS ES UNA SENTENCIA POR SÍ MISMA TAMBIÉN. LOS DIFERENTES TIPOS DE SENTENCIAS
SON DESCRITOS EN ESTE CAPÍTULO. .................................................................................................... 40
IF.......................................................................................................................................................... 40
ELSE ..................................................................................................................................................... 41
ELSEIF/ELSE IF ...................................................................................................................................... 41
SENTENCIA SWITCH ............................................................................................................................. 42
LABORATORIOS ................................................................................................................................... 43
LAB1: FORMULARIO I ........................................................................................................................... 43
LAB2: FORMULARIO II .......................................................................................................................... 43
LAB3: TABLA DINÁMICA ....................................................................................................................... 43
ARREGLOS EN PHP ............................................................................................................................... 43
INCLUSIÓN DE CÓDIGO ........................................................................................................................ 45
REQUIRE .............................................................................................................................................. 45
FORMULARIOS ..................................................................................................................................... 46
FUNCIONES EN PHP ............................................................................................................................. 46
FUNCIÓN PRINT() ................................................................................................................................. 51
FUNCIÓN PRINTF() ............................................................................................................................... 51

FUNCIÓN SPRINTF() ............................................................................................................................. 51
FUNCIÓN STRTOUPPER() Y STRTOLOWER () ......................................................................................... 53
STRTOUPPER .............................................................................................................................................. 54
FUNCIÓN STRLEN() ............................................................................................................................... 54
FUNCIÓN NUMBER_FORMAT() ............................................................................................................ 54
FUNCIÓN SUBSTR() .............................................................................................................................. 56
FUNCIÓN RTRIM() ................................................................................................................................ 57
FUNCIÓN LTRIM() ................................................................................................................................ 57
FUNCIÓN TRIM() .................................................................................................................................. 58
FUNCIÓN STR_WORD_COUNT() ........................................................................................................... 58
FUNCIÓN SPLIT() .................................................................................................................................. 59
FUNCIONES DE REDONDEO .................................................................................................................. 59
FUNCIÓN ROUND() .............................................................................................................................. 59
FUNCIÓN CEIL() .................................................................................................................................... 60
FUNCIÓN FLOOR() ................................................................................................................................ 60
FUNCIONE DEFINIDAS POR EL USUARIO .............................................................................................. 60
BASE DE DATOS MYSQL ....................................................................................................................... 61
APLICACIONES ..................................................................................................................................... 61
ENTORNO MYSQL.- .............................................................................................................................. 63
PHPMYADMIN ..................................................................................................................................... 64
EL LENGUAJE SQL ................................................................................................................................. 67
LENGUAJE DE DEFINICIÓN DE DATOS (DDL) ...................................................................................................... 67

CREATE | CREAR ................................................................................................................................ 67
ALTER | MODIFICAR ........................................................................................................................... 67
DROP | ELIMINAR .............................................................................................................................. 68
TRUNCATE | BORRAR TABLA ............................................................................................................. 68
LENGUAJE DE MANIPULACIÓN DE DATOS DML(DATA MANIPULATION LANGUAGE) .................................................. 68
Definición ........................................................................................................................................... 68
SELECT | SELECCIONAR ...................................................................................................................... 68
INSERT | INSERTAR ............................................................................................................................ 72
UPDATE .............................................................................................................................................. 74
DELETE ............................................................................................................................................... 74
RECUPERACIÓN DE CLAVE ............................................................................................................................. 74
DISPARADORES ........................................................................................................................................... 75
PHP CON BASES DE DATOS MYSQL ..................................................................................................... 76
CONECTANDO PHP CON BASES DE DATOS ........................................................................................... 76
DEFINICIÓN .......................................................................................................................................... 76
MYSQL ................................................................................................................................................. 76

FUNCIONES DE PHP PARA INTERACTUAR CON MYSQL......................................................................... 76
MYSQLI_CONNECT() ............................................................................................................................ 76
MYSQLI_CLOSE() .................................................................................................................................. 76
MYSQLI_SELECT_DB() .......................................................................................................................... 76
MYSQLI_QUERY() ................................................................................................................................. 76
MYSQLI_NUM_ROWS () ....................................................................................................................... 76
MYSQLI_FETCH_ARRAY() ..................................................................................................................... 76
MYSQLI_ERROR() ................................................................................................................................. 76
MODIFICACIONES DE DATOS ............................................................................................................... 76
INSERTAR UN REGISTRO ...................................................................................................................... 76
MODIFICAR UN REGISTRO ................................................................................................................... 76
BORRAR UN REGISTRO ........................................................................................................................ 77
LISTADO DE PRODUCTOS ..................................................................................................................... 77
ARMAR EL REPORTE DE PRODUCTOS ................................................................................................... 77
ARMAR LA CONSULTA SQL................................................................................................................... 77
REPORTE .............................................................................................................................................. 77
COLORES INTERLINEADOS.................................................................................................................... 77
BÚSQUEDAS INTERNAS EN EL SITIO ..................................................................................................... 77
PAGINACIÓN DE LOS RESULTADOS DEL REPORTE ................................................................................ 77
UPLOAD ? SUBIR ARCHIVOS AL SERVER ............................................................................................... 77
INTRODUCCIÓN ................................................................................................................................... 77
FORMULARIO PARA SUBIR ARCHIVOS ................................................................................................. 77
TIPOS DE CONTENIDO DEL FORMULARIO............................................................................................. 77
ETIQUETA FILE ..................................................................................................................................... 77
CAMPO OCULTO MAX_FILE_SIZE ......................................................................................................... 77
FORMULARIO COMPLETO DE CARGA ................................................................................................... 77
PAGINA DESTINO ? COPIAR AL SERVIDOR ............................................................................................ 78
LA VARIABLE $_FILES ........................................................................................................................... 78
GRABANDO EL ARCHIVO SUBIDO ......................................................................................................... 78
PHP EN LA PRÁCTICA ........................................................................................................................... 78
INTRODUCCIÓN ................................................................................................................................... 78
CAMPOS OCULTOS............................................................................................................................... 78
HIDDEN ................................................................................................................................................ 78
FINALIDAD ........................................................................................................................................... 78

EJEMPLO: ............................................................................................................................................. 78
SESIONES ............................................................................................................................................. 78
INTRODUCCIÓN ................................................................................................................................... 78
PORQUE USAR SESIONES ..................................................................................................................... 78
IDENTIFICADOR DE SESION - SID .......................................................................................................... 78
GESTION DE UNA SESION ..................................................................................................................... 78
COOKIES .............................................................................................................................................. 78
POR URL REWRITING: .......................................................................................................................... 79
CARACTERÍSTICAS ................................................................................................................................ 79
FUNCIONES DE PHP PARA INTERACTUAR CON SESIONES ..................................................................... 79
CONSTRUCCIÓN DE VARIABLES DE SESIÓN .......................................................................................... 79
IDENTIFICACIÓN DE LA SESIÓN ............................................................................................................ 79
DESTRUCCIÓN DE UNA SESIÓN ............................................................................................................ 79
CREAR VARIABLES DE SESIÓN .............................................................................................................. 79
AUTENTIFICACIÓN DE USUARIOS A UN SITIO WEB CON USO DE SESIONES .......................................... 79
LOGUEO AL SITIO ................................................................................................................................. 79
AUTENTIFICACIÓN Y CREACIÓN DE LA SESIÓN. .................................................................................... 79
CERRAR SESIÓN: PAGINA DESCONECTARSE ......................................................................................... 79
COOKIES .............................................................................................................................................. 79
INTRODUCCIÓN ................................................................................................................................... 79
DEFINICIÓN .......................................................................................................................................... 79
CADUCIDAD ......................................................................................................................................... 79
DOMINIOS Y SUBDOMINIOS ................................................................................................................ 80
CARACTERÍSTICAS ................................................................................................................................ 80
LIMITACIONES ..................................................................................................................................... 80
FUNCIONES DE PHP PARA INTERACTUAR CON COOKIES ...................................................................... 80
CONSTRUCCIÓN ................................................................................................................................... 80
UTILIZACIÓN ........................................................................................................................................ 80
EXPIRACIÓN ......................................................................................................................................... 80
ELIMINACIÓN ....................................................................................................................................... 80
LA FUNCIÓN ISSET() ............................................................................................................................. 80


Datos del Autor
MOS DAVID ORTEGA MAZZINI
David Ortega Mazzini es Tecnólogo en análisis de sistemas computacionales, certificado en

tecnologías Microsoft. Desde 1998 se dedica a la informática & sistemas, especialmente a los
temas de desarrollo y base de datos. En la actualidad, es uno de los profesionales más
conocidos de nuestro medio debido a su amplia experiencia.
Como desarrollador y consultor de sistemas ha brindado sus servicios a instituciones públicas y

privadas como Aduana del Ecuador, Sistemas & Servicios, Multimodal, Ambiensa, Eclpsoft,
MAGAP, entre otras.
Como docente cuenta con más de 10 años de experiencia dictando cursos de desarrollo
orientado a los procesamientos de datos, elaboración de manuales técnicos y de difusión de
tecnologías. Actualmente es catedrático en el Tecnológico Euroamericano, así como Facilitador
en las charlas que organiza la Compañía Ramos & Asociados, adicionalmente ha dictado
cátedra en las universidad Católica Santiago de Guayaquil.

Prólogo
Ser un desarrollador competente hoy en día implica, en primer lugar, tener los conceptos
claros sobre la programación orientada a objetos (POO), ya que es la base de los lenguajes de
programación.
PHP es uno de los lenguajes de programación más usados en el desarrollo de aplicaciones

comerciales que tengan un requerimiento de 24x7x365, y con la ventaja de poder
implementarla en cualquier plataforma.
En este contexto, es necesario contar con un texto que sirva de guía para crear soluciones
empresariales aplicando POO, PHP Data Object, AJAX y patrones de diseño DAO y MVC.
Por lo que esta obra abarca el conocimiento general de la tecnología PHP con su base de datos
nativa MYSQL. Le da al alumno la completa guía para iniciarse en el desarrollo de aplicaciones
en este lenguaje programación.

Introducción.-
PHP es uno de los lenguajes de programación que más personas en el mundo lo usan, tanto en
el ambiente académico, como en el desarrollo de aplicaciones empresariales.
Php es un lenguaje orientado a objetos. Entre sus principales características podemos

mencionar:
 Multiplataforma, porque PHP corre sobre cualquier sistema operativo

 Orientado a Objetos
A esto tenemos que agregarle una gran cantidad de librerías y recursos para desarrollar todo
tipo de aplicaciones, desde las más sencillas, como registrar un cliente en una base de datos,
hasta las más avanzadas, como componentes web services.
Qué es PHP
PHP es un lenguaje de programación de uso general de código del lado del servidor
originalmente diseñado para el desarrollo web de contenido dinámico. Fue uno de los
primeros lenguajes de programación del lado del servidor que se podían incorporar
directamente en el documento HTML en lugar de llamar a un archivo externo que procese los
datos. El código es interpretado por un servidor web con un módulo de procesador de PHP que
genera la página Web resultante. PHP ha evolucionado por lo que ahora incluye también una
interfaz de línea de comandos que puede ser usada en aplicaciones gráficas independientes.
Puede ser usado en la mayoría de los servidores web al igual que en casi todos los sistemas
operativos y plataformas sin ningún costo.
Fue creado originalmente por Rasmus Lerdorf en 1995. Actualmente el lenguaje sigue siendo
desarrollado con nuevas funciones por el grupo PHP.2 Este lenguaje forma parte del software
libre publicado bajo la licencia PHP, que es incompatible con la Licencia Pública General de
GNU debido a las restricciones del uso del término PHP.3
Qué se puede hacer con PHP

Cualquier cosa. PHP está enfocado principalmente a la programación de scripts del
lado del servidor, por lo que se puede hacer cualquier cosa que pueda hacer otro
programa CGI, como recopilar datos de formularios, generar páginas con contenidos
dinámicos, o enviar y recibir cookies. Aunque PHP puede hacer mucho más.
Existen principalmente tres campos principales donde se usan scripts de PHP.
Scripts del lado del servidor. Este es el campo más tradicional y el foco principal.
Son necesarias tres cosas para que esto funcione. El analizador de PHP (módulo CGI o
servidor), un servidor web y un navegador web. Es necesario ejecutar el servidor con
una instalación de PHP conectada. Se puede acceder al resultado del programa de PHP
con un navegador, viendo la página de PHP a través del servidor. Todo esto se puede

ejecutar en su máquina si está experimentado con la programación de PHP. Véase la

sección sobre las instrucciones de instalación para más información.
Scripts desde la línea de comandos. Se puede crear un script de PHP y ejecutarlo

sin necesidad de un servidor o navegador. Solamente es necesario el analizador de
PHP para utilizarlo de esta manera. Este tipo de uso es ideal para scripts que se
ejecuten con regularidad empleando cron (en *nix o Linux) o el Planificador de tareas
(en Windows). Estos scripts también pueden usarse para tareas simples de
procesamiento de texto. Véase la sección Uso de PHP en la línea de comandos para
más información.
Escribir aplicaciones de escritorio. Probablemente PHP no sea el lenguaje más

apropiado para crear aplicaciones de escritorio con una interfaz gráfica de usuario,
pero si se conoce bien PHP, y se quisiera utilizar algunas características avanzadas de
PHP en aplicaciones del lado del cliente, se puede utilizar PHP-GTK para escribir dichos
programas. También es posible de esta manera escribir aplicaciones independientes de
una plataforma. PHP-GTK es una extensión de PHP, no disponible en la distribución
principal. Si está interesado en PHP-GTK, puede visitar su propio sitio web.
PHP puede emplearse en todos los sistemas operativos principales, incluyendo Linux,
muchas variantes de Unix (incluyendo HP-UX, Solaris y OpenBSD), Microsoft Windows,
Mac OS X, RISC OS y probablemente otros más. PHP admite la mayoría de servidores
web de hoy en día, incluyendo Apache, IIS, y muchos otros. Esto incluye cualquier
servidor web que pueda utilizar el binario de PHP FastCGI, como lighttpd y nginx. PHP
funciona tanto como módulo como procesador de CGI.
De modo que con PHP, se tiene la libertad de elegir el sistema operativo y el servidor
web. Además, se tiene la posibilidad de utilizar programación por procedimientos o
programación orientada a objetos (POO), o una mezcla de ambas.
Con PHP no se está limitado a generar HTML. Entre las capacidades de PHP se incluyen
la creación de imágenes, ficheros PDF e incluso películas Flash (usando libswf y Ming)
generadas sobre la marcha. También se puede generar fácilmente cualquier tipo de
texto, como XHTML y cualquier otro tipo de fichero XML. PHP puede autogenerar estos
ficheros y guardarlos en el sistema de ficheros en vez de imprimirlos en pantalla,
creando una caché en el lado del servidor para contenido dinámico.
Una de las características más potentes y destacables de PHP es su soporte para un

amplio abanico de bases de datos. Escribir una página web con acceso a una base de
datos es increíblemente simple utilizando una de las extensiones específicas de bases
de datos (p.ej., para mysql), o utilizar una capa de abstracción como PDO, o conectarse
a cualquier base de datos que admita el estándar de Conexión Abierta a Bases de

Datos por medio de la extensión ODBC. Otras bases de datos podrían utilizar cURL o
sockets, como lo hace CouchDB.
PHP también cuenta con soporte para comunicarse con otros servicios usando
protocolos tales como LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (en Windows) y
muchos otros. También se pueden crear sockets de red puros e interactuar usando
cualquier otro protocolo. PHP tiene soporte para el intercambio de datos complejos de
WDDX entre virtualmente todos los lenguajes de programación web. Y hablando de
interconexión, PHP tiene soporte para la instalación de objetos de Java y emplearlos
de forma transparente como objetos de PHP.
PHP tiene útiles características de procesamiento de texto, las cuales incluyen las
expresiones regulares compatibles con Perl (PCRE), y muchas extensiones y
herramientas para el acceso y análisis de documentos XML. PHP estandariza todas las
extensiones XML sobre el fundamento sólido de libxml2, y amplía este conjunto de
características añadiendo soporte para SimpleXML, XMLReader y XMLWriter.
Existen otras extensiones interesantes, las cuales están categorizadas alfabéticamente

y por categoría. También hay extensiones adicionales de PECL que podrían estar
documentadas o no dentro del manual de PHP, tal como » XDebug.
Como se puede apreciar, esta página no es suficiente para enumerar todas las
características y beneficios que ofrece PHP. Consulte las secciones Instalación de PHP y
Referencia de las funciones para una explicación de las extensiones mencionadas aquí.
El Modelo Cliente – Servidor
La arquitectura cliente-servidor es un modelo de aplicación distribuida en el que las

tareas se reparten entre los proveedores de recursos o servicios, llamados servidores,
y los demandantes, llamados clientes. Un cliente realiza peticiones a otro programa, el
servidor, quien le da respuesta. Esta idea también se puede aplicar a programas que se
ejecutan sobre una sola computadora, aunque es más ventajosa en un sistema
operativo multiusuario distribuido a través de una red de computadoras.
En esta arquitectura la capacidad de proceso está repartida entre los clientes y los
servidores, aunque son más importantes las ventajas de tipo organizativo debidas a la
centralización de la gestión de la información y la separación de responsabilidades, lo
que facilita y clarifica el diseño del sistema.

La separación entre cliente y servidor es una separación de tipo lógico, donde el

servidor no se ejecuta necesariamente sobre una sola máquina ni es necesariamente
un sólo programa. Los tipos específicos de servidores incluyen los servidores web, los
servidores de archivo, los servidores del correo, etc. Mientras que sus propósitos
varían de unos servicios a otros, la arquitectura básica seguirá siendo la misma.
Una disposición muy común son los sistemas multicapa en los que el servidor se
descompone en diferentes programas que pueden ser ejecutados por diferentes
computadoras aumentando así el grado de distribución del sistema.
La red cliente-servidor es una red de comunicaciones en la cual los clientes están

conectados a un servidor, en el que se centralizan los diversos recursos y aplicaciones
con que se cuenta; y que los pone a disposición de los clientes cada vez que estos son
solicitados. Esto significa que todas las gestiones que se realizan se concentran en el
servidor, de manera que en él se disponen los requerimientos provenientes de los
clientes que tienen prioridad, los archivos que son de uso público y los que son de uso
restringido, los archivos que son de sólo lectura y los que, por el contrario, pueden ser
modificados, etc. Este tipo de red puede utilizarse conjuntamente en caso de que se
esté utilizando en una red mixta.
Páginas Estáticas
Páginas web donde el contenido no es editable. La información permanece fija en un

95% de la veces pudiéndose hacer pequeñas modificaciones de contenido por parte
del desarrollador web. Este tipo de páginas es más bien para el tipo de sitios web
institucionales
Páginas Dinámicas
Sitios web que pueden ser editables. Se realiza una programación diferente al de los
sitios web estáticos para que en un futuro se puedan hacer modificaciones de
contenido.

Servidor Web Apache
El servidor HTTP Apache es un servidor web HTTP de código abierto, para plataformas
Unix (BSD, GNU/Linux, etc.), Microsoft Windows, Macintosh y otras, que implementa
el protocolo HTTP/1.12 y la noción de sitio virtual. Cuando comenzó su desarrollo en
1995 se basó inicialmente en código del popular NCSA HTTPd 1.3, pero más tarde fue
reescrito por completo. Su nombre se debe a que Behelendorf quería que tuviese la
connotación de algo que es firme y enérgico pero no agresivo, y la tribu Apache fue la
última en rendirse al que pronto se convertiría en gobierno de EEUU, y en esos
momentos la preocupación de su grupo era que llegasen las empresas y "civilizasen" el
paisaje que habían creado los primeros ingenieros de internet. Además Apache
consistía solamente en un conjunto de parches a aplicar al servidor de NCSA. En inglés,
a patchy server (un servidor "parcheado") suena igual que Apache Server.
El servidor Apache se desarrolla dentro del proyecto HTTP Server (httpd) de la Apache
Software Foundation.
Apache presenta entre otras características altamente configurables, bases de datos

de autenticación y negociado de contenido, pero fue criticado por la falta de una
interfaz gráfica que ayude en su configuración.
Apache tiene amplia aceptación en la red: desde 1996, Apache, es el servidor HTTP
más usado. Alcanzó su máxima cuota de mercado en 2005 siendo el servidor empleado
en el 70% de los sitios web en el mundo, sin embargo ha sufrido un descenso en su
cuota de mercado en los últimos años. (Estadísticas históricas y de uso diario
proporcionadas por Netcraft3 ).
La mayoría de las vulnerabilidades de la seguridad descubiertas y resueltas tan sólo

pueden ser aprovechadas por usuarios locales y no remotamente. Sin embargo,
algunas se pueden accionar remotamente en ciertas situaciones, o explotar por los
usuarios locales malévolos en las disposiciones de recibimiento compartidas que
utilizan PHP como módulo de Apache.

Por qué PHP
En los últimos años he escuchado a muchos de los nuevos programadores decir que
PHP es malo, esta afirmación la hacen programadores que en su vida han tocado PHP y
lo repiten como loros por que escucharon al amigo de un amigo decir lo mismo.
PHP es el lenguaje más difundido en la programación WEB, no tiene rival por cada 10
aplicaciones web habrá 1 en C# y otra en Ruby o NodeJ o cualquier otra cosa. La
verdad es que PHP impone y ese es el problema. Cuando algo se vuelve institucional
las personas tienden a ir en contra de eso aun sin razón alguna. Muchos Linuxeros
piensan que son Linuxeros por que van en contra de Microsoft y de Windows solo
porque Microsoft domina los sistemas operativos de escritorio.
Java tiene el mismo problema, Java es sin duda alguna el lenguaje más usado en
cualquier cosa, PC, Teléfonos, Televisores, tal vez hasta las tostadoras traen Java, Java
y es por eso por ser la INSTITUCION que algunos programadores van en contra de Java,
nunca lo han usado. No entienden en donde radica su poder aun asi despotrican
contra el. Ha tenido fallos si, pero los fallos son absurdos prácticamente inexplotables.
Tiene que reunirse una serie de situaciones para poder hacer daño con alguna de sus
vulnerabilidades. Me atrevo a decir que tendría que alinearse los planetas para que
todo esté en su lugar y poder explotar algo.
PHP es un gran lenguaje de programación lo tiene todo, no le falta nada, en su

repertorio de librerías, APIs, me atrevo a decir que si alguna tecnología nueva sale,
primero será escrita en PHP y después para los demás lenguajes competidores.
Java en su propio terreno de juego tiene las mismas ventajas en su propio nicho.
Algunas personas no despotrican contra Java o PHP por gusto, algunas no consideran
que sea malo, pero son personas que son de carácter débil, no les gusta dar su opinión
si esta va en contra de lo que la mayoría y tienen que decir PHP es malo solo por
convivir.
En un grupo de 10 personas que diga que PHP es malo, 7 de ellas nunca habrá escrito
nada en PHP, aprendió a programar en Internet y alguien les robo la oportunidad de
saber PHP diciéndole que usara Ruby on Rails u otra cosa, ahora que no saben
programar en PHP tienen que ir en contra de PHP para que la gente no se dé cuenta
que no lo odia que simplemente lo ignora y se pone el parche antes de que alguien
descubra que no sabe programar en PHP

Si aun no aprendes PHP, apréndelo en la programación WEB el PHP es el estándar de

facto y no saberlo te puede limitar, por ejemplo pero no limitando… cualquier
proveedor de hosting en internet y ahora la tan de moda nube, todos, TODOS. Proveen
servicio de ejecución de PHP, si sabes PHP tus programas se ejecutaran en cualquier
proveedor incluso en el más humilde de ellos, preguntante cuantos proveedores
soportan Ruby, NodeJ y cualquiera de esos lenguajes de la nueva ola.
Ventajas
Es muy versátil, se pueden hacer muchas cosas.
 Es un lenguaje muy sencillo de aprender.

 A pesar de que pueda costarte controlar la seguridad, su núcleo está muy
testeado por una amplia comunidad de seguidores.
 Es gratuito y está muy bien documentado.
Ejemplos de webs creadas en PHP.

 Facebook
 Yahoo
 Wikipedia
 Entre otros
Desventajas
 Es difícil controlar toda la seguridad si no eres un experto en la materia, y sin

usar frameworks puedes tener algunos agujeros en tu sistema.
 No tiene una separación de capas, es decir, código HTML, SQL, y PHP están
todos mezclados, aunque se puede optimizar por ejemplo recogiendo datos al
principio del documento etc.
Instalación
Aunque PHP podemos instalarlo en Windows, Mac y Linux, vamos a centrar este curso en la
instalación en sistemas Windows, pero si gustas asesoría en otro sistema operativo escríbeme
a [email protected]

Manual de Instalación
Esta sección contiene instrucciones para instalar y configurar manualmente PHP en
Windows de Microsoft.
Selección y descarga del paquete de distribución PHP

Descarga la distribución binaria de PHP zip » PHP para Windows: Binarios y Fuentes .
Hay varias versiones diferentes del paquete zip - Seleccione por la versión que sea
adecuado para el servidor web utilizado:
Si se utiliza PHP con IIS a continuación elija PHP 5.3 VC9 Non Thread Safe o PHP 5.2
VC6 Non Thread Safe;
Si PHP se utiliza con IIS7 o superior y PHP 5.3+, a continuación los archivos binarios VC9
de PHP que se deben utilizar.
Si se utiliza PHP con Apache 1 o Apache 2 a continuación elija PHP 5.3 VC6 o PHP 5.2
VC6.
Nota:
Versiones VC9 se compilan con el compilador de Visual Studio 2008 y tiene mejoras en
el rendimiento y estabilidad. Las versiones VC9 requieren que tenga la » Microsoft
2008 C++ Runtime (x86) o la » Microsoft 2008 C++ Runtime (x64) instalado.
La estructura del paquete PHP y el contenido.
Descomprimir el contenido del archivo zip en un directorio de su elección, por ejemplo

C:\PHP\. La estructura de directorios y archivos extraídos de del zip se verá de la
siguiente manera:

Ejemplo #1 PHP 5 paquete de estructura
c:\php
+--dev
| |
| |-php5ts.lib -- php5.lib in non thread safe version
+--ext -- extension DLLs for PHP
| |
| |-php_bz2.dll
| |
| |-php_cpdf.dll
| |
| |-...
+--extras -- empty
+--pear -- initial copy of PEAR
|-go-pear.bat -- PEAR setup script
|-...
|-php-cgi.exe -- CGI executable

|-php-win.exe -- executes scripts without an opened command prompt
|-php.exe -- Command line PHP executable (CLI)
|-...
|-php.ini-development -- default php.ini settings
|-php.ini-production -- recommended php.ini settings
|-php5apache2_2.dll -- does not exist in non thread safe version
|-php5apache2_2_filter.dll -- does not exist in non thread safe version
|-...
|-php5ts.dll -- core PHP DLL ( php5.dll in non thread safe version)
|-...
A continuación se muestra la lista de los módulos y archivos ejecutables incluidos en la

distribución del archivo zip de PHP:
go-pear.bat - el script de configuración de PEAR. Consulte » Instalación (PEAR) para

más detalles.
php-cgi.exe - ejecutable CGI que se puede utilizar cuando se ejecuta PHP en IIS a través
de CGI o FastCGI.

php-win.exe - el ejecutable para la ejecución de scripts en PHP sin necesidad de utilizar

una ventana de línea de comandos de PHP (Por ejemplo, las aplicaciones PHP que
utilizan Windows GUI).
php.exe - el ejecutable para la ejecución de scripts PHP dentro de una interfaz de línea
de comandos (CLI) de PHP.
php5apache2_2.dll - Apache 2.2.X module.
php5apache2_2_filter.dll - Apache 2.2.X filter.
Cambio el fichero php.ini
Después de que el contenido del paquete de PHP se ha extraído, copie el php.ini-

production en php.ini en la misma carpeta. Si es necesario, también es posible colocar
el php.ini en cualquier otro lugar. Pero se requieren pasos adicionales de configuración
como se describe en Configuración de PHP.
El fichero php.ini le dice a PHP cómo se configura, y cómo trabajar con el ambiente que
se ejecuta. Aquí hay una serie de ajustes para el fichero php.ini PHP que ayudan a
trabajar mejor con Windows. Algunos de estos son opcionales. Hay muchas otras
directivas que puedan ser relevantes para su ambiente - dirijase lista de directivas
php.ini para más información.
Las directivas:
extension_dir = <path to extension directory> - La extension_dir necesidades para
indicar el directorio donde las extensiones de PHP se almacenan los ficheros. La ruta
puede ser absoluta (i.e. "C:\PHP\ext") o (i.e. ".\ext"). Extensiones que se enumeran
más baja en el php.ini ficheros que se encuentra en el extension_dir .
extension = xxxxx.dll - Para cada extensión que desee habilitar, necesita un

correspondiente "extension=" directiva que le dice a PHP que las extensiones en el
extension_dir para cargar en tiempo de inicio.
log_errors = On - PHP tiene un error de registro de instalación que se puede utilizar

para enviar los errores a un fichero, o de un servicio (i.e. syslog) y trabaja en conjunto
con el error_log Directiva a continuación. Cuando se ejecuta bajo IIS, la log_errors
debe estar habilitado, con una validez error_log .
error_log = <path to the error log file> - El error_log tiene que especificar la ruta de
acceso absoluta, o en relación con el archivo donde los errores de PHP debe estar
registrado. Este archivo debe tener permisos de escritura para el servidor web. Los
lugares más comunes para este archivo en varios directorios TEMP, por ejemplo
"C:\inetpub\temp\php-errors.log".

cgi.force_redirect = 0 - La presente Directiva se requiere para ejecutar en IIS. Se trata

de una protección de la instalación de la guía necesaria por muchos otros servidores
web. Sin embargo, lo que permite que en IIS hacer que el motor de PHP a un error en
Windows.
cgi.fix_pathinfo = 1 - Esto le permite acceder a PHP al real path después de la

especificación CGI. IIS FastCGI implementa las necesidades de este conjunto.
fastcgi.impersonate = 1 - FastCGI bajo IIS admite la posibilidad de hacerse pasar por

tokens de seguridad del cliente que llama. Esto permite que IIS defina el contexto de
seguridad que solicita ejecutar.
fastcgi.logging = 0 - FastCGI debe estar deshabilitado en IIS. Si se deja habilitada, los

mensajes de cualquier clase son tratados por FastCGI como las condiciones de error
que hará que IIS genere una excepción HTTP 500.
Directivas opcionales
max_execution_time = ## - Esta directiva le dice a PHP, el importe máximo de tiempo
que puede ejecutar cualquier script determinado. El defecto es 30 segundos.
Aumentar el valor de esta directiva, si la aplicación PHP tomar mucho tiempo para
ejecutarse.
memory_limit = ###M - La cantidad de memoria disponible para el proceso de PHP, en

Megabytes. El valor por defecto es 128, lo cual está bien para la mayoría de las
aplicaciones PHP. Algunos de los más complejos puede ser que necesite más.
display_errors = Off - Esta directiva le dice a PHP si se incluyen los mensajes de error
en el corriente que devuelve al servidor web. Si se establece en "On", entonces PHP
enviará lo que las clases de errores que se define con la error_reporting directiva de
nuevo al servidor web como parte de la secuencia de error. Por razones de seguridad,
se recomienda "Off" en los servidores de producción con el fin de no revelar ninguna
información sensible de la seguridad que a menudo se incluyen en los mensajes de
error.
open_basedir = <paths a directorios, separados por semicolon>, por ejemplo,

openbasedir="C:\inetpub\wwwroot;C:\inetpub\temp". Esta directiva especifica las
rutas de directorio en donde PHP se le permite realizar las operaciones del sistema de
archivos. Cualquier operación de fichero fuera de las rutas especificadas se producirá
un error. Esta directiva es especialmente útil para bloquear la instalación de PHP en
entornos de alojamiento compartido para evitar que scripts PHP de acceso a los
archivos fuera del directorio raíz del sitio web.

upload_max_filesize = ###M and post_max_size = ###M - El tamaño máximo

permitido de un archivo subido y los datos posteriores, respectivamente. Los valores
de estas directivas serán aumenta si las aplicaciones PHP necesita realizar grandes
cargas, como por ejemplo fotos o archivos de vídeo.
PHP esta ahora configurado en el sistema. El siguiente paso es elegir un servidor web,
a fin de que pueda ejecutar PHP. Elegir un servidor web de la tabla de contenido.
Entorno de trabajo
Vamos a comenzar a preparar el entorno con el que vamos a trabajar para poder crear páginas
web durante este curso. Lo primero que debemos hacer es descargar el editor de texto
Notepad++ e instalarlo. Para ello nos vamos a ir a la dirección siguiente: http://notepad-plus-
plus.org Aunque se puede usar cualquier editor de textos como: Sublime, Dreamweaver,
Netbeans, etc.
Cuando la página haya terminado de cargar, hacemos click en la sección download del menú
izquierdo, tal y como se muestra en la siguiente imagen.
En la página web que nos aparecerá, descargamos la versión “Installer” actual, por ejemplo
Notepad++ v6.9.6.2 Installer.
Una vez descargado el archivo, lo ejecutamos para instalarlo en nuestro ordenador haciendo
doble click sobre él. El proceso de instalación es muy simple y no entraremos a explicarlo con
más detalle.
Cuando tengamos instalado el programa, ya dispondremos del editor de texto Notepad++, con
el que podremos abrir y editar cualquier fichero HTML. Podremos acceder al programa desde
Inicio -- > Programas -- > Notepad++ ó desde el icono de acceso directo en el escritorio si se ha
creado.
EJEMPLO: COMENZAR A USAR NOTEPAD++
Desde el explorador de archivos de Windows, creamos una carpeta llamada curso_php_apr2

en la unidad C.
Una vez creada la carpeta, abrimos el Notepadd++, pulsamos en Archivo -- > Guardar como -- >
CU00808B.php (este nombre de archivo es solo un ejemplo, puedes ponerle el que tú quieras).
Ahora cierra Notepad++. Paso seguido, para editar este archivo (o cualquier otro) con el
programa Notepad++, hacemos lo siguiente:
1.- Clickamos sobre el archivo, pulsamos el botón derecho del ratón y se mostrará un menú
similar a éste.

En el menú desplegado seleccionamos “Edit with Notepad++”. Se abrirá el archivo php con
dicho editor.
2.- Ahora escribimos el siguiente código HTML y guardamos el archivo.
<?php
echo “Curso básico de PHP.”;
?>
Una vez realizados los pasos anteriores debemos seguir preparando el entorno de desarrollo
antes de poder visualizar la página PHP creada porque todavía no disponemos de un servidor
PHP que interprete nuestro código PHP. Es decir, no podrás ver la página web simplemente
haciendo doble click sobre el archivo.
Ten cuidado porque si copias el código en vez de escribirlo es posible que tengas problemas:
hay muchos tipos de comillas: “curvadas”, “sin curvar”, etc. En el código las comillas son
simples, si tú las has copiado de otro sitio es posible que el formato de las comillas no sea el
correcto. Esto puede pasar también con otros caracteres. Esto no significa que no puedas
cortar y copiar código de otro sitio, sino que debes tener presente que se te pueden presentar
problemas con el juego de caracteres (ten cuidado especialmente si pretendes copiar algo
desde Microsoft Word porque es habitual que haya problemas con los caracteres).
Si has seguido paso a paso todo lo que hemos expuesto y has llegado a visualizar en pantalla el
texto, es que has completado correctamente la instalación de Notepad++, que es el editor que
vamos a usar durante el curso. Si no has podido instalarlo, revisa las instrucciones y
comprueba que las hayas seguido correctamente.
XAMPP
XAMPP es el entorno más popular de desarrollo con PHP
XAMPP es una distribución de Apache completamente gratuita y fácil de instalar que contiene
MySQL, PHP y Perl. El paquete de instalación de XAMPP ha sido diseñado para ser
increíblemente fácil de instalar y usar.
¿Por qué usar XAMPP?

 El entorno de desarrollo PHP más popular.
 Para Windows, Mac OS X y Linux
 Fácil instalación y configuración.
 Completamente gratuito

APPSERV
AppServ es un software que nos permite instalar sobre Windows Apache, PHP, MySQL
y phpMyAdmin (interfaz gráfica para adminsitrar MySQL) de forma conjunta. Es una
aplicación muy útil para empezar a familiarizarnos con Gestores de Contenidos,
aprender a configurarlos e instalarlos, ya que nos permite realizar pruebas sobre
nuestro pc y una vez que dominemos el tema podemos decidirnos a comprar un
dominio y un alojamiento.
Comprobación de la instalación
Para comprobar que todo va bien debes dirigirte al explorador y digitar
http://localhost y debe mostrar un página web de bienvenida de la suite que hayas
elegido.
Para una asesoría en línea escríbeme a [email protected]
PHP: Lenguaje de Programación

PHP es un lenguaje de programación de uso general de código del lado del servidor
originalmente diseñado para el desarrollo web de contenido dinámico. Fue uno de los
primeros lenguajes de programación del lado del servidor que se podían incorporar
directamente en el documento HTML en lugar de llamar a un archivo externo que
procese los datos. El código es interpretado por un servidor web con un módulo de
procesador de PHP que genera la página Web resultante. PHP ha evolucionado por lo
que ahora incluye también una interfaz de línea de comandos que puede ser usada en
aplicaciones gráficas independientes. Puede ser usado en la mayoría de los servidores
web al igual que en casi todos los sistemas operativos y plataformas sin ningún costo.
Sintaxis
Se puede definir una constante usando la función define() o también declarándola

fuera de la clase con const desde PHP 5.3.0. Una vez que la constante está definida, no
puede ser cambiada o redifinida en ningún momento.
Antes de PHP 5.6, solamente los datos escalares (boolean, integer, float y string)
pueder estar contenidos en constante. Desde PHP 5.6 en adelante, también es posible
definir una constantes de array. Es posible definir constantes como un resource, pero
debería evitarse, ya que podría ocasionar resultados inesperados.

Para obtener el valor de una constante solo es necesario especificar su nombre. A

diferencia de las variables, no se debe prefijar una constante con el signo $. También
se puede usar la función constant() para leer el valor de una constante si se desea
obtener el valor de una constante de forma dinámica. Use get_defined_constants()
para obtener una lista de todas las constantes definidas.
Nota: Las contantes y las variables (globales) se encuentran en un espacio de nombres

distinto. Esto implica que por ejemplo TRUE y $TRUE son diferentes.
Si se usa una constante que todavía no está definida, PHP asume que se está refiriendo
al nombre de la constante en si, igual que si fuera una string (CONSTANT vs
"CONSTANT"). Cuando esto suceda, se mostrará un error de nivel E_NOTICE. Ver
también la sección en el manual de porqué $foo[bar] es incorrecto (a no ser que
primero define() bar como constante). Si simplemente quiere comprobar si una
constante está definida, use la función defined().
Estas son las diferencias entre constantes y variables:

 Las constantes no llevan el signo dólar ($), como prefijo.
 Las constantes solo pueden ser definidas usando la función define(), y no por
simple asignación.
 Las constantes pueden ser definidas y accedidas desde cualquier sitio sin
importar las reglas de acceso de variables.
 Las constantes no pueden ser redefinidas o eliminadas una vez se han definido.
Y
 Las constantes podrían evaluarse como valores escalares, o valores de array en
PHP 5.6 en adelante.
Ejemplo:
<?php
define("CONSTANTE", "Hola mundo.");
echo CONSTANTE; // muestra "Hola mundo."
echo Constante; // muestra "Constant" y se emite un aviso.
?>
Etiquetas de PHP
Cuando PHP interpreta un fichero, busca las etiquetas de apertura y cierre, que son
<?php y ?>, y que indican a PHP dónde empezar y finalizar la interpretación del código.
Este mecanismo permite a PHP ser incrustado en todo tipo de documentos, ya que
todo lo que esté fuera de las etiquetas de PHP será ignorado por el intérprete.

PHP también permite las etiquetas abreviadas <? y ?> (las cuales están desaconsejadas
debido a que sólo están disponibles si se habilitan con la directiva short_open_tag del
fichero de configuración php.ini, o si PHP se configuró con la opción --enable-short-
tags .
Si un fichero contiene código PHP puro, es preferible omitir la etiqueta de cierre de

PHP al final del fichero. Esto impide que se añadan espacios en blanco o nuevas líneas
después de la etiqueta de cierre de PHP, los cuales pueden causar efectos no deseados
debido a que PHP iniciará la salida del buffer cuando no había intención por parte del
programador de enviar ninguna salida en ese punto del script.
Comentarios en PHP
PHP soporta comentarios 'C', 'C++' y estilo consola Unix (estilo Perl). Por ejemplo:
<?php
echo 'Esto es una prueba'; // Esto es un comentario estilo c++ de
una sola línea
/* Esto es un comentario multi-línea
y otra línea de comentarios */
echo 'Esto es otra prueba';
echo 'Una prueba final'; # Esto es un comentario estilo consola de
una sola línea
?>
Los comentarios del estilo "una sola línea" solo comentan hasta el final de la línea o del
bloque actual de código de PHP, lo primero que suceda. Esto implica que el código
HTML después de // ... ?> o # ... ?> SERÁ impreso: ?> sale del modo PHP y vuelve al
modo HTML, por lo que // o # no pueden influir en eso. Si la directiva de configuración
asp_tags está activada, actúa igual que // %> y # %>. Sin embargo, la etiqueta </script>
no sale del modo PHP en un comentario de una sola línea.
<h1>Esto es un <?php # echo 'simple';?> ejemplo</h1>

<p>El encabezado anterior dirá 'Esto es un ejemplo'.</p>
Variables
En PHP las variables se representan con un signo de dólar seguido por el nombre de la
variable. El nombre de la variable es sensible a minúsculas y mayúsculas.
Los nombres de variables siguen las mismas reglas que otras etiquetas en PHP. Un
nombre de variable válido tiene que empezar con una letra o un carácter de subrayado
(underscore), seguido de cualquier número de letras, números y caracteres de
subrayado. Como expresión regular se podría expresar como: '[a-zA-Z_\x7f-\xff][a-zA-
Z0-9_\x7f-\xff]*'

Nota: Para los propósitos de este manual, una letra es a-z, A-Z, y los bytes del 127 al
255 (0x7f-0xff).
Nota: $this es una variable especial que no puede ser asignada.
<?php
$var = 'Roberto';
$Var = 'Juan';
echo "$var, $Var"; // imprime "Roberto, Juan"
$4site = 'aun no'; // inválido; comienza con un número

$_4site = 'aun no'; // válido; comienza con un carácter de subrayado
$täyte = 'mansikka'; // válido; 'ä' es ASCII (Extendido) 228
?>
De forma predeterminada, las variables siempre se asignan por valor. Esto significa que
cuando se asigna una expresión a una variable, el valor completo de la expresión
original se copia en la variable de destino. Esto quiere decir que, por ejemplo, después
de asignar el valor de una variable a otra, los cambios que se efectúen a una de esas
variables no afectará a la otra. PHP también ofrece otra forma de asignar valores a las
variables: asignar por referencia. Esto significa que la nueva variable simplemente
referencia (en otras palabras, "se convierte en un alias de" ó "apunta a") la variable
original. Los cambios a la nueva variable afectan a la original, y viceversa.
Para asignar por referencia, simplemente se antepone un signo ampersand (&) al

comienzo de la variable cuyo valor se está asignando (la variable fuente). Por ejemplo,
el siguiente segmento de código produce la salida 'Mi nombre es Bob' dos veces:
<?php
$foo = 'Bob'; // Asigna el valor 'Bob' a $foo
$bar = &$foo; // Referenciar $foo vía $bar.
$bar = "Mi nombre es $bar"; // Modifica $bar...
echo $bar;
echo $foo; // $foo también se modifica.
?>
Algo importante a tener en cuenta es que sólo las variables con nombre pueden ser
asignadas por referencia.
<?php
$foo = 25;
$bar = &$foo; // Esta es una asignación válida.
$bar = &(24 * 7); // Inválida; referencia una expresión sin nombre.

function test()
{
return 25;
}
$bar = &test(); // Inválido.

?>
No es necesario inicializar variables en PHP, sin embargo, es una muy buena práctica.
Las variables no inicializadas tienen un valor predeterminado de acuerdo a su tipo
dependiendo del contexto en el que son usadas - las booleanas se asumen como
FALSE, los enteros y flotantes como cero, las cadenas (p.ej. usadas en echo) se
establecen como una cadena vacía y las matrices se convierten en un array vacío.
Ejemplo #1 Valores predeterminados en variables sin inicializar
<?php
// Una variable no definida Y no referenciada (sin contexto de uso); imprime NULL
var_dump($variable_indefinida);
// Uso booleano; imprime 'false' (Vea operadores ternarios para más información sobr
e esta sintaxis)
echo($booleano_indefinido ? "true\n" : "false\n");
// Uso de una cadena; imprime 'string(3) "abc"'

$cadena_indefinida .= 'abc';
var_dump($cadena_indefinida);
// Uso de un entero; imprime 'int(25)'

$int_indefinido += 25; // 0 + 25 => 25
var_dump($int_indefinido);
// Uso de flotante/doble; imprime 'float(1.25)'

$flotante_indefinido += 1.25;
var_dump($flotante_indefinido);
// Uso de array; imprime array(1) { [3]=> string(3) "def" }

$array_indefinida[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
var_dump($array_indefinida);
// Uso de objetos; crea un nuevo objeto stdClass (vea http://www.php.net/manual/en

/reserved.classes.php)

// Imprime: object(stdClass)#1 (1) { ["foo"]=> string(3) "bar" }

$objeto_indefinido->foo = 'bar';
var_dump($objeto_indefinido);
?>
Depender del valor predeterminado de una variable sin inicializar es problemático al

incluir un archivo en otro que use el mismo nombre de variable. También es un
importante riesgo de seguridad cuando la opción register_globals se encuentra
habilitada. Un error de nivel E_NOTICE es emitido cuendo se trabaja con variables sin
inicializar, con la excepción del caso en el que se anexan elementos a un array no
inicializado. La construcción del lenguaje isset() puede ser usada para detectar si una
variable ya ha sido inicializada.
Tipos de Datos
PHP soporta ocho tipos primitivos.
Cuatro tipos escalares:
 boolean
 integer
 float (número de punto flotante, también conocido como double)
 string
Dos tipos compuestos:
 array
 object
Y finalmente dos tipos especiales:
 resource
 NULL
Este manual introduce también algunos pseudo-tipos por razones de legibilidad:
 mixed
 number
 callback
Y la pseudo-variable $... .

Puede que algunas referencias al tipo "double" aun existan en el manual. Considere al
tipo double como el mismo que float; los dos nombres existen sólo por razones
históricas.
El tipo de una variable usualmente no es declarado por el programador; en cambio, es

decidido en tiempo de ejecución por PHP dependiendo del contexto en el que es
usado la variable.
Nota: Para comprobar el tipo y el valor de una expresión, utilice la función var_dump().
Para obtener una representación legible para humanos del tipo para propósitos de
depuración, use la función gettype(). Para comprobar un cierto tipo, no use gettype(),
si no las funciones is_tipo. Algunos ejemplos:
<?php
$un_bool = TRUE; // un valor booleano
$un_str = "foo"; // una cadena
$un_str2 = 'foo'; // una cadena
$un_int = 12; // un entero
echo gettype($un_bool); // imprime: boolean

echo gettype($un_str); // imprime: string
// Si este valor es un entero, incrementarlo en cuatro

if (is_int($un_int)) {
$un_int += 4;
}
// Si $un_bool es una cadena, imprimirla

// (no imprime nada)
if (is_string($un_bool)) {
echo "Cadena: $un_bool";
}
?>
Ámbitos de las Variables

El ámbito de una variable es el contexto dentro del que la variable está definida. La
mayor parte de las variables PHP sólo tienen un ámbito simple. Este ámbito simple
también abarca los ficheros incluidos y los requeridos. Por ejemplo:
<?php
$a = 1;
include 'b.inc';
?>
Aquí, la variable $a estará disponible al interior del script incluido b.inc. Sin embargo, al
interior de las funciones definidas por el usuario se introduce un ámbito local a la función.
Cualquier variable usada dentro de una función está, por omisión, limitada al ámbito local de la
función. Por ejemplo:

<?php
$a = 1; /* ámbito global */
function test()
{
echo $a; /* referencia a una variable del ámbito local */
}
test();
?>
Este script no producirá salida, ya que la sentencia echo utiliza una versión local de la
variable $a, a la que no se ha asignado ningún valor en su ámbito. Puede que usted
note que hay una pequeña diferencia con el lenguaje C, en el que las variables globales
están disponibles automáticamente dentro de la función a menos que sean
expresamente sobreescritas por una definición local. Esto puede causar algunos
problemas, ya que la gente puede cambiar variables globales inadvertidamente. En
PHP, las variables globales deben ser declaradas globales dentro de la función si van a
ser utilizadas dentro de dicha función.
La palabra clave global
En primer lugar, un ejemplo de uso de global:
Ejemplo #1 Uso de global:

<?php
$a = 1;
$b = 2;
function Suma()
{
global $a, $b;
$b = $a + $b;
}
Suma();
echo $b;
?>
El script anterior producirá la salida 3. Al declarar $a y $b globales dentro de la función,

todas las referencias a tales variables se referirán a la versión global. No hay límite al
número de variables globales que se pueden manipular dentro de una función.
Un segundo método para acceder a las variables desde un ámbito global es usando el
array $GLOBALS. El ejemplo anterior se puede reescribir así:

Operadores
Un operador es algo que toma uno más valores (o expresiones, en jerga de programación) y
produce otro valor (de modo que la construcción en si misma se convierte en una expresión).
Los operadores se pueden agrupar de acuerdo con el número de valores que toman. Los
operadores unarios toman sólo un valor, por ejemplo! (el operador lógico de negación) o ++ (el
operador de incremento). Los operadores binarios toman dos valores, como los familiares
operadores aritméticos + (suma) y - (resta), y la mayoría de los operadores de PHP entran en
esta categoría. Finalmente, hay sólo un operador ternario, ? :, el cual toma tres valores;
usualmente a este se le refiere simplemente como "el operador ternario" (aunque podría tal
vez llamarse más correctamente como el operador condicional).
Una lista completa de operadores de PHP sigue en la sección Precedencia de Operadores. La

sección también explica la precedencia y asociatividad de los operadores, las cuales gobiernan
exactamente cómo son evaluadas expresiones que contienen varios diferentes operadores.
Operadores aritméticos
¿Recuerda la aritmética básica de la escuela? Estos funcionan igual que aquellos.
Operadores aritméticos
Ejemplo Nombre Resultado
-$a Negación Opuesto de $a.
$a + $b Adición Suma de $a y $b.
$a - $b Sustracción Diferencia de $a y $b.
$a * $b Multiplicación Producto de $a y $b.
$a / $b División Cociente de $a y $b.
$a % $b Módulo Resto de $a dividido por $b.
$a ** Exponenciación Resultado de elevar $a a la potencia $bésima. Introducido
$b en PHP 5.6.
El operador de división ("/") devuelve un valor flotante a menos que los dos operandos
sean integers (o strings que se conviertan a integers) y los números sean divisibles, en
cuyo caso será devuelto un valor integer.
Los operandos del módulo se convierten en integers (por extracción de la parte

decimal) antes del procesamiento.
El resultado del operador módulo % tiene el mismo signo que el dividendo — es decir,
el resultado de $a % $b tendrá el mismo signo que $a. Por ejemplo:

Operadores de Asignación
El operador básico de asignación es "=". Se podría inclinar a pensar primero que es
como un "igual a". No lo es. Realmente significa que el operando de la izquierda se
establece con el valor de la expresión de la derecha (es decir, "se define como").
El valor de una expresión de asignación es el valor asignado. Es decir, el valor de "$a =

3" es de 3. Esto permite hacer algunas cosas intrincadas:
Paso de Variables por URL

Para pasar las variables de una página a otra lo podemos hacer introduciendo dicha variable
dentro del enlace hipertexto de la página destino. La sintaxis sería la siguiente:
<a href="destino.php?variable1=valor1&variable2=valor2&...">Mi enlace</a>
Podéis observar que estas variables no poseen el símbolo $ delante. Esto es debido a
que en realidad este modo de pasar variables no es específico de PHP sino que es
utilizado por otros lenguajes.
Ahora nuestra variable pertenece también al entorno de la página destino.php y está

lista para su explotación.
Nota: No siempre se definen automáticamente las variables recibidas por parámetro en las
páginas web, depende de una variable de configuración de PHP: register_globals, que tiene
que estar activada para que así sea. Ver comentarios del artículo al final de la página para más
información.
Para aclarar posibles dudas, veamos esto en forma de ejemplo. Tendremos pues dos
páginas, origen.html (no es necesario darle extensión PHP puesto que no hay ningún
tipo de código) y destino.php:
<HTML>
<HEAD>
<TITLE>origen.html</TITLE>
</HEAD>
<BODY>
<a href="destino.php?saludo=hola&texto=Esto es una variable texto">Paso variables
saludo y texto a la página destino.php</a>
</BODY>
</HTML>
<HTML>
<HEAD>
<TITLE>destino.php</TITLE>
</HEAD>

<BODY>
<?
echo "Variable $saludo: $saludo <br>n";
echo "Variable $texto: $texto <br>n"
?>
</BODY>
</HTML>
$HTTP_GET_VARS
Recordamos que es posible recopilar en una variable tipo array el conjunto de variables que
han sido enviadas al script por este método a partir de la variable de sistema
$HTTP_GET_VARS, que es un array asociativo. Utilizándolo quedaría así:
<?
echo "Variable $saludo: $HTTP_GET_VARS["saludo"] <br>n";
echo "Variable $texto: $HTTP_GET_VARS["texto"] <br>n"
?>
Nota: Aunque podamos recoger variables con este array asociativo o utilizar
directamente las variables que se definen en nuestra página, resulta más seguro
utilizar $HTTP_GET_VARS por dos razones, la primera que así nos aseguramos que esa
varible viene realmente de la URL y la segunda, que así nuestro código será más claro
cuando lo volvamos a leer, porque quedará especificado que esa variable estamos
recibiéndola por la URL.
$_GET
A partir de la versión 4.1.0 de PHP se ha introducido el array asociativo $_GET, que es
idéntico a $HTTP_GET_VARS, aunque un poco más corto de escribir.
Caracteres especiales en URL y su codificación con PHP
Hay algunos caracteres raros que no se pueden pasar, tal cual, por la URL. Por ejemplo, una
URL no puede contener espacios en blanco, por lo que si intentas enviar una variable por URL
con un valor que tiene un espacio en blanco, te dará problemas. Por ejemplo, el signo "*" no
puede figurar tampoco en una URL. Así pues, tenemos que hacer algo para convetir esos
caracteres, de modo que no den problemas en la URL.
La solución en PHP es sencilla, simplemente debemos codificar la variable que tiene

caracteres conflictivos a formato URL. Para ello utilizamos la función urlenconde(), que
viene en la librería de funciones de PHP.

Ejemplos de casos de páginas con parámetros
Laboratorios
Lab: Practica con parámetros GET 1
Lab: Practical con FORM
Lab: Practica con parámetros GET 2 (opcional)
Lab: Parámetros GET y uso de variables locales (opcional)
Estructuras de Control
While
Los bucles while son el tipo más sencillo de bucle en PHP. Se comportan igual que su
contrapartida en C. La forma básica de una sentencia while es:
while (expr)
sentencia
El significado de una sentencia while es simple. Le dice a PHP que ejecute las
sentencias anidadas, tanto como la expresión while se evalúe como TRUE. El valor de
la expresión es verificado cada vez al inicio del bucle, por lo que incluso si este valor
cambia durante la ejecución de las sentencias anidadas, la ejecución no se detendrá
hasta el final de la iteración (cada vez que PHP ejecuta las sentencias contenidas en el

bucle es una iteración). A veces, si la expresión while se evalúa como FALSE desde el
principio, las sentencias anidadas no se ejecutarán ni siquiera una vez.
Al igual que con la sentencia if, se pueden agrupar varias instrucciones dentro del
mismo bucle while rodeando un grupo de sentencias con corchetes, o utilizando la
sintaxis alternativa:
while (expr):
sentencias
...
endwhile;
Los siguientes ejemplos son idénticos y ambos presentan los números del 1 al 10:
<?php
/* ejemplo 1 */
$i = 1;
while ($i <= 10) {
echo $i++; /* el valor presentado sería
$i antes del incremento
(post-incremento) */
}
/* ejemplo 2 */
$i = 1;
while ($i <= 10):
echo $i;
$i++;
endwhile;
?>
do-while
Los bucles do-while son muy similares a los bucles while, excepto que la expresión
verdadera es verificada al final de cada iteración en lugar que al principio. La diferencia
principal con los bucles while es que está garantizado que corra la primera iteración de
un bucle do-while (la expresión verdadera sólo es verificada al final de la iteración),
mientras que no necesariamente va a correr con un bucle while regular (la expresión
verdadera es verificada al principio de cada iteración, si se evalúa como FALSE justo
desde el comienzo, la ejecución del bucle terminaría inmediatamente).
Hay una sola sintaxis para bucles do-while:

<?php
$i = 0;
do {
echo $i;
} while ($i > 0);
?>
El bucle de arriba se ejecutaría exactamente una sola vez, ya que después de la

primera iteración, cuando la expresión verdadera es verificada, se evalúa como FALSE
($i no es mayor que 0) y termina la ejecución del bucle.
Los usuarios avanzados de C pueden estar familiarizados con un uso distinto del bucle
do-while, para permitir parar la ejecución en medio de los bloques de código,
mediante el encapsulado con do-while (0), y utilizando la sentencia break. El siguiente
fragmento de código demuestra esto:
<?php
do {
if ($i < 5) {
echo "i no es lo suficientemente grande";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
echo "i está bien";
/* procesar i */
} while (0);
?>
For
Los bucles for son los más complejos en PHP. Se comportan como sus homólogos en C. La
sintaxis de un bucle for es:
for (expr1; expr2; expr3)
sentencia
La primera expresión (expr1) es evaluada (ejecutada) una vez incondicionalmente al comienzo

del bucle.

En el comienzo de cada iteración, se evalúa expr2. Si se evalúa como TRUE, el bucle continúa y
se ejecutan la/sy sentencia/s anidada/s. Si se evalúa como FALSE, finaliza la ejecución del
bucle.
Al final de cada iteración, se evalúa (ejecuta) expr3.
Cada una de las expresiones puede estar vacía o contener múltiples expresiones separadas por
comas. En expr2, todas las expresiones separadas por una coma son evaluadas, pero el
resultado se toma de la última parte. Que expr2 esté vacía significa que el bucle debería ser
corrido indefinidamente (PHP implícitamente lo considera como TRUE, como en C). Esto puede
no ser tan inútil como se pudiera pensar, ya que muchas veces se debe terminar el bucle
usando una sentencia condicional break en lugar de utilizar la expresión verdadera del for.
Considere los siguientes ejemplos. Todos ellos muestran los números del 1 al 10:
<?php
/* ejemplo 1 */
for ($i = 1; $i <= 10; $i++) {

echo $i;
}
/* ejemplo 2 */
for ($i = 1; ; $i++) {

if ($i > 10) {
break;
}
echo $i;
}
/* ejemplo 3 */
$i = 1;
for (; ; ) {
if ($i > 10) {
break;
}
echo $i;
$i++;
}
/* ejemplo 4 */
for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);

?>
Por supuesto, el primer ejemplo parece ser el mejor (o quizás el cuarto), pero se puede
observar que la posibilidad de usar expresiones vacías en los bucles for resulta útil en
muchas ocasiones.

PHP también admite la sintaxis alternativa de los dos puntos para bucles for.
for (expr1; expr2; expr3):
sentencia
...
endfor;
Todo script PHP está construido en base a una serie de sentencias. Una sentencia
puede ser una asignación, una llamada de función, un ciclo, una sentencia condicional
o incluso una sentencia que no hace nada (una sentencia vacía). Las sentencias
generalmente finalizan con un punto y coma. Adicionalmente, las sentencias pueden
agruparse en un conjunto de sentencias, encapsulándolas entre corchetes. Un grupo
de sentencias es una sentencia por sí misma también. Los diferentes tipos de
sentencias son descritos en este capítulo.
If
El constructor if es una de las características más importantes de muchos lenguajes,
incluido PHP. Permite la ejecución condicional de fragmentos de código. PHP dispone
de una estructura if que es similar a la de C:
if (expr)
sentencia
Como se describe en la sección sobre expresiones , la expresión es evaluada a su valor

booleano. Si la expresión se evalúa como TRUE, PHP ejecutará la sentencia y si se
evalúa como FALSE la ignorará. Más información sobre qué valores evalúan como
FALSE se puede encontrar en la sección 'Convirtiendo a booleano'.
El siguiente ejemplo mostraría a es mayor que b si $a es mayor que $b:
<?php
if ($a > $b) {
echo "a es mayor que b";
}
?>

A menudo se desea tener más de una sentencia para ser ejecutada condicionalmente.
Por supuesto, no hay necesidad de envolver cada sentencia con una cláusula if. En
cambio, se pueden agrupar varias sentencias en un grupo de sentencias. Por ejemplo,
este código mostraría a es mayor que b si $a es mayor que $b y entonces asignaría el
valor de $a a $b:
<?php
if ($a > $b) {
$b = $a;
}
?>
Las sentencias if pueden anidarse dentro de otra sentencias if infinitamente, lo cual provee
completa flexibilidad para la ejecución condicional de diferentes partes del programa.
Else
Con frecuencia se desea ejecutar una sentencia si una determinada condición se cumple y una
sentencia diferente si la condición no se cumple. Esto es para lo que sirve else. El else extiende
una sentencia if para ejecutar una sentencia en caso que la expresión en la sentencia if se
evalúe como FALSE. Por ejemplo, el siguiente código deberá mostrar a es mayor que b si $a es
mayor que $b y a NO es mayor que b en el caso contrario:
<?php
if ($a > $b) {
} else {
echo "a NO es mayor que b";
}
?>
La sentencia else sólo es ejecutada si la expresión if es evaluada como FALSE y si hay algunas
expresiones elseif - sólo se ejecuta si también todas son evaluadas como FALSE (ver elseif).
elseif/else if
elseif, como su nombre lo sugiere, es una combinación de if y else. Del mismo modo
que else, extiende una sentencia if para ejecutar una sentencia diferente en caso que
la expresión if original se evalúe como FALSE. Sin embargo, a diferencia de else, esa
expresión alternativa sólo se ejecutará si la expresión condicional del elseif se evalúa
como TRUE. Por ejemplo, el siguiente código debe mostrar a es mayor que b, a es igual
que b o a es menor que b:

<?php
if ($a > $b) {
} elseif ($a == $b) {
echo "a es igual que b";
} else {
echo "a es menor que b";
}
?>
Puede haber varios elseif dentro de la misma sentencia if. La primera expresión elseif
(si hay alguna) que se evalúe como TRUE sería ejecutada. En PHP también se puede
escribir 'else if' (en dos palabras) y el comportamiento sería idéntico al de 'elseif' (en
una sola palabra). El significado sintáctico es ligeramente diferente (si se está
familiarizado con C, este es el mismo comportamiento) pero la conclusión es que
ambos resultarían tener exactamente el mismo comportamiento.
La sentencia elseif es ejecutada solamente si la expresión if precedente y cualquiera de

las expresiones elseif precedentes son evaluadas como FALSE, y la expresión elseif
actual se evalúa como TRUE.
Sentencia Switch
La sentencia switch es similar a una serie de sentencias IF en la misma expresión. En

muchas ocasiones, es posible que se quiera comparar la misma variable (o expresión)
con muchos valores diferentes, y ejecutar una parte de código distinta dependiendo de
a que valor es igual. Para esto es exactamente la expresión switch.
Nota: Cabe señalar que a diferencia de algunos otros lenguajes, la sentencia continue
se aplica a switch y actúa de manera similar a break. Si se tiene un switch dentro de un
bucle y se desea continuar a la siguiente iteración de del ciclo exterior, se utiliza
continue 2.
Nota:
Tener en cuenta que switch/case hace comparaciones flexibles.
Los dos ejemplos siguientes son dos formas diferentes de escribir lo mismo, uno con
una serie de sentencias if y elseif, y el otro usando la sentencia switch:

Ejemplo #1 Estructura switch:
<?php
if ($i == 0) {
echo "i es igual a 0";
} elseif ($i == 1) {
} elseif ($i == 2) {
}
switch ($i) {
case 0:
break;
case 1:
break;
case 2:
break;
}
?>
Laboratorios
Lab1: Formulario I
Lab2: Formulario II
Lab3: Tabla Dinámica
Arreglos en PHP
Un array en PHP es realmente un mapa ordenado. Un mapa es un tipo de datos que

asocia valores con claves. Este tipo es optimizado para varios usos diferentes; puede
ser usado como una matriz real, una lista (vector), una tabla asociativa (una
implementación de un mapa), diccionario, colección, pila, cola, y posiblemente más. Ya

que los valores de un array pueden ser otros arrays, árboles y también son posibles
arrays multidimensionales.
Una explicación sobre tales estructuras de datos está fuera del alcance de este manual,
pero encontrará al menos un ejemplo de cada uno de ellos. Para más información,
consulte la extensa literatura que existe sobre este amplio tema.
Sintaxis
Especificación con array()
Un array puede ser creado usando el constructor del lenguaje array(). Éste toma un
cierto número de parejas clave => valor como argumentos.
array(
clave => valor,
clave2 => valor2,
clave3 => valor3,
...
La coma después del último elemento del array es opcional y se puede omitir. Esto
normalmente se hace para arrays de una única línea, es decir, es preferible array(1, 2)
que array(1, 2, ). Por otra parte, para arrays multilínea, la coma final se usa
comúnmente, ya que permite la adición sencilla de nuevos elementos al final.
A partir de PHP 5.4 también se puede usar la sintaxis de array corta, que reemplaza
array() con [].
Ejemplo #1 Un array simple
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
);
// a partir de PHP 5.4

$array = [
"foo" => "bar",
"bar" => "foo",
];
?>

Inclusión de Código
include
La sentencia include incluye y evalúa el archivo especificado.
La siguiente documentación también se aplica a require.
Los archivos son incluidos con base en la ruta de acceso dada o, si ninguna es dada, el
include_path especificado. Si el archivo no se encuentra en el include_path, include
finalmente verificará en el propio directorio del script que hace el llamado y en el
directorio de trabajo actual, antes de fallar. El constructor include emitirá una
advertencia si no puede encontrar un archivo, éste es un comportamiento diferente al
de require, el cual emitirá un error fatal..
Si una ruta es definida — ya sea absoluta (comenzando con una letra de unidad o \ en
Windows o / en sistemas Unix/Linux) o relativa al directorio actual (comenzando con .
o ..) — el include_path será ignorado por completo. Por ejemplo, si un nombre de
archivo comienza con ../, el interprete buscará en el directorio padre para encontrar el
archivo solicitado.
Para más información sobre como PHP maneja la inclusión de archivos y la ruta de
accesos para incluir, ver la documentación de include_path.
Cuando se incluye un archivo, el código que contiene hereda el ámbito de las variables
de la línea en la cual ocurre la inclusión. Cualquier variable disponible en esa línea del
archivo que hace el llamado, estará disponible en el archivo llamado, desde ese punto
en adelante. Sin embargo, todas las funciones y clases definidas en el archivo incluido
tienen el ámbito global.
Require
require_once
La sentencia require_once es idéntica a require excepto que PHP verificará si el archivo
ya ha sido incluido y si es así, no se incluye (require) de nuevo.
Ver la documentación de include_once para información sobre el comportamiento de

_once, y como difiere de sus hermanos no _once.

Formularios
Un formulario es un documento, ya sea físico o digital, diseñado con el propósito de
que el usuario introduzca datos estructurados (nombre, apellidos, dirección, etc.) en
las zonas del documento destinadas a ese propósito, para ser almacenados y
procesados posteriormente.
En informática, un formulario consta de un conjunto de campos de datos solicitados

por un determinado programa, los cuales se almacenarán para su procesamiento y
posterior uso. Cada campo debe albergar un dato específico, por ejemplo, el campo
"Nombre" debe rellenarse con un nombre personal; el campo "Fecha de nacimiento"
debe aceptar una fecha válida, etc.
En Internet y sistemas informáticos, los formularios pueden rellenarse en línea, con

validación de datos, y son muy útiles para registrar usuarios, realizar encuestas,
acceder a sistemas restringidos, etc. Los formularios por Internet se llaman formularios
web, y generalmente se construyen mediante etiquetas HTML, aunque también
pueden emplearse otras tecnologías como Flash, Java, etc.
En matemáticas, también se conoce como formulario a un compendio de fórmulas

matemáticas o algebraicas, pertenecientes a una o varias categorías, que sirve de guía
o recordatorio para el momento de aplicarlas. Por ejemplo, para cálculos
trigonométricos, conversiones entre cifras expresadas en diferentes unidades de
medida, movimientos, fuerzas, pesos, volúmenes, potencias eléctricas, etc.
Funciones en PHP
Utilidad de las funciones, creación y almacenamiento en archivos. Ejemplo práctico de

creación de función.
En nuestro manual de páginas dinámicas vimos el concepto de función. Vimos que la

función podría ser definida como un conjunto de instrucciones que explotan ciertas
variables para realizar una tarea más o menos elemental.
PHP basa su eficacia principalmente en este tipo de elemento. Una gran librería que
crece constantemente, a medida que nuevas versiones van surgiendo, es
complementada con las funciones de propia cosecha dando como resultado un sinfín
de recursos que son aplicados por una simple llamada.

Las funciones integradas en PHP son muy fáciles de utilizar. Tan sólo hemos de realizar
la llamada de la forma apropiada y especificar los parámetros y/o variables necesarios
para que la función realice su tarea.
Lo que puede parecer ligeramente más complicado, pero que resulta sin lugar a dudas
muy práctico, es crear nuestras propias funciones. De una forma general, podríamos
crear nuestras propias funciones para conectarnos a una base de datos o crear los
encabezados o etiquetas meta de un documento HTML. Para una aplicación de
comercio electrónico podríamos crear por ejemplo funciones de cambio de una
moneda a otra o de cálculo de los impuestos a añadir al precio de artículo. En
definitiva, es interesante crear funciones para la mayoría de acciones más o menos
sistemáticas que realizamos en nuestros programas.
Aquí daremos el ejemplo de creación de una función que, llamada al comienzo de

nuestro script, nos crea el encabezado de nuestro documento HTML y coloca el título
que queremos a la página:
<?
function hacer_encabezado($titulo)
$encabezado="<html><head>t<title>$titulo</title></head>";
echo $encabezado;
?>
Esta función podría ser llamada al principio de todas nuestras páginas de la siguiente
forma:
$titulo="Mi web";
hacer_encabezado($titulo);
De esta forma automatizamos el proceso de creación de nuestro documento.

Podríamos por ejemplo incluir en la función otras variables que nos ayudasen a
construir las etiquetas meta y de esta forma, con un esfuerzo mínimo, crearíamos los
encabezados personalizados para cada una de nuestras páginas. De este mismo modo
nos es posible crear cierres de documento o formatos diversos para nuestros textos
como si se tratase de hojas de estilo que tendrían la ventaja de ser reconocidas por
todos los navegadores.

Por supuesto, la función ha de ser definida dentro del script ya que no se encuentra
integrada en PHP sino que la hemos creado nosotros. Esto en realidad no pone
ninguna pega ya que puede ser incluida desde un archivo en el que iremos
almacenando las definiciones de las funciones que vayamos creando o recopilando.
Estos archivos en los que se guardan las funciones se llaman librerías. La forma de
incluirlos en nuestro script es a partir de la instrucción require o include:
require("libreria.php") o include("libreria.php")
En resumen, la cosa quedaría así:
Tendríamos un archivo libreria.php como sigue
<?
//función de encabezado y colocación del titulo
function hacer_encabezado($titulo)
$encabezado="<html>n<head>nt<title>$titulo</title>n</head>n";
echo $encabezado;
?>
Por otra parte tendríamos nuestro script principal página.php (por ejemplo):
<?
include("libreria.php");
$titulo="Mi Web";
hacer_encabezado($titulo);
?>
<body>
El cuerpo de la página
</body>

</html>
Echar un vistazo al código fuente del navegador
Podemos meter todas las funciones que vayamos encontrando dentro de un mismo
archivo pero resulta muchísimo más ventajoso ir clasificándolas en distintos archivos
por temática: Funciones de conexión a bases de datos, funciones comerciales,
funciones generales, etc. Esto nos ayudara a poder localizarlas antes para corregirlas o
modificarlas, nos permite también cargar únicamente el tipo de función que
necesitamos para el script sin recargar éste en exceso además de permitirnos utilizar
un determinado tipo de librería para varios sitios webs distintos.
También puede resultar muy práctico el utilizar una nomenclatura sistemática a la hora
de nombrarlas: Las funciones comerciales podrían ser llamadas com_loquesea, las de
bases de datos bd_loquesea, las de tratamiento de archivos file_loquesea. Esto nos
permitirá reconocerlas enseguida cuando leamos el script sin tener que recurrir a
nuestra oxidada memoria para descubrir su utilidad.
No obstante, antes de lanzarnos a crear nuestra propia función, merece la pena echar
un vistazo a la documentación para ver si dicha función ya existe o podemos
aprovecharnos de alguna de las existentes para aligerar nuestro trabajo. Así, por
ejemplo, existe una función llamada header que crea un encabezado HTML
configurable lo cual nos evita tener que crearla nosotros mismos.
Como puede verse, la tarea del programador puede en algunos casos parecerse a la de
un coleccionista. Hay que ser paciente y metódico y al final, a base de trabajo propio,
intercambio y tiempo podemos llegar poseer nuestro pequeño tesoro.
Nota: Si lo deseas puedes repasar todos los conceptos anteriores sobre las funciones,
así como diversas otras cosas interesantes en el Videotutorial sobre las funciones en
PHP.
Vamos a ver un ejemplo de creación de funciones en PHP. Se trata de hacer una

función que recibe un texto y lo escribe en la página con cada carácter separado por "-
". Es decir, si recibe "hola" debe escribir "h-o-l-a" en la página web.
Nota:Para comprender este ejemplo necesitamos conocer el bucle for, que se explica
en el capítulo Control del flujo en PHP: Bucles II.
La manera de realizar esta función será recorrer el string, caracter a caracter, para
imprimir cada uno de los caracteres, seguido de el signo "-". Recorreremos el string
con un bucle for, desde el carater 0 hasta el número de caracteres total de la cadena.

El número de caracteres de una cadena se obtiene con la función predefinida en PHP

strlen(), que recibe el string entre paréntesis y devuelve el número de los caracteres
que tenga.
<html>
<head>
<title>funcion 1</title>
</head>
<body>
<?
function escribe_separa($cadena){
for ($i=0;$i<strlen($cadena);$i++){
echo $cadena[$i];
if ($i<strlen($cadena)-1)
echo "-";
escribe_separa ("hola");
echo "<p>";
escribe_separa ("Texto más largo, a ver lo que hace");
?>
</body>
</html>
La función que hemos creado se llama escribe_separa y recibe como parámetro la

cadena que hay que escribir con el separador "-". El bucle for nos sirve para recorrer la
cadena, desde el primer al último carácter. Luego, dentro del bucle, se imprime cada
carácter separado del signo "-". El if que hay dentro del bucle for comprueba que el
actual no sea el último carácter, porque en ese caso no habría que escribir el signo "-"
(queremos conseguir "h-o-l-a" y si no estuviera el if obtendríamos "h-o-l-a-").

En el código mostrado se hacen un par de llamadas a la función para ver el resultado

obtenido con diferentes cadenas como parámetro.
Función print()
Sirve para mostrar una cadena:
print("Hola mundo");
Función printf()
Imprimir una cadena con formato
printf("%d", "17,999")
Función sprintf()
Devuelve un string formateado
Parámetros
format
El string de formato está compuesto de cero o más directivas: caracteres ordinarios

(excluyendo %) que son copiados directamente al resultado y especificaciones de
conversión, donde cada una de las cuales da lugar a extraer su propio parámetro. Esto
se aplica tanto para sprintf() como para printf().
Cada especificación de conversión consiste en un signo de porcentaje (%), seguido

por uno o más de estos elementos, en orden:
Un especificador de signo opcional que fuerza a usar un signo (- o +) en un

número. Por defecto, sólo el signo - se utiliza en un número si es negativo. Esta
especificación fuerza números positivos para que también tengan adjunto el signo +
(agregado en PHP 4.3.0).
Un especificador de relleno opcional que indica qué carácter se utiliza para

rellenar el resultado hasta el tamaño justo del string. Este puede ser un carácter de
espacio o un 0 (el carácter cero). El valor por defecto es rellenar con espacios. Un
carácter de relleno alternativo se puede especificar prefijándolo con una comilla
simple ('). Ver los ejemplos más adelante.

Un especificador de alineación opcional que indica si el resultado debe ser

alineado a la izquierda o a la derecha. El valor por defecto es justificado a la derecha,
un carácter - lo justificará a la izquierda.
Un número opcional, un especificador de ancho que indica de cuántos caracteres

(mínimo) resultará esta conversión.
Un especificador de precisión opcional en la forma de un punto ('.') seguido de un

string opcional de dígitos decimales que indica cuántos dígitos decimales deben
mostrarse para los números de punto flotante. Cuando se utiliza este especificador con
un string, actúa como un punto de corte, estableciendo un límite máximo de
caracteres al string.
Un especificador de tipo que indica con qué tipo deben ser tratados los datos del
argumento. Los tipos posibles son:
% - un carácter de porcentaje literal. No se requiere argumento.
b - el argumento es tratado como un valor de tipo integer y presentado como un

número binario.
c - el argumento es tratado como un valor de tipo integer y presentado como el

carácter con ese valor ASCII.
d - el argumento es tratado como un valor de tipo integer y presentado como un

número decimal (con signo).
e - el argumento es tratado con notación científica (e.g. 1.2e+2). El especificador

de precisión indica el número de dígitos después del punto decimal a partir de PHP
5.2.1. En versiones anteriores, se tomó como el número de dígitos significativos
(menos uno).
E - como %e pero utiliza la letra mayúscula (e.g. 1.2E+2).
f - el argumento es tratado como un valor de tipo float y presentado como un

número de punto flotante (considerando la configuración regional).
F - el argumento es tratado como un valor de tipo float y presentado como un

número de punto flotante (no considerando la configuración regional). Disponible
desde PHP 4.3.10 y PHP 5.0.3.
g - lo mismo que %e y %f.
G - lo mismo que %E y %f.

o - el argumento es tratado como un valor de tipo integer y presentado como un

número octal.
s - el argumento es tratado y presentado como un string.
u - el argumento es tratado como un valor de tipo integer y presentado como un

número decimal sin signo.
x - el argumento es tratado como un valor de tipo integer y presentado como un

número hexadecimal (con las letras en minúsculas).
X - el argumento es tratado como un valor de tipo integer y presentado como un

número hexadecimal (con las letras en mayúsculas).
Función strtoupper() y strtolower ()

Convierte una cadena a minúsculas
Descripción
string strtolower ( string $str )
Devuelve una string con todos los caracteres alfabéticos convertidos a minúsculas.
Nótese que 'alfabético' se determina por la localización actual. Por ejemplo, los
carácteres de localización "C" como umlaut-a (Ä) no serán convertidos.
Parámetros
str
La cadena de entrada.
Valores devueltos
Devuelve la cadena en minúsculas.
Ejemplos
Ejemplo #1 Ejemplo de strtolower()
<?php
$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtolower($str);
echo $str; // Prints mary had a little lamb and she loved it so
?>

strtoupper
Convierte un string a mayúsculas
Descripción
string strtoupper ( string $string )
Devuelve el string con todos los caracteres alfabéticos convertidos a mayúsculas.
Notar que ser 'alfabético' está determinado por la configuración regional actual. Por
ejemplo, en la configuración regional por defecto "C" caracteres como la diéresis-a (ä)
no se convertirán.
Parámetros
string
El string de entrada.
Valores devueltos
Devuelve el string en mayúsculas.
Ejemplos
<?php
$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtoupper($str);
echo $str; // muestra: MARY HAD A LITTLE LAMB AND SHE LOVED IT SO
?>
Función strlen()
Obtiene la longitud de un string
<?php
$str = 'abcdef';
echo strlen($str); // 6
$str = ' ab cd ';

echo strlen($str); // 7
?>
Función number_format()
Formatear un número con los millares agrupados.
Esta función acepta uno, dos, o cuatro parámetros (no tres):

Si solo se proporciona un parámetro, number será formateado sin decimales, pero con
una coma (",") entre cada grupo de millares.
Si se proporcionan dos parámetros, number será formateado con tantos decimales

como se hayan definido en decimals colocando un punto (".") delante, y una coma (",")
entre cada grupo de millares.
Si se proporcionan los cuatro parámetros, number será formateado con tantos

decimales como hayamos definido en decimals, dec_point sustituirá al punto (".")
como seperador de los decimales y el separador por defecto de los millares, la coma
(","), será sustituida por thousands_sep.
Parámetros
number
El número al que dar formato.
decimals
Establece el número de puntos decimales.
dec_point
Establece el separador para los decimales.
thousands_sep
Establece el separador para los millares.
Valores devueltos
Una versión formateada de number.
<?php
$número = 1234.56;
// notación inglesa (por defecto)

$número_formato_inglés = number_format($número);
// 1,235
// notación francesa
$nombre_format_francais = number_format($número, 2, ',', ' ');
// 1 234,56
$número = 1234.5678;
// notación inglesa sin separador de millares

$english_format_number = number_format($número, 2, '.', '');

// 1234.57
?>
Función substr()
Devuelve parte de una cadena.
Parámetros
string
La cadena de entrada. Debe ser de al menos de un caracter.
start
Si start no es negativo, la cadena devuelta comenzará en el start de la posición del

string empezando desde cero. Por ejemplo, en la cadena 'abcdef', el caracter en la
posición 0 es 'a', el carácter en la posición 2 es 'c', y así sucesivamente.
Si start es negativo, la cadena devuelta empezará en start contando desde el final de

string.
Si la longitud del string es menor o igual a start, la función devolverá FALSE.
Ejemplo #1 Usando un start negativo:
<?php
$rest = substr("abcdef", -1); // devuelve "f"
$rest = substr("abcdef", -2); // devuelve "ef"
$rest = substr("abcdef", -3, 1); // devuelve "d"
?>
length
Si se especifica el length y es positivo, la cadena devuelta contendrá como máximo
de caracteres de la cantidad dada por length que comienza en start (dependiedo de la
longitud del string).
Si se especifica length es negativo, entonces ese número de caracteres se omiten al

final del string (después de la posición inicial se ha calculado a start es negativo). Si
start indica la posición de su truncamiento o más allá, se devolverá false.
Si se omite el length, la subcadena empezará por start hasta el final de la cadena

donde será devuelta.
Si se especifica length y es 0, FALSE o NULL devolverá una cadena vacía.

Ejemplo #2 Usando un length negativo:
<?php
$rest = substr("abcdef", 0, -1); // devuelve "abcde"
$rest = substr("abcdef", 2, -1); // devuelve "cde"
$rest = substr("abcdef", 4, -4); // devuelve false
$rest = substr("abcdef", -3, -1); // devuelve "de"
?>
Función rtrim()
Retira los espacios en blanco (u otros caracteres) del final de un string
<?php
$text = "\t\tThese are a few words :) ... ";

$binary = "\x09Example string\x0A";
$hello = "Hello World";
var_dump($text, $binary, $hello);
print "\n";
$trimmed = rtrim($text);
var_dump($trimmed);
$trimmed = rtrim($text, " \t.");

var_dump($trimmed);
$trimmed = rtrim($hello, "Hdle");

var_dump($trimmed);
// retira los caracteres ASCII de control al inicio de $binary

// (de 0 a 31 inclusive)
$clean = rtrim($binary, "\x00..\x1F");
var_dump($clean);
?>
Función ltrim()
Retira espacios en blanco (u otros caracteres) del inicio de un string
<?php

print "\n";
$trimmed = ltrim($text);
var_dump($trimmed);

$trimmed = ltrim($text, " \t.");

var_dump($trimmed);
$trimmed = ltrim($hello, "Hdle");

var_dump($trimmed);
// retira los caracteres ASCII de control al inicio de $binary

// (de 0 a 31 inclusive)
$clean = ltrim($binary, "\x00..\x1F");
var_dump($clean);
?>
Función trim()
Elimina espacio en blanco (u otro tipo de caracteres) del inicio y el final de la cadena
<?php

print "\n";
$trimmed = trim($text);
var_dump($trimmed);
$trimmed = trim($text, " \t.");

var_dump($trimmed);
$trimmed = trim($hello, "Hdle");

var_dump($trimmed);
$trimmed = trim($hello, 'HdWr');

var_dump($trimmed);
// Elimina los caracteres de control ASCII al inicio y final de $binar

y
// (from 0 to 31 inclusive)
$clean = trim($binary, "\x00..\x1F");
var_dump($clean);
?>
Función str_word_count()
Devuelve información sobre las palabras utilizadas en un string
Parámetros
string

Especifica el valor devuelto de esta función. Los valores soportados actualmente son:
0 - devuelve el número de palabras encontradas
1 - devuelve un array que contiene todas las palabras encontradas dentro del string
2 - devuelve un array asociativo, donde la clave es la posición numérica de una palabra

dentro del string y el valor es la palabra en sí.
Una lista de caracteres adicionales los cuales serán considerados como de 'palabra'.
Función split()
Convierte un string en un array
Ejemplo:
<?php
$str = "Hello Friend";
$arr1 = str_split($str);
$arr2 = str_split($str, 3);
print_r($arr1);
print_r($arr2);
?>
Funciones de Redondeo
Función Round()
Redondea un float
<?php
echo round(3.4); // 3
echo round(3.6, 0); // 4
echo round(1.95583, 2); // 1.96
echo round(1241757, -3); // 1242000
echo round(5.045, 2); // 5.05
echo round(5.055, 2); // 5.06
?>

Función Ceil()
Redondear fracciones hacia arriba
<?php
echo ceil(4.3); // 5
echo ceil(9.999); // 10
echo ceil(-3.14); // -3
?>
Función Floor()
Redondear fracciones hacia abajo
<?php
echo floor(4.3); // 4
echo floor(9.999); // 9
echo floor(-3.14); // -4
?>
Funcione definidas por el Usuario

Una función puede ser definida usando una sintaxis como la siguiente:
Ejemplo #1 Pseudo código para demostrar el uso de funciones
<?php
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
echo "Función de ejemplo.\n";
return $valordevuelto;
}
?>
Cualquier código PHP válido puede aparecer dentro de una función, incluso otras
funciones y definiciones de clases.
Los nombres de las funciones siguen las mismas reglas que otras etiquetas de PHP. Un
nombre de función válido comienza con una letra o guión bajo, seguido de cualquier
número de letras, números, o guiones bajos. Como expresión regular se expresaría así:
[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.
Las funciones no necesitan ser definidas antes de que se referencien, excepto cuando
una función está condicionalmente definida como se muestra en los dos ejemplos de
abajo.
Cuando una función está definida de una forma condicional como en los dos ejemplos
mostrados, sus definiciones deben ser procesadas antes de ser llamadas.

Base de Datos MySQL

MySQL es un sistema de gestión de bases de datos relacional, multihilo y multiusuario con más
de seis millones de instalaciones.1 MySQL AB —desde enero de 2008 una subsidiaria de Sun
Microsystems y ésta a su vez de Oracle Corporation desde abril de 2009— desarrolla MySQL
como software libre en un esquema de licenciamiento dual.
Por un lado se ofrece bajo la GNU GPL para cualquier uso compatible con esta licencia, pero
para aquellas empresas que quieran incorporarlo en productos privativos deben comprar a la
empresa una licencia específica que les permita este uso. Está desarrollado en su mayor parte
en ANSI C.
Al contrario de proyectos como Apache, donde el software es desarrollado por una comunidad
pública y los derechos de autor del código están en poder del autor individual, MySQL es
patrocinado por una empresa privada, que posee el copyright de la mayor parte del código.
Esto es lo que posibilita el esquema de licenciamiento anteriormente mencionado. Además de
la venta de licencias privativas, la compañía ofrece soporte y servicios. Para sus operaciones
contratan trabajadores alrededor del mundo que colaboran vía Internet. MySQL AB fue
fundado por David Axmark, Allan Larsson y Michael Widenius.
Aplicaciones
MySQL es muy utilizado en aplicaciones web, como Drupal o phpBB, en plataformas
(Linux/Windows-Apache-MySQL-PHP/Perl/Python), y por herramientas de seguimiento
de errores como Bugzilla. Su popularidad como aplicación web está muy ligada a PHP,
que a menudo aparece en combinación con MySQL.
MySQL es una base de datos muy rápida en la lectura cuando utiliza el motor no
transaccional MyISAM, pero puede provocar problemas de integridad en entornos de
alta concurrencia en la modificación. En aplicaciones web hay baja concurrencia en la
modificación de datos y en cambio el entorno es intensivo en lectura de datos, lo que
hace a MySQL ideal para este tipo de aplicaciones. Sea cual sea el entorno en el que va
a utilizar MySQL, es importante monitorizar de antemano el rendimiento para detectar
y corregir errores tanto de SQL como de programación.
Características
Inicialmente, MySQL carecía de elementos considerados esenciales en las bases de
datos relacionales, tales como integridad referencial y transacciones. A pesar de ello,
atrajo a los desarrolladores de páginas web con contenido dinámico, justamente por
su simplicidad.

Poco a poco los elementos de los que carecía MySQL están siendo incorporados tanto
por desarrollos internos, como por desarrolladores de software libre. Entre las
características disponibles en las últimas versiones se puede destacar:
 Amplio subconjunto del lenguaje SQL. Algunas extensiones son incluidas

igualmente.
 Disponibilidad en gran cantidad de plataformas y sistemas.
Posibilidad de selección de mecanismos de almacenamiento que ofrecen diferentes

velocidades de operación, soporte físico, capacidad, distribución geográfica,
transacciones...
 Transacciones y claves foráneas.

 Conectividad segura.
 Replicación.
 Búsqueda e indexación de campos de texto.
MySQL es un sistema de administración de bases de datos. Una base de datos es una

colección estructurada de tablas que contienen datos. Esta puede ser desde una
simple lista de compras a una galería de pinturas o el vasto volumen de información en
una red corporativa. Para agregar, acceder a y procesar datos guardados en un
computador, usted necesita un administrador como MySQL Server. Dado que los
computadores son muy buenos manejando grandes cantidades de información, los
administradores de bases de datos juegan un papel central en computación, como
aplicaciones independientes o como parte de otras aplicaciones.
MySQL es un sistema de administración relacional de bases de datos. Una base de

datos relacional archiva datos en tablas separadas en vez de colocar todos los datos en
un gran archivo. Esto permite velocidad y flexibilidad. Las tablas están conectadas por
relaciones definidas que hacen posible combinar datos de diferentes tablas sobre
pedido.
MySQL es software de fuente abierta. Fuente abierta significa que es posible para
cualquier persona usarlo y modificarlo. Cualquier persona puede bajar el código fuente
de MySQL y usarlo sin pagar. Cualquier interesado puede estudiar el código fuente y
ajustarlo a sus necesidades. MySQL usa el GPL (GNU General Public License) para
definir qué puede hacer y qué no puede hacer con el software en diferentes
situaciones. Si usted no se ajusta al GPL o requiere introducir código MySQL en
aplicaciones comerciales, usted puede comprar una versión comercial licenciada.

Características distintivas
Las siguientes características son implementadas únicamente por MySQL:
Permite escoger entre múltiples motores de almacenamiento para cada tabla. En

MySQL 5.0 éstos debían añadirse en tiempo de compilación, a partir de MySQL 5.1 se
pueden añadir dinámicamente en tiempo de ejecución:
Los hay nativos como MyISAM, Falcon, Merge, InnoDB, BDB, Memory/heap,
MySQL Cluster, Federated, Archive, CSV, Blackhole y Example
Desarrollados por partners como solidDB, NitroEDB, ScaleDB, TokuDB, Infobright

(antes Brighthouse), Kickfire, XtraDB, IBM DB2). InnoDB Estuvo desarrollado así pero
ahora pertenece también a Oracle
Desarrollados por la comunidad como memcache, httpd, PBXT y Revision
Agrupación de transacciones, reuniendo múltiples transacciones de varias

conexiones para incrementar el número de transacciones por segundo.
Tipos de compilación del servidor

Hay tres tipos de compilación del servidor MySQL:
Estándar: Los binarios estándar de MySQL son los recomendados para la mayoría de
los usuarios, e incluyen el motor de almacenamiento InnoDB.
Max (No se trata de MaxDB, que es una cooperación con SAP): Los binarios incluyen
características adicionales que no han sido lo bastante probadas o que normalmente
no son necesarias.
MySQL-Debug: Son binarios que han sido compilados con información de depuración
extra. No debe ser usada en sistemas en producción porque el código de depuración
puede reducir el rendimiento.
Entorno MySQL.-
Para manejar el entorno de MySql tenemos herramientas como SQLYog y
phpmyadmin, la primera es una aplicación desktop y que en versión gratuita tiene
algunas limitaciones, pero las operaciones básicas puede realizar sin ningún problema,
pero se debe descargar desde la web, la segunda es PhpMyadmin, y es gratuita con
interfaz web y ya viene instalada como paquete en Xammp o Appserv.

PHPMyAdmin
phpMyAdmin es una herramienta web que permite acceder de forma intuitiva a las
bases de datos MySQL se compone de un conjunto de archivos escritos en PHP que
una vez copiados en un directorio de nuestro servidor web podremos encontrar las
bases de datos a las que tenemos acceso en nuestro servidor y todas sus tablas.
La herramienta nos permite la creacion de tablas, insertar datos en las mismas,

navegar por sus registros,editarlos y borrarlos, borrar tablas y un largo etcétera. Se
podrá ejecutar sentencias SQL y hacer backups de las bases de datos existentes.
La página del proyecto es http://www.phpmyadmin.net/.
Desde allí podemos descargar los ficheros de la última versión de la aplicación, que
posteriormente debemos colocar en nuestro servidor web.
Un proyecto de código abierto en PHP para administrar la base de datos MySQL a través de
una interfaz web. Descripción funcionalidades y ayudas para la instalación.
phpMyAdmin es un programa de libre distribución en PHP, creado por una comunidad sin
ánimo de lucro, que sólo trabaja en el proyecto por amor al arte. Es una herramienta muy
completa que permite acceder a todas las funciones típicas de la base de datos MySQL a través
de una interfaz web muy intuitiva.
La aplicación en si no es más que un conjunto de archivos escritos en PHP que podemos copiar
en un directorio de nuestro servidor web, de modo que, cuando accedemos a esos archivos,
nos muestran unas páginas donde podemos encontrar las bases de datos a las que tenemos
acceso en nuestro servidor de bases de datos y todas sus tablas. La herramienta nos permite

crear tablas, insertar datos en las tablas existentes, navegar por los registros de las tablas,
editarlos y borrarlos, borrar tablas y un largo etcétera, incluso ejecutar sentencias SQL y hacer
un backup de la base de datos.
Página de phpMyAdmin
La página de inicio del proyecto es http://www.phpmyadmin.net/. Desde allí podemos

descargar los ficheros de la última versión de la aplicación, que posteriormente debemos
colocar en nuestro servidor web. También podemos encontrar a phpMyAdmin dentro de la red
Sourceforge.net, que es un sitio que recoge multitud de proyectos "Open Source" (código
abierto).
Hay varias versiones disponibles, pero es recomendable escoger la que nos aconsejen como la
última versión estable (The last stable versión). En el momento de escribir este artículo era la
2.2.6. De modo que, si nuestro sistema es Windows, descargaremos el archivo phpMyAdmin-
2.2.6-php.zip
Los archivos que hemos descargado son de la versión 4 de PHP, aunque también ofrecen la
posibilidad de bajarse los archivos que guardan compatibilidad con la versión 3 de PHP, para
que aquellos que no dispongan del motor de PHP más actual.
La página de inicio del programa también nos ofrece la posibilidad de ver un demo online,
aunque nos avisan de que el servidor donde se aloja puede estar caído.
http://www.phpmyadmin.net/phpMyAdmin/

Instalando phpMyAdmin
Una vez descargada la última versión la tenemos que descomprimir, con lo que obtendremos
los ficheros PHP que conforman la herramienta y colocarlos dentro del directorio de
publicación de nuestro servidor web.
Nota: recordamos que phpMyAdmin es un proyecto escrito en PHP, por lo que

necesitaremos colocar los archivos en un servidor web que permita programación de
páginas PHP. Además, deberemos acceder a la herramienta a través de la dirección
del servidor web, seguida del directorio en el que tenemos los archivos que hemos
descomprimido. Por ejemplo, si nuestro servidor es el PWS y hemos colocado los
archivos dentro del directorio de publicación (Generalmente C:\Inetpub\wwwroot),
en el subdirectorio phpMyAdmin, debemos escribir algo como
http://localhost/phpMyAdmin
Si tuviéramos instalado un servidor Apache los colocaríamos en la carpeta que

hayamos indicado como "documentRoot", que suele ser htdocs.
Lo primero que podemos leer es el archivo de la documentación, que encontramos junto con
los archivos de phpMyAdmin. Explica datos generales del programa, como sus requerimientos,
instrucciones de instalación, configuración, preguntas frecuentes, etc.
Posteriormente, tal como explica la documentación, hay que editar el archivo config.inc.php
para cambiar los valores de host de la base de datos (ordenador que tiene instalado el MySQL)
y el usuario y password con el que nos conectamos. Se pueden configurar muchos aspectos en
la herramienta, aunque ahora solo comentaré los que he encontrado esenciales para hacerla
funcionar, en la documentación tenemos un apartado dedicado por completo a especificar el
sentido de cada variable.
$cfgPmaAbsoluteUri
Debemos asignarlo a la ruta completa necesaria para acceder a phpMyAdmin. Podría ser algo
como http://localhost/phpMyAdmin o http://www.midominio.com/phpMyAdmin
$cfgServers[$i]['host'] string
El nombre del host de la base de datos. Por ejemplo localhost, si es que es el mismo ordenador
donde estamos instalandos phpMyAdmin y la base de datos. También podría ser la dirección IP
del ordenador al que nos conectamos.
$cfgServers[$i]['user'] string
$cfgServers[$i]['password'] string
El par usuario/contraseña que debe utilizar phpMyAdmin para conectarse con el servidor
MySQL.

Con estas sencillas configuraciones ya podemos acceder a phpMyAdmin y trabajar con nuestra
base de datos a golpe de ratón, que resulta muy de agradecer teniendo en cuenta que, en caso
de no tener esta herramienta u otra parecida, la otra opción consistiría en utilizar el lenguaje
SQL, y, en caso de que la base de datos esté alojada remotamente en Internet, no podríamos
hacerlo sino es con acceso por TELNET al servidor de la base de datos.
El lenguaje SQL
El lenguaje de consulta estructurado o SQL (por sus siglas en inglés Structured Query
Language) es un lenguaje declarativo de acceso a bases de datos relacionales que
permite especificar diversos tipos de operaciones en ellas. Una de sus características
es el manejo del álgebra y el cálculo relacional que permiten efectuar consultas con el
fin de recuperar de forma sencilla información de interés de bases de datos, así como
hacer cambios en ellas.
Lenguaje de definición de datos (DDL)
El lenguaje de definición de datos (en inglés Data Definition Language, o DDL), es el

que se encarga de la modificación de la estructura de los objetos de la base de datos.
Incluye órdenes para modificar, borrar o definir las tablas en las que se almacenan los
datos de la base de datos. Existen cuatro operaciones básicas: CREATE, ALTER, DROP y
TRUNCATE.
CREATE | CREAR
Este comando permite crear objetos de datos, como nuevas bases de datos, tablas,
vistas y procedimientos almacenados.
Ejemplo (crear una tabla)
CREATE TABLE 'CLIENTES';
ALTER | MODIFICAR
Este comando permite modificar la estructura de un objeto. Se pueden agregar/quitar

campos a una tabla, modificar el tipo de un campo, agregar/quitar índices a una tabla,
modificar un TRIGGER, etc.
Ejemplo (agregar columna a una tabla)
ALTER TABLE 'ALUMNOS' ADD EDAD INT UNSIGNED;

DROP | ELIMINAR
Este comando elimina un objeto de la base de datos. Puede ser una tabla, vista, índice,
trigger, función, procedimiento o cualquier objeto que el motor de la base de datos
soporte. Se puede combinar con la sentencia ALTER.
Ejemplo
DROP TABLE 'ALUMNOS';.
TRUNCATE | BORRAR TABLA
Este comando trunca todo el contenido de una tabla. La ventaja sobre el comando
DROP, es que si se quiere borrar todo el contenido de la tabla, es mucho más rápido,
especialmente si la tabla es muy grande. La desventaja es que TRUNCATE sólo sirve
cuando se quiere eliminar absolutamente todos los registros, ya que no se permite la
cláusula WHERE. Si bien, en un principio, esta sentencia parecería ser DML (Lenguaje
de Manipulación de Datos), es en realidad una DDL, ya que internamente, el comando
TRUNCATE borra la tabla y la vuelve a crear y no ejecuta ninguna transacción.
Ejemplo
TRUNCATE TABLE 'NOMBRE_TABLA';
Lenguaje de manipulación de datos DML(Data Manipulation Language)
Definición
Un lenguaje de manipulación de datos (Data Manipulation Language, o DML en inglés)

es un lenguaje proporcionado por el sistema de gestión de base de datos que permite
a los usuarios llevar a cabo las tareas de consulta o manipulación de los datos,
organizados por el modelo de datos adecuado.
El lenguaje de manipulación de datos más popular hoy día es SQL, usado para
recuperar y manipular datos en una base de datos relacional.
SELECT | SELECCIONAR
La sentencia SELECT nos permite consultar los datos almacenados en una tabla de la
base de datos.
Forma básica
SELECT [ALL | DISTINCT ]
<nombre_campo> [{,<nombre_campo>}]
FROM <nombre_tabla>|<nombre_vista>

[{,<nombre_tabla>|<nombre_vista>}]
[WHERE <condicion> [{ AND|OR <condicion>}]]
[GROUP BY <nombre_campo> [{,<nombre_campo >}]]
[HAVING <condicion>[{ AND|OR <condicion>}]]
[ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC]
[{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]

Palabra clave que indica que la sentencia de SQL que queremos ejecutar es
SELECT de selección.
Indica que queremos seleccionar todos los valores.Es el valor por defecto y
ALL
no suele especificarse casi nunca.
DISTINCT Indica que queremos seleccionar sólo los valores distintos.
Indica la tabla (o tablas) desde la que queremos recuperar los datos. En el

caso de que exista más de una tabla se denomina a la consulta "consulta
FROM
combinada" o "join". En las consultas combinadas es necesario aplicar una
condición de combinación a través de una cláusula WHERE.
Especifica una condición que debe cumplirse para que los datos sean
WHERE
devueltos por la consulta. Admite los operadores lógicos AND y OR.
GROUP Especifica la agrupación que se da a los datos. Se usa siempre en

BY combinación con funciones agregadas.
Especifica una condición que debe cumplirse para que los datos sean
devueltos por la consulta. Su funcionamiento es similar al de WHERE pero
HAVING aplicado al conjunto de resultados devueltos por la consulta. Debe aplicarse
siempre junto a GROUP BY y la condición debe estar referida a los campos
contenidos en ella.
Presenta el resultado ordenado por las columnas indicadas. El orden puede

ORDER
expresarse con ASC (orden ascendente) y DESC (orden descendente). El
BY
valor predeterminado es ASC.

Ejemplo:
Para formular una consulta a la tabla Coches y recuperar los campos matricula, marca,
modelo, color, numero_kilometros, num_plazas debemos ejecutar la siguiente
consulta. Los datos serán devueltos ordenados por marca y por modelo en orden
ascendente, de menor a mayor. La palabra clave FROM indica que los datos serán
recuperados de la tabla Coches.
SELECT matricula, marca, modelo, color, numero_kilometros, num_plazas

FROM Coches
ORDER BY marca,modelo;
Ejemplo de Consulta simplificada a través de un comodín de Campos (*):
El uso del asterisco indica que queremos que la consulta devuelva todos los campos
que existen en la tabla y los datos serán devueltos ordenados por marca y por modelo.
SELECT * FROM Coches ORDER BY marca, modelo;
Cláusula WHERE
La cláusula WHERE es la instrucción que nos permite filtrar el resultado de una

sentencia SELECT. Habitualmente no deseamos obtener toda la información existente
en la tabla, sino que queremos obtener sólo la información que nos resulte útil en ese
momento. La cláusula WHERE filtra los datos antes de ser devueltos por la consulta.
Cuando en la Cláusula WHERE queremos incluir un tipo texto, debemos incluir el valor
entre comillas simples.
Ejemplos:
En nuestro ejemplo, se desea consultar un coche en concreto, para esto se agregó una
cláusula WHERE. Esta cláusula especifica una o varias condiciones que deben cumplirse
para que la sentencia SELECT devuelva los datos. En este caso la consulta devolverá
sólo los datos del coche con matrícula para que la consulta devuelva sólo los datos del
coche con maricula MF-234-ZD o bien la matrícula FK-938-ZL . Se puede utilizar la
cláusula WHERE solamente, ó en combinación con tantas condiciones como queramos.
SELECT matricula, marca, modelo, color, numero_kilometros, num_plazas

FROM Coches
WHERE matricula = 'MF-234-ZD'
OR matricula = 'FK-938-ZL' ;
Una Condición WHERE puede ser negada a través del Operador Lógico NOT. La
Siguiente consulta devolverá todos los datos de la tabla Coches, menos el que tenga la
Matrícula MF-234-ZD .

SELECT matricula,marca, modelo, color, numero_kilometros, num_plazas

FROM coches
WHERE NOT matricula = 'MF-234-ZD';
La Siguiente consulta utiliza la condicional DISTINCT, la cual nos devolverá todos los
valores distintos formados por los Campos Marca y Modelo. de la tabla coches.
SELECT DISTINCT marca, modelo FROM coches;
Cláusula ORDER BY
La cláusula ORDER BY es la instrucción que nos permite especificar el orden en el que

serán devueltos los datos. Podemos especificar la ordenación ascendente o
descendente a través de las palabras clave ASC y DESC. La ordenación depende del
tipo de datos que este definido en la columna, de forma que un campo númerico será
ordenado como tal, y un alfanúmerico se ordenará de la A a la Z, aunque su contenido
sea númerico. El valor predeterminado es ASC si no se especifica al hacer la consulta.
Ejemplos:
SELECT matricula,
marca,
modelo,
color,
numero_kilometros,
num_plazas
FROM coches
ORDER BY marca ASC,modelo DESC; Este ejemplo, selecciona todos los campos
matricula, marca, modelo, color, numero_kilometros y num_plazas de la tabla coches,
ordenándolos por los campos marca y modelo, marca en forma ascendente y modelo
en forma descendente.
SELECT matricula,
marca,
modelo,
color,
numero_kilometros, num_plazas
FROM coches
ORDER BY 2;
Este ejemplo, selecciona todos los campos matrícula, marca, modelo, color,
numero_kilometros y num_plazas de la tabla coches, ordenándolos por el campo
marca, ya que aparece en segundo lugar dentro de la lista de campos que componen la

SELECT.
INSERT | INSERTAR
Una sentencia INSERT de SQL agrega uno o más registros a una (y sólo una) tabla en
una base de datos relacional.
Forma básica
INSERT INTO 'tablatura' ('columna1',['columna2,... '])
VALUES ('valor1', ['valor2,...'])
Las cantidades de columnas y valores deben ser iguales. Si una columna no se

especifica, le será asignado el valor por omisión. Los valores especificados (o
implícitos) por la sentencia INSERT deberán satisfacer todas las restricciones aplicables.
Si ocurre un error de sintaxis o si alguna de las restricciones es violada, no se agrega la
fila y se devuelve un error.
Ejemplo
INSERT INTO agenda_telefonica (nombre, numero)
VALUES ('Roberto Jeldrez', 4886850);
Cuando se especifican todos los valores de una tabla, se puede utilizar la sentencia
acortada:
INSERT INTO nombreTabla VALUES ('valor1', ['valor2,...'])
Ejemplo (asumiendo que 'nombre' y 'número' son las únicas columnas de la tabla
'agenda_telefonica'):
INSERT INTO agenda_telefonica

VALUES ('Jhonny Aguiar', 080473968);
Formas avanzadas
Una característica de SQL (desde SQL-92) es el uso de constructores de filas para

insertar múltiples filas a la vez, con una sola sentencia SQL:
INSERT INTO ''tabla'' (''columna1'', [''columna2,... ''])

VALUES (''valor1a'', [''valor1b,...'']),
(''value2a'', [''value2b,...'']),...;
Esta característica es soportada por DB2, PostgreSQL (desde la versión 8.2), MySQL, y
H2.
Ejemplo (asumiendo que 'nombre' y 'número' son las únicas columnas en la tabla
'agenda_telefonica'):

INSERT INTO agenda_telefonica VALUES ('Roberto Fernández', '4886850'), ('Alejandro

Sosa', '4556550');
Que podía haber sido realizado por las sentencias
INSERT INTO agenda_telefonica VALUES ('Roberto Fernández', '4886850');

INSERT INTO agenda_telefonica VALUES ('Alejandro Sosa', '4556550');
Notar que las sentencias separadas pueden tener semántica diferente (especialmente
con respecto a los triggers), y puede tener diferente rendimiento que la sentencia de
inserción múltiple.
Para insertar varias filas en MS SQL puede utilizar esa construcción:
INSERT INTO phone_book

SELECT 'John Doe', '555-1212'
UNION ALL
SELECT 'Peter Doe', '555-2323';
Tenga en cuenta que no se trata de una sentencia SQL válida de acuerdo con el
estándar SQL (SQL: 2003), debido a la cláusula subselect incompleta.
Para hacer lo mismo en Oracle se usa DUAL TABLE, siempre que se trate de solo una
simple fila:

SELECT 'John Doe', '555-1212' FROM DUAL
UNION ALL
SELECT 'Peter Doe','555-2323' FROM DUAL
Una implementación conforme al estándar de esta lógica se muestra el siguiente

ejemplo, o como se muestra arriba (no aplica en Oracle):

SELECT 'John Doe', '555-1212' FROM LATERAL ( VALUES (1) ) AS t(c)
UNION ALL
SELECT 'Peter Doe','555-2323' FROM LATERAL ( VALUES (1) ) AS t(c)
Copia de filas de otras tablas
Un INSERT también puede utilizarse para recuperar datos de otros, modificarla si es

necesario e insertarla directamente en la tabla. Todo esto se hace en una sola
sentencia SQL que no implica ningún procesamiento intermedio en la aplicación
cliente. Un SUBSELECT se utiliza en lugar de la cláusula VALUES. El SUBSELECT puede
contener JOIN, llamadas a funciones, y puede incluso consultar en la misma TABLA los
datos que se inserta. Lógicamente, el SELECT se evalúa antes que la operación INSERT
esté iniciada. Un ejemplo se da a continuación.

INSERT INTO phone_book2
SELECT *
FROM phone_book
WHERE name IN ('John Doe', 'Peter Doe')
Una variación es necesaria cuando algunos de los datos de la tabla fuente se está
insertando en la nueva tabla, pero no todo el registro. (O cuando los esquemas de las
tablas no son iguales.)
INSERT INTO phone_book2 ( [name], [phoneNumber] )
SELECT [name], [phoneNumber]

FROM phone_book
WHERE name IN ('John Doe', 'Peter Doe')
El SELECT produce una tabla (temporal), y el esquema de la tabla temporal debe

coincidir con el esquema de la tabla donde los datos son insertados.
UPDATE
Una sentencia UPDATE de SQL es utilizada para modificar los valores de un conjunto de
registros existentes en una tabla.
Ejemplo
UPDATE My_table SET field1 = 'updated value asd' WHERE field2 = 'N';
DELETE
Una sentencia DELETE de SQL borra uno o más registros existentes en una tabla.
Forma básica
DELETE FROM tabla WHERE columna1 = 'valor1'
Ejemplo
DELETE FROM My_table WHERE field2 = 'N';
Recuperación de clave
Los diseñadores de base de datos que usan una clave suplente como la clave principal
para cada tabla, se ejecutará en el ocasional escenario en el que es necesario
recuperar automáticamente la base de datos, generando una clave primaria de una
sentencia SQL INSERT para su uso en otras sentencias SQL. La mayoría de los sistemas
no permiten sentencias SQL INSERT para retornar fila de datos. Por lo tanto, se hace
necesario aplicar una solución en tales escenarios.
Implementaciones comunes incluyen:

 Utilizando un procedimiento almacenado específico de base de datos que

genera la clave suplente, realice la operación INSERT, y finalmente devuelve la
clave generada.
 Utilizando una sentencia SELECT específica de base de datos, sobre una tabla
temporal que contiene la última fila insertada. DB2 implementa esta
característica de la siguiente manera:
SELECT *
FROM NEW TABLE ( INSERT INTO phone_book VALUES ( 'Cristobal
Jeldrez','0426.817.10.30' ) ) AS t
 Utilizando una sentencia SELECT después de la sentencia INSERT con función

específica de base de datos, que devuelve la clave primaria generada por el
registro insertado más recientemente.
 Utilizando una combinación única de elementos del original SQL INSERT en una
posterior sentencia SELECT.
 Utilizando un GUID en la sentencia SQL INSERT y la recupera en una sentencia
SELECT.
 Utilizando la función de PHP mysql_insert_id() de MySQL después de la
sentencia INSERT.
 Utilizando un INSERT con la cláusula RETURNING para Oracle, que sólo se
puede utilizar dentro de un PL/SQL bloque, en el caso de PostgreSQL se puede
usar también tanto con SQL como con PL/SQL.
INSERT INTO phone_book VALUES ( 'Cristobal Jeldrez','0426.817.10.30' )

RETURNING phone_book_id INTO v_pb_id
 En el caso de MS SQL se puede utilizar la siguiente instrucción:
SET NoCount ON;

INSERT INTO phone_book VALUES ( 'Cristobal Jeldrez','0426.817.10.30' );
SELECT @@IDENTITY AS ID
Disparadores
Los disparadores, también conocidos como desencadenantes (triggers en inglés) son

definidos sobre la tabla en la que opera la sentencia INSERT, y son evaluados en el
contexto de la operación. Los desencadenantes BEFORE INSERT permiten la
modificación de los valores que se insertarán en la tabla. Los desencadenantes AFTER
INSERT no puede modificar los datos de ahora en adelante, pero se puede utilizar para
iniciar acciones en otras tablas, por ejemplo para aplicar mecanismos de auditoría.

PHP con Bases de Datos MySQL
Conectando PHP con Bases de Datos
Definición
MySQL
Funciones de PHP para interactuar con MySQL
mysqli_connect()
mysqli_close()
mysqli_select_db()
mysqli_query()
Mysqli_num_rows ()
mysqli_fetch_array()
mysqli_error()
Modificaciones de Datos
Insertar un Registro
Modificar un Registro

Borrar un Registro
Listado de Productos
Armar el Reporte de Productos
Armar la consulta SQL
Reporte
Colores Interlineados
Búsquedas internas en el sitio
Paginación de los resultados del Reporte
UPLOAD ? Subir Archivos al Server
Introducción
Formulario para subir archivos
Tipos de contenido del Formulario
Etiqueta FILE
Campo oculto MAX_FILE_SIZE
Formulario completo de Carga

Pagina Destino ? Copiar al Servidor
La variable $_FILES
Grabando el archivo subido
PHP en la Práctica
Introducción
Campos Ocultos
hidden
Finalidad
Ejemplo:
Sesiones
Introducción
Porque usar sesiones
Identificador de Sesion - SID
Gestion de una sesion
Cookies

Por URL rewriting:
Características
Funciones de PHP para interactuar con Sesiones
Construcción de variables de sesión
Identificación de la sesión
Destrucción de una sesión
Crear variables de sesión
Autentificación de Usuarios a un Sitio Web con uso de Sesiones
Logueo al Sitio
Autentificación y Creación de la sesión.
Cerrar sesión: Pagina Desconectarse
Cookies
Introducción
Definición
Caducidad

DOMINIOS Y SUBDOMINIOS
Características
Limitaciones
Funciones de PHP para interactuar con Cookies
Construcción
Utilización
Expiración
Eliminación
La función isset()

Guia de Estudio de PHP

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia de Estudio de PHP

Cargado por

Copyright:

Formatos disponibles

PHP & MYSQL I & II

Guía de PHP & MYSQL I

Guía de PHP & MYSQL I

MOS. David Ortega Mazzini 2

DATOS DEL AUTOR ................................................................................................................................ 9

MOS DAVID ORTEGA MAZZINI ............................................................................................................... 9

QUÉ ES PHP .......................................................................................................................................... 11

QUÉ SE PUEDE HACER CON PHP ........................................................................................................... 11

EL MODELO CLIENTE – SERVIDOR ........................................................................................................ 13

PÁGINAS ESTÁTICAS ............................................................................................................................ 14

SERVIDOR WEB APACHE ...................................................................................................................... 15

POR QUÉ PHP....................................................................................................................................... 16

ENTORNO DE TRABAJO ........................................................................................................................ 23

COMPROBACIÓN DE LA INSTALACIÓN ................................................................................................. 25

PHP: LENGUAJE DE PROGRAMACIÓN................................................................................................... 25

ETIQUETAS DE PHP .............................................................................................................................. 26

COMENTARIOS EN PHP ........................................................................................................................ 27

TIPOS DE DATOS .................................................................................................................................. 30

ÁMBITOS DE LAS VARIABLES ............................................................................................................... 31

OPERADORES ARITMÉTICOS ................................................................................................................ 33

LOS OPERANDOS DEL MÓDULO SE CONVIERTEN EN INTEGERS (POR EXTRACCIÓN DE LA PARTE

MOS. David Ortega Mazzini 3

OPERADORES DE ASIGNACIÓN ............................................................................................................ 34

PASO DE VARIABLES POR URL .............................................................................................................. 34

CARACTERES ESPECIALES EN URL Y SU CODIFICACIÓN CON PHP .......................................................... 35

EJEMPLOS DE CASOS DE PÁGINAS CON PARÁMETROS ........................................................................ 36

LAB: PRACTICA CON PARÁMETROS GET 1 ............................................................................................ 36

LAB: PRACTICAL CON FORM ................................................................................................................. 36

LAB: PRACTICA CON PARÁMETROS GET 2 (OPCIONAL) ........................................................................ 36

LAB: PARÁMETROS GET Y USO DE VARIABLES LOCALES (OPCIONAL) ................................................... 36

ESTRUCTURAS DE CONTROL ................................................................................................................ 36

SENTENCIA SWITCH ............................................................................................................................. 42

LAB1: FORMULARIO I ........................................................................................................................... 43

LAB2: FORMULARIO II .......................................................................................................................... 43

LAB3: TABLA DINÁMICA ....................................................................................................................... 43

ARREGLOS EN PHP ............................................................................................................................... 43

INCLUSIÓN DE CÓDIGO ........................................................................................................................ 45

FUNCIONES EN PHP ............................................................................................................................. 46

FUNCIÓN PRINT() ................................................................................................................................. 51

FUNCIÓN PRINTF() ............................................................................................................................... 51

MOS. David Ortega Mazzini 4

FUNCIÓN SPRINTF() ............................................................................................................................. 51

FUNCIÓN STRTOUPPER() Y STRTOLOWER () ......................................................................................... 53

FUNCIÓN STRLEN() ............................................................................................................................... 54

FUNCIÓN NUMBER_FORMAT() ............................................................................................................ 54

FUNCIÓN SUBSTR() .............................................................................................................................. 56

FUNCIÓN RTRIM() ................................................................................................................................ 57

FUNCIÓN LTRIM() ................................................................................................................................ 57

FUNCIÓN TRIM() .................................................................................................................................. 58

FUNCIÓN STR_WORD_COUNT() ........................................................................................................... 58

FUNCIÓN SPLIT() .................................................................................................................................. 59

FUNCIONES DE REDONDEO .................................................................................................................. 59

FUNCIÓN ROUND() .............................................................................................................................. 59

FUNCIÓN CEIL() .................................................................................................................................... 60

FUNCIÓN FLOOR() ................................................................................................................................ 60

FUNCIONE DEFINIDAS POR EL USUARIO .............................................................................................. 60

BASE DE DATOS MYSQL ....................................................................................................................... 61

ENTORNO MYSQL.- .............................................................................................................................. 63

EL LENGUAJE SQL ................................................................................................................................. 67

LENGUAJE DE DEFINICIÓN DE DATOS (DDL) ...................................................................................................... 67

PHP CON BASES DE DATOS MYSQL ..................................................................................................... 76

CONECTANDO PHP CON BASES DE DATOS ........................................................................................... 76

MOS. David Ortega Mazzini 5

FUNCIONES DE PHP PARA INTERACTUAR CON MYSQL......................................................................... 76