Vamos a interactuar con nuestro usuarios, por supuesto a través del navegador
¡Saludos nuevamente!
Como mencionamos en el tema de conceptos básicos, PHP posee un conjunto de variables que nos permiten obtener información de distintas fuentes como: los datos de formularios, las cookies, las sesiones, el servidor, entre otras cosas. Estas son llamadas variables predefinidas y trataremos con ellas en este artículo.
Leer datos de formularios
Los formularios HTML permiten a los usuarios capturar datos en diferentes formatos, y la información capturada puede ser enviada al servidor al momento que los usuarios lo ordenen, lo más común es que se incluya un input de tipo submit para realizar esta tarea, de modo que cuando el usuario realice el submit el formulario enviará la información contenida siguiendo las especificaciones que nosotros mismos le definimos:
<html>
<head>
<title>Formulario con GET</title>
</head>
<body>
<form action="leerDatos.php" method="get" enctype="text/plain">
Nombre: <input type="text" name="nombre" size="25" maxlength="50"><br />
Apellidos: <input type="text" name="apellidos" size="35" maxlength="100"><br />
Sexo: <select name="sexo">
<option value="M">Masculino</option>
<option value="F">Femenino</option>
</select><br />
<input type="submit" name="envio" value="Enviar" />
</form>
</body>
</html>
*Nota: si no se define el atributo name de una entrada del formulario este dato no será enviado con el resto de la información.
En el ejemplo vemos que se definió un formulario con una serie de entradas para captura y un submit para enviar la información, las especificaciones del envío se establecen como atributos del elemento <form>, de modo que definimos que el método de envío será GET, y la página a la que serán enviados es leerDatos.php, cuyo código aparece a continuación:
leerDatos.php
<?php
if(isset($_GET['envio']))
{
$nombre = $_GET['nombre'];
$apellidos = $_GET['apellidos'];
$sexo = ($_GET['sexo'] == "M")? "Masculino":"Femenino";
echo "Usted ha enviado al servidor el nombre $nombre, $apellidos, con el sexo $sexo";
}
?>
Los datos pueden ser enviados al servidor por dos tipos de métodos: GET o POST, lo cual se especifica en el atributo method del formulario; en el método GET los datos que se se envían dentro de la URL de la página destino, es decir la página Web que recibe los datos, como ocurrió con el ejemplo anterior. En el método POST en cambio, los datos no podrán ser visualizados por los usuarios después de que fueron enviados a la página destino, pero de forma similar a la del ejemplo anterior pueden ser leídos por nuestra aplicaciones Web.
En el caso del método GET en nuestra aplicación en PHP utilizamos la variable predefinida $_GET para leer los datos recibidos. Esta variable se lee como si se tratara de un arreglo asociativo, donde cada llave corresponde al nombre (es decir, atributo name) de un campo, así la forma de acceder al valor del campo de texto "nombre" es por medio de la variable $_GET['nombre'] por ejemplo.
Si deseamos probar el método POST bastará con que en el formulario cambiemos el atributo method por "post", y que en nuestro programa leerDatos.php se accese a los datos por medio de la variable predefinida $_POST como se muestra a continuación:
leerDatos.php
<?php
if(isset($_POST['envio']))
{
$nombre = $_POST['nombre'];
$apellidos = $_POST['apellidos'];
$sexo = ($_POST['sexo'] == "M")? "Masculino":"Femenino";
echo "Usted ha enviado al servidor el nombre $nombre, $apellidos, con el sexo $sexo";
}
?>
El método POST es una buena forma de mantener ocultos los datos capturados por el usuario en nuestros formularios, como pueden ser contraseñas e información que será almacenada en un archivo o en una base de datos. En cambio el método GET se recomienda cuando no existe problema con que la información enviada sea visualizada en el navegador del usuario, como por ejemplo en las búsquedas que hacemos por Internet. Ésta última forma también resulta muy útil cuando en nuestro navegador queremos regresar a una página anterior, en la que se realizó un submit por GET, ya que los navegadores conservan las direcciones URL de todas las páginas desplegadas, incluyendo los datos enviados por GET, de modo que la lectura de datos enviados se puede volver a realizar como la primera vez. Además el método GET permite enviar ciertos datos a una página sin necesidad de un formulario, si dentro de nuestra dirección URL incluimos los datos por nosotros mismos, por ejemplo si en la barra de direcciones del navegador escribimos la siguiente URL:
http://localhost/leerDatos.php?nombre=Beto&apellidos=Gonzalez&envio=Enviar
El resultado será el mismo a si hubiéramos utilizado la página HTML con su formulario.
*Nota: Las direcciones incluidas en en el atributo method de los formularios pueden incluir cualquier tipo de dirección URL.
Además de las dos formas anteriores, PHP también incluye la variable predefinida $_REQUEST, la cual puede recoger los datos enviados por ambos métodos, así como los datos de $_COOKIE de la que se hablará más adelante.
Envio de archivos
Dentro de las entradas de un formulario se incluye el tipo file, el cual nos permite capturar un archivo dentro de nuestro equipo y enviarlo al servidor Web:
<html>
<head>
<title>Formulario con envío de archivos</title>
</head>
<body>
<form action="leerArchivo.php" method="post" enctype="multipart/form-data">
Nombre: <input type="text" name="nombre" size="25" maxlength="50"><br />
Apellidos: <input type="text" name="apellidos" size="35" maxlength="100"><br />
Sexo: <select name="sexo">
<option value="M">Masculino</option>
<option value="F">Femenino</option>
</select><br />
Archivo: <input type="file" name="imagen" /><br />
<input type="submit" name="envio" value="Enviar" />
</form>
</body>
</html>
Es indispensable para enviar un archivo que el enctype de nuestro formulario este definido como "multipart/form-data" y que el método de envío sea POST.
Para acceder al archivo del usuario, desde nuestra aplicación Web utilizaremos la variable predefinida $_FILES, en nuestro ejemplo el programa se almacenaría dentro del archivo leerArchivo.php, que es al que se envía la información del formulario:
leerArchivo.php
<?php
if(isset($_POST['envio'])) {
$nombre = $_POST['nombre'];
$apellidos = $_POST['apellidos'];
$sexo = ($_POST['sexo'] == "M")? "Masculino":"Femenino";
echo "Usted ha enviado al servidor el nombre $nombre, $apellidos, con el sexo $sexo.";
if(isset($_FILES['imagen'])) {//Comprobamos que se recibió el archivo
$nomArchivo = $_FILES['imagen']['name']; //Nombre del archivo
$tipArchivo = $_FILES['imagen']['type']; //Tipo de archivo
$tmpArchivo = $_FILES['imagen']['tmp_name']; //Nombre temporal del archivo (con el que se almacenó en el servidor)
$tamArchivo = $_FILES['imagen']['size']; //Tamaño del archivo
$errArchivo = $_FILES['imagen']['error']; //Mensaje de error generado, si es que hubo alguno
if($errArchivo == "") { //Si no hubo error
echo "<br />El archivo de nombre $nomArchivo fué recibido correctamente, cuenta con un tamaño de $tamArchivo bytes y es del tipo $tipArchivo, almacenándose en el servidor con el nombre temporal de $tmpArchivo.";
}
else {
echo "<br />Error de recepción de archivo: $errArchivo";
}
}
}
?>
Como vemos, la variable $_FILES tiene un primer índice para localizar el nombre el archivo enviado utilizando el name de la entrada file del formulario, después utiliza un segundo índice para obtener la información del archivo recibido, entre los que se encuentran el nombre, tamaño y tipo de archivo recibido, que utilizamos en el ejemplo para desplegar como información del archivo recibido. Además se incluye un campo dentro del arreglo para el manejo de errores. Si quisiéramos acceder al contenido del archivo recibido tendríamos que utilizar el campo $_FILES['imagen']['tmp_name'], que guarda el nombre temporal del archivo, es decir el nombre con el que el archivo se almacenó en nuestro servidor -normalmente en un directorio de archivos temporales-, para con esa dirección física poder leer su contenido o copiarlo a otra dirección, o realizar la labor que quisiéramos hacer con el.
Es importante notar que pueden existir algunos errores asociados con el envío de archivos al servidor, el más común consiste en que el tamaño del archivo enviado supera las especificaciones del archivo de configuración php.ini.
Manejo de Cookies
Las cookies son archivos de texto que almacenan nuestros navegadores, dentro de los que registran información relacionada con nuestra una visita a alguna página, para de esta forma poder recuperar estos datos en un acceso posterior que hagamos, de modo que el usuario no necesite volver a capturarlos. Un ejemplo de su uso lo encontramos en los sitios que proporcionan la opción de almacenar nuestro nombre de usuario y contraseña después de iniciar sesión, para que en nuestros siguientes ingresos no tengamos que volver a teclearlos.
PHP nos permite grabar y leer cookies utilizando la función setcookie() y la variable predefinida $_COOKIE, respectivamente.
Una cookie consiste en una variable que registramos por medio de la función anterior, dentro de la cual definimos su nombre y valor, una vez hecho esto podemos leer el valor de la variable por medio de la variable predefinida $_COOKIE, la cual también se accede como un arreglo asociativo -de manera similar a las otras variables que hemos visto-, lo interesante aquí es que al refrescar la página o cambiarnos a cualquier otra página, la información se conservará, ya que nuestro navegador conservará la información que declaramos con setcookie dentro de un archivo. Por ejemplo:
cookie.php
<?php
$nombre = "unaVariable";
$valor = "Hola mundo!";
if(!isset($_COOKIE['unaVariable'])) {
setcookie($nombre, $valor);
echo "Cookie establecida";
}
else {
echo "El valor de la cookie es ".$_COOKIE['unaVariable'];
}
?>
Si probamos el ejemplo anterior, tendremos al inicio el mensaje "Cookie establecida", debido a que al ingresar a la página por primera vez esta variable aún no había sido registrada y se tuvo que realizar este trabajo, si refrescamos la página entonces nos encontraremos con que el mensaje desplegado es "El valor de la cookie es Hola mundo!", ya que la cookie identificada con $_COOKIE['unaVariable'] ya fue almacenada por el navegador. Podemos refrescar la página y cambiarnos de ubicación tantas veces como queramos pero al volver a ejecutar el programa el resultado será siempre el mismo. Las cookies pueden ser eliminadas directamente desde el navegador del archivo, o si durante su establecimiento incluimos en la función setcookie un tiempo de expiración para la éstas.
Además de datos simples también se pueden almacenar datos compuestos como arreglos y objetos utilizando las funciones serialize() y unserialize(), serializando el contenido de uno de estos dos tipos de datos como una cadena y registrándola con un dato simple, para reconstruir el arreglo u objeto original aplicamos la desserialización que proporciona la función unserialize().
Utilización de sesiones
PHP puede crear sesiones que nos permiten mantener ciertos datos en la memoria del navegador, de forma que podamos acceder a ellos en cada una de las páginas que visitemos mientras el navegador se encuentre en ejecución. Así, nuestras aplicaciones en PHP pueden contar con información importante, sin tener que solicitarla constantemente al usuario o tener que acceder a un medio externo como un archivo o una base de datos, haciéndolas de esta manera más dinámicas. Los datos pueden ser eliminados al cerrar el navegador o utilizar una función explícita del lenguaje para ese trabajo.
Estos datos se escriben en la sesión por medio de la variable predefinida $_SESSION, para crear una variable dentro de este arreglo asociativo antes tenemos que iniciar una sesión utilizando la función session_start(), para posteriormente declarar las variables de sesión que vayamos a manejar, como se muestra en el siguiente ejemplo:
session1.php
<?php
session_start();
$valor = "Hola mundo!";
if(!isset($_SESSION['unDato'])) {
$_SESSION['unDato'] = $valor;
echo "Variable de sesión establecida";
}
else {
echo "El valor de la variable es ".$_SESSION['unDato'];
}
?>
En el ejemplo se inicia una sesión con la función sesion_start() para porteriomente comprobar si ya existe la variable de sesión $_SESSION['unDato'], en caso de no ser así se crea esa variable, para que en un siguiente acceso a la página veamos que el valor se mantuvo en la sesión. Si queremos que en cada página podamos acceder a un dato almacenado en la sesión es necesario incluir la función sesion_start() al inicio de éstas. Esto nos permitirá conservar valores al cambiar de páginas, si por ejemplo tenemos una segunda página:
session2.php
<?php
session_start();
if(isset($_SESSION['unDato'])) {
echo "El valor de la variable sigue siendo ".$_SESSION['unDato'];
}
else
echo "Variable no declarada";
?>
El valor original se conservará. Una idea común es que los usuarios realicen la captura los datos que requeriremos en varias páginas una sola vez, y estos los mantengamos con las variables de sesión.
Esta variables pueden ser eliminadas de la memoria del navegador por medio de las funciones session_unset() y session_destroy(), una seguida de la otra ya que la primera elimina todas las variables de sesión y la segunda destruye la sesión actual, o también se pueden eliminar variables específicas por medio de la función unset(), si le pasamos como parámetro el nombre de la variable de sesión.
Así como con las cookies, podemos escribir datos compuestos en las sesiones utilizando las funciones serialize() y unserialize().
Dentro del manual oficial podemos encontrar el grupo completo de funciones relacionadas con las sesiones.
Datos del servidor
También podemos obtener cierta información relacionada con el servidor Web en el que ejecutamos nuestros programas PHP a través de la variable predefinida $_SERVER, como por ejemplo, la ubicación del archivo que se está ejecutando, la hora del servidor, su sistema operativo, entre otras cosas. En el siguiente programa se muestra como podemos desplegar la información del servidor en nuestro navegador:
server1.php
<?php
echo "Cliente del usuario (navegador Web): ".$_SERVER['HTTP_USER_AGENT']."<br />";
echo "Software del servidor: ".$_SERVER['SERVER_SOFTWARE']."<br />";
echo "Archivo PHP que estamos ejecutando: ".$_SERVER['PHP_SELF']."<br />";
?>
Variables de entorno
También existe la variable predefinida $_ENV, la cual nos permite acceder a la información del entorno en el cual se están ejecutando nuestros programas PHP, como por ejemplo en nombre del usuario que ejecuta el script en el servidor o el nombre del servidor.
Y con estas últimas anotaciones es que concluimos con el artículo sobre variables predefinidas, ahora ya pueden hacerse una idea de la forma en la que sus aplicaciones pueden interactuar con sus usuarios finales, para construir aplicaciones completas, para lo que solo falta que conozcan las diferentes funcionalidades que pueden poseer nuestros programas gracias a las muchas opciones que PHP posee.
Hasta la próxima.
Entradas
