Orígenes
y tipología del lenguaje PHP
PHP es el acrónimo de "PHP: Hypertext
Preprocessor", es decir, un "preprocesador del hipertexto" que
se basa en una sintaxis parecida al C, al Java y al Perl, por supuesto con unos
añadidos más. Nació en 1994 como proyecto "personal" y la primera
versión se utilizó públicamente en 1995 con el nombre "Personal Home
Page". El resto es historia. Como cada buen proyecto que llama la atención
de los usuarios y de los programadores, el lenguaje se ha desarrollado como
proyecto open-source hasta el punto que, en 1996, ya se estaba utilizando en
15.000 sitios web. En el momento de la release 3 (a mediados de 1999) el número
de servidores que utilizaban PHP se había decuplicado.
El PHP es un lenguaje de scripting server-side. Se trata de un lenguaje
"embeeded" en las páginas que lo incluyen, por citar un ejemplo, el
lenguaje Javascript. La principal diferencia es que el PHP lo ejecuta en el
servidor en lugar de en el cliente directamente. Por lo tanto, no se necesitan
compatibilidades particulares o estándar definidos por otros (como el ejemplo
más clásico del Javascript). El mecanismo de realización de los script, para
los que los conocen, es parecido al lenguaje
ASP.
Por ejemplo, si en una página estuviera el código:
<html><body>
<? phpinfo(); ?>
</body></html>
si invocáis la página desde el browser, no veis la línea del código entre <?
y ?> (las verdaderas etiquetas del PHP), sino el resultado que esta
instrucción devuelve. En la práctica, el servidor HTTP, una vez que se le haya
solicitado una página parecida, la reconoce (si ha sido configurado
debidamente) y pone en marcha la parte "dinámica". Lo que llega a
vuestro browser es la elaboración de este código y podéis entender que se trata
de una página escrita en lenguaje PHP sólo por su extensión (típicamente
.php3).
Las posibilidades del lenguaje PHP son excelentes, hasta el punto que es
posible crear en PHP todas las aplicaciones que se podrían crear con unos
script CGI. La diferencia principal entre los dos es que el primero hace mucho
más simple la conexión y las preguntas con las bases de datos; el PHP3 soporta
las siguientes bases de datos:
Al igual que con los CGI, con el PHP es posible utilizar los protocolos de red
más famosos como IMAP, SMTP, POP3 e incluso HTTP, o utilizar los socket (enchufes).
CGI y
PHP: principales diferencias
Es sabido que los script CGI escritos en Perl y los script
PHP se utilizan sobre todo para la realización de páginas dinámicas, dejando de
lado por un momento el lenguaje ASP que, recordamos, es
propietario y puede utilizarse (casi) sólo en webserver
NT con IIS.
El PHP, sobre todo en estos últimos tiempos, se está imponiendo como lenguaje
principal de scripting para la realización de páginas dinámicas. En primer
lugar porque es multiplataforma, es decir, es posible encontrar el motor PHP
para las plataformas más utilizadas.
Pero el PHP, lentamente y inexorablmente, está superando por complejidad a los
CGI y esto se puede justificar por varias cuestiones:
Por
supuesto, estas son sólo algunas de las características que permiten al PHP
superar a los CGI, y pueden ser criticadas por los fanáticos del "otro
bando". Obviamente, los CGI tienen sus ventajas y elegir entre uno y otro
lenguaje (o los dos a la vez) es algo personal. Si hablamos de "qué se
puede hacer con PHP" se puede decir que, a partir de la versión 4, las
posibilidades del PHP son prácticamente iguales a las de los CGI en Perl, pero
no a las del mismo Perl.
Creación
de las páginas y sintaxis de base
Como vimos
en el pequeño ejemplo anterior y como probablemente muchos de vosotros habrá
leído en el resto del curso publicado anteriormente, la sintaxis del PHP se
tiene que introducir entre las etiquetas:
<?php
y
?>
Sin embargo es posible itroducir el código de otras formas:
<? ?> /* short tags*/
<script language="php"> </script> /* default junto a
<?php y ?> */
<% %> /* ASP-like tags */
Por ejemplo, es lo mismo escribir:
<?echo ("Yo soy un script PHP\n"); ?>
<?php echo ("Yo soy un script PHP\n"); ?>
<script language="php">
echo ("Yo soy un script PHP\n");
</script>
<% echo ("Yo soy un script PHP"); %>
aunque para los ejemplos que citaremos, vamos a utilizar la sintaxis <?
?>
Recordamos que las etiquetas aceptadas por default son <?php ?> y
<script>. Para establecer las etiquetas cortas y los ASP-like tags se
necesita modificar el archivo de configuración de las primeras líneas, en las
que es posible leer algo como:
short_open_tag = On ; allow the <? tag.
asp_tags = On ; allow ASP-style <% %> tags
Además es posible, como para todos los lenguajes de programación, introducir
los comentarios en el código: el PHP soporta tres tipos de comentarios:
/* */ -> como en el lenguaje C;
// -> como en el lenguaje C++;
# -> como en el scripting de shell y en el Perl.
Para que el servidor ejecute el código a enviar a los clientes es necesario
además dar a las páginas una determinada extensión y hacer que el servidor de
la red sea capaz de interpretar estas páginas e invocar el motor para su
interpretación. En Apache, por ejemplo, es necesario cargar el módulo que se
refiere al PHP3 en el archivo de configuración y definir una extensión
apropiada para las páginas PHP.
Para cargar el módulo en el archivo httpd.conf la instrucción es:
LoadModule php3_module /usr/lib/apache/1.3/libphp3.so
con la correcta localización de la biblioteca libphp3.so.
En cuanto a la extensión será necesario abrir el archivo srm.conf e introducir
(o descomentar, en el caso de que haya un comentario delante) la instrucción:
AddType application/x-httpd-php3 .php3
LLegados a este punto, después de haber reiniciado Apache, podemos hacer las
primeras pruebas. Será suficiente con cargar las páginas con el código php en
la DocumentRoot del servidor y controlar que todo haya ido bien.
Variables
Como con todos los lenguajes de programación, también con el
PHP es posible utilizar las variables que se representan con el símbolo de
dólar ($) seguido por el nombre de la variable.
$variable = 1;
$Variable = "Ésta es una variable";
Estas variables son diferentes no tanto por el valor que tienen como por sus
nombres: realmente, en PHP las variables son case-sensitive.
Elegir los nombres de las variables sirve sobre todo para entender y recordar
el papel de una variable dentro del código y, por lo tanto, a cada variable se
le puede dar cualquier nombre. Alguna de ellas, sin embargo, son, por decirlo
de alguna forma, "reservadas" y no pueden (mejor dicho, no tendrían)
que ser utilizados. Estas variables se pueden dividir en tres grupos: las
variables de Apache (o del servidor), las variables de ambiente, y las
variables PHP. Considerando que muchas de éstas cambian de equipo a equipo y de
servidor a servidor, intentemos hacer un recorrido panorámico por todas ellas
que, por otra parte, podéis leer en una página del tipo:
<html><body>
<? phpinfo(); ?>
</body></html>
Además, hay que recordar otras variables, y que algunas dependen directamente
del PHP. Las dividimos en tres clases:
· Variables de Apache;
· Variables de
ambiente;
· Variables PHP.
Variables
de Apache
La serie de variables de las que hablaremos están en Apache.
Si utilizamos otros servidores, algunas de ellas serán, por supuesto,
diferentes.
Antes de analizarlas detalladamente, recordamos que es posible leer el valor de
cada variable o con la función phpinfo() o con una simple.
echo "NOMBRE_DE LA_VARIABLE";
Además, los valores de ejemplo se han tomado o directamente de la documentación
del PHP, o del valor que tienen en el servidor que se ha utilizado para
escribir estas páginas.
Variables
de ambiente
También con
PHP, como con otros lenguajes, es posible especificar y utilizar las variables
de ambiente, pero tienen que depender de la shell que se ha utilizado si no es
inútil especificarlas. Para leerlas, intentad invocarlas desde el script PHP de
esta forma:
echo "Mi path es $PATH";
que visualizará vuestro path en el sistema.
Variables
PHP
Para terminar, vamos a ver las variables que el mismo PHP
nos pone a disposición:
· argv: un array que
inclluye los parámetros que pasan al script;
· argc: como arriba,
pero si el script se ejecuta a través de la línea de mando;
· PHP_SELF: el nombre
del script actualmente en ejecución;
· HTTP_COOKIE_VARS: un
array de asociación que incluye las variables que han pasado al script a través
de los cookies HTTP;
· HTTP_GET_VARS: un
array de asociación que incluye las variables que han pasado al script a través
de la solicitud de GET;
· HTTP_POST_VARS: como
arriba, pero referido al método POST.
Hay que recordar que las últimas tres variables tienen sentido sólo si, en el
archivo de configuración (track_vars=On) o en el script con la instrucción
"php_track_vars", ha sido habilitado el tracking de las variables.
Constantes
Además de
los datos que hemos visto anteriormente, PHP pone a disposición de los
programadores también unas constantes, es decir, lo opuesto a las variables. A
un nombre se asocia un valor que el programador puede utilizar, pero que no
puede modificar. Vamos a ver cuáles son:
__FILE__
El nombre del script que está sometido al parsing;
__LINE__
La línea en la que se encuentra esta declaración;
PHP_VERSION
La versión di PHP en uso;
PHP_OS
El nombre del sistema operativo sobre el que trabaja el script;
TRUE
Un valor siempre verdadero;
FALSE
Un valor siempre falso;
E_ERROR
Un error, diferente del error usual de parsing (es decir, escritura del
código), que no se puede recuperar;
E_WARNING
Como arriba, pero en este caso el PHP puede seguir la ejecución del código;
E_PARSE
Un error del parser (es ecir, de la sintaxis del archivo);
E_NOTICE
Algo que podría o no podría ser un error. La ejecución no se interrumpe;
La pregunta, a este punto, es: ¿cómo utilizamos estas constantes? La respuesta
es bastante simple: hay que utilizar un código como:
<?
echo "Línea ", __LINE__ . " del file " ,__FILE__;
?>
que os devolverá Linea XX del archivo NOMBREFILE. Probadlo. Además hay que
añadir que, si éstas son las constantes "de default" del lenguaje, es
posible definir en un script las propias constantes de forma mucho más simple,
como veremos cuando hablemos de las funciones internas del lenguaje.
Tipos
de datos
El PHP soporta distintos tipos de datos, que no los tiene
que impostar el programador, sino que son asumidos directamente por el motor,
siempre que el programador no cambie el tipo (utilizando la función settype()
).
Los datos pueden ser:
· Integer;
· Floating Point
number;
· String;
· Array;
· Object.
Operadores
aritméticos
Los operadores aritméticos son los más simples y son:
$a + $b -> sumar
$a - $b -> restar
$a * $b -> multiplicar
$a / $b -> dividir
$a % $b -> resto
Fijémonos un momento en los últimas dos:
Asignación
A menudo,
desgraciadamente, los operadores de asignación se confunden con el operador de
identidad. El operador "=" tiene un significado que no hay que
confundir con el de "==".
El operdaor de asignación es el símbolo igual a (=) que da a una variable un valor,
por ejemplo
$a = 2;
asigna a "$a" el valor "2".
El error que se hace a menudo es escribir algo como:
if ($a=2) {
do_something;
}
que, si lo leen ojos inexpertos, podría parecer una expresión para decir que si
$a es IGUAL a 2 hay que ejecutar el código que está entre las llaves. Pues
bien, no es tan grave: si hubieramos querido escribir lo que acabamos de decir,
hubiéramos tenido que utilizar:
if ($a == 2) {
do_something;
}
Estructuras
de control
No pueden
faltar en un lenguaje de programación las estructuras de control que permiten
que el programador ejecute unas acciones en el programa cuando se dan (o no se
dan) determinadas condiciones.
IF
If permite ejecutar un bloque de noticias si se da (o no se da) una determinada
condición. Su sintaxis es:
if (condición)
statement
Por ejemplo, queremos que un script nos indique si dos variables son iguales:
$a = 2;
$b = 2;
if ($a == $b) {
eco "\$a es igual a \$b y valen $a.\n";
}
If se puede utilizar también de forma diferente de la que acabamos de explicar.
Aquí hay un ejemplo:
<? $a = 2; $b = 2; if ($a == $b) : ?>
$a es igual a $b.
<? endif; ?>
que hace lo mismo que la de arriba.
"if" se puede utilizar incluso entre llaves, utilizando
"endif" cuando se quiera terminar el bloque "if"; por
ejemplo:
if ($a == $b)
eco "\$a es igual a \$b y valen $a.\n";
endif;
ELSE
Else sirve
para "completar" if: con if, de hecho, hemos decidido que ocurra algo
cuando se da una condición. Con else podemos programar qué ocurre cuanda esta
condición no se da. Un ejemplo podría ser:
$a = 2;
$b = 3;
if ($a == $b) {
eco "\$a es igual a \$b y valen $a.\n";
} else {
eco "\$a es distinta de \$b.\n\$a vale \"$a\" mientras \$b vale
\"$b\".\n";
}
ELSEIF
Elseif
permite especificar casos no definidos por "if". Un ejemplo podría
ser: "Si $a es igual a $b visualiza $a, si $a es distinto de $b visualiza
un mensaje de error; avisa si $a no existe, avisa si $b no existe". Sólo
con if y else no se podría conseguir, sin embargo con elseif se convierte en
una oparación muy simple:
if ($a == $b) {
echo "\$a es igual a \$b.\n";
} elseif ($a != $b) {
echo "\$a es distinto de \$b.\n";
} elseif (!$a) {
echo "\$a no existe.\n";
} elseif (!$b) {
echo "\$b no existe.\n";
}
Fijaos en dos aspectos: en un bloque pueden estar todos los elseif que
necesitáis y, para los que conocen el Perl, cuidado con no escribir
"elsif" en lugar de "elseif", porque el significado es el
mismo pero "elsif" no es reconocido por el PHP así como elseif no es
reconocido por el Perl.
WHILE
La
condición "while" se comporta exactamente como en C; la sintaxis de
base es:
while (expresión) declaración
Como "if", además, "while" se puede utilizar con o sin
corchetes, añadiendo en el segundo caso la declaración "endwhile".
Los dos ejemplos que ponemos a continuación son lo iguales:
/* Primer ejemplo: */
/* $a se incrementa y se visualiza */
/* hasta que su valor no supere "5" */
$a = 1;
while ($a <= 5) {
print $i++;
}
/* Segundo ejemplo */
$a = 1;
while ($a <= 5)
print $i++;
endwhile;
Traducidas, estas expresiones hacen posible que, hasta que (while) $a sea menor
o igual a "5", $a se incrementa de una unidad y luego se visualiza.
FOR
También "for" se comporta exáctamente como en C o
en Perl. Después del "for", se tienen que introducir tres expresiones
que, mientras devuelvan "TRUE" permiten la ejecución de la
declaración que está a continuación. Vamos a ver el ejemplo:
for ($a = 0 ; $a <=10 ; $a++) {
print $a;
}
Esto visualizará los números entre "0" y"10". En las tres
expresiones entre paréntesis hemos definido que:
· $a tiene valor
"0";
· $a es menor o igual
a "10";
· $a se incrementa de
una unidad.
Por lo tanto, por cada valor de $a a partir de "0" hasta
"10" $a se visualiza.
SWITCH
"Switch"
permite sustituir una serie de "if" en la misma expresión y, por
supuesto, actuar independientemente del valor de ésta:
switch ($i) {
case 0:
echo "\$i vale 0";
break;
case 1:
echo "\$i vale 1";
break;
}
Aquí hemos introducido "break" que permite salir de un bloque en el
caso de que se realice una condición establecida.
Funciones
Empecemos con una pequeña adevertencia: todas las funciones
que se refieren a la base de datos PostgreSQL tienen el nombre que empieza por
"pg_" para diferenciarlas de las funciones parecidas utilizadas en
otras bases de datos. No hubiera tenido ningún sentido utilizar una función con
el nombre genérico "connect()" para la conexión a una base de datos.
Por lo tanto tendréis la función "pg_Connect()" y la función
"mysql_connect()" y muchas más cuyo nombre termina por
"connect", pero que se refieren a diferentes bases de datos.
Ahora podemos empezar el análisis de las funciones que pueden ser útiles para
nuestros script.
pg_connect
Abre la conexión a una base de datos Postgres; la sintaxis de la función acepta
mediante argumentos el huésped, la puerta, determinadas opciones (opcionales),
la tty (opcionales) y el nombre de la base de datos. Todos los valores se
tienen que poner entre comillas. La conexión desde una base de datos PostgreSQL
se puede hacer con:
pg_connect("dbname=... port=... host=... tty=... options=... user=...
password=...");
Obviamente, se tienen que sustituir los puntos suspensivos con los valores
necesarios para la conexión. Podemos escribir simplemente:
$conexión = pg_connect("dbname=agenda");
Con esta sintaxis, por lo tanto, nos hemos conectado a nuestra base de datos.
Para comprobarlo, sin embargo, podemos añadir:
$conexión = pg_connect("prueba_db");
if ($conexión) {
print "Conectado\n";
}
De este modo, si se logra establecer una conexión (y, por tanto, si la variable
$conexión esta definida) aparecerá una línea de confirmación. Uno de los
errores más usuales es pensar que $conexión, en este caso, se puede leer para
ver los valores introducidos en la base de datos. Introducir "echo
$conexión" no tiene ningún sentido porque el script sólo conseguiría
restituirnos un "1", en caso de que la conexión se efectúe, y un
"0", en caso contrario. Por tanto, $conexión y, en general, cualquier
variable que asociemos a la función pg_connect ( y, en general, a todas las
funciones de connect relativas a otras bases de datos) es solamente el estado
de la conexión, y no un instrumento para leer los datos del database. Veremos a
continuación cómo leer los datos y visualizarlos en una página web.
pg_Close
Como podemos imaginar, la función pg_Close cierra una conexión precedentemente
abierta con pg_Connect.
Para cerrar la conexión que hemos abierto con el código antes presentado, será
suficiente utilizar la sintaxis:
$desconexión = pg_Close($conexión);
que reproducirá valor verdadero (1) en caso de que la conexión se haya
establecido precedentemente y, con este mando, cerrada, falso, en caso
contrario.
pg_DBname
Esta función restituye el nombre de la base de datos a la que estemos
conectados, o el valor falso en caso de que no se haya establecido ninguna
conexión; la sintaxis para utilizar este mando es:
$dbname = pg_DBname($conexión);
echo "$dbname\n";
pg_ErrorMessage
Restituye una cadena que contiene un mensaje de error que proviene del
database.
pg_Exec
-------- Básicamente, este mando ejecuta unna query (pregunta) en la base de
datos. Nos podríamos esperar que esta función representa los campos interesados
en la query pero no es así. Si escribimos, por ejemplo:
$query = pg_Exec($conexión, "SELECT * FROM indirizzi");
no podemos visualizar directamente el valor de $query, o mejor no tiene sentido
hacerlo. Tendremos que servirnos de otras funciones que veremos a continuación,
por ejemplo pg_Numrows, pg_Fetch_Array etc.
pg_Fetch_Array
Ejecuta el fetch de una línea introduciendo los valores dentro de un array.
Hemos hablado antes de pg_Exec y de que muchas funciones son
"complementari" a ésta. Es el caso de pg_Fetch_Array. Podemos
ejemplificar todo:
$query = pg_Exec($conexión, "SELECT * FROM direcciones");
$query_result = pg_Fetch_Array($query, 0);
echo "<b>Nombre:</b> ";
echo $query_result[0], "<br>";
echo "<b>Apellidos:</b> ";
echo $query_result[1], "<br>";
echo "<b>Dirección:</b> ";
echo "$query_result[2], $query_result[3] <br>";
Veamos más de cerca lo que hemos hecho. Entretanto con pg_Exec_Query hemos
colocado la query que queremos ejecutar en la base de datos; con el sucesivo
pg_Fetch_array hemos especificado que la primera línea de la query (la línea
cuyo número es cero) se memorizase en la variable $query_result; después hemos
visualizado todos los datos formatándolos para una página HTML.
Notad que pg_Fetch_Array acepta como parámetros la query (en nuestro caso
$query) y la línea a la que hace referencia; nosotros, en este caso hemos
elegido la primera, pero con una sintaxis más "fina" podremos crear
la misma página con todos los datos introducidos en el database:
$query = pg_Exec($conexión, "SELECT * FROM direcciones");
$righe=pg_numrows($query); // veremos la función pg_numrows más adelante
for ($num=0;$num<=$líneas-1;$num++) {
$query_result=pg_fetch_array($query, $num);
echo "<b>Nombre:</b> ";
echo $query_result[0], "
";
etc. etc.
}
De esta forma, con un simple "for" y sabiendo el número total de las
líneas interesadas en la query, hemos logrado que todas sean procesadas y
visualizadas.
pg_Fetch_Object
Esta función ejecuta las mismas operaciones que la anterior con la diferencia
de que en este caso se crea un objeto con los resultados de la query y no un
array de datos. De este modo no tendremos ya que invocar los datos del interior
del array con los números del índice, sino que podremos utilizar el nombre del
campo, por ejemplo:
$query = pg_Exec($conexión, "SELECT * FROM direcciones");
$query_result = pg_Fetch_Object($query, 0);
echo "Nombre: ", $query_result->nombre;
echo "Apellidos: ", $query_result->apellidos, "\n";
echo "Dirección:", $query_result->dirección, "\n";
También en este caso hubiéramos podido introducir un bloque "for"
para visualizar todos los datos presentes en la base de datos.
pg_NumFields e pg_NumRows
Estas dos funciones restituyen, respectivamente, el número de campos y de
líneas interesadas en la query. Hemos visto la función pg_NumRows
precedentemente, pero podemos resumir el uso de las dos funciones con:
$query = pg_Exec($conexión, "SELECT * FROM direcciones WHERE nombre
LIKE
'Ma%' OR apellidos LIKE 'Ro%'");
$righe = pg_NumRows($query);
$campi = pg_NumFields($query);
echo "La query interesa $líneas líneas y $campos campos.\n";
Como veis, hemos complicado la query pero el resto del código es muy fácil de
entender.
Gestión
de los Cookies
Como todo buen lenguaje referido a la creación dinámica de
páginas web, también el PHP permite gestionar los cookies, que son pequeños
archivos de texto que incluyen informaciones útiles y no peligrosas para la
gestión de las sesiones en el web.
Siendo PHP un lenguaje que nació para la interacción con el WWW, las funciones
que se refieren a los Cookies son internas al PHP mismo. Otra cosa totalmente
diferente ocurre con los demás lenguajes, Perl en primer lugar (para este tema
véase el seminario sobre los Cookies en Perl publicado en CGIpoint y la
recensión de cookie-lib en el mismo sitio).
La función que nos interesa es sólo una setcookie(). Básicamente su sintaxis
es:
setcookie(Nombre, Valor, Caducidad, Recorrido, Dominio, Secure);
Intentemos aclarar las opciones que se pueden pasar a la función:
· Nombre es el nombre
del cookie que se puede elegir de forma arbitraria;
· Valor es el
valor,arbitrario, que se asigna al cookie;
· Caducidad es la
fecha de caducidad del cookie;
· Recorrido es el
directorio a partir del dominio (ver abajo) para el que es válido;
· Dominio es el
dominio para el que es válido;
· Secure es un valor
que decide si el cookie se tiene que enviar a través de una conexión HTTPS.
Si queremos enviar de nuestra página un cookie llamado "Test", con
valor "Prueba del cookie Test", con duración de un minuto del envío,
para el directorio "/nombreusuario" del dominio
"http://www.dominio.com" sin utilizar una conexión HTTPS, los
parámetros que hay que pasar a setcookie son:
setcookie("Test", "Prueba del cookie Test", time()+60,
"/nombreusuario", ".dominio.com", 0);
Las cosas interesantes que hay que analizar son dos: el tiempo de duración y la
conexión HTTPS. Por lo que se refiere a la segunda, fijamos con "0" que
la conexión tiene que ser normal. Si quisiéramos utilizar el protocolo seguro
HTTPS, tendríamos que introducir el valor "1". El tiempo de duración
no se puede fijar como "Tres minutos", porque no da tiempo. En cambio
tenemos que fijar el momento de caducidad a partir del momento en el que el
cookie se envía al usuario, por eso utilizamos las función interna time() a la
que añadimos el número de segundos a partir de los que tiene que caducar el
cookie. Por ejemplo, si el cookie se envía a las 13:20:00 y queremos que
caduque al cabo de 30 minutos (60x30=1800 secondi), podemos escribir una
expresión de expire:
time()+1800
De esta forma, time() corresponde a 13:20:00 y time()+1800 será 13:50:00
Entre los seis valores que hay que pasar como argumento al cookie, solamente el
primero es obligatorio, los demás se pueden dejar en blanco si no nos
interesan. Además, para enviar un cookie, es necesario que éste se envíe al
browser antes de cualquier output, por eso es necesario introducir la función
delante de todos los tag <HTML> o <HEAD>.
Para terminar, vamos a ver cómo leer un determinado cookie de un script.
Recordemos que un cookie se envía como un array de datos y que podemos acudir a
las funciones relacionadas a los array. Por lo tanto, podemos escribir:
if (isset ($cookie) ) {
while (list ($nombre, $valor) = each ( $cookie ) ) {
echo "$nombre = $value\n";
}
}
Para todas las informaciones introducidas en el cookie se visualizará una
pareja "nombre = valor". Obviamente, el valor es el que habéis
establecido en el cookie, los "nombres" son: cookie, expires, path,
domain y secure (éste último es singular porque si se fija en 1 da
"secure" en el cookie, sino no da nada).
Para nuestro cookie de ejemplo, leeremos algo como:
cookie=Test; epires=Thursday, expires=Monday, 31-Jul-00 11:50:00 GMT;
path=/nombreusuario; domain=.dominio.com
Si hubiéramos fijado 1 en vez de 0 para el protocolo HTTPS, hubiera aparecido
también "secure" al final de la cadena. Fijaos en una última cosa: la
fecha se gestiona de default según la hora GMT. La caducidad, de hecho, se ha
fijado para las 11:50:00 GMT, que son las 13:50:00 locales.