Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Guia de Estudio de PHP
Guia de Estudio de PHP
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.
Contenido
INTRODUCCIÓN Y GENERALIDADES ....................................................................................................... 2
REQUISITOS ................................................................................................................................................. 2
PRÓLOGO ............................................................................................................................................ 10
INTRODUCCIÓN.- ................................................................................................................................. 11
PÁGINAS DINÁMICAS........................................................................................................................... 14
VENTAJAS ............................................................................................................................................ 17
DESVENTAJAS ...................................................................................................................................... 17
INSTALACIÓN ....................................................................................................................................... 17
XAMPP................................................................................................................................................. 24
APPSERV .............................................................................................................................................. 25
SINTAXIS .............................................................................................................................................. 25
VARIABLES ........................................................................................................................................... 27
OPERADORES ....................................................................................................................................... 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
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
$HTTP_GET_VARS .................................................................................................................................. 35
$_GET ..................................................................................................................................................... 35
LABORATORIOS ................................................................................................................................... 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
LABORATORIOS ................................................................................................................................... 43
REQUIRE .............................................................................................................................................. 45
FORMULARIOS ..................................................................................................................................... 46
STRTOUPPER .............................................................................................................................................. 54
APLICACIONES ..................................................................................................................................... 61
PHPMYADMIN ..................................................................................................................................... 64
DEFINICIÓN .......................................................................................................................................... 76
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
REPORTE .............................................................................................................................................. 77
COLORES INTERLINEADOS.................................................................................................................... 77
INTRODUCCIÓN ................................................................................................................................... 77
INTRODUCCIÓN ................................................................................................................................... 78
CAMPOS OCULTOS............................................................................................................................... 78
HIDDEN ................................................................................................................................................ 78
FINALIDAD ........................................................................................................................................... 78
EJEMPLO: ............................................................................................................................................. 78
SESIONES ............................................................................................................................................. 78
INTRODUCCIÓN ................................................................................................................................... 78
COOKIES .............................................................................................................................................. 78
CARACTERÍSTICAS ................................................................................................................................ 79
COOKIES .............................................................................................................................................. 79
INTRODUCCIÓN ................................................................................................................................... 79
DEFINICIÓN .......................................................................................................................................... 79
CADUCIDAD ......................................................................................................................................... 79
CARACTERÍSTICAS ................................................................................................................................ 80
LIMITACIONES ..................................................................................................................................... 80
CONSTRUCCIÓN ................................................................................................................................... 80
UTILIZACIÓN ........................................................................................................................................ 80
EXPIRACIÓN ......................................................................................................................................... 80
ELIMINACIÓN ....................................................................................................................................... 80
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.
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.
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
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
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.
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.
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í.
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.
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.
Páginas Estáticas
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.
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 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 ).
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.
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
Ventajas
Desventajas
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.
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.
c:\php
+--dev
| |
| |
| |-php_bz2.dll
| |
| |-php_cpdf.dll
| |
| |-...
+--extras -- empty
|-...
|-...
|-...
|-...
php-cgi.exe - ejecutable CGI que se puede utilizar cuando se ejecuta PHP en IIS a través
de CGI o FastCGI.
php.exe - el ejecutable para la ejecución de scripts PHP dentro de una interfaz de línea
de comandos (CLI) 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 .
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".
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.
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.
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.
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.
<?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.
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.
Sintaxis
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.
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().
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 .
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.
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).
<?php
$var = 'Roberto';
$Var = 'Juan';
echo "$var, $Var"; // imprime "Roberto, Juan"
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.
<?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;
}
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.
<?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");
Tipos de Datos
PHP soporta ocho tipos primitivos.
boolean
integer
float (número de punto flotante, también conocido como double)
string
array
object
resource
NULL
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.
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
<?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.
function Suma()
{
global $a, $b;
$b = $a + $b;
}
Suma();
echo $b;
?>
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).
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.
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").
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.
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";
?>
</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.
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.
Laboratorios
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).
<?php
$i = 0;
do {
echo $i;
} while ($i > 0);
?>
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:
sentencia
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.
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 */
/* ejemplo 2 */
/* ejemplo 3 */
$i = 1;
for (; ; ) {
if ($i > 10) {
break;
}
echo $i;
$i++;
}
/* ejemplo 4 */
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.
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
<?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) {
echo "a es mayor que 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) {
echo "a es mayor que 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) {
echo "a es mayor que 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.
Sentencia 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:
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:
<?php
if ($i == 0) {
echo "i es igual a 0";
} elseif ($i == 1) {
echo "i es igual a 1";
} elseif ($i == 2) {
echo "i es igual a 2";
}
switch ($i) {
case 0:
echo "i es igual a 0";
break;
case 1:
echo "i es igual a 1";
break;
case 2:
echo "i es igual a 2";
break;
}
?>
Laboratorios
Lab1: Formulario I
Lab2: Formulario II
Arreglos en PHP
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(
...
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 [].
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
);
Inclusión de Código
include
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.
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.
Funciones en PHP
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.
<?
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);
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")
<?
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>
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.
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.
<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>";
?>
</body>
</html>
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
Un especificador de tipo que indica con qué tipo deben ser tratados los datos del
argumento. Los tipos posibles son:
Descripción
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
Ejemplos
<?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
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
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
Función number_format()
Formatear un número con los millares agrupados.
Si solo se proporciona un parámetro, number será formateado sin decimales, pero con
una coma (",") entre cada grupo de millares.
Parámetros
number
decimals
dec_point
thousands_sep
Valores devueltos
<?php
$número = 1234.56;
// notación francesa
$nombre_format_francais = number_format($número, 2, ',', ' ');
// 1 234,56
$número = 1234.5678;
?>
Función substr()
Devuelve parte de una cadena.
Parámetros
string
start
<?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).
<?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
print "\n";
$trimmed = rtrim($text);
var_dump($trimmed);
?>
Función ltrim()
Retira espacios en blanco (u otros caracteres) del inicio de un string
<?php
print "\n";
$trimmed = ltrim($text);
var_dump($trimmed);
?>
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);
?>
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:
1 - devuelve un array que contiene todas las palabras encontradas dentro del string
Una lista de caracteres adicionales los cuales serán considerados como de 'palabra'.
Función split()
Convierte un string en un array
Ejemplo:
<?php
$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.5); // 4
echo round(3.6); // 4
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
?>
<?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.
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:
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:
Los hay nativos como MyISAM, Falcon, Merge, InnoDB, BDB, Memory/heap,
MySQL Cluster, Federated, Archive, CSV, Blackhole y Example
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.
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
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.
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.
CREATE | CREAR
Este comando permite crear objetos de datos, como nuevas bases de datos, tablas,
vistas y procedimientos almacenados.
ALTER | MODIFICAR
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
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
Definición
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>}]
Indica que queremos seleccionar todos los valores.Es el valor por defecto y
ALL
no suele especificarse casi nunca.
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.
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.
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.
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.
Cláusula WHERE
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.
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 .
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.
Cláusula ORDER BY
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,...'])
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:
Ejemplo (asumiendo que 'nombre' y 'número' son las únicas columnas de la tabla
'agenda_telefonica'):
Formas avanzadas
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'):
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.
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 *
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.)
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.
SELECT *
FROM NEW TABLE ( INSERT INTO phone_book VALUES ( 'Cristobal
Jeldrez','0426.817.10.30' ) ) AS t
Disparadores
Definición
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
Reporte
Colores Interlineados
Introducción
Etiqueta FILE
La variable $_FILES
PHP en la Práctica
Introducción
Campos Ocultos
hidden
Finalidad
Ejemplo:
Sesiones
Introducción
Cookies
Características
Identificación de la sesión
Logueo al Sitio
Cookies
Introducción
Definición
Caducidad
DOMINIOS Y SUBDOMINIOS
Características
Limitaciones
Construcción
Utilización
Expiración
Eliminación
La función isset()