jueves, 4 de junio de 2009

Notas para iniciarse en PHP, Parte 8 (Final): La funcionalidad


Manos a la obra


Y si ya dominamos todas las bases entonces ¿qué podemos hacer con PHP?

Cómo mencionamos antes, PHP nos ofrece un gran grupo de funciones internas para realizar diferentes trabajos, así como algunas clases complementarias que se han venido incorporando. Entre las funcionalidades cubiertas encontramos el manejo de archivos de texto, manipulación de bases de datos, envío de correos electrónicos, funciones matemáticas, operaciones con cadenas de texto, uso de los puertos físicos del equipo, manejo de archivos XML, compresión de archivos, creación de imágenes, y eso no es todo, al revisar el manual encontramos muchas opciones más, ya que las funcionalidades que no se encuentran dentro de PHP se pueden incorporar por medio de extensiones, lo cual se ha venido haciendo con varias de las funciones antes mencionadas, como es el caso de el manejo de las bases de datos, gracias a lo que ahora PHP cuenta con una colección de APIs que le permiten acceder a las gran mayoría de los sistemas de bases de datos existente, incluyendo los más importantes de la actualidad como son:
Junto con un grupo de funciones para una capa de abstracción de datos, que nos permiten acceder a diferentes fuentes de datos desde una misma interface:
  • DBA — Database (dbm-style) Abstraction Layer
  • dbx
  • ODBC — ODBC (Unified)
  • PDO — PHP Data Objects
Aquellas extensiones que no estén incorporadas dentro de las opciones del PHP con el que estemos trabajando, pueden incluir fácilmente de diferentes maneras. En Windows basta con copiar los archivos binarios (DLL) en el directorio de extensiones de PHP, normalmente ubicado en el directorio /ext dentro del directorio principal de PHP, y modificar el archivo de configuración php.ini agregando en la sección de extensiones dinámicas la línea extension=nombre_de_la_extension.dll, por ejemplo, para agregar la extensión de acceso a bases de datos de MS SQLServer, bastaría con agregar extension=msql.dll, entonces solo tendríamos que reiniciar el servidor Web para que el cambio surtiera efecto.

En GNU/Linux en cambio, en lugar de archivos DLL se utilizan los archivos Shared Object o de objetos compartidos, que funcionan de manera similar a los DLL ya que nos permiten agregar funcionalidades adicionales a nuestras aplicaciones desde un componente independiente. Para el ejemplo anterior, primero tendríamos que haber incorporado a PHP el archivo binario .so de la extensión, y después incluir en el archivo de configuración la línea extension=msql.so, el primer paso se puede hacer de diferentes formas, como con los asistentes de actualización de software que nos brinda la distribución del sistema operativo que estemos utilizando, algunos de los cuales nos liberan del segundo paso de modificar el archivo php.ini, otra opción más es utilizar el módulo php-dev, que desde la consola de comandos nos permite compilar e instalar extensiones dinámicas para PHP sin la necesidad de tocar el archivo de configuración, gracias a que incorpora a nuestro sistema la instrucción phpize.


Algunas funciones interesantes

Ahora mostraré algunos ejemplos de las diferentes funciones trabajando, como una muestra de los que se puede hacer con PHP, veamos:

Manejo de archivos de texto

Entre las funciones para manipulación de archivos de texto, encontramos las funciones fread() y fwrite(), que nos permiten leer y escribir en archivos respectivamente. En el siguiente ejemplo se muestra una de los usos que podemos darle a estas funciones implementado un contador de vistas:

contador.php
<?php
$total = 0;
$archivo = "contador.txt"; //Nombre del archivo de texto
if(!file_exists($archivo)) { //Comprobamos la existencia del archivo contador.txt
$abre = fopen($archivo, "w"); //De no existir el archivo
$grabar = fwrite($abre, "0"); //lo creamos guardando el valor de 0 dentro
fclose($abre);
}
else {
$grabar = true;
}
if($grabar) {
// Abrimos el archivo para solamente leerlo ("r" para "read")
$abre = fopen($archivo, "r");
// Leemos todo el contenido del archivo
$total = fread($abre, filesize($archivo));
// Cerramos el archivo
fclose($abre);

// Abrimos nuevamente el archivo pero ahora para escribir
$abre = fopen($archivo, "w");
// Sumamos 1 nueva visita
$total = $total + 1;
// Y reemplazamos el contenido por la nueva cantidad de visitas
$grabar = fwrite($abre, $total);
// Cerramos la conexión al archivo
fclose($abre);
}
?>
<html>
<head><title>Contador de visitas</title></head>
<body>
<div align="center">
Eres el visitante número <?php echo $total?> de esta página.
</div>
</body>
</html>


