Tutoriales Varios
Curso php-MySQL
PHP es un lenguaje con capacidad de conexión con bases de datos. En este apartado solo nos vamos a centrar en el uso de php con mysql, ya que sql es un lenguaje en particular, y muy generalizado. Normalmente, para la administración de bases de datos mysql, se usa PhpMyAdmin, una interfaz muy amigable con la que manejar las db
Indice:
Tabla de contenidos:
1
1 HTML
1.1 ¿Qué es HTML?
1.2 Etiquetas básicas
1.2.1 <HTML>
1.2.2 <HEAD>
1.2.3 <BODY>
1.2.4 <TITLE>
1.2.5 <HX>
1.2.6 <P>
1.2.7 <BR>
1.2.8 <TABLE>
1.2.9 <DIV>
1.3 Otras etiquetas
1.3.1 <IMG>
1.3.2 <A HREF>
1.3.3 <HR>
1.3.4 <FONT>
1.3.5 <I>
1.3.6 <B>
1.4 Caracteres especiales
1.5 Formularios
1.6 Ejemplo de una página HTML
2 PHP
2.1 ¿Qué es PHP?
2.1.1 Historia de PHP
2.1.2 PHP
2.2 Instalando PHP en nuestro servidor
2.3 Herramientas libres para escribir PHP
2.4 Sintaxis, variables y operadores
2.5 Primer script en PHP
2.6 Instrucciones básicas
2.7 Tipos de variables
2.8 Constantes
2.9 Estructuras de control
2.9.1 if/elseif/else
2.9.2 while
2.9.3 do … while
2.9.4 for
2.9.5 foreach
2.9.6 break
2.9.7 continue
2.9.8 switch
2.10 Incluyendo archivos include() y require()
2.11 Funciones
2.11.1 Formas de usar una función
2.11.2 Devolviendo valores desde funciones return()
2.12 Clases
2.13 Matrices, arrays o vectores
2.14 Ficheros
2.14.1 fopen
2.14.2 fwrite
2.14.3 fread
2.14.4 Upload de ficheros al servidor
2.15 Cookies
2.15.1 Cómo usar las cookies
2.16 Sesiones
2.16.1 Inicio de sesión
2.16.2 Variables de sesión
2.16.3 Cierre de sesión
3 MySQL
3.1 ¿Qué es una base de datos relacional?
3.2 Tipos de datos en MySQL
3.3 Instalando MySQL en nuestro servidor
3.4 Creando una base de datos y una tabla
3.4.1 Modo phpmyadmin
3.4.2 Modo mysql-admin/mysql-query-browser
3.4.3 Modo desde consola
3.5 Consultas MySQL
3.5.1 Consultas de inserción
3.5.2 Consultas de selección
3.5.3 Consulta de Actualización/Modificación
3.5.4 Consultas de Eliminación
4 Uso de bases de datos desde código PHP
4.1 Funciones MySQL
4.1.1 mysql_pconnect
4.1.2 mysql_select_db
4.1.3 mysql_query
4.1.4 mysql_fetch_row
4.1.5 mysql_result
4.1.6 mysql_escape_string
5 Herramientas para otras plataformas
5.1 Instalación de PHP en Apache para Windows
5.2 Instalación de MySQL en Windows
5.3 Herramientas para trabajar con MySQL en Windows
5.4 Instalación completa en Windows
5.4.1 AppServ
5.4.2 XAMMP
6 Complementos
6.1 phpMyAdmin
6.2 CMS
HTML
¿Qué es HTML?
HTML es el acrónimo inglés de HiperText Markup Languaje, lenguaje de marcado de hipertexto en castellano. Es el lenguaje universal de Internet, el que todos los navegadores entienden y en el que se representa más del 90% del contenido web (el resto son imágenes, animaciones en flash, etc).
REFERENCIAS:
Definición de HTML según la Wikipedia en español (https://es.wikipedia.org/wiki/HTML)
Página de las especificaciónes para HTML del consorcio W3C (https://www.w3.org/MarkUp/)
Etiquetas básicas
Las etiquetas básicas presentes en cualquier página que valide su contenido en HTML son las siguientes: <HTML>, <HEAD>, <BODY>, <TITLE>, <HX>, <P>, <BR>, <TABLE> y <DIV>. Aunque todas estén escritas con mayúsculas, no tiene por qué escribirse en mayúscula, es más, desde hace tiempo todas las etiquetas se suelen poner en minúscula. Otro aspecto importante en las etiquetas es que casi todas se cierran, así <HEAD> se cierra con </HEAD>, algunas como <BR> no se cierran.
<HTML>
Es la etiqueta que define el inicio del documento html, le indica al navegador que todo lo que viene a continuación debe tratarlo como una serie de códigos html. Se cierra con </HTML>.
<HEAD>
Define la cabecera del documento html, esta cabecera suele contener información sobre el documento que no se muestra directamente en el navegador, su codificación (charset=ISO-8859-1 o UTF-8 …) , etc. Se cierra con </HEAD>.
<BODY>
Define el contenido principal o cuerpo del documento, esta es la parte del documento html que se muestra en el navegador, dentro de esta etiqueta pueden definirse propiedades comunes a toda la página, como color de fondo y márgenes. Se cierra con </BODY>.
<TITLE>
Define el título de la página. Por lo general, el título aparece en la barra de título encima de la ventana. Se cierra con </TITLE>.
<HX>
Son encabezados o títulos del documento en diferentes tamaños de fuente, la X debe se un número del 1 al 6, el 1 es el más grande y el 6 el más pequeño. Se cierra con </HX> donde X debe ser el mismo número que abrió la etiqueta.
<P>
Es un párrafo nuevo, viene de paragraph. Se cierra con </P>.
<BR>
Es un salto de línea forzado, viene de branch. Esta etiqueta no se cierra en HTML, en XHTML sí se cierra con <br/>.
<TABLE>
Es el comienzo de una tabla, las filas se identifican con <TR> y las celdas dentro de las filas con <TD>. La tabla se cierra con </TABLE>, las filas con </TR> y las celdas con </TD>.
<DIV>
Indica el comienzo de una división vertical de la página, se usa mucho para alinear a la izquierda, centro o derecha los textos e imágenes, veamos un ejemplo:
<div align=»center»>Esto es un texto alineado en el centro</div>
Y el resultado:
Esto es un texto alineado en el centro
Como vemos, esta etiqueta se cierra con </DIV>.
Otras etiquetas
Otras etiquetas muy útiles y usadas en HTML son: <IMG>, <A HREF>, <HR>, <FONT>, <I>, <B>.
<IMG>
La etiqueta <IMG> sirve para empotrar una imagen cualquiera en HTML. Su uso suele ser:
<img src=»/direccion/imagen.png» alt=»Texto alternativo» title=»Título» width=»312″ height=»416″>
Los parámetros alt, title, width y height no son obligatorios, aunque el primero sí es necesario para validar correctamente la página en HTML, el segundo se refiere al título de la imagen, éste será visible si ponemos el ratón encima de la imagen. Los campos width y height hacen referencia al tamaño de la imagen, pudiendo modificar el tamaño original al gusto del programador, si estos campos no se pasan, se toma el tamaño original. Esta etiqueta no se cierra.
<A HREF>
La etiqueta <A HREF> hace referencia a un hiperenlace, puede ser a otra página o bien a una subsección de la misma página, lo que se conoce como un ancla. La URL ha de ir siempre entre las comillas o no será válido, el texto que está entre <A HREF=»…»> y </a> es el que contendrá el enlace, es imprescindible cerrar el hiperenlace o bien todo lo que escribamos a partir de <A HREF=»…»> estará hiperenlazado. Si no escribimos https:// estaremos haciendo referencia a un enlace en el mismo servidor, por lo que si se nos olvida el enlace estará roto.
Como muchas etiquetas, esta también tiene opciones, uno de las más usadas y más detestadas por los usuarios es target=»_blank». Se recomienda no usarla porque últimamente los navegadores más modernos disponen de solapas o pestañas para navegar, mucho más útil que la apertura de un nuevo navegador, además los usuarios se quejan de que esta opcion coarta su libertad: «Si quiero abrir un nuevo navegador para ver esa página ya lo hago yo, no me obligues».
Esta etiqueta pude usar distintos protocolos siendo el más común https://, otros son, mailto: ftp:// news: //.
<HR>
Esta etiqueta imprime una línea horizontal separatoria.
<FONT>
Esta etiqueta modifica el tipo de fuente, su tamaño, su tipo, su color… veamos un ejemplo:
<font style=»font-family: monospace;» color=»#ff0000″ size=»4″>este es un texto enriquecido</font>
Como vemos se ha de cerrar con </FONT>.
<I>
Esta etiqueta hace que el texto comprendido entre <I></I> esté escrito en cursiva. El acrónimo viene de italic.
<B>
Esta etiqueta hace que el texto comprendido entre <B></B> esté escrito en negrita. El acrónimo viene de bold.
Caracteres especiales
En el castellano tenemos varios caracteres especiales que en ocasiones HTML no entiende muy bien, estos son la ñ, las tildes y los comienzos de pregunta y admiración. El problema fundamental por el que un navegador puede no interpretar bien estos caracteres es porque el programador ha elegido mal el conjunto de caracteres de codificación del texto, el charset, porque el navegador es antiguo y no distingue entre codificaciones, o bien porque el servidor web tiene una codificación distinta a la que usa la página. Para ahorrarnos estos problemas siempre que trabajemos con estos caracteres usaremos los caracteres especiales del HTML estándar:
Para la ñ: & ntilde;
Para tilde en la a: & aacute;
Para tilde en la e: & eacute;
Para tilde en la i: & iacute;
Para tilde en la o: & oacute;
Para tilde en la u: & uacute;
Para el inicio de pregunta: & iquest;
Para el inicio de admiración: & iexcl;
En las tildes, si queremos ponerlas en mayúsculas sólo habría que sustituir la letra minúscula que está después del ampersán por su equivalente en mayúscula.
Formularios
Los formularios son herramientas con campos de texto, botones, menus desplegables y/o campos seleccionables que se encuentran en muchas webs, se suelen utilizar para hacer búsquedas, introducir datos, etc. Realmente sirven para interactuar de alguna forma con la página web enviando información que luego se procesará de alguna manera, en nuestro caso será vía un script o programa en PHP.
Los formularios siempre se han de enviar a una página, puede ser la misma en la que está el formulario o bien otra. Existen dos métodos de enviar un formulario, get y post, el primero envía todos los datos sin encriptar y son visibles en el navegador, mientras que el segundo los encripta y envía ocultos al navegador, lo que nos da seguridad a la hora de enviar datos.
Se define un formulario de método post como:
<form method=»post»></form>
Podemos tener distintos tipos de modificadores o campos en el formulario: Botones de envío de datos…
<input type=»submit»>
o de borrado de todos los datos introducidos…
<input type=»reset»>
cajas de texto de tamaño 12 y longitud máxima 20…
<input type=»text» name=»texto» size=»12″ maxlength=»20″>
campos ocultos de nombre «oculto» y valor «16»…
<input type=»hidden» name=»oculto» value=»16″>
áreas de texto con 6 filas y 8 columnas de extensión…
<textarea name=»área de texto» rows=»6″ cols=»8″></textarea>
menús desplegables de única opción…
<select name=»nombre»>
<option value=»0″ default>——–</option>
<option value=»1″>Opción 1</option>
<option value=»2″>Opción 2</option>
</select>
menús desplegables de varias opciones…
<select name=»nombre[]» size=»2″ multiple>
<option value=»1″>Opción 1</option>
<option value=»2″>Opción 2</option>
</select>
Hay muchas más opciones para incluir dentro de un formulario, las anteriores son las más típicas y básicas.
Ejemplo de una página HTML
<html>
<head>
<meta content=»text/html; charset=ISO-8859-1″ http-equiv=»content-type»>
<title>Página de prueba</title>
</head>
<body>
<h1>Este es el título de la página</h1><br>
<br>
Esto es un texto normal.<br>
<hr style=»width: 100%; height: 2px;»><br>
</body>
</html>
PHP
¿Qué es PHP?
PHP es el acrónimo recursivo de «PHP: Hypertext Preprocessor». Es un lenguaje multiplataforma de programación interpretado de alto nivel, pensado para desarrollos web y empotrable en páginas HTML. La facilidad de PHP es que tiene muchas funciones copiadas de C, Java y/o Perl, por ello su curva de aprendizaje es exponencial. Lo que ve el cliente es el código ejecutado, es decir, el cliente solo ve lo que el código PHP ha producido, no la programación de éste, como pasaría con un Javascript.
PHP está llamado a sustituir a los vetustos CGIs (Common Gateway Interface) que fueron unas de las primeras maneras prácticas de crear contenido dinámico. En los CGIs el servidor web pasa las solicitudes del cliente a un programa externo, como si fuese un script en bash, y la salida es enviada al cliente como un archivo estático tradicional.
Historia de PHP
PHP/FI fué creado por Rasmus Lerdorf en 1995 como un conjunto de scripts escritos en Perl para controlar los accesos de su página. Fueron llamados Personal Home Page Tools. Más tarde fue ampliando su implementación en C y hacer posibles comunicaciones con bases de datos al tiempo que liberó el código para que usuarios de todo el mundo le ayudasen.
En 1997 se llegó a la versión 2.0 de PHP/FI, segunda escritura de la implementación en C y se cree que varios miles de usuarios por todo el mundo lo utilizaron. 50.000 dominios de la joven internet de aquel entonces lo tenían instalado, alrededor del 1%. Aunque ya había mucha gente colaborando con el proyecto era básicamente el trabajo de una sola persona. PHP/FI 2.0 fue pronto sustituido por las primeras versiones alfa de PHP 3.0.
PHP 3.0 fue reescrito completamente desde cero y se asemeja bastante al PHP con el que se trabaja hoy día. Andi Gutmans y Zeev Zuraski fueron los autores de PHP 3.0. Rasmus Lerdorf y estas dos personas decidieron anunciar como sucesor ofical del PHP/FI al PHP 3.0 que se perfilaba como una herramienta que podría crear aplicaciones comerciales.
La característica principal de PHP 3.0 fue su gran extensibilidad, proveía además una infraestructura sólida y consistente para muchas bases de datos, protocolos y APIs lo que atrajo a muchos desarrolladores al proyecto que enviaron nuevos módulos y extensiones. En PHP 3.0 ya empezamos a ver soporte de sintáxis orientada a objetos.
En 1998 se estimaba que cientos de miles de sitios web lo tenían instalado, sobre un 10% del total. PHP 3.0 fue liberado oficialmente en Junio de 1998, después de muchos meses de pruebas públicas para comprobar su funcionamiento y robustez y también para descubrir errores.
PHP
Como en todo proyecto Open Source, en cuanto sale una Release, los desarrolladores se ponen a trabajar en la siguiente, así pues a finales de 1998 Andi Gutmasn y Zeev Suraski se pusieron a reescribir el núcleo de PHP para mejorar la ejecución de aplicaciones y la modularidad del código base. El nuevo motor diseñado fue llamado Zend Engine y fue introducido a mediadios de 1999. PHP 4.0 fue liberado con este motor en Mayo del 2000. Con soporte para la mayoría de servidores web, sesiones HTTP, características de seguridad y nuevas construcciones del lenguaje.
Más del 20% de servidores de internet tienen instalado un servidor con PHP hoy día.
Existe una mejor implementación del motor de PHP también llamado Zend Engine que precompila las páginas y es mucho más eficiente en aplicaciones grandes, anque es de pago.
PHP 5 fué recientemente liberado con un soporte muy amplio para la programación orientada a objetos, claramente el futuro.
PHP no es un lenguaje que se interprete en el cliente o en el navegador, es un lenguaje que interpreta el servidor y manda la salida en el formato deseado (HMLT, XML…) al navegador. Esto quiere decir que no necesitamos que nuestro navegador tenga ninguna característica especial para poder ver páginas web programadas en PHP.
REFERENCIAS:
(C) PHP Documentation Group Manual oficial de PHP (https://www.php.net/docs.php)
La wikipedia en español (https://es.wikipedia.org/wiki/CGI)
Instalando PHP en nuestro servidor
La instalación en el sistema GNU/Linux debian es más que sencilla, en sus tres versiones actuales (woody, sarge, sid o stable, testing, unstable) tenemos disponible el paquete PHP 4.
Nos haremos superusuarios (root) de la máquina en una consola o en un terminal desde el escritorio, con el comando:
‘su -‘
Haremos una actualización de los paquetes con el comando:
‘apt-get update’
y a continuación instalaremos php con:
‘apt-get install php4’
Suponemos que ya tenemos instalado el servidor web apache, de lo contrario instalaremos apache y php a la vez con:
‘apt-get install apache2 libapache2-php4’
El archivo de configuración estará en el directorio /etc/php4/apache2/ de nuestro sistema y en principio dejaremos todo como el sistema lo ha instalado, ya que no necesitamos tocar las configuraciones para empezar a jugar con PHP.
Más adelante veremos cómo instalar PHP en una máquina que use Microsoft Windows y también una referencia para instalarlo en un servidor MS-IIS.
RFERENCIA:
(C) PHP Documentation Group Manual oficial de PHP (https://es.php.net/install)
Herramientas libres para escribir PHP
Cualquier editor de texto por simple que sea puede ser usado para escribir PHP, desde el omnipresente VI hasta los editores basado en escritorio como NVu, Mozilla Composer, Bluefish o gPHPEdit. Nosotros usaremos durante este curso Bluefish y gPHPEdit ya que el primero es capaz de interpretar códigos de otros muchos lenguajes y en concreto los dos que nos interesan: HTML y PHP, y el segundo está pensado para PHP y ofrece más posibilidades en este sentido que Bluefish.
NVu es un programa muy completo pero aún en una fase de desarrollo muy temprana, es un potente editor WYSIWYG (What You See Is What You Get, o lo que ves es lo que obtendrás), aspira a ser rival del conocido Dreamweaver de Macromedia. Esta desarrollado por Linspire (antigua Lindows). El Mozilla Composer es el editor que el paquete de Mozilla trae para todas las plataformas en las que es posible su ejecución y también está bastante bien, es WYSIWYG pero tiene el problema de que muchas veces añade demasiado código extra a nuestras páginas. Por lo general las ventajas de un WYSIWYG sólo se ven cuando uno se está iniciando en la programación web, más tarde se controla todo mucho más desde un editor corriente, habiendo mucha gente que las programa desde VI, nano o joe.
Para instalar bluefish en nuestro escritorio, ya sea GNOME, KDE, XFCE u otro gestor de ventanas cualquiera seguirmos los pasos que hemos dado para instalar PHP, es decir, iremos a una consola o sacaremos un terminal y nos haremos superusuarios (root).
‘su -‘
Si hace falta haremos un apt-get update y si no instalaremos directamente ‘bluefish’:
‘apt-get install bluefish’
Si estamos en GNOME o KDE veremos que en el menú correspondiente aparecerá el programa Bluefish, en XFCE podemos lanzarlo vía consola o terminal o desde la barra de ejecución.
RFERENCIAS:
Página web de gPHPEdit (https://www.gphpedit.org/)
Página web de Bluefish (https://bluefish.openoffice.nl)
Página web de NVu (https://www.nvu.com)
Página web de Mozilla (https://www.mozilla.org)
Sintaxis, variables y operadores
Un archivo .php no es más que un HTML con unos caracteres especiales empotrados en la parte del código que queremos que el motor de PHP lo interprete. Los expresiones o etiquetas que permiten al motor reconocer el código que va a ejecutar son tres principalmente <?php ?>, <script language=»php»> </script> y <? ?> pares de entrada/salida. Hay otros caracteres que podemos editar en el archivo de configuración php.ini pero no lo haremos ya que la inmensa mayoría de las veces se usa sólo una pareja de etiquetas <?php ?> que es la más estándar y la que nuestros editores bluefish y gPHPEdit reconocen perfectamente coloreando el código, lo que ayuda enormemente a su interpretación. Para empotrar código en XML o XHTML el formato <?php ?> es obligatorio.
Como curiosidad, decir que el PHP también admite las etiquetas ASP/ASP.NET de entrada-salida de código.
Primer script en PHP
Comenzando por el mismo (y odioso) primer “programa” que todo el mundo hace en todo lenguaje también haremos el conocido «HOLA MUNDO». Para hacer este script veremos la primera función, la función echo que representa en pantalla lo que se introduzca dentro de las comillas, y para finalizar la llamada a cualquier función se escribe punto y coma «;», olvidarse el punto y coma es un error muy típico que todo programador ha sufrido muchas veces, el punto y coma solo se puede obviar al final del código, ya que las etiquetas «?>» también indican el final de la función.
Vamos con el ejemplo, primero abrimos los tags (etiquetas) de comienzo de script:
<?php echo «HOLA MUNDO»; ?>
las comillas se pueden sobrentender si en lugar de sacar a pantalla un texto representamos una variable, el ejemplo quedaría así:
<?php
$variable = «HOLA MUNDO»;
echo $variable;
?>
Como vemos, las variables en PHP se declaran con un símbolo dólar delante del nombre de nuestra variable, no hace falta definir el tipo de variable como en otros lenguajes (C, Pascal …) simplemente se declara ésta y se le da un valor.
La función echo también puede sacar por pantalla código HTML, por ejemplo, si queremos que nuestro «HOLA MUNDO» salga en lugar de con la letra predefinida con una “Times New Roman” a un tamaño distinto del predefinido, como el «4», pondremos esto:
<?php echo «<font size=»4″ face=»Times New Roman, Times, serif»><b>HOLA MUNDO</b></font>»; ?>
La cuestión de porqué se ponen barras antes de las comillas es simple, lo que queremos es que escriba en pantalla literalmente lo que hay entre las comillas, si ponemos entre medias del texto unas comillas la función creerá que hasta ese punto es donde tiene que procesar, para evitar esto se ponen las barras delante de las comillas que queremos que procese.
En PHP tenemos varias maneras de mostrar la salida de una cadena o variable, usaremos echo ya que es muy fácil y se ha comprobado que es más rápida que las demás otras dos, print, printf. La función print sirve sólo para imprimir una cadena, mientras que echo es capaz de imprimir varias. La función printf es engorrosa por tener que andar definiendo el formato de salida de las variables, ej:
<?php
printf(«Existe una minuscula diferencia entre %f y %d», 2.9999, 3);
?>
La inserción de comentarios dentro del código PHP es igual que en C o C++ pudiéndose comentar una línea:
<?php //Esto es un comentario de una sola linea ?>
o bien comentándose un párrafo:
<?php
/*
Este comentario
abarca desde el
comienzo de la
barra asterisco
hasta el final
*/
?>
REFERENCIAS:
(C) PHP Documentation Group echo (https://es.php.net/manual/es/function.echo.php)
(C) PHP Documentation Group print (https://es.php.net/manual/es/function.print.php)
(C) PHP Documentation Group printf (https://es.php.net/manual/es/function.printf.php)
Instrucciones básicas
Como ya hemos dicho PHP es un lenguaje de programación interpretado por el servidor en el momento de la demanda de carga de una página por un usuario.
La forma de programar en PHP, es muy parecida a C o javascript, lenguajes no desconocidos para nosotros. Para que el contenido no sea sólo texto PHP se ve mezclado frecuentemente con etiquetas HTML para que el diseño de la web sea más atractivo a la vista.
<?php
$a=1;
if($a == 1){
?>
<center><b>a vale 1</b></center>
<?php
}
else{
?>
<center><b>a NO vale 1</b></center>
<?php
}
?>
Vemos en este ejemplo que el HTML y el PHP van mezclados y obtendremos una salida u otra dependiendo del valor que tenga a. Si a=1 la página se vería asi:
a vale 1
si a es distinto de 1 se vería asi:
a NO vale 1
La tendencia actual es a separar el código PHP (programación) del HTML (diseño), ya que es una labor que hoy hacen personas distintas en un gran proyecto. Eso se consigue con templates o plantillas y con clases, ya veremos como funcionan.
Tipos de variables
PHP soporta ocho tipos primitivos.
Cuatro tipos escalares:
* boolean (verdadero/falso, sí/no, 1/0) se trata como TRUE o FALSE (1 o 0)
* integer (número entero)
* float (número en coma-flotante, también conocido como ‘double’)
* string (cadena de texto)
Dos tipos compuestos:
* array (matriz de valores)
* object (objetos)
Y finalmente dos tipos especiales:
* resource (variable especial, que contiene una referencia a un recurso externo)
* NULL (variable no tiene valor)
PHP dispone de funciones que sirven para averiguar en cada momento si una variable es nula o que tipo de dato contiene (gettype($mivar);, is_int($entero) ), pongamos un ejemplo con gettype():
<?php
$a = TRUE;
$b = gettype($a);
echo $b;
?>
Esto nos devolverá «boolean», sin embargo si ponemos entre comillas («TRUE») obtendremos la salida «string» ya que no identifica la variable como un booleana sino como una cadena de texto.
Constantes
En PHP se pueden definir constantes:
define («saluda», «Buenas tardes.»);
En cualquier parte del código saludo siempre va a valer lo mismo, no puede cambiar su valor. Esto es útil para información estática pero modificable como rutas a archivos, o cadenas de conexión a bases de datos. No todos los nombres de constantes estan libres PHP dispone de varias constantes predifinidas, por ejemplo PHP_VERSION.
<?php
define(«saludo», «hola majo»);
echo saludo;
?>
Como vemos «saludo» no lleva ningún tipo de comillas ni el símbolo $ de variable porque no es una variable normal (podríamos tener la variable $saludo) ni queremos que se escriba literalmente «saludo».
Estructuras de control
Las estructuras típicas de control de flujo son el if/elseif/else, el while y el do … while, el for y el foreach, el break, el continue y el switch. Cada una de estas estructuras es controlada por una o más variables.
if/elseif/else
La estructura if corresponde al si del pseudocódigo, puede incluir varias variables en la condición, al igual que elseif que sería un si_no, si en pseudocódigo o también acompañada de un else, si_no en pseudocódigo, que no lleva variables o parámetros de control.
<?php
if (expresión)
sentencia
?>
La expresión o variable es evaluada como booleana, es decir, como VERDADERA o FALSA.
Una típica estructura de control de este tipo en php podría ser:
<?php
if($variable == «SI»){
echo «La variable vale SI»;
}
elseif($variable == «NO»){
echo «La variable vale NO»;
}
else{
echo «No sabemos qué valor tiene la variable»;
}
?>
Cuando estas estructuras sólo tienen una sentencia implicada en su ejecución podemos ahorrarnos las llaves:
<?php
if($variable == «SI»)
echo «La variable vale SI»;
?>
pero conviene ponerlos para ver más claramente cuando se cierra y abre cada estructura. Un error muy frecuente es poner al final del if un punto y coma ; lo que invalida el control de la estructura.
<?php
$variable = «NO»;
if($variable == «SI»);
//esto no funcionará
echo «La variable vale SI»;
?>
El echo se ejecutará siempre independientemente de la estructura de control.
REFERENCIAS:
(C) PHP Documentation Group if (https://es.php.net/manual/es/print/control-structures.php#control-structures.if)
(C) PHP Documentation Group else (https://es.php.net/manual/es/print/control-structures.else.php)
(C) PHP Documentation Group elseif (https://es.php.net/manual/es/print/control-structures.elseif.php)
while
La estructura while corresponde al mientras del pseudocódigo, es controlada por una variable de condición. El comportamiento es igual al que toman estos bucles en C, siendo el tipo de bucle más fácil de implementar.
while (parametro) sentencia
La estructura while le dice a PHP que ejecute la o las sentencias anidadas dentro de su campo de control mientras la variable o parámetro de control sea verdadera/o. El valor de la variable o parámetro de control se evalúa al principio del bucle antes de ejecutar las sentencias. Si el resultado de la evaluación es falso la primera vez que se entra en el bucle no se ejecutará ninguna sentencia.
Como con la estructura if, se pueden anidar varias sentencias dentro del bucle while con llaves o bien con la forma alternativa:
<?php
$i = 1;
while ($i <= 10):
echo $i;
$i++;
endwhile;
?>
ó bien mediante llaves:
<?php
$i = 1;
while ($i <= 10) {
echo $i++;
}
?>
REFERENCIAS:
(C) PHP Documentation Group while (https://es.php.net/manual/es/print/control-structures.while.php)
do … while
Los bucles do … while son similares a los bucles while salvo que las condiciones de repetición del bucle son comprobadas al final del bucle en lugar de al principio. La diferencia principal es que se garantiza la ejecución del bucle al menos una vez.
Existe una sóla sintaxis para los bucles do … wile.
<?php
$i = 0;
do {
print $i;
} while ($i>0);
?>
En el ejemplo de arriba, el bucle sólo se ejecutará una vez ya que cuando se comprueba la condición, ésta resulta ser falsa:
$i es igual a ‘0’ y no mayor que ‘0’
<?php
$i = 10;
do {
print $i;
$i–;
} while ($i>0);
?>
Este script sí que nos haría una cuenta atrás de 10 a 1.
REFERENCIAS:
(C) PHP Documentation Group do … while (https://es.php.net/manual/es/print/control-structures.do.while.php)
for
La estructura de control de flujo for corresponde al para de pseudocódigo y está controlada por tres parámetros, uno de comienzo, uno de fin y uno de paso incremental.
for (expresión1; expresión2; expresión3) sentencia
La primera expresión (‘expresión1’) se evalúa incondicionalmente una vez al principio del bucle. Al comienzo de cada iteración, se evalúa ‘expresión2’. Si es evaluada como VERDADERA el bucle continúa y las sentencias anidadas se ejecutan. Si es evaluada como FALSA la ejecución del bucle finaliza.
Al final de cada iteración, se evalúa ‘expresión3’.
Cada una de las expresiones puede estar vacía. Que ‘expresión2’ esté vacía significa que el bucle debería correr indefinidamente (PHP implicitamente lo considera como VERDADERA, al igual que C). Esto puede que no ser tan inútil como podría pensarse, puesto que a menudo se quiere salir de un bucle usando una sentencia break condicional en vez de usar la condición de for.
Ejemplo típico de estructura for:
<?php
$contador = 10;
for ($contador=0; $contador<10; $contador++){
echo «<br>numero $contador; <br>»;
}
?>
Con la estructura anterior pasaremos por todos los números del 0 al 9, si queremos incluir el 10 cambiaríamos el menor_que por un menor_que o igual_que:
for ($contador=0; $contador<10; $contador++){
por
for ($contador=0; $contador<=10; $contador++){
En función de las necesidades de nuestro script cambiaremos los incrementos por decrementos, los mayores_que por menores_que o iguales, etc.
La forma alternativa de declarar un bucle for es la siguiente:
<?php
$contador = 10;
for ($contador=0; $contador<10; $contador++):
echo «<br>numero $contador; <br>»;
endfor;
?>
aunque procuraremos usar la forma de declarar con llaves ya que está más extendida y en un código amplio las llaves ayudan mucho a identificar los bucles.
REFERENCIAS:
(C) PHP Documentation Group for (https://es.php.net/manual/es/print/control-structures.for.php)
foreach
La construcción foreach es un método construido específicamente para operar sobre matrices y vectores, esto facilita mucho la utilización de este tipo de variables. La sentencia devuelve un error si se usa sobre cualquier tipo de datos que no sean matrices o vectores.
Hay dos posibles sintaxis para foreach:
foreach(expresion_vector as $valor) sentencia
foreach(expresion_vector as $llave => $valor) sentencia
Cada una de las sintaxis recorre uno a uno los elementos que forman el array dado por expresion_vector. En cada iteración, el valor almacenado en expresion_vector se asigna a $valor, de forma que al finalizar el bucle todos los elementos de expresion_vector quedará almacenado en $valor.
La segunda sintaxis hace lo mismo, salvo que sólamente asignará la clave del elemento que esté recorriendo en ese momento en la variable $llave. Cuando nos referimos a la clave del elemento estamos haciendo referencia a un array multidimensional en el que los elementos almacenados están especificados en distintos campos. Esto resulta muy útil cuando almacenamos elementos en un array que tienen distintos parámetros que interesan ser referenciados de forma distinta (un buen ejeplo sería una agenda telefónica en el que podríamos distinguir la clave nombre y la clave teléfono).
Cuando foreach comienza por primera vez a ejecutarse, el puntero interno a la matriz o vector se reinicia automáticamente al primer elemento de la matriz. Esto hace que no sea necesario llamar a reset() antes de un bucle foreach. La estructura foreach trabaja con una copia de la matriz y no con ella en sí, por eso el puntero de la lista no se modifica a diferencia de la estructura each(), además los cambios en el elemento de la matriz devuelto no afectan a la matriz original.
Ejemplo de uso de foreach:
<?php
$vector = array(«uno», «dos», «tres»);
//ejemplo con while
reset ($vector);
while (list(, $valor) = each ($vector)) {
echo «Valor: $valor<br>»;
}
//ejemplo con foreach
foreach ($vector as $valor) {
echo «Valor: $valor<br>»;
}
?>
En este ejemplo los dos scripts hacen lo mismo, pero como vemos es más sencillo el implementado con foreach ya que no tenemos que acordarnos de resetear el vector.
Otros ejemplos más completo de foreach:
<?php
// foreach ejemplo 1: sólo valor
$a = array(1, 2, 3, 17);
foreach($a as $v) {
echo «Valor actual de $a: $v.<br>»;
}
?>
<?php
// foreach ejemplo 2: valor (con clave impresa para mostrar)
$a = array(1, 2, 3, 17);
$i = 0; // sólo para propósitos demostrativos
foreach($a as $v) {
echo «$a[$i] => $v.<br>»;
$i++;
}
?>
<?php
// foreach ejemplo 3: clave y valor
$a = array(
«uno» => 1,
«dos» => 2,
«tres» => 3,
«diecisiete» => 17
);
foreach($a as $k => $v) {
echo «$a[$k] => $v.<br>»;
}
?>
<?php
// foreach ejemplo 4: matriz multi-dimensional
$a[0][0] = «a»;
$a[0][1] = «b»;
$a[1][0] = «y»;
$a[1][1] = «z»;
foreach($a as $v1) {
foreach ($v1 as $v2) {
echo «$v2<br>»;
}
}
?>
<?php
// foreach ejemplo 5: matriz dinámica
foreach(array(1, 2, 3, 4, 5) as $v) {
echo «$v <br>»;
}
?>
REFERENCIAS:
(C) PHP Documentation Group foreach (https://es.php.net/manual/es/control-structures.foreach.php)
break
La sentencia break hace que se finalice una estructura de control, sólo es aplicable en bucles for, while, o switch. Accepta un parámetro opcional, el cual determina de cuantas estructuras de control hay que escapar.
Ejemplo de uso de break:
<?php
$i = 0;
while (++$i) {
switch ($i) {
case 5:
echo «Alto 5<br>»;
break 1; // Salir sólo del switch
case 10:
echo «Alto 10; saliendo<br>»;
break 2; // Salir del bucle switch y del while
default:
break;
}
}
?>
Al ejecutar este script veremos que se para en los valores «5» y «10», si queremos comprobar todos los valores sólo tendremos que introducir una pequeña modificación al script entre el while y el switch:
while (++$i) {
echo «<b>$i</b><br>»;
switch ($i) {
La mayoría de las veces break se utiliza junto con switch y sin el parámetro opcional.
REFERENCIAS:
(C) PHP Documentation Group break (https://es.php.net/manual/es/print/control-structures.break.php)
continue
La sentencia continue se usa dentro de la estructura de un bucle para saltar el resto de la iteración actual del bucle y continuar la ejecución al comienzo de la siguiente iteración.
Hay que tener en cuenta que en PHP switch es considerada como una estructura de bucle por continue.
continue accepta un parámetro opcional, el cual determina cuantos niveles (bluces) hay que saltar antes de continuar con la ejecución.
<?php
$i = 0;
while ($i++ < 5) {
echo «$i<br>»;
echo «Fuera<br>»;
while (1) {
echo » En el medio<br>»;
while (1) {
echo » Dentro<br>»;
continue 3;
}
echo «Esto nunca se imprime.<br>»;
}
echo «Y esto tampoco.<br>»;
}
?>
En bucle while que tienen un «1» dentro, es equivalente a poner TRUE y se refiere a la expresión del primer ‘while’, ser menor que 5, si cambiamos el «1» por un «0» lo que pasaría es que no se ejecutaría ninguno de los dos bucles y sí los dos echo(s) que están debajo. Realmente la estructura continue se usa muy poco en scripts normales o de programadores noveles.
REFERENCIAS:
(C) PHP Documentation Group continue (https://es.php.net/manual/es/print/control-structures.continue.php)
switch
La sentencia switch es equivalente a una serie de sentencias if en la misma expresión. En muchas ocasiones se quiere comparar la misma variable (o expresión) con nuchos valores diferentes, y ejecutar una parte de código distinta dependiendo de a qué valor es igual. Para ello sirve la sentencia switch.
Nota: Tener en cuenta que al contrario que otros lenguajes de programación, continue se aplica a switch y funciona de manera similar a break. Si teneis un switch dentro de un bucle y deseais continuar con el paso siguiente en el bucle externo, usar continue 2.
Los siguientes dos ejemplos son dos modos distintos de escribir la misma cosa, uno usa una serie de sentencias if, y el otro usa la sentencia switch:
<?php
$i = 1;
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»;
}
echo «<br>»
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;
}
?>
Es importante entender cómo se ejecuta la sentencia switch para evitar errores. La sentencia switch ejecuta línea por línea (realmente, sentencia a sentencia). Al comienzo, no se ejecuta código, sólo cuando se encuentra una sentencia case con un valor que coincide con el valor de la expresión switch PHP comienza a ejecutar las sentencias. PHP continúa ejecutando las sentencias hasta el final del bloque switch, o la primera vez que vea una sentencia break. Si no se escribe una sentencia break al final de una lista de sentencias case, PHP seguirá ejecutando las sentencias del siguiente case. Por ejemplo:
<?php
switch ($i) {
case 0:
echo «i es igual a 0<br>»;
case 1:
echo «i es igual a 1<br>»;
case 2:
echo «i es igual a 2<br>»;
}
?>
Aquí, si la variable $i es igual a ‘0’, PHP ejecutaría todas las sentecias echo. Si la variable $i es igual a ‘1’, PHP ejecutaría las últimas dos sentencias echo y sólo si $i es igual a ‘2’, se obtendría la conducta ‘esperada’ y solamente se mostraría ‘i es igual a 2’. Así, es importante no olvidar las sentencias break, incluso aunque pueda querer evitar escribirlas intencionadamente en ciertas circunstancias.
En una sentencia switch, la condición se evalúa sólo una vez y el resultado se compara a cada sentencia case. En una sentencia elseif, la condición se evalúa otra vez. Si la condición es más complicada que una comparación simple y/o está en un bucle estrecho, un switch puede ser más rápido.
La lista de sentencias de un case puede también estar vacía, lo cual simplemente pasa el control a la lista de sentencias del siguiente case.
<?php
switch ($i) {
case 0:
case 1:
case 2:
echo «i es menor que 3, pero no es negativo»;
break;
case 3:
echo «i es 3»;
}
?>
Un caso especial es el default case. Este case coincide con todo lo que no coincidan los otros case. Por ejemplo:
<?php
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;
default:
echo «i es distino de 0, 1 y 2»;
}
?>
La expresión case puede ser cualquier expresión que se evalúe a un tipo simple, es decir, números enteros o en coma flotante y cadenas de texto. No se pueden usar aquí ni matrices/arrays/vectores ni objetos a menos que se conviertan a un tipo simple.
También existe sintaxis alternativa para switch.
<?php
switch ($i):
case 0:
echo «i es igual 0»;
break;
case 1:
echo «i es igual a 1»;
break;
case 2:
echo «i es igual a 2»;
break;
default:
echo «i es distinto de 0, 1 o 2»;
endswitch;
?>
REFERENCIAS:
(C) PHP Documentation Group switch (https://es.php.net/manual/es/print/control-structures.switch.php)
Incluyendo archivos include() y require()
Si tenemos una o varias páginas en las que queremos que otras páginas sean incluídas ya que contienen variables o funciones que queremos utilizar, no tenemos por qué escribir en todas ellas las variables, podemos usar las funciones include(‘archivo’) o require(‘archivo’) y automáticamente serán incluidas dentro de nuestra página, no se muostrará el archivo pero se evalúa con lo que el script queda más limpio y podemos hacer uso de ese o esos archivos con sus respectivos scripts, funciones o variables.
La única diferencia entre include() y require() es que el primero continuará la ejecución del script si no encuentra el archivo pedido produciendo un Warning y el segundo no continuará provocando un Error Fatal, por lo que si el archivo es importante para la ejecución del script utilizaremos la segunda forma.
Ejemplo de uso:
Archivo variables.php
<?php
$color = «azul»;
$tamanio = «grande»;
$forma = «cubo»;
?>
Archivo que llama a variables.php
<?php
include(‘variables.php’);
echo «Es un $forma de color $color y es $tamanio»;
?>
Como vemos podemos usar todas las variables que están en el archivo variables.php. Para llamar al archivo que queramos tanto include() como require() necesitan que éste vaya entre comillas simples o dobles («archivo» ó ‘archivo’) ya que sin ellas obtendremos un error.
También tenemos la función include_once(‘archivo’) y require_once(‘archivo’) cuya única diferencia con include y require() respectivamente es que si el archivo ya ha sido incluido anteriormente no volverá a hacerlo.
REFERENCIAS:
(C) PHP Documentation Group include (https://es.php.net/manual/es/print/function.include.php)
(C) PHP Documentation Group require (https://es.php.net/manual/es/print/function.require.php)
(C) PHP Documentation Group include_once (https://es.php.net/manual/es/print/function.include-once.php)
(C) PHP Documentation Group require_once (https://es.php.net/manual/es/print/function.require-once.php)
Funciones
Una función es un conjunto de código agrupado con la intención de ejecutarse varias veces, o con distintos parámetros o variables.
<?php
function prueba($arg1, $arg2) {
echo «Función de ejemplo.n»;
echo «Argumento 1 vale: $arg1<br>»;
echo «Argumento 2 vale: $arg2<br>»;
if ($arg1 < $arg2){
return true;
}
else {
return false;
}
}
?>
Esta función puede recibir como parámetros dos variables numéricas, las cuales se imprimen por pantalla, para después hacer la comparación de ámbas. La sentencia especial return sirve para devolver valores después de la ejecución de la función desde el lugar donde fue invocada. En nuestro ejemplo devuelve true verdadero si argumento1 es menor que argumento2 y falso en el resto de los casos.
Formas de usar una función
Para ejecutar el código de una función simplemente ponemos su nombre y entre paréntesis los parámetros que necesita
<?php
$valor_devuelto = prueba(5,10);
if($valor_devuelto){
echo «Argumento 1 es menor que Argumento 2»;
}
else{
echo «Argumento 1 es mayor o igual que Argumento 2»;
}
?>
Este pequeño ejemplo junto con la función declarada más arriba imprimirá por pantalla lo siguiente.
Función de ejemplo.
Argumento 1 vale: 5
Argumento 2 vale: 10
Argumento 1 es menor que Argumento 2
Devolviendo valores desde funciones return()
Si en una función queremos devolver un valor el modo de hacerlo es mediante la función return(parámetro), donde parámetro puede ser símplemente un «1» para indicar que todo fue correctamente, un «0» para indicar un error o una variable donde devolvamos el valor de lo procesado por la función.
Veamos un ejemplo:
<?php
$valor = funcion();
?>
donde $valor es el resultado devuelto por la función o bien pasando un parámetro o una variable a la función:
<?php
$valor = funcion($variable);
?>
Las funciones pueden ser llamadas desde include() o require() o directamente desde el script principal, no influye a la hora de ejecutar las funciones y devolver los valores.
REFERENCIAS:
(C) PHP Documentation Group return (https://es.php.net/manual/es/print/function.return.php)
Clases
Como peldaño inmediatamente superior a las funciones se encuentran las clases en el código PHP. Esto es lo que hace de PHP un entorno orientado a objetos (POO) como los grandes lenguajes de desarrollo (java).
Ejemplo de una clase sencilla:
<?php
class MiPrimeraClase {
var $nombre;
function dimeNombre($nombre_leido){
$this->nombre = $nombre_leido;
}
function saluda() {
echo «Hola » . $this->nombre;
}
}
?>
Esta es una clase muy básica que, por ejemplo, guardaríamos en el archivo miprimeraclase.inc.php Para después usarla en cuantos documentos necesitemos sin escribirla de nuevo.
Una clase puede contener constantes, variables funciones y otras clases. Para nuestra primera clase hemos usado una variable $nombre y dos funciones, a una le pasamos una cadena de texto y otra que imprime en salida estandar la frase «Hola $nombre».
Para usarla en otro documento, la incluimos y creamos una instancia de esa clase de esta forma:
<?php
include(‘miprimeraclase.inc.php’);
$miclase = new MiPrimeraClase;
$miclase->dimeNombre(«Mundo»);
$miclase->saluda();
?>
El código anterior nos mostraría por pantalla Hola Mundo. Lo que hemos hecho es incluir el código de la clase (siempre al principio del código), crear una instancia de la clase miclase pasar una cadena de texto que la clase almacena como $nombre y para terminar mandar la órden de ejecutar la función saluda().
Este ejemplo no es nada productivo, pero ahora imginamos que creamos una clase que iteraccione con una base de datos y se encargue de hacer de contador de visitas, administrar entradas de usuarios, sessiones y tendríamos una importante herramienta que ahorraría muchas líneas de código. La potencia de las clases la pone la imaginación de cada uno.
Existen en internet muchos sitios con clases php listas para incluir y usas, uno de ellos es www.phpclasses.org, es necesario darse de alta para descargar alguna clase.
Matrices, arrays o vectores
Una matriz es un tipo de variable que permitirá almacenar múltiples valores en una única variable. El término array inglés significa cadena, y es comunmente utilizado en los lenguajes de programación al referirnos a vectores o secuencias de datos. Nos referiremos a matrices con el término array ya que supone una extrapolación a varias dimensiones de un vector.
Los arrays suponen un gran ahorro en la programación ya que nos permite tratar de una forma sistemática secuencias de datos que de otra forma resultarían muy complejos. La sintaxis para construir un array es la siguiente:
$invierno = array («Enero», «Febrero», «Marzo»);
Según esta sintaxis almacenamos en el array $invierno los valores que mandamos a la función array. Este array asigna un número a cada elemento de forma automática, comenzando por el cero.
En el siguiente ejemplo veremos como referenciar los diferentes valores de nuestro array
<?php
$invierno = array («Enero», «Febrero», «Marzo»);
echo («Uno de «.$invierno[0].», dos de «.$invierno[1].», tres de «.$invierno[2].»…»);
?>
Existen otras formas de construir un array y de añadir nuevos elementos. En este caso se almacenan elemento a elemento.
$invierno[] = «Enero»;
$invierno[] = «Febrero»;
$invierno[] = «Marzo»;
Este código funciona exactamente igual que el anterior. Aunque parezca una forma un tanto repetitiva y poco eficaz de construir un vector supone unas ventajas cuando los elementos que se almacenan en el vector son producto de la interacción con el usuario.
Los elementos se irán almacenando desde el índice [0]. En este ejemplo Enero será el elemento 0 y Marzo será el 2.
Hay una forma muy útil de almacenar información a través de arrays teniendo en cuenta el tipo de información que deseamos almacenar. Se tratan de arrays asociativos y consisten en almacenar la información a través de claves que permitirán acceder a la información almacenada de forma más intuitiva. Lo vemos en el siguiente ejemplo:
$ficha = array(
nombre=>»Gonso»,
direccion=>»Alamillos»,
telefono=>»10494676″,
edad=>»24″
);
La forma de acceder a este array será a través de las claves que hemos definido. Por ejemplo, acceder al nombre sería: $ficha[nombre].
Los arrays multidimensionales nos permitirán construir arrays construidos por otros arrays. Aunque parece un tanto endogámico resulta muy útil. Supongamos que queremos hacer una agenda, definiríamos el array $agenda de la forma habitual:
$agenda = array();
y rellenamos los datos de forma referenciada por claves:
$agenda = array(
array( nombre=>»Gonso»,
direccion=>»Alamillos»,
telefono=>»10494676″,
edad=>»24″),
array( nombre=>»Peggy»,
direccion=>»Don Sancho»,
telefono=>»10494665″,
edad=>»22″),
array( nombre=>»Cremy»,
direccion=>»Don Sancho»,
telefono=>»1214665″,
edad=>»25″)
);
Para extraer la información de los arrays multidimensionales llamaremos al array $agenda con el número que corresonda al array que queremos referenciar y la clave que queremos. Por ejemplo, si quieremos obtener el teléfono de Peggy lo haríamos de la siguiente manera:
echo $agenda[1][telefono];
En lo siguientes apartados se explica el bucle foreach que facilita mucho el uso de vectores.
Ficheros
De forma muy parecida a C, PHP permite acceder a lectura y escritura de ficheros.
En PHP hay varias funciones para éste cometido.
fopen
fopen — Abre un fichero o una URL
Síntaxis:
int fopen (string nombre_fichero, string modo [, int use_include_path])
Esta función puede abrir un archivo local o remoto. Los protocolos remotos soportados son http y ftp. El modo puede ser:
r Apertura para sólo lectura; ubica el apuntador de archivo al comienzo del mismo.
r+ Apertura para lectura y escritura; ubica el apuntador de archivo al comienzo del mismo.
w Apertura para sólo escritura; ubica el apuntador de archivo al comienzo de éste y lo trunca a una longitud de cero. Si el archivo no existe, intenta crearlo.
w+ Apertura para lectura y escritura; ubica el apuntador de archivo al comienzo de éste y lo trunca a una longitud cero. Si el archivo no existe, intenta crearlo.
a Apertura para sólo escritura; ubica el apuntador de archivo al final del mismo. Si el archivo no existe, intenta crearlo.
a+ Apertura para lectura y escritura; ubica el apuntador de archivo al final del mismo. Si el archivo no existe, intenta crearlo.
x Creación y apertura para sólo escritura; ubica el apuntador de archivo al comienzo de éste. Si el archivo ya existe, la llamada a fopen() fallará devolviendo FALSE y generando un error de nivel E_WARNING. Si el archivo no existe, intenta crearlo. Esto es equivalente a especificar las banderas O_EXCL|O_CREAT en la llamada de sistema open(2) interna. Esta opción es soportada en PHP 4.3.2 y versiones posteriores, y sólo funciona con archivos locales.
x+ Creación y apertura para lectura y escritura; ubica el apuntador de archivo al comienzo de éste. Si el archivo ya existe, la llamada a fopen() fallará devolviendo FALSE y generando un error de nivel E_WARNING. Si el archivo no existe, intenta crearlo. Esto es equivalente a especificar las banderas O_EXCL|O_CREAT en la llamada de sistema open(2) interna. Esta opción es soportada en PHP 4.3.2 y versiones posteriores, y sólo funciona con archivos locales.
fwrite
fwrite — Escribe ficheros en modo binario
Síntaxis:
int fwrite (int fp, cadena string [, int longitud])
fwrite() escribe el contenido de cadena al fichero apuntado por fp. Si se da el argumento longitud, la escritura acaba antes de que longitud bytes sean escritos o se alcance el final de string, lo que ocurra primero.
fread
fread — Lee archivos en modo binario
Síntaxis:
string fread (int fp, int longitud)
fread() lee hasta longitud bytes del apuntador de fichero referenciado por fp. La lectura acaba cuando longitud bytes se han leido o se alcanza EOF, lo que ocurra primero.
A partir de estas tres funciones simples ya podemos realizar el primer ejemplo de acceso a ficheros.
<?php
$archivo=»/var/www/web/datos.txt»;
//comprobamos si podemos leer el archivo y creamos el puntero
if (!($fp=fopen($archivo,»r»))){
die(«No se encontro $archivo»);
}
//lo mostramos por pantalla
$texto=fread($fp,20);
fclose($fp);
echo «El texto que tiene el archivo es: <b>$texto</b>»;
//lo guardamos con otro valor
$fp=fopen($archivo,»w»);
$texto=»Otro texto…»;
fwrite($fp,$texto);
//cerramos el puntero
fclose($fp);
?>
Upload de ficheros al servidor
Otra opción muy interesante en cualquier script PHP es la posibilidad de subir ficheros al servidor. Necesitamos un formulario HTML que tenga lo opción de seleccionar fichero y un script PHP que lo recoja:
<?php
if ($_POST[‘subir’] != «si»){
?>
<form action=»subearchivo.php» method=»post» enctype=»multipart/form-data»>
<br>
<b>Enviar un fichero: </b>
<br><br><br>
<input name=»userfile» type=»file»>
<input type=»hidden» name=»subir» value=»si»>
<br><br><br>
<input type=»submit» value=»Enviar»>
</form>
<?php
}
else{
if (move_uploaded_file($HTTP_POST_FILES[‘userfile’][‘tmp_name’],
«/tmp/» . $HTTP_POST_FILES[‘userfile’][‘name’]))
{
echo «El archivo ha sido cargado correctamente.<br>
<a href=’subearchivo.php’>Subir Otro</a>»;
}
else{
echo «Ocurrió algún error al subir el fichero. No pudo guardarse.»;
}
}
?>
Cookies
Las cookies (galletas) son pequeños archivos que intercambian el navegador web y el servidor. Su finalidad es que el navegador y el servidor intercambinen información y el servidor pueda saber cuál es el cliente al que debe enviarla.
Su funcionamiento es muy básico, el servidor envía un cookie al navegador y este la almacena hasta que caduque o se borre manualmente. Si el servidor durante esa visita a la web o durante otra (puede ser en distintos días) necesita la información el navegador se la envía y el servidor la valida.
Cómo usar las cookies
El manejo de cookies en PHP se realiza mediante el uso de la función setcookie, esta función esta disponible a partir de la versión 3 de PHP.
Síntaxis:
int setcookie (string Nombre [, string Valor
[, int Expire [, stringPath
[, string Dominio [, int Secure]]]]])
Setcookie() define una cookie que es enviada junto con el resto de la información de la cabecera(header). Las cookies deben ser enviadas antes de cualquier etiqueta (tag) de html, por lo tanto deberemos realizar la llamada a estas funciones antes de cualquier etiqueta <HTML> o <HEAD>. Esta es una restricción de las cookies no de PHP.
Todos los argumentos excepto el nombre son opcionales.
Nombre. Nombre de la cookie. Si creamos una cookie solamente con el nombre, en el cliente se eliminará la cookie que exista con ese nombre. También podemos reemplazar cualquier argumento con una cadena vacía («»).
Value. Valor que almacenará la cookie en el cliente.
Expire. El argumento expire es un argumento entero que indica la hora en que se eliminara la cookie. Normalmente se usa time() + N. segundos de duración, para especificar la duración de una cookie.
Path. Subdirectorio en donde tiene valor la cookie.
Dominio. Dominio en donde tiene valor la cookie. Si ponemos como dominio www.domain.com la cookie no se transmite para domain.com, mientras que si ponemos domain.com la cookie se transmite tanto para domain.com como para www.domain.com.
Secure. El argumento secure indica que la cookie solo se transmitirá a través de una conexión segura HTTPS.
Ejemplo:
<?php
setcookie(«usuario», «SOLEUP», time()+3600,»/»,»soleup.eup.uva.es»);
?>
Para que el script de PHP (el servidor), recupere el valor de la cookie se lee desde el objeto $_COOKIE[‘nombre_cookie’].
Ejemplo:
<?php
echo «El valor de la cookie usuario es: » . $_COOKIE[‘usuario’];
?>
Sesiones
Requiere tener las cookies del navegador activadas.
Las sesiones consisten en mantener datos en un sitio o página web a lo largo de un tiempo, tras el cual son destruidos, son ampliamente usados en sistemas de autenticación y registros.
El funcionamiento es sencillo, a cada visitante, diferenciados por el navegador que usen, se le asigna un identificador único llamado session id o identificador de sesión. Este valor es almacenado en una cookie o bien se propaga en la URL y se hace visible al usuario a través del navegador.
Cuando un visitante accede a una web que tiene scripts para tratar las sesiones, PHP comprobará si la variable session.auto_start está puesto a 1 o bien se puede activar mediante session_start() y/o session_register(), este último se considera obsoleto, si ya tiene un identificador de sesión se recrearán las variables que se habían guardado anteriormente.
REFERENCIAS:
(C) PHP Documentation Group sesiones (https://es.php.net/manual/es/print/ref.session.php)
Inicio de sesión
Para iniciar una sesión que no tenga nombre concreto se ha de llamar a la función session_start();
<?php
session_start();
?>
para llamar a una sesión con un nombre concreto deberemos llamar antes a la función session_name([cadena]);
<?php
session_name(«MiSesion»);
session_start();
?>
aunque lo anterior no se suele usar para sitios pequeños o sitios que no deban manejar muchas variables de sesión y deban distinguir entre unas sesiones y otras.
REFERENCIAS:
(C) PHP Documentation Group session-start (https://es.php.net/manual/es/print/function.session-start.php)
(C) PHP Documentation Group session-name (https://es.php.net/manual/es/print/function.session-name.php)
Variables de sesión
Las variables de una sesión son globales, es decir, en cualquier momento de un script, de una página o de un sitio web entero podemos llamarlas si tenemos la sesión activa. Para registrar una variable de sesión antiguamente se usaba session_register([cadena]); o bien $HTTP_SESSION_VARS[cadena].
<?php
$monstruo = «Verde, grande y viscoso.»;
session_register(«monstruo»);
$HTTP_SESSION_VARS[«princesa»] = «Bella y cautiva en la torre»;
?>
pero está obsoleto y se prefiere siempre el uso de $_SESSION[«variable»]
<?php
$_SESSION[‘variable’] = «SI»
?>
Son tratadas como variables normales y corrientes, pueden tener valores booleanos, enteros, cadenas, etc.
Para destruir una variable de sesión concreta se usa unset($variable):
<?php
unset ($_SESSION[‘variable’]);
?>
pero si queremos destruir todas las variables de sesión a la vez usaremos session_unset():
<?php
session_unset();
?>
REFERENCIAS:
(C) PHP Documentation Group registro de variables de sesión (https://es.php.net/manual/es/print/reserved.variables.php#reserved.variables.session)
(C) PHP Documentation Group destrucción de variables de sesión (https://es.php.net/manual/es/print/function.unset.php)
(C) PHP Documentation Group destrucción todas las variables de sesión (https://es.php.net/manual/es/print/function.session-unset.php)
Cierre de sesión
El cierre de una sesión se hace mediante la función session_destroy(); que destruye todos los datos guardados en una sesión pero no destruye ninguna de las variables globales asociadas a la sesión o a las cookies.
<?php
session_destroy();
?>
La función devuelve TRUE si se ha destruido la sesión correctamente y FALSE si ha habido algún problema al intentarlo.
REFERENCIAS:
(C) PHP Documentation Group session-destroy (https://es.php.net/manual/es/print/function.session-destroy.php)
MySQL
¿Qué es una base de datos relacional?
Una base de datos es una estructura ordenada de información. Puede ir desde una lista de la compra hasta una galería de la más ámplia información corporativa de una empresa. Para poder acceder a éstos datos y al equipo que los contiene se necesita un gestor/servidor de bases de datos como por ejemplo MySQL.
Una base de datos relacional, entonces es una aplicación capaz de almacenar grandes cantidades de información y de ofrecerla de manera rápida con capacidad para combinar y ordenar los datos, ajustándose a los requerimientos del usuario.
SQL es el acrónimo de Structured Query Language (Lenguaje estructurado de consultas). Este es un estándar que utilizan las bases de datos relacionales para insertar, actualizar, eliminar y recuperar información. Existen muchas bases de datos relacionales, las más difundidas son MySQL, Oracle, SQL Server y PostgresSQL. Cada una de ellas es compatible con el estándar SQL, aunque cada una de ellas tiene un juego de instrucciones propias.
La estructura interna de una base de datos relacional está basada en tablas y a su vez en filas o registros, por ejemplo:
Tabla: Productos
id producto precio
1 Pan 0.45
2 Leche 0.80
3 Aceite 1.40
En este pequeño ejemplo tenemos una tabla llamada Productos que contiene tres columnas: id (identificador), producto y precio. Los datos de la tabla se leen por filas, por ejemplo sabemos que el producto pan tiene un precio de 0.45.
Tipos de datos en MySQL
Igual que veíamos en PHP y en otros lenguages de programación en MySQL hay varios tipos de datos:
TINYINT, SMALLINT, MEDIUMINT, INT y BIGINT Números enteros. Se diferencian en el rango, es decir, en el mayor número representable en un campo.
FLOAT y DOUBLE Número de punto flotante (decimal).
DATE Un campo de fecha con formato AAAA-MM-DD.
DATETIME Campo de fecha y hora. Su formato es AAAA-MM-DD HH:MM:SS.
CHAR Campo alfanumérico.
VARCHAR Campo alfanumérico de longitud variable.
BLOB y TEXT Campos alfanuméricos largos.
MEDIUMBLOB y MEDIUMTEXT Análogo a los campos BLOB y TEXT. Longitud máxima 16777215 caracteres.
LONGBLOB y LONGTEXT Análogo a los campos BLOB y TEXT. Longitud máxima 4294967295 caracteres.
En todos los tipos de datos (menos en las fechas) es necesario especificar el tamaño del campo y para datos numéricos si es con signo o sin signo, la diferencia de esto último es que los campos sin signo UNSIGNED tienen el doble de rango que los que usan signo SIGNED
REFERENCIAS:
(C) Documentación MySQL: Tipos de datos (https://dev.mysql.com/doc/mysql/en/column-types.html)
Instalando MySQL en nuestro servidor
Tanto en sistemas Linux como Windows podemos usar este servidor de bases de datos.
Para instalar MySQL en los equipos que usaremos debemos ejecutar como usuario root:
# apt-get update
# apt-get install mysql-server mysql-client php4-mysql libapache2-mod-php
Como interfaz gráfico para la creación de tablas usaremos phpmyadmin o mysql-admin/mysql-query-browser, desde consola podemos usar comandos, instalando el paquete mysql-client
# apt-get install phpmyadmin
# apt-get install mysql-admin mysql-query-browser
# apt-get install mysql-client
Una vez instalado correctamente el sistema por defecto arranca el servicio de mysql y podremos conectarnos a él.
Creando una base de datos y una tabla
En las instalaciones por defecto existe un usuario de la base de datos: root, SIN CONTRASEÑA. Tan pronto como podamos es conveniente asignar contraseña a ese usuario y crear otro con menos privilegios (ésta es una de las filosofías de GNU/Linux). En las últimas versiones de mysql no se permite el acceso del usuario root a la base de datos, nada más que para administrarla.
Modo phpmyadmin
Desde un navegador web entramos en la dirección: (https://localhost/phpmyadmin)(*) e ingresamos con usuario root y sin clave. Nada más entrar veremos un aviso en rojo indicándonos que el usuario no tiene clave, picando en ese enlace nos permitirá cambiarla.
Acto seguido en el menu principal, sección privilegios crearemos un nuevo usuario con el nombre que queramos y que se conecte sólo desde la máquina local. Por defecto MySQL viene configurado para no permitir conexiones externas. Le daremos permiso para ejecutar consultas y crear bases de datos.
Crearemos una base de datos nueva (Menú principal) de nombre prueba1, a continuación en el desplegable izquierdo podremos seleccionar la base de datos que usaremos.
Creamos una nueva tabla llamada tabla1 con 3 campos. A continuación especificaremos que tipos de variables vamos a usar para cada una de las tres columnas o campos.
Campo: id, tipo TINYINT, atributos UNSIGNED, extra auto_increment y marcaremos la casilla Primaria (la que tiene el símbolo de la llave)
Campo: producto, tipo VARCHAR, tamaño 255
Campo: precio, tipo FLOAT, atributos UNSIGNED
Pulsamos el botón guardar y obtendremos, si todo ha ido bien, el código SQL que se ejecuta para crear esa tabla:
CREATE TABLE `tabla1` (
`id` tinyint(3) unsigned NOT NULL auto_increment,
`producto` varchar(255) NOT NULL default ,
`precio` float unsigned NOT NULL default ‘0’,
PRIMARY KEY (`id`)
) TYPE=MyISAM AUTO_INCREMENT=1 ;
(*)Si no pudieramos acceder a esta web tendremos que teclear:
# ln -s /usr/share/phpmyadmin /var/www/
Modo mysql-admin/mysql-query-browser
Ejecutamos desde consola (como usuario) el comando mysql-admin, en la pantalla que nos sale ponemos los siguientes datos de conexión:
Server hostname: localhost
Username: usuario
Password: pass
Port: 3306
Al pulsar en botón Connect obtendremos el panel de control del servidor de bases de datos local. mysql-admin no permite la creación de bases de datos pero sí la monitorización y modificación. Para el trabajo de crer y modificar usaremos mysql-query-browser
Ejecutamos desde consola (como usuario) el comando mysql-query-browser, en la pantalla que nos sale ponemos los siguientes datos de conexión:
Server hostname: localhost
Username: usuario
Password: pass
Port: 3306
Al pulsar en botón Connect obtendremos el panel de control de consultas sobre la base de datos. A la derecha tendremos las bases de datos que contiene nuestro servidor (Schemata). Pulsando en una base de datos se desplegarán las tablas que contiene, y pulsando nuevamente en la tabla veremos los registros después de pulsar EXECUTE En la parte inferior derecha tenemos las consultas y funciones que podemos usar en este programa con ayuda incluida.
Modo desde consola
Aunque es el modo más tosco funciona siempre y a veces es útil cuando no disponemos de phpmyadmin, el servidor no tiene instalado un servidor gráfico o lo hacemos en un equipo remoto conectados por ssh, por ejemplo.
Para crear la nueva base de datos, ejecutamos:
$ mysqladmin -uroot -p create prueba2
Después de ingresar la contraseña (si el usuario root no tiene contraseña no poner el modificador -p) ya se habrá creado la base de datos nueva. Para ver las tablas de una base de datos:
$ mysqlshow -uroot -p prueba2
Enter password:
Database: prueba2
+——–+
| Tables |
+——–+
+——–+
De un modo semi-gráfico podremos usar este comando para ver tablas o el contenido de las mismas. Crear un usuario:
mysql> GRANT USAGE ON * . * TO ‘usuario’@’localhost’ IDENTIFIED BY ‘password’;
mysql> GRANT SELECT , INSERT , UPDATE , DELETE, CREATE, DROP ON `prueba` . * TO ‘usuario’@’localhost’;
Ahora debemos crear una tabla e indicar su formato:
$ mysql -uusuario -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or g.
Your MySQL connection id is 189 to server version: 4.0.23_Debian-7-log
Type ‘help;’ or ‘h’ for help. Type ‘c’ to clear the buffer.
mysql> use prueba2;
Database changed
mysql> create table `tabla2`(
-> `id` tinyint(3) unsigned NOT NULL auto_increment,
-> `producto` varchar(255) NOT NULL default ,
-> `precio` float unsigned NOT NULL default ‘0’,
-> PRIMARY KEY (`id`)
-> ) TYPE=MyISAM AUTO_INCREMENT=1 ;
Query OK, 0 rows affected (0.03 sec)
mysql> exit
Bye
vemos que básicamente hemos copiado la estructura que usó phpmyadmin para crear la otra tabla.
NOTA IMPORTANTE: Las comillas que indican los nombres de los campos son comillas francesas (comilla grave), la tecla en un teclado español está a la derecha de la P y se obtiene presionando una vez la comilla y a continuación un espacio.
Para ver si se creo correctamente:
$ mysqlshow -uusuario -p prueba2
Enter password:
Database: prueba2
+——–+
| Tables |
+——–+
| tabla2 |
+——–+
$ mysqlshow -uusuario -p prueba2 tabla2
Enter password:
Database: prueba2 Table: tabla2 Rows: 0
+———-+———————+——+—–+———+—————-+———————————+
| Field | Type | Null | Key | Default | Extra | Privileges |
+———-+———————+——+—–+———+—————-+———————————+
| id | tinyint(3) unsigned | | PRI | | auto_increment | select,insert,update,references |
| producto | varchar(255) | | | | | select,insert,update,references |
| precio | float unsigned | | | 0 | | select,insert,update,references |
+———-+———————+——+—–+———+—————-+———————————+
Consultas MySQL
En cualquier base de datos es necesario leer, modificar, añadir y borrar datos, de ésta afirmación se obtienen cuatro tipos de consultas:
Consultas de inserción
Tenemos nuestra tabla pero aún no contiene datos, la forma de introducir datos nuevos es:
INSERT INTO nombre_tabla (columna1,columna2,…,columnaN) VALUES (valor1,valor2,…,valorN)
Los nombres de los campos se pueden omitir siempre y cuando el número de valores coincida con el número de campos totales de la tabla.
Un ejemplo para nuestra tabla de la compra:
$ mysql -uusuario -p
mysql> INSERT INTO tabla2 (`producto`,`precio`) VALUES (‘pan’, ‘0.45’);
Query OK, 1 row affected (0.10 sec)
mysql> INSERT INTO tabla2 (`producto`,`precio`) VALUES (‘leche’, ‘0.80’);
Query OK, 1 row affected (0.10 sec)
mysql> INSERT INTO tabla2 (`producto`,`precio`) VALUES (‘aceite’, ‘1.80’);
Query OK, 1 row affected (0.10 sec)
Consultas de selección
Extrae datos de una o varias tablas, combinando, ordenando o filtrando cuando sea necesario determinados criterios. La sintaxis es la siguiente:
SELECT expresión
[FROM tabla_o_tablas]
[[modo_de_unión] JOIN tabla_o_tablas ON expresión_where]
[WHERE expresión_where]
[ORDER BY columna] [ASC o DESC]
[LIMIT [límite,] registros]]
Usando nuestro ejemplo anterior:
$ mysql -uusuario -p
mysql> select * from tabla2;
+—-+———-+——–+
| id | producto | precio |
+—-+———-+——–+
| 1 | pan | 0.45 |
| 2 | leche | 0.8 |
| 3 | aceite | 1.4 |
+—-+———-+——–+
3 rows in set (0.02 sec)
mysql> exit
Bye
Una calculadora con MySQL:
$ mysql -uusuario -p
mysql> select 5*9;
+—–+
| 5*9 |
+—–+
| 45 |
+—–+
1 row in set (0.06 sec)
La consulta SELECT admite varias funciones especiales:
CONCAT: Junta columnas obteniendo como resultado una única columna. Ejemplo:
mysql> SELECT CONCAT(‘El producto ‘,`producto`,’ vale ‘,`precio`,’ euros’) as todo FROM tabla2;
+———————————–+
| todo |
+———————————–+
| El producto pan vale 0.45 euros |
| El producto leche vale 0.8 euros |
| El producto aceite vale 1.4 euros |
+———————————–+
3 rows in set (0.00 sec)
COUNT: Cuenta el número de registros o filas en una base de datos. Ejemplo:
mysql> SELECT COUNT(`producto`) FROM tabla2;
+——————-+
| COUNT(`producto`) |
+——————-+
| 3 |
+——————-+
1 row in set (0.00 sec)
SUM, AVG, MAX, MIN: Devuelven respectivamente la suma, media, máximo y mínimo del campo especificado. Ejemplo:
mysql> SELECT SUM(`precio`) as total, AVG(`precio`) as media, MAX(`precio`)
>as maximo, MIN(`precio`) as minimo FROM tabla2;
+—————–+——————+—————–+——————+
| total | media | maximo | minimo |
+—————–+——————+—————–+——————+
| 2.65 | 0.883 | 1.4 | 0.45 |
+—————–+——————+—————–+——————+
1 row in set (0.00 sec)
LIMIT: Muy importante cuando tenemos muchos registros, el rendimiento de una lectura de una tabla de más de 3.000 registros es apreciablemente más lento, más de 10.000 registros (depende de la potencia del servidor) puede llegar a colgarlo. Lleva asociado dos números, el primero indica el primer registro a mostrar (se empieza a contar desde 0) y el segundo el número de registros. Por ejemplo, para mostrar dos registros a partir del segundo pondríamos:
mysql> SELECT * FROM tabla2 LIMIT 1,2;
+—-+———-+——–+
| id | producto | precio |
+—-+———-+——–+
| 2 | leche | 0.8 |
| 3 | aceite | 1.4 |
+—-+———-+——–+
2 rows in set (0.00 sec)
ORDER BY: Ahora que sabemos como leer registros vamos a ordenarlos. Esta sentencia por defecto usa el órden ASCendente, pero también se puede usar DESCendente. Se pueden usar varios nombres de campos para que compare el primero y en caso de ser iguales el segundo, compara caracteres y números. Ejemplo:
mysql> SELECT * FROM tabla2 ORDER BY `precio` DESC;
+—-+———-+——–+
| id | producto | precio |
+—-+———-+——–+
| 3 | aceite | 1.4 |
| 2 | leche | 0.8 |
| 1 | pan | 0.45 |
+—-+———-+——–+
3 rows in set (0.00 sec)
WHERE: Es la expresión que permite filtrar la consulta, es de las más usadas en lenguaje SQL. Permite operadores de igualdad, comparación (mayor >, menor que <, distinto, !=), y en el caso de campos de texto, búsqueda de patrones con el operador LIKE y comodines %. Ejemplos:
mysql> SELECT * FROM tabla2 WHERE `precio`<=1;
+—-+———-+——–+
| id | producto | precio |
+—-+———-+——–+
| 1 | pan | 0.45 |
| 2 | leche | 0.8 |
+—-+———-+——–+
2 rows in set (0.06 sec)
mysql> SELECT * FROM tabla2 WHERE `producto` LIKE ‘%cei%’;
+—-+———-+——–+
| id | producto | precio |
+—-+———-+——–+
| 3 | aceite | 1.4 |
+—-+———-+——–+
1 row in set (0.00 sec)
JOIN: Consulta de unión para seleccionar datos de varias tablas. Las uniones pueden ser por la izquierda LEFT, por la derecha RIGHT, e internas INNER. El ejemplo aquí es más dificil ya que necesitamos dos tablas:
mysql> SELECT tabla1.campo1 tabla1.campo2 tabla2.campo1 tabla2.campo2
> LEFT JOIN tablas tabla2 ON tabla1.campo1=tabla2.campo1;
Este ejemplo tan enrevesado lo que hace es tomar dos campos de tabla1 y dos campos de tabla2 y mostraría los datos de una supuesta tabla llamada tablas donde los campos1 de las anteriores son los mismos.
Consulta de Actualización/Modificación
UPDATE: Con esta consulta modificamos el valor de los registros, su sintaxis es:
UPDATE tabla SET campo1=valor1, campo2=valor2 …. WHERE filtro
Podemos modificar el valor de una campo o de varios a la vez y modificar toda la tabla o sólo aquellos registros que cumplan un determinado filtro WHERE. Ejemplo:
mysql> UPDATE tabla2 SET producto=’Aceite de Oliva’ WHERE producto=’Aceite’;
Query OK, 1 row affected (0.09 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> SELECT * FROM tabla2;
+—-+—————–+——–+
| id | producto | precio |
+—-+—————–+——–+
| 1 | pan | 0.45 |
| 2 | leche | 0.8 |
| 3 | Aceite de Oliva | 1.4 |
+—-+—————–+——–+
3 rows in set (0.00 sec)
Consultas de Eliminación
DELETE: Consulta que elimina todos o algún registro de una tabla. Su síntaxis es:
DELETE FROM tabla WHERE filtro
Igual que antes la condición WHERE es opcional. Ejemplo:
mysql> DELETE FROM tabla2 WHERE precio<1;
Query OK, 2 rows affected (0.09 sec)
mysql> SELECT * FROM tabla2;
+—-+—————–+——–+
| id | producto | precio |
+—-+—————–+——–+
| 3 | Aceite de Oliva | 1.4 |
+—-+—————–+——–+
1 row in set (0.00 sec)
Uso de bases de datos desde código PHP
PHP permite iteraccionar con bases de datos relacionales como son Oracle, MySQL, SQLServer, mSQL, PostgreSQL, etc.
Nos vamos a centrar en MySQL, aunque la síntaxis es similar en otras bases de datos.
Un buen punto de referencia para todas las funciones que vamos a usar se encuentra en:
referencia MySQL en PHP (https://es2.php.net/manual/es/ref.mysql.php)
Funciones MySQL
PHP dispone de varias funciones para el acceso a datos, una es la encargada de realizar la conexión y otras en leer los datos, por ejemplo.
mysql_pconnect
Síntaxis:
mysql_pconnect(servidor, login, password)
Abre una conexión persistente con la base de datos, el tipo de conexión puede ser local, por red, o por socket, ejemplos:
<?php
$conexion = mysql_pconnect(‘localhost’, ‘user’, ‘pass’);
$conexion = mysql_pconnect(‘192.168.0.5’, ‘user’, ‘pass’);
$conexion = mysql_pconnect(‘/var/run/mysqld/mysqld.sock’, ‘user’, ‘pass’);
$conexion = mysql_pconnect(«mysql://user:encripted_pass@localhost/database»);
?>
Por comodidad usaremos la primera, ya que el nombre especial localhost siempre es la máquina local. El servidor mysql por defecto sólo permite conexiones desde el host local (aunque se puede activar las conexiones remotas).
Archivo /etc/mysql/my.cnf
# Instead of skip-networking the default is now to listen only on
# localhost which is more compatible and is not less secure.
bind-address = 192.168.0.3
Antes existía una línea skip-networking que con descomentarla
ya podíamos acceder desde el exterior, ahora se usa la IP desde
la que se quieren realizar conexiones (127.0.0.1 sólo local)
Esta función devuelve un tipo de dato especial llamado recurso, si la conexión falla devuelve un error. Si queremos llevar un control de errores en nuestras web hechas con PHP deberemos leer los errores en los puntos donde sea posible detectarlos. Ejemplo:
<?php
$conexion = mysql_pconnect(‘localhost’, ‘user’, ‘pass’);
if (! $conexion){
echo «Hubo un error al conectar al servidor»;
exit;
}
else{
echo «Conexión correcta.»;
}
?>
mysql_select_db
Síntaxis:
mysql_select_db (base_de_datos, identificador_de_conexión)
Una vez establecida la conexión con el servidor deberemos indicar desde qué base de datos queremos leer (o modificar/borrar) datos. Esta función selecciona la base de datos activa para la conexión actual, y es similar a la sentencia use base_de_datos, que veíamos en modo consola. Ejemplo:
<?php
mysql_select_db (‘prueba2’,$conexion);
?>
Si no especificamos identificador, esta función usa el último devuelto por la función mysql_pconnect.
mysql_query
Síntaxis:
mysql_query (consulta, identificador_de_conexión)
Es la función encargada de hablar con el servidor MySQL, es decir, enviar acciones como insertar, borrar, o leer. Ejemplo:
<?php
$resultado = mysql_query («SELECT * FROM tabla2», $conexion);
if (! $resultado){
echo «No se pudo ejecutar la consulta»;
}
else{
echo «Consulta ejecutada correctamente»;
}
?>
mysql_fetch_row
Síntaxis:
mysql_fetch_row (recurso_devuelto_por_la_consulta)
Recupera los registros de la base de datos y los devuelve como un array (vector). Si lo llamamos varias veces irá devolviendo los siguientes registros hasta que no haya más, en este caso devuelve FALSE. Ejemplo:
<?php
$array_datos = mysql_fetch_row ($resultado);
?>
Para leer todos los valores devueltos por una consutla se suelen usar estructuras de control del tipo while, foreach, for. Ejemplo:
<?php
$conexion = mysql_pconnect(«localhost», «user», «pass»);
if(! $conexion){
echo «No se pudo conectar con la base de datos»;
exit;
}
mysql_select_db(«prueba2», $conexion);
$resultado = mysql_query(«SELECT * FROM tabla2», $conexion);
if (! $resultado){
echo «No se pudo ejecutar la consulta»;
}
while( $array_datos = mysql_fetch_row($resultado) ){
echo «<br><br>n»;
foreach ( $array_datos as $out ){
echo $out . «—«;
}
}
?>
El resultado de este script debería ser:
1—pan—0.45—
2—leche—0.8—
3—aceite—1.8—
mysql_result
Síntaxis:
mysql_result ( id_resultado, numero_de_fila [, mixed campo] )
Devuelve el contenido de una celda de resultado de la ejecución de una consulta MySQL.
<?php
$conexion = mysql_connect(‘localhost’, ‘user’, ‘pass’);
if (!$conexion) {
echo «No se pudo conectar.»;
exit;
}
mysql_select_db(«prueba2», $conexion);
$resultado = mysql_query(‘SELECT producto FROM tabla2’);
if (!$resultado) {
echo «No se pudo ejecutar consulta.»;
}
echo mysql_result($resultado, 2); // imprime el tercer producto
mysql_close($conexion);
?>
Este script debería imprimir por pantalla aceite
mysql_escape_string
Síntaxis:
mysql_escape_string (cadena)
Esta función es una de las más importantes en el tema de seguridad en bases de datos y un fenómeno conocido como SQL Injection, basado en pasar caracteres especiales en consultas mysql con el fin de saltar restricciones como usuario o contraseña o incluso BORRAR NUESTRA BASE DE DATOS. vamos a poner un ejemplo de una consulta que valida un usuario cuyos datos estan guardados en una tabla.
<?php
$consulta = «SELECT * FROM usuarios WHERE usuario='{$_GET[‘username’]}’ AND password='{$_GET[‘password’]}'»;
echo $consulta;
?>
Este script se comportará bien si pasamos como variables GET el usuario y la contraseña en modo texto, la forma de ejecutarlo sería:
https://localhost/prueba.php?username=user&password=secret
Con esto la consulta queda:
SELECT * FROM usuarios WHERE usuario=’user’ AND password=’secret’
Ahora imaginamos que ponemos:
https://localhost/prueba.php?username=user&password=1%27%20OR%20TRUE
SELECT * FROM usuarios WHERE usuario=’user’ AND password=’1′ OR TRUE’
Con lo que la consulta que se ejecutaría tendría muy mala pinta, el usuario se loguearía con el nombre y la contraseña del primer usuario registrado (¿administrador?) sin necesidad de saber la clave. Puede parecer de risa pero existen algunas web con estos fallos y mucho peor, los webmaster los desconocen.
Para evitarlo todos los datos que leamos de un formulario a través de $_GET o $_POST deberemos filtrarlos con la función mysql_escape_string o mysql_real_escape_string:
<?php
$usuario=mysql_escape_string($_GET[‘username’]);
$pass=mysql_escape_string($_GET[‘password’]);
$consulta = «SELECT * FROM usuarios WHERE usuario='{$usuario}’ AND password='{$pass}'»;
echo $consulta;
?>
La consulta anterior ejecutaría:
SELECT * FROM usuarios WHERE usuario=’user’ AND password=’1′ OR TRUE’
la variable password vale 1′ OR true, esa comilla ya no se ejecuta en php
Por defecto el servidor apache con PHP4 tiene activado el Magic-Quotes:
Archivo /etc/php4/apache2/php.ini
; Magic quotes for incoming GET/POST/Cookie data.
magic_quotes_gpc = On
más información en magic-quotes-gpc (https://es2.php.net/manual/es/ref.info.php#ini.magic-quotes-gpc)
Los parámetros que pasemos usando comillas sin necesidad de escaparlos ya lo hará el servidor. Aún así como no sabemos donde vamos a colgar la página y la configuración de un servidor donde sólo tenemos una cuenta de usuario normal SIEMPRE ESCAPAREMOS LOS CAMPOS PASADOS POR FORMULARIO.
Herramientas para otras plataformas
Instalación de PHP en Apache para Windows
Apache es un servidor web muy flexible y puede funcionar tanto en sistemas *nix como Windows.
Para instalar apache sobre Windows entraremos en uno de los mirror (en España rediris) y buscaremos los binarios del servidor web:
https://apache.rediris.es/httpd/binaries/win32/ (https://apache.rediris.es/httpd/binaries/win32/)
En marzo de 2.005 hay disponibles dos versiones:
Apache 1.3.3
Apache 2.0.53
Descargaremos el archivo .exe o .msi que corresponda y lo instalaremos como cualquier otro programa de windows. Posiblemente nos instale apache como servicio de inicio (Windows NT, 2000, XP) o lo lance al iniciar sesión (Windows 98, Me).
Instalación de MySQL en Windows
MySQL es un servidor de bases de datos relacional. Es uno de los servidores de bases de datos más rápidos a la hora de generar consultas simples.
Para su instalación en windows de manera similar a apache vamos a su web y escojemos el mirror más cercano (rediris de nuevo)
https://mysql.rediris.es/ (https://mysql.rediris.es/downloads/mysql/4.1.html)
Tenemos que descargar (Sección Windows) el paquete Windows Essentials (x86) o Windows (x86), la diferencia de ámbos además del tamaño de la descarga es que el primero trae lo básico para funcionar y el segundo es el completo.
Herramientas para trabajar con MySQL en Windows
phpmyadmin (https://www.phpmyadmin.net/home_page/), incluido en XAMMP, que veremos más tarde, es un gestor de bases de datos mysql programado en php, con el que podremos gestionar usuarios, bases de datos, tablas, hacer consultas, eliminar campos, etc… Sólo necesitamos un navegador para usarlo.
mysql-admin y mysql-query-browser (https://www.mysql.com/products/administrator/), nueva versión del gestor de bases de datos mysql, con una apariencia bastante agradable, capaz de hacer las misma cosas que phpmyadmin y además generar backups de la base de datos programados, replicado, monitorizar el estado del servidor, e incluso configurar el mismo si el usuario que lo ejecuta tiene los permisos apropiados.
Si queremos podemos gestionar tablas, y consultas desde programas como Excel o Access con el conector ODBC de mysql (https://www.mysql.com/products/connector/odbc/).
Instalación completa en Windows
Debido a la «dificultad» de instalar todos los servidores que necesitemos y ponerlos a funcionar en conjunto, se han contruido paquetes para facilitar el proceso de montaje de un servidor web, base de datos, correo, ftp, etc… en un sólo paquete.
AppServ
AppServ es un paquete completo que facilita la instalación, configuración e interoperabilidad de Apache, PHP y MySQL.
El paquete completo contiene:
Apache
PHP
MySQL
Motor Zend Optimizer
phpMyAdmin
Hay dos versiones de desarollo, una basada en Apache 1.3 y otra en Apache 2.0, además la primera trae PHP 4.x y la segunda PHP 5.x que trae un motor Zend más potente y mejor soporte para programación orientada a objetos.
Este es un paquete básico para comenzar a trabajar con páginas web, PHP y SQL, pero si deseamos tener más características o lenguajes de programación para nuestras páginas y no sabemos muy bien como añadir módulos, deberemos irnos a algún otro paquete.
Web del proyecto
https://www.appservnetwork.com/
XAMMP
Uno de los paquetes más completos es XAMMP, que incluye:
Apache
MySQL
PHP + PEAR
Perl
Módulos de apache (mod_php, mod_perl, mod_ssl)
OpenSSL
phpMyAdmin
Webalizer
Mercury Mail Transport System for Win32 and NetWare Systems v3.32
JpGraph
FileZilla FTP Server
mcrypt
Turck MMCache
SQLite
WEB-DAV + mod_auth_mysql
Está basado en la filosofía de descomprimir y ejecutar, y con unos pocos clics podremos tener funcionando todo un servidor.
Para descargar XAMMP podemos hacerlo desde aquí (https://www.apachefriends.org/en/xampp-windows.html#641)
Para instalarlo se debe descomprimir en la raiz de una partición, por ejemplo C: y seguir las instrucciones que tiene el archivo readme.
Web del proyecto
https://www.apachefriends.org/en/xampp.html
Complementos
phpMyAdmin
https:
CMS
CMS es el acrónimo de Content Management System y es un conjunto de scripts PHP que trabajan de forma conjunta, con el fin de realizar alguna labor.
Existen muchos CMS, podremos ver, descargar e incluso probar online muchos de los que existen en:
opensourcecms (https://www.opensourcecms.com/)
Los CMS están normalmente clasificados según su uso:
Portales completos (PostNuke, PHP-Nuke, Drupal, Mambo, Geeklog, etc…)
Blogs o diarios (WordPress, pLog, BLOG:CMS, etc…)
Tiendas virtuales (osCommerce, ZenCart, etc…)
Entornos colaborativos de trabajo en grupo (PHPGroupWare, PhpProject, etc…)
Foros (phpBB, Phorum, etc…)
Entornos educacionales para profesores (Escritorio Virtual) (Claroline, WordCicle)
Wikis o entornos de colaboración documentativa (Mediawiki)
Otros (Gallery, Webcalendar)
Algunos de los CMS están disponibles para distribuciones basadas en Debian, como Drupal, phpBB o WordPress.
Como tarea añadida se propone descargar e instalar un CMS en el equipo local, cada alumno podrá elegir el que quiera. Las instrucciones de instalación está incluidas en el archivo comprimido de cada uno.
Obtenido de «https://soleup.eup.uva.es/mediawiki/index.php/Curso_PHP-MySQL»
manual extraido de :soleup.eup.uva.es