El programa PHP implementa nuestro contador, el cual va llevando dentro de un archivo de texto la cuenta de las ocasiones en que la página es cargada por los usuarios, para posteriormente desplegar la información dentro de la misma.

Si lo que queremos en cambio es acceder únicamente al texto de un archivo para usarlo como una cadena, es más eficiente utilizar la función file_get_contents(), que recibe el nombre o la URL de un archivo y devuelve su contendido como una cadena de texto para que la podamos manipular.

Funciones para cadenas de texto

Entre la gran cantidad de funciones existentes para el manejo de cadenas de texto, encontramos un interesante conjunto contenido en por las funciones POSIX Regex y PCRE, ya que en ambos grupos encontramos que podemos utilizar expresiones regulares para el trabajo de cadenas, así como para la transformación de arreglos a cadenas y viceversa.

Una muestra interesante de esto es la función split que encontramos entre las funciones POSIX:
<?php
$cadena = "En ese camino lago\nQué un día me vio caminar\nNació esta ciega herida";
$arreglo = split("\n", $cadena); //Separamos la cadena por los saltos de línea que contenga
print_r($arreglo);
?>


La cual permite crear un arreglo a partir de una cadena de texto, dividiendo en partes la cadena según el texto que proporcionamos como segundo parámetro a la función. El ejemplo anterior arrojaría un resultado como el siguiente en el navegador:
Array ( [0] => En ese camino lago [1] => Qué un día me vio caminar [2] => Nació esta ciega herida )


Las funciones PCRE son extensiones tipo PERL, que utilizan en todo momento expresiones regulares para trabajar, las cuales resulta muy útiles al momento de validar cadenas de texto, por ejemplo si queremos saber si una cadena cumple con un determinado formato podemos evaluarla con la función preg_match:

validarCadena.php
<?php
$er_nombre = "/^([a-zA-Z]|[ÁÉÍÓÚáéíóúÑñÜü]|[\s,\.'\-])+$/"; //Expresión regular que será utilizada
if(isset($_GET['txtNombre'])) {
$nombre = stripslashes($_GET['txtNombre']); //Eliminamos el caracter de diagonal invertida que PHP agrega automaticamente para los caracteres de comilla simple (')
if(preg_match($er_nombre,$nombre)) //Evaluamos el contenido del texto recibido
$respuesta = "Nombre correcto :)";
else
$respuesta = "Nombre no válido :(";
}
?>
<html>
<head><title>Validador</title></head>
<body>
<form method="get">
Escribe un nombre <input type="text" name="txtNombre" /> <input type="submit" name="enviar" value="Validar" />
</form>
<p><?php echo $respuesta?></p>
</body>
</html>


En el ejemplo anterior se creó una expresión contenida en $er_nombre que sirvió para validar el texto capturado en el formulario de la página, al ser utilizada por la función preg_match(), la cual devuelve un valor booleano dependiendo de si el texto cumple o no con la expresión regular. Puede verse entonces que estas expresiones son herramientas muy útiles al momento de validar los datos capturados por los usuarios en nuestras páginas.

Sin embargo es recomendable utilizar las expresiones regulares solo cuando la situación lo amerita, ya que el tiempo de procesamiento que consumen es superior al de otras instrucciones de procesamiento de texto, que cuales utilizan cadenas simples como parámetros para manipular cadenas.

Manipulación de bases de datos

Como un ejemplo de la funcionalidad ofrecida, vamos probar la extensión mysql par el manejo de bases de datos MySQL, con la cual ya trabajamos en algunos de los artículos antiguos, convendría que revisaran el tema de Introducción al uso de MySQL que tratamos en este blog hace un tiempo para poder seguir este ejemplo, ya que aquí trabajaremos con la misma base de datos. En el siguiente código podemos ver el programa PHP en acción:

consultaMySQL.php
<?php
//Parámetros para la conexión a la base de datos
$servidor = "localhost";
$usuario = "root";
$contrasenia = "[TuConstraseña]";
$baseDeDatos = "obras_literarias";
$conexion = @mysql_connect($servidor,$usuario,$contrasenia); //Abrimos la conexión con MySQL
if(mysql_select_db($baseDeDatos,$conexion)) { //Accedemos a la base de datos
//Establecemos que la información que se intermabiará estará codificada en utf-8
mysql_query("SET NAMES 'utf8'",$conexion);
//Comprobamos que se recibieron correctamente
if(isset($_GET['txtNombre']) && ($nombre = stripslashes(trim($_GET['txtNombre'])))!="") {
$consulta = "SELECT * FROM autores WHERE Nombre LIKE '%".addslashes($nombre)."%'";
$resultado = mysql_query($consulta,$conexion); //Realizamos la consulta
if($resultado) { //Si no hubo error
if(mysql_num_rows($resultado) > 0){//Comprobamos si se encontraron registros
//Almacenamos en una matriz de arreglos asociativos los registros que resultaron
$matriz = array();
while($renglon = mysql_fetch_assoc($resultado)) {//Extrae un renglon del resultado como un arreglo asosciativo
$matriz[] = $renglon;
}
}
else{
$mensajeDeError = "Autor no encontrado";
}
}
else {
$mensajeDeError = mysql_error();
}
}
else {
$mensajeDeError = "Datos imcompletos";
}
}
else{
$mensajeDeError = mysql_error();
}
?>
<head>
<title>Consulta a MySQL</title>
</head>
<body>
<form method="get">
Escribe un nombre <input type="text" name="txtNombre" /> <input type="submit" name="enviar" value="Validar" />
</form>
<? if($mensajeDeError != "") :?>
<p><?php echo $mensajeDeError?></p>
<? else :?>
<table>
<tr><td>Id</td><td>Nombre</td><td>Nacionalidad</td><td>Profesion</td></tr>
<? foreach($matriz as $autor):?>
<tr><td><?=$autor['Id']?></td><td><?=$autor['Nombre']?></td><td><?=$autor['Nacionalidad']?></td><td><?=$autor['Profesion']?></td></tr>
<? endforeach;?>
</table>
<? endif;?>
</body>
</html>

*Nota: Si desean probar el programa recuerden reemplazar el valor de la contraseña en el texto señalado por [tuContraseña].

En este ejemplo, vemos la forma en la que podemos acceder a una base de datos de MySQL y realizar una consulta sobre una tabla, para posteriormente desplegar la información obtenida dentro de una página HTML, lo cual puede parecer algo muy sencillo pero nos permite darnos una idea del potencial de PHP para trabajar son sistemas manejadores de bases de datos. Para ampliar un poco más el ejemplo anteriorla es también pueden revisar el post de este blog titulado Otra forma de acceder a la base de datos con PHP, donde se describe la creación de una clase para abstracción del acceso a datos, es decir que creamos una clase que encapsulará todas las funcionalidades de la extensión mysql dentro de sus métodos, para facilitar el trabajo con la base de datos y el mantenimiento de nuestros programas.

Espero que con este breve artículo hayan podido hacerse una idea general de la funcionalidad de PHP para la creación de proyectos profesionales, como siempre hay que recordar que estos documentos son un compendio de los contenidos de PHP pero no una guía definitiva, por lo que de estarse iniciando en el aprendizaje del lenguaje conviene que revisen los enlaces que fuí colocando como referencias en cada tema. Ahora dependerá de cada desarrollador decidir si PHP es la herramienta que necesitan para resolver sus problemas y de ser así, qué funciones del lenguajes les serán útiles. Y con esta conclusión es que finaliza la serie de post sobre el aprendizaje de PHP que he venido realizando, espero que más de un programador encuentre útil alguna de mis notas y de ser posible me envíen algún comentario.

Hasta la próxima.

martes, 2 de junio de 2009

Notas para iniciarse en PHP, Parte 7: Manejo de variables predefinidas


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.