Vous êtes sur la page 1sur 60

PHP INICIAL

Introducción al lenguaje

A lo mejor la mayoría de vosotros ya hayan leído el curso al PHP y, quizás,


hayan empezado a poner en práctica los ejemplos que hemos propuesto. En
esta guía no queremos volver a repetir lo que ya dijimos, sino que queremos
sólamente tratar el tema del lenguaje desde un punto de vista más teórico y
menos práctico.
Visto el éxito, a partir de la versión 3, del PHP, es importante para los que
quieran considerarse programadores web tener unos conocimientos más
profundos para saber crear aplicaciones con determinadas finalidades y
también para dejar que su propia fantasía se desahogue.

Orígenes y tipología del lenguaje

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:

1. Adabas D
2. InterBase

3. Solid

4. dBase

5. mSQL

6. Sybase

7. Empress

8. MySQL

9. Velocis

10. FilePro

11. Oracle

12. Unix dbm

13. Informix

14. PostgreSQL

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).

El primer ejercicio podría ser realizar un archivo prueba.php3 que incluya el siguiente código:
<HTML>
<BODY>

<? phpinfo(); ?>

</BODY>
</HTML>
Este aerchivo produce una panorámica en la que se visualizan los parámetros de configuración
de Php en el servidor donde se ejecuta el código. Puede ser útil para averiguar la presencia de
Php en un servidor o para saber el valor de las variables del sistema (para programadores
expertos).

Otro ejemplo podría ser el siguiente.


<HTML>
<BODY>

<? echo("Última modificación:


".date("d/m/Y",filemtime($PATH_TRANSLATED))); ?>

</BODY>
</HTML>
Visualiza la fecha de la última modificación de vuestro archivo. Puede ser útil cuando se
construyen sitios en la red, porque a menudo nos olvidamos tras una serie de actualizaciones
de cambiar la fecha. De esta forma, la página visualizará correctamente la fecha, sin que
tengamos que preocuparnos.
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:

 PHP es un lenguaje embeeded (empotrado) en el código HTML de


las páginas y no necesita, por lo tanto, otros archivos para que se
ponga en marcha;

 un script PHP, de hecho, no necesita ser instalado como ocurre con


un script CGI. Los que han leído alguna vez algún artículo en
www.cgipoint.it, se habrán dado cuenta de que cada script tieneque
cargarse en el servidor en determinados directorios, con permisos
especiales, etc.. Con el PHP esto ya no pasa: además de no
necesitar un directorio cgi-bin, ya que el código se introducee
directamente en las páginas, una vez que la página se cargue el
script está listo para el uso, siempre que se haya configurado
correctamente;

 con el PHP ya no se necesitan configuraciones especiales del


servidor de la red para que se habiliten directorios cgi-bin o la
realización de unos archivos que tengan determinadas extensiones.
Primero se dan instrucciones al servidor de la red, luego cada script
(o mejor, cada página que tenga el código del script) se puede poner
en marcha en CADA directorio donde esté. Fijaos en la comodidad
de esta característica del PHP.

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


e

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

?>

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.

 GATEWAY_INTERFACE: la versión de los CGI específicos que ha


utlizado el servidor, por ejemplo "CGI/1.1";
 SERVER_NAME: el nombre del servidor, que en Apache se define
como "ServerName" en httpd.conf, por ejemplo "myhost.com";

 SERVER_SOFTWARE: el nombre del software utilizado por el


servidor de la red, por ejemplo "Apache/1.3.9 (Unix) Debian/GNU
PHP/3.0.15 mod_perl/1.21_03-dev";

 SERVER_PROTOCOL: el nombre y la versión del protocolo con el


que se ha solicitado la página, por ejemplo "HTTP/1.0";

 REQUEST_METHOD: utilizado en el form, puede ser "GET",


"POST", "HEAD", "PUT";

 QUERY_STRING: si está, la cadena con la que se ha solicitado la


página;

 DOCUMENT_ROOT: la DocumentRoot del servidor, como


configurada httpd.conf, por ejemplo "/var/www";

 HTTP_ACCEPT: el contenido del header Accept, por ejemplo "text/*,


image/*, audio/*, application/*";

 HTTP_ACCEPT_CHARSET: el charset aceptado, por ejemplo "iso-


8859-1";

 HTTP_ENCODING: el encoding de la solicitud, si está; por ejemplo,


"gzip";

 HTTP_ACCEPT_LANGUAGE: por ejemplo el lenguaje "in";

 HTTP_CONNECTION: el contenido del header Connection, por


ejemplo "Keep-alive";

 HTTP_HOST: el nombre del huésped, por ejemplo "localhost";

 HTTP_REFERER: el nombre de la página de la que se llega;

 HTTP_USER_AGENT: el contenido del header User_Agent, por


ejemplo "Mozilla/4.72 [en] (X11; I; Linux 2.2.14 i586)";

 REMOTE_ADDR: la dirección IP del usuario conectado a nuestra


página;

 REMOTE_PORT: como antes, pero referido a la puerta; por ejemplo,


las dos variables podrían tener un output del tipo: "127.0.0.1 1275";

 SCRIPT_FILENAME: el nombre del script solicitado por el servidor,


por ejemplo "prova.php3";

 SERVER_ADMIN: el nombre del administrador del sistema;

 SERVER_PORT: la puerta en la que el servidor está en escucha, por


ejemplo la puerta 80;

 SERVER_SIGNATURE: la posible "firma" del servidor;

 PATH_TRANSLATED: el recorrido del script invocado, por ejemplo


"/var/www/php/prova.php3";

 SCRIPT_NAME: el path, a partir de la DocumentRoot, del script; por


ejemplo, /php/prova.php3";

 REQUEST_URI: el URI que se necesita para acceder a la página;

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.

Vamos a verlos de uno en uno.

Integer

Los Integers, o enteros, pueden tener distintos valores númericos que se


expresan con diferentes anotaciones.

$a = 18; # decimal
$a = -18; # decimal negativo
$a = 022; # anotación octal; es igual a 18 decimales
$a = 0x12; # anotación exadecimal, es igual a 18 decimales

Probablmente, por lo menos para empezar, tendréis que utilizar sobre todo
los números decimales, sin embargo hay que saber que el lenguaje admite
incluso otras anotaciones ademas de la decimal.

Floating point number

Este tipo de datos son los números con la coma móvil, por ejemplo, 9.876.
La sintaxis para utilizarlos es bastante simple:

$a = 9.876;
$a = 9.87e6;

Strings

Con respecto a las strings hay mucho más que decir porque son tipos de
datos diferentes. La sintaxis de base es:

$string = "Yo soy una cadena";

Si se utilizan las comillas (""), el contenido de la cadena se expande (o,


técnicamente, "interpolado") , como en el ejemplo a continuación:

$num = 10;
$string = "El número es $num";

Esto visualizará "El número es 10".


Sin embargo, como con todos los lenguajes, también con los PHP tenemos
caracteres especiales que tienen que estar anticipados por un símbolo, por
ejemplo:

$num = 10;
$string = "El número es "$num"";
Los que piensen que el output de este código es 'El número es "10"' se
equivocan. A parte de que, así como está escrito, el script daría un error de
redacción, las comillas son caracteres especiales, sin embargo, es posible
utilizarlas. Por lo tanto la sintaxis correcta para el mando es:

$num = 10;
$string = "El número es \"$num\"";

Otros caracteres especiales son:

\n -> newline
\r -> carriage return
\t -> tabulación
\\ -> backslash
\$ -> símbolo del dólar

La alternativa a los caracteres de escape, cuando no haya contenidos que


extender, son los ápices (''); por ejemplo:

$string = '$ es el símbol del dólar';

visualizará precisamente los que están en los ápices. Cuidado con un error
muy común:

$num = 10;
$string = 'El número es $num';

no visualizará "El número es 10" sino "El número es $num". Por lo tanto,
podemos decir que con los ápices el contenido de la cadena se se hace una
transmisión literal, tal como está escrito entre las ápices.

Array

El PHP soporta tanto los array escalares como los array asociativos.

En PHP un array de valores se puede crear explícitamente definiendo los


elementos, o su creación puede hacerse introduciendo valores en el array.
Por ejemplo:

$a = ("abc", "def", "ghi");

crea el array definiendo explícitamente los elementos del array, al contrario


de lo que ocurre en el ejemplo siguiente:

$a[0] = "abc";
$a[1] = "def";
$a[2] = "ghi";

En este caso, el array se crea con tres elementos. Recordemos que el primer
elemento de un array se identifica con el número "0". Si, por ejemplo, la
longitud de una array es "5", éste incluye seis elementos. El elemento que
tiene el índice "0" es el primero del array.
Si, en cambio, para añadir elementos a un array (supongamos que nos
referimos al que hemos creado arriba) se utilizan los corchetes vacíos y los
datos se ajustan al array. Por ejemplo:
$a[] = "lmn";
$a[] = "opq";

En este caso caso, el array se alarga 2 elementos y resulta ser:

$a[0] = "abc";
$a[1] = "def";
$a[2] = "ghi";
$a[3] = "lmn";
$a[4] = "opq";

Este ejemplo es mucho más útil cuando queremos ajustar los elementos al
array sin acudir a funciones específicas y sin tener que leer el número de los
elementos que están en el array. Todo se ajustará automáticamente y
correctamente.

Los array asociativos se basan, en cambio, en parejas "name-value" y un


ejemplo podría ser:

$a = array(
"nombre" => "Mario",
"apellido" => "Rossi",
"email" => "mario@rossi.com",
);

Es interesante la posibilidad que tiene la función array de introducir las


entries, como en el ejemplo que sigue:

$a = array(
"primero" => array(
"nombre" => "Mario",
"apellido" => "Rossi",
"email" => "mario@rossi.com",
),
"segundo" => array(
"nombre" => "Marco",
"apellido" => "Verdi",
"email" => "mario@verdi.com",
)
);

Ejecutar en este array una instrucción del tipo:

<? echo $a["segundo"]["email"]; ?>

visualizará "mario@verdi.com".

Objects

En PHP se pueden utilizar también los objetos. Para empezar vamos a ver
un ejemplo:

class visualiza {
function ejecutar_visualiza () {
eco "Visualiza un mensaje";
}
}

$obj=new visualiza;
$obj->ejecutar_visualiza();

En primer lugar definimos la clase "visualiza", que incluye la función


"ejecutar_visualiza" que quiere decir que visualiza simplemente un mensaje
en la pantalla.
Con la declaración "new" inicializamos el objeto "$obj" e invocamos la
función visualizar con el operador -> en $obj.
Como podéis ver, utilizar los objetos no es nada difícil aunque, para
describirlos más en detalle, serían neceserario más explicaciones.

Operadores

Los operadores que se pueden utilizar con PHP son parecidos a los que se
utilizan con otros lenguajes de programación. Para nuestra comodidad, los
vamos a dividir en distintas "familias": los operadores aritméticos, los
operadores de asignación y todos los demás.

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:

 El resultado de la división no se aproxima al entero que está más


cerca sino que da todo el número. El número de los caracteres
después del punto se define en el archivo php3.ini en la línea:

precision = 14

Por lo tanto, saldrán sólo 14 números después de la coma, siempre


que los haya, como en el ejemplo:

$a = 12;
$b = 5;
$c = $a / $b;
echo $c;

el resultado es 2.4 y se visualizará precisamente como 2.4, no como


2.40000000000000. Por lo tanto, los 14 decimales se visualizan sólo
si existen y no indiscriminadamente como ceros inútiles.

 el resto se da por sí solo, sin el resultado de la división misma. Si en


el ejemplo anterior hubieramos utilizado "%" en vez de "/", el
resultado habría sido "2".

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;
}

Otros operadores

Los operadores que el PHP nos pone a disposición son muchos y veremos
en está página los más importantes que hasta ahora no hemos tenido la
posibilidad de analizar. En particular, hablaremos de los valores booleanos,
los matemáticos y los de incremento-decremento:

$a & $b
operador "And" ($a e $b);

$a && $b
como arriba, pero con una procedencia más alta;

$a | $b
operador "Or" ($a o $b);

$a || $b
como arriba, pero con una procedencia más alta;

$a ^ $b
operador "Xor" ($a o $b pero con ambos);

!$a
operador "Not" (verdadero si $a no es verdadera);

$a == $b
operador de igualdad, verdadero si $a tiene el mismo valor que $b;

$a != $b
lo opuesto de lo de arriba;

$a < $b;
$a es menor de $b;

$a <= $b
$a es menor o igual a $b;

$a > $b
$a mayor que $b;

$a >= $b
$a es mayor o igual a $b;

$a ? $b : $c
éste, se utiliza más con las expresiones que con las variables, evalúa $b si
$a es verdadera, y evalúa $c si $a es falsa;

++$a
incrementa de uno $a y la devuelve;

$a++ devuelve $a y la incrementa de uno

--$a
$a--
como los dos anteriores, pero se decrementa el valor;

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.

Abs, acos, array, asin, atan

Vamos a ver ahora, después de haber visto qué y cuáles son las variables,
qué se hace con ellas y cómo se gestionan los bloques, es decir, pasemos a
las funciones. Las funciones son una de las partes más importantes de un
lenguaje de programación, porque permiten ejecutar unas operaciones en un
script.

Las funciones que el PHP nos pone a disposición son muchísimas, y verlas
todas sería inútil. Por lo tanto nos centraremos en las más importantes
ordenadas alfabéticamente.

 abs: devuelve el valor absoluto de un número.

$num = -3.4;
$aa = abs($a);
echo $aa, "\n";

devolverá 3.4

 acos: devuelve el arco coseno del argumento.

$arg = 1;
$arc_cos = acos($arg);
echo "$arc_cos\n";

devolverá 0.

 array: véase la explicación anterior con respecto a estos tipos de datos;


 asin: devuelve el seno del argumento;

 atan: devuelve el arco tangente del argumento;

bcadd, bcdiv, bcmult, bcpow...

 base64_decode: descodifica una cadena codificada en MIME base64


(véase abajo);

 base64_encode: codifica datos en MIME base64; por ejemplo con:

$str = "Hola, soy tribilín\n";


echo "$str\n";
$enc_str = base64_encode($str);
echo "$enc_str\n";
$dec_str = base64_decode($enc_str);
echo "$dec_str\n";

si pasa al script la cadena "$str" que se ha codificado y visualizado antes,


después se vuelve a codificar y a visualizar otra vez;

 basename: devuelve, estableciendo un recorrido, su componente


identificada por un nombre de archivo. Por ejemplo:

$path = "/var/www/php/index.php3";
$base = basename($file);
echo "$basename\n";

devolverá "index.php3";

 bcadd: sumar dos números;

$num = bcadd(1.334, 4.44554, 2);


echo "$num\n";

devolverá 5.77. La función "bcadd" toma, como los primeros dos


argumentos, dos números y, como terceros argumentos opcionales, el
número de cifras que hay que visualizar después de la coma;

 bccomp: compara dos números. La función toma como argumento dos


números y, como opción, otro número que determina el número de decimales
que hay que tener en cuenta después de la coma para considerar los dos
números iguales. Devuelve "0" si los dos números son iguales, "+1" si el
número a la izquierda es mayor que el de la derecha y "-1" si ocurre lo
contrario. Fjaos en el ejemplo siguiente:

$comp = bccomp(0.334, 0.301, 2);


echo $comp;

que devolverá "1". Pero, si en vez de "2" hubiésemos introducido 1 o nada, el


resultado sería "0".

 bcdiv: divide dos númers, con las mismas modalidades descritas para
"bcadd" y "bccomp";
 bcmult: multiplica dos números y es posible añadir un parámetro más
para limitar el número de cifras después de la coma:

$molt = bcmul(2.31, 3.21, 2);


echo "$molt\n";

devolverá 7.41;

 bcpow: eleva a potencia dos números con la posibilidad de especificar el


número de cifras después de la coma:

$pot = bcpow(2.3, 3, 2);


echo "$pot\n";

eleva 2.3 a la tercera potencia, aproximando el resultado a la segunda cifra


decimal;

 bcsqrt: calcula la raíz cuadrada de un número con la posibilidad de


aproximar el número de cifras después de la coma, añadiendo un segundo
elemento a la función (como ocurría para las demás funciones matemáticas
vistas antes);

 bcsub: resta un número de otro con la posibilidad de aproximar las cifras


después de la coma:

$num = bcsub(2, 5);


echo "$num\n";

devolverá "-3";

 bin2hex: convierte una cadena de datos del formato binario al formato


exadecimal;

Ceil, chdir, checkdate, chgrp...

 ceil: devuelve el valor entero más alto con respecto al número que se ha
pasado como argumento a la función:

$num = ceil(3.22112);
echo "$num\n";

devuelve "4";

 chdir: cambia el directorio de trabajo:

$dir = "/var/www/";
chdir($dir);

devuelve TRUE si la operación tiene éxito, FALSO en el caso contrario. Por


ejemplo si el directorio no se puede leer;

 checkdate: controla que una fecha sea válida. Para que sea válida una
fecha tiene que tener:

- año entre "0" y "32767";


- mes entre "1" y "12";
- día entre "0" y el número que se refiere al número de días del mes al que
nos referimos;

 chgrp: intenta cambiar el grupo de un archivo a "grupo". La función


acepta como argumentos el nombre del archivo al que queremos cambiar los
permisos y el nuevo grupo al que pertenecen:

chgrp(filename, grupo);

En los sistemas Windows no funciona, sin embargo devuelve siempre


verdadero.

 chmod: es lo mismo que el mando de sistema Unix "chmod" y tiene la


misma sintaxis que chgrp;

 chmop: desplaza los "whitespaces" de una cadena. Se utiliza a menudo


para borrar los caracteres "\n" cuando se recibe un argumento del estándar
input; el carácter que se elimina se puede leer con:

$carácter = chop($string);
echo "$carácter\n";

 chown: cambia el propietario de un archivo, como el correspondiente


mando de sisetma Unix. Acepta como argumento el nombre del archivo y el
nombre del nuevo propietario:

$file = "prueba.txt";
chown($file, $user);

En los sistemas Windows no hace nada y devuelve siempre verdadero (y


además es útil introducir esta función en un script que no soporta el
"chown");

 chr: devuelve el carácter ASCII especificado por el número


correspondiente. Me imagino que sabréis, por ejemplo, que la combinación
"Alt + 0126" devuelve la símbolo (~); se puede ver con este código:

$ascii= "0126";
$char = chr($ascii);
echo "$char\n";

 chunk_split: divide una cadena en partes de "n" caracteres. El número


puede pasar a la función después de la cadena que hay que dividir. Si no se
imposta, de default es asumido como 76. Por ejemplo:

$string = "Éste es un curso para aprender el lenguaje php":


$split = chunk_split($string, 5);

devolverá:

Ést
o es u
n cur
so pa
ra apr
ender
el l
engua
je
php

La función es útil para el encoding MIME base64 que hemos visto


anteriormente con la fución "base64_encode";

 closedir: cierra un directorio que hemos abierto antes con la función


opendir() - véase;

 copy: crea la copia di un archivo:

$file = "prueba.txt";
copy($file, "$file.bak");

 cos: devuelve el valor del coseno del argumento;

 count: cuenta los elementos en una variable, por ejemplo:

$arr[0] = "abc";
$arr[1] = "def";
$arr[2] = "ghi";
$count = count($arr);
echo $count;

devolverá "3", visto que en el array "$arr" hay 3 elementos ($arr[0], $arr[1],
$arr[2]);

 crypt: cripta una cadena; la sintaxis de la función crypt() es:

crypt(string, salt);

Prácticamente tendríamos que pasar a la función la cadena que tendrá que


ser criptada y, como opción, el signo con el que la criptamos. Si éste no pasa
a la función, se dará de forma random del PHP mismo. Un ejemplo podría
ser el siguiente:

$var = "Ésta es una variable";


$crypt = crypt($var, "aa");
echo $crypt;

que devolverá la cadena criptada;

 current: devuelve el primer elemento de un array:

$arr[0] = "abc";
$arr[1] = "def";
$arr[2] = "ghi";
$current = current($arr);
echo $current;

visualizará "abc";

Debugger_off, date, decoct...

 date: visualiza la fecha en un formato que se puede definir. La función


reconoce como válidos los siguientes formatos:
a: am/pm;
A: AM/PM
d: día del mes con dos cifras, entre "0" y "31";
D: día del mes en formato texto, por ejemplo "Mon";
F: mes, en formato texto, por ejemplo "March";
h: hora en el formato "01", "12";
H: hora en el formato "00", "23";
g: hora en el formato "1", "12";
G: hora en el formato "0", "23";
i: minutos, en el formato "00", "59";
j: día del mes en el formato "1", "31";
l: día de la semana, por ejemplo "Monday";
L: especifica si el año es bisiesto o no ("1" o "0");
m: mes en el formato "01", "12";
n: mes en el formato "1", "12";
M: mes en formato texto corto, por ejemplo "Jan";
s: segundos entre "00" y "59";
S: sufijo inglés para los ordinales, "st", "nd", "rd", "th";
t: número de días del mes en curso, entre "28" y "31";
w: día de la semana en formato numérico ("0"=domingo);
Y: año en cuatro cifras, por ejemplo "2000";
y: año en dos cifras, por ejemplo "00";

Por ejemplo se podría escribir:

echo (date("l d F y H:i:s a));

para tener la fecha en curso que, por ejemplo, podría ser:

Friday 23 June 00 11:45:48 am

 debugger_off: inhabilita el depurador PHP;

 debugger_on: habilita el depurador PHP;

 decibin: convierte un número decimal en otro binario; por ejemplo, el


número "10" decimal es "1010" en formato binario, y con el código PHP
podemos escribir:

$bin = decbin(10);
echo $bin, "\n";

que devuelve precisamente "1010";

 dechex: convierte un número decimal en otro exadecimal; la sintaxis es


igual a la que se ha utilizado para "decbin()";

 decoct: convierte un número de formato decimal en otro de formato octal;


la sintaxis es la misma que se ha utilizado para "decbin()";

 define: define una constante. Como hemos visto en el capítulo de las


constantes, éstas son parecidas a las variables, lo único es que no llevan el
símbolo del dólar delante. Para definir una constante se utiliza la siguiente
sintaxis:

define("CONSTANTE", "Ésta es una constante");


echo CONSTANTE;
El ejemplo visualiza "Ésta es una constante";

 defined: controla si existe una constante ya establecida. Por ejemplo,


podría ser:

define("CONSTANTE", "Ésta es una constante");


if (defined("CONSTANTE")) {
echo "La constante se ha definido\n";
} else {
echo "La constante no se ha definido\n";
}

que visualiza un mensaje según la constante se haya definido o no;

 die: visualiza un mensaje y sale del programa:

if (defined($num)) {
echo "\$num se ha definido\n";
} else {
die ("\$num no se ha definido; imposibile seguir adelante\n");
}

 dirname: cuando se especifica un path, devuelve el path sin el nombre


del archivo final: si por ejemplo el path es
"/home/yourname/public_html/index.php3" la función devolverá solamente
"/home/yourname/public_html":

$path = "/home/yourname/public_html";
echo(dirname($path));

Os habéis dado cuenta de que esta función hace exáctamente lo contrario de


la función "basename()". Si combinamos las dos funciones, se puede obtener
el path completo de un archivo, incluso su nombre;

 diskfreespace: devuelve el espacio del disco que está libre; si queremos,


por ejemplo, ver cuál es el espacio que nos queda en el directorio root del
equipo, podemos escribir:

echo(diskfreespace("/"));

Each, echo, ereg_replace, ereg...

 each: devuelve el primer valor de un array utilizando las claves 0, 1, key y


value; si el array es asociativo, se puede escribir:

$array = array ("nombre" => "valor", "nombre2" => "valor2");


while (list($key, $val) = each ($array)) {
echo "$key => $val\n";
}

que devuelve:

nombre => valor


nombre2 => valor2
Si, en cambio, el array no es asociativo, el código será:

$array = array ("nombre", "valor", "nombre2", "valor2");


while (list($key, $val) = each ($array)) {
echo "$key => $val\n";
}

y el resultado:

0 => nombre
1 => valor
2 => nombre2
3 => valor2

Seguramente os habéis fijado en que la función "each()" a menudo se utiliza


junto a "list()", que veremos a continuación;

 echo: visualiza una o más cadenas. No creo que haya mucho que
comentar sobre esta función, en principio porque es muy simple y además
porque ya la hemos analizado y hemos visto como funciona.

 ereg_replace: devuelve una expresión regular con valores establecidos.


En la función hay que incluir tres argumentos: el primero indica el texto que
hay que sustituir, el segundo es el texto que se está utilizando y el tercero es
la cadena que hay que modificar. Por ejemplo:

$stringa = "Éste es un curso ASP";


echo ereg_replace("ASP", "PHP", $cadena);

Se hubiera podido escribir también:

echo ereg:replace("ASP", "PHP", "Éste es un curso ASP");

que, sin embargo, no tendría mucho sentido.

 ereg: ejecuta el matching de una expresión regular. El ejemplo que se


encuentra en la documentación es bastante claro:

if (ereg("([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})", $date, $regs)) {


echo "$regs[3].$regs[2].$regs[1]";
} else {
echo "Invalid date format: $date";
}

Todo el procedimiento se desarrolla para controlar que una fecha esté escrita
en un formato correcto. Vamos a ver el significado de "[0-9]{4})-([0-9]{1,2})-
([0-9]{1,2}". Para los que conocen las expresiones regulares, no será difícil
traducirlo con "un número entre 0 y 9 que hay que repetir cuatro veces y que
tiene que astar seguido de un '-', de un número entre 0 y 9 repetido una o
dos veces, de un '-' y de un número entre 0 y 9 repetido una o dos veces".
Muy a menudo es mucho más simple leer una expresión regular que
traducirla al lenguaje hablado.

 eregi_replace: funciona exáctamente como "ereg_replace()", solamente


que, en este caso, la expresión regular se sustituye por una forma "case
insensitive", es decir, pasando de los caracteres mayúsculas y minúsculas;

 eregi: funciona exácatmente como "ereg()", solamente que en este caso


la expresión regular se sustituye mediante una forma "case insensitive";
 error_log: envía un mensaje de error al archivo de log del servidor,
directamente a la puerta TCP de la que ha llegado la solicitud o a un archivo.
La sintaxis es:

error_log(message, mesage_type, destination);

Message_type es un número que especifica donde tiene que llegar el


mensaje Puede ser:

0: el mensaje se envía al logger del PHP o al archivo especificado por


"error_log";
1: el mensaje se envía por email al parámetro (probablemente una dirección
email válida) especificado en "destination"; 2: el mensaje se envía al
depurador;
3: el mensaje se introduce en append en el parámetro especificado en
destination";

 escapeshellcmd: si se invoca un mando exterior de una shell, con este


mando se consigue que delante de los metacaracteres de la shell haya un
carácter de escape para evitar que el mando produzca errores;

 exec: ejecuta un programa externo;

 exit: sale de un script; el mando "exit()" es útil cuando se quiere parar un


script siempre que no se cumplan unas condiciones, por ejemplo:

if (condición) {
ejecutar el bloque;
} else {
exit;
}

Recordad que "exit()" no lleva un mensaje de error como "die()": si os


interesa dar "explicaciones" sobre el porqué el script termina, hay que utilizar
"die()", pero no es posible escribir:

exit "Salir del programa\n";

o mejor, es posible pero no tiene ningún efecto excepto el de salir;

 exp: eleva "e" (2.71828.....) a la potencia que es el argumento de la


función:

echo exp(3);

devolverá: 20.0855369...

 explode: divide una cadena según un determinado pattern. Por ejemplo,


si queremos dividir una cadena que incluye tres nombres separados por
comas, podemos escribir:

$nombres = "Fulano,Mengano y Zutano";


list ($nombre1, $nombre2, $nombre3) = explode (",", $nombres);
echo "$nombre1\n$nombre2\n$nombre3\n";

que devolverá:

Fulano
Mengano
Zutano
Explode() es una versión simplificada de "split() que veremos sucesivamente.
Las dos funciones, además, son muy útiles cuando tenemos la necesidad de
leer unos archivos incluidos en los listados.

<

Fclose, feof, filegroup, filesize...

 fclose: cierra un puntero en un archivo que se ha abierto antes con fopen().


Véase fopen() para más informaciones;

 feof: controla un puntero en un archivo para ver si está al final del mismo;

 fgetc: restituye el primer carácter del puntero que se ha abierto antes con fopen().
Si, por ejemplo, el puntero $file señala el archivo "/tmp/prova.txt" que incluye
solamente la línea "Hola", aparecerá un código como el siguiente:

$char = fgetc($file);
echo "$char\n";

devolverá "C" (por supuesto sin comillas);

 file_exists: controla si un archivo existe, en este caso dará TRUE sino FALSE,
por ejemplo :

if (file_exists($file)) {
print "$file esiste;
}

Puede ser muy útil utilizar esta función cuando necesitamos intervenir en uno o más
archivos para actuar sobre el mismo sólo si éste existe sin arriesgarse a
inexplicables "anomalías" del script;

 filegroup: devuelve el grupo al que pertenece el archivo:

$filename = "/tmp/prueba.txt";
$group = filegroup($filename);
echo "$filename pertenece al gruppo $group\n";

Obviamente, la función se implementa sólo en los sistemas multiuser;

 filesize: devuelve la domensión de un archivo:

$filename = "/tmp/prueba.txt";
$size = filesize($filename);
echo "$filename -> $size\n";

 filetype: determina el tipo de archivo; los valores posibles son: fifo, char, dir,
block, link, file y unknown;

 flock: aplica el locking a un archivo; de modo específico flock() opera en un


puntero en un archivo que se ha abierto antes y las operaciones posibles son:

1: para el lock en lectura;


2: para el lock en escritura;
3: para quitar el lock, cualquiera que sea el tipo;
4: para impedir que flock() bloquee un archivo cuando aplica el lock;

Por ejemplo, para aplicar flock() en un puntero "$file" definido antes, se necesita
escribir:

flock($file, 2);
/* Para impedir que el archivo se lea*/
.....
/* Código para trabajar en el archivo */
flock($file, 3);
/* Para quitar el flock */

 fopen: abre un archivo o un URL. La sintaxis es:

fopen(filename, mode);

Obviamente a "filename" le corresponde el nombre del archivo o el URL del mismo, y


a "mode" la modalidad con la que se tiene que abrir. Aquí se puede elegir entre:

r -> abre el archivo sólo cuando se lee;


r+ -> abre el archivo cuando se lee y se escribe;
w -> abre el archivo sólo cuando se escribe;
w+ -> abre el archivo cuando se lee y se escribe;
a -> abre el archivo sólo cuando se escribe e introduce el puntero al final del archivo
("w" lo introduce al final)
a+ -> abre el archivo cuando se lee y se escribe introduciendo el puntero al final del
archivo;

Por ejemplo, para abrir un archivo local sólo para leerlo tendremos que escribir:

$file = fopen("/tmp/prueba.txt", "r");

Para un URL, en cambio:

$file = fopen("http://www.myhost.com/index.html", r");

Para todas las sucesivas operaciones en el archivo, además, tendremos que actuar
directamente sobre el puntero ($file) y no directamente sobre el archivo.

Header, hexdec, implode, in_array...

 header: envía cualquier header HTTP; por ejemplo:

header("Pragma: no-cache");

Esta función es muy útil en distintos casos: por ejemplo, para forzar una
autorización se puede enviar un "401", etc.;

 hexdec: devuelve el valor decimal de un número exadecimal;

 implode: como se puede entender por el nombre, esta función no es


nada más que lo contrario de "explode". La sintaxis es igual, pero en este
caso devuelve una cadena con los valores separados del primer argumento y
la función;

 in_array: devuelve valor verdadero si en un array hay un determinado


valor. Un ejemplo podría ser:

$números = array("1", "2", "3", "4", "5");


$num = 2;
if (in_array($num, $números)) {
print "$num está en el array \$números\n";
}

 is_array: controla si una fecha variable es un array:

if (is-array($var)) {
echo "\$var es un array\n";
}

Lo mismo ocurre con las funciones siguientes, con la única diferencia del
argumento:

- is_dir;
- is_double;
- is_executable;
- is_file;
- is_float;
- is_int;
- is_integer;
- is_link;
- is_long;
- is_object;
- is_readable;
- is_real;
- is_string;
- is_writeable.

 isset: devuelve TRUE si existe la variable, falso si no existe. Por ejemplo,


para ver si existe o no una variable es posible escribir:

$a = 10;
echo isset($a), "\n";
echo isset($b), "\n";

que devolverá 1 y 0. recordemos que 1 se considera valor positivo (TRUE), 0


negativo (FALSE);

 join: une los elementos de un array con una cadena determinada; el uso
es igual al de implde();

 key: toma una clave de un array asociativo. Un ejemplo simple puede ser:

$array = array("1" => "uno");


$clave = key($array);
echo "$clave\n";

que devolverá "1". Esta función es útil pata retomar todas las claves de los
array asociativos complejos;

 link: crea un hard enlace. La sintaxis es:

link(target, link);
Las informaciones sobre los enlaces (a propósito de la existencia del archivo
al que se refiere el enlace mismo) se pueden visualizar con linkinfo();

 list: da unas variables como si fueran partes de un array. Volvamos al


ejemplo que hemos hecho con each:

$array = array ("nombre" => "valor", "nombre2" => "valor2");


while (list($key, $val) = each ($array)) {
echo "$key => $val\n";
}

En este caso, list() se utiliza para "redactar" una lista de variables que se
recogerán del array sin darles un valor sino dejando a las partes sucesivas
del código la asignación de sus valores. Además hay que notar que las
variables creadas por list() no tienen sólo un valor, sino que cada vez que se
invocan tienen un valor diferente, según los elementos que se encuentran en
el array.

Mail, max, mkdir, opendir, phpinfo...

 mail: funcion para enviar email. La función tiene una sintaxis:

mail(To, Subject, Message, Otros_headers);

Si queremos enviar un email a "nombre@host.com" con subject "Prueba" y


queremos especificar el nombre del remitente, podemos escribir:

mail("nombre@host.com", "Subject", "Éste es el texto del email",

"From: remitente <remitente@host.net>);

Como podéis ver, enviar email con script PHP utilizando la función "mail" es
muy simple.
Obviamente, en el archivo de configuración, tenéis que haber especificado la
locación de sendmail (o programa análogo para enviar email);

 max: restituye el valor más alto de una serie de variables:

$num = 1;
$num2 = 23;
$num3 = 0.3;
$max = max($num, $num2, $num3);
echo $max, "\n";

devolverá "23";
Opuesto a max() es min(), que tiene la misma sintaxis que max();

 mkdir: crea un directorio del que se tiene que especificar el recorrido y los
permisos:

mkdir("/tmp/prueba", 0777);

crea el directorio "/tmp/prueba" con permisos impostados en 0777;


 opendir: abre un directorio del que es posible leer los elementos con
readdir() y, sucesivamente, cerrarla con closedir();

 phpinfo: es la función más "representativa" del PHP, porque visualiza


muchísimas informaciones en el PHP mismo. Su uso tendría que concerse
ya:

phpinfo();

 phpversion: visualiza la versión de PHP que se está utilizando;

 popen: abre un puntero para un procedimiento que se tiene que cerrar


con pclose();

 print: visualiza una cadena de vídeo como eco();


 rand: genera un valor numérico de forma casual. Si quisiéramos un valor
entre 10 y 20, se podría escribir: $random = rand(10, 20);

 range: crea un array que incluye una serie de valores enteros


especificados. Por ejemplo, para crear un array con valores de 1 a 10 será
necesario escribir:

$array = range(1, 10);

 rename: vuelve a nombrar un archivo. Por ejemplo, si se usa:

rename("oldname", "newname");

para volver a nombrar "oldname" como "newname";

 rmdir: como el análogo mando unix, suprime un directorio. Esto se puede


conseguir sólo si:

- el directorio está vacío;


- los permisos en el directorio lo permiten.

 round: redondea un número:

$número = round(2,3); /* devuelve 2 */


$número = round(2.5); /* devuelve 3 */
$número = round(2.6); /* devuelve 3 */

Como podéis ver, los decimales de 0 a 4 se redondean en el número entero


anterior, de 5 a 9 al número entero sucesivo.

Shuffle, sin, sizeof, sleep, split...

 shuffle: ordena de forma casual los elementos de un array. Por ejemplo,


para poder visualizar los elementos de un array de manera casual se podría
escribir:

$num = range(0,10);
shuffle($num);
while (list(,$número) = each($num)) {
echo "$número ";
}

 sin: devuelve el seno de la expresión;

 sizeof: calcula el número de los elementos en un array. Si, por ejemplo,


se quiere calcular el número de elementos y actuar consecuentemente, se
podría escribir:

$array = array("1", "2", "3", "4", "5");


$size = sizeof($array);
if ($size <= 10) {
echo "El array incluye menos de 10 elementos\n";
} else {
echo "El array incluye más de 10 elementos\n";
}

 sleep: pone el script en pausa unos segundos que se pueden establecer


y especificar como argumento de la función. Por ejemplo, "sleep(10)" deja el
script inactivo durante 10 segundos, para proceder después;

 split: divide una cadena según un determinado pattern; por ejemplo:

$linea = "fulano||mengano||zutano";
list ($uno, $dos, $tres) = split("\|\|", $línea, 3);
print "1 => $uno\n2 => $dos\n3 => $tres\n";

Fijaos que ha sido necesario introducir un carácter de escape (\) delante de


cada "|" en la expresión que hay que utilizar para dividir la línea;

 sqrt: restituye la raíz cuadrada del argumento;

 strcmp: ejecuta una comparación en dos líneas. Por ejemplo:

$cmp = strcmp("Hola", "Hola a todo el mundo");


if ($cmp == "0") {
print "Las cadenas son iguales\n";
} elseif ($cmp < 0) {
print "La segunda línea es más larga que la primera\n";
} elseif ($cmp < 0) {
print "La primera línea es más larga que la segunda\n";
}

devuelve "La segunda línea es más larga que la primera". La función, por lo
tanto, devuelve "0" si las cadenas son iguales, un valor menor de cero si la
segunda es más larga que la primera y mayor de cero si la primera es más
larga que la segunda;

 system: ejecuta un programa de sistema, devuelve el output y vuelve al


script;

 tan: devuelve la tangente del argumento;

 unset: elimina el valor de una variable;

 usleep: como sleep(), pero esta función bloquea el script durante N


microsegundos.

Con esto hemos acabado el análisis de las funciones más útiles del PHP, sin
detenernos en argumentos como la base de datos y parecidos.
Obviamente, el listado de las funciones no termina aquí. Sin embargo, como
hay muchas que no son tan útiles para los que empiezan a programar con
este lenguaje, hemos preferido parar aquí.

Introducción a las demás funciones

Hasta ahora, hemos visto las funciones principales del lenguaje, las que se
podrían definir "esenciales" para crear nuestros script.
Pero el PHP, debido también a su amplia difusión, no se limita a esto. Pone a
disposición otras familias de funciones con las que se pueden resolver otros
problemas y crear nuevas soluciones, sin tener que acudir a ningún
mecanismo extraño como invocar las funciones de sistema u otras cosas.
Para nuestra comodidad, vamos a dividir estas funciones por "familia de
pertenencia". Habrá funciones dedicadas a Apache, a la criptación, al
protocolo FTP y mucho más.

Funciones ligadas a Apache

apache_lookup_uri

Esta función ejecuta una solicitud para un determinado URI (Uniform


Resource Identifier: lo definimos más simplemente una direccón web) y
enseña los resultados de esta solicitud. Los resultados están incluidos en un
array y la sintaxis es:

$array = apache_lookup_uri($url);

Con estas función tendremos informaciones sobre:

 estatus (que es un código numérico);


 the_request: el tipo de solicitud, el método, el archivo solicitado y el
protocolo utilizado;
 method: el método utilizado;
 uri: el uri al que se refiere a la solicitud;
 filename: el nombre del archivo con el path local;
 path_info: informaciones sobre path;
 no_cache;
 no_local_copy;
 allowed;
 sent_bodyct;
 bytes_sent;
 byterange;
 clenght;
 unparsed_uri;
 request_time.

Por ejemplo, utilizando un código como el siguiente:

$uri = "http://localhost";
$array = apache_lookup_uri("$uri");
while ( list ( $header, $valor ) = each( $array ) ) {
echo "$header: $valor<br>\n";
}

se podría obtener algo parecido a :

status: 200
the_request: GET /php/prueba.php3 HTTP/1.0
method: GET
uri: /php/localhost
filename: /var/www/php/localhost
path_info:
no_cache: 0
no_local_copy: 1
allowed: 0
sent_bodyct: 0
bytes_sent: 0
byterange: 0
clength: 0
unparsed_uri: /php/localhost
request_time: 965150868

getallheaders

con esta función es posible pedir todos los headers que se refieren a una
solicitud: estos headers, como muchos otros, se pueden leer incluso con la
función "phpinfo()". La sintaxis es:

$array = getallheaders();

y, utilizando un código como:

$headers = getallheaders();
while (list($header, $value) = each($headers)) {
echo "$header: $value<br>\n";
}

se puede obtener algo parecido a:

Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*


Accept-Charset: iso-8859-1,*,utf-8
Accept-Encoding: gzip
Accept-Language: en
Connection: Keep-Alive
Host: localhost
Pragma: no-cache
User-Agent: Mozilla/4.72 [en] (X11; I; Linux 2.2.14 i586)

virtual

virtual() es igual a <!--# include virtual="/file.txt"-->, que se refiere a los


Server Side Includes. Con esta función podemos incluir un archivo cualquiera
en una página redactada de forma dinámica con el PHP.
La sintaxis es simple:

virtual(file);

El archivo que hay que especificar puede ser cualquier archivo de texto y,
normalmente, se refiere al directorio raíz del huésped. Por lo tanto, si
tenemos un archivo visible en la red con "http:/www.dominio.com/file.txt", la
sintaxis que hay que utilizar con "virtual()" es:

virtual("/file.txt");

Funciones relativas a la criptación

PHP ofrece a los programadores una serie de funciones para la criptación,


ligadas a la biblioteca mcrypt. Esta biblioteca soporta muchísimos algoritmos
de criptación, unos más utilizados que otros. Los algoritmos son:

 DES
 TripleDES
 Blowfish
 3-WAY
 SAFER-SK64
 SAFER-Sk128
 TWOFISH
 TEA
 RC2
 GOST
 RC6
 IDEA

Para funcionar con esta biblioteca, el PHP se tiene que haber redactado con
la opción "--with-mcrypt".

Los mandos fundamentales son cuatro, todos con la misma sintaxis:

 mcrypt_cfb(): cipher feedback; codifica byte por byte;


 mcrypt_cbc(): cipher block chaining: útil para el encoding de los archivos
con un amplio márgen de seguridad;
 mcrypt_ecb(): electronic codebook: utilizada para datos remotos en el que
el nivel de seguridad no es altísimo;
 mcrypt_ofb(): output feedback: parecido a cfb, pero cuida más de los
errores.

La sintaxis en general es:

$encrypted = mcrypt_XXX(algoritmo, clave, input, encode/decode)

en el que:

 XXX es el método que se quiere utilizar (cfb, cbc, cfb o ofb);


 algoritmo es el algoritmo que se quiere utilizar, con la sintaxis:
MCRYPT_ALGORITMO
Por ejemplo, se podría utilizar
MCRYPT_BLOWFISH o MCRYPT IDEA
 clave no es más que la clave con la que se van a criptar los datos;
 input son los datos que hay que criptar;
 encode/decode indica la función si se deben criptar o descriptar los datos.
Por eso, se utilizan respectivamente:
MCRYPT_ENCRYPT e MCRYPT_DECRYPT

Vamos a ver un ejempo: si queremos criptar una cadena de texto con clave
criptada "Mi clave" utilizando CFB con el algoritmo IDEA, tendríamos que
escribir:

$cadena = "Una cadena de texto";


$chiave = "Mi clave";
$encrypted = mcrypt_cfb(MCRYPT_IDEA, $clave, $cadena,
MCRYPT_ENCRYPT);

Todos los que quieran leer nuestros datos criptados ($encrypted) tendrán
obviamente que conocer las claves, el método y el algoritmo utilizados. Por
lo tanto, se podría escribir algo parecido a:

$clave = "Mi clve";


$cadena = mcrypt_cfb(MCRYPT_IDEA, $chiave, $encrypted,
MCRYPT_DECRYPT);

Su variable "$cadena", por lo tanto, incluirá "Una cadena de texto".

Funciones relacionadas con el


protocolo FTP

Entre los protocolos que PHP nos pone a disposición existe una amplia
biblioteca de funciones relacionadas con el protocolo FTP (FILE TRANSFER
PROTOCOL), para el traslado de un archivo de un ordenador a otro en la
red. Vamos a ver las principales.

ftp_connect

Ésta es una función "principal" en el sentido de que nos permite establecer


una conexión FTP entre nuestro equipo y el servidor FTP remoto. Su sintaxis
es:

$stream = ftp_connect(host, port);

en el que el huésped es el nombre del servidor al que queremos conectarnos


y port (opcional) es la puerta alternativa a la que nos queremos conectar. Si
ésta no se ha especificado se utiliza la puerta de default para el protocolo
FTP, es decir la 21. En la variable $stream, además, se almacenan
precisamente el flujo de datos que el cliente (en este caso el PHP) recibe del
servidor, es decir, los mensajes de conexión aceptada (incluidos los detalles)
o de conexión rechazada.

Por ejemplo, para conectarnos a la puerta de default del servidor FTP


"ftp://ftp.host.com" utilizaremos:

$stream = ftp_connect("ftp://ftp.host.com");

ftp_login

Después de la conexión, necesitamos identificarnos de forma que el servidor


nos permita el intercambio de datos. Muchos estarán acostumbrados a no
ver esta fase porque con los más difundisos clientes FTP gráficos se
desarrolla automáticamente utilizando las informaciones de login (nombre dle
usuario y contraseña) introducidos como opciones para la conexión. Sin
embargo, hay que saber que ésta es una fase muy importante para la
conexión. La sintaxis de la función es:

$login = ftp_login(stream, username, password);


Si, por ejejmplo, antes nos habíamos conectado al huésped "ftp.host.com",
utilizando la variable "$stream", ahora podemos pasar al login verdadero con:

$login = ftp_login($stream, "usuario", "contraseña");

La variable $login nos sirve para entender si el login se ha llevado a cabo o


no, y si incluye el valor "1" para el éxito, "0" para el fracaso. Por ejemplo,
para ver si continuamos el intercambio de datos después de la autorización
podemos utilizar el valor que se ha dado a esta variable y escribir:

if ($login == "1") {
... # Ejecutar las demás operaciones
} else {
echo "Autorización no llevada a cabo\n";
}

Cuando nos hemos conectado, podemos saber sobre qué equipo estamos
trabajando con la función "ftp_systype()" que tiene la sintaxis:

$system = ftp_systype($stream);
ftp_pwd

Esta función invoca el mando "pwd", es deicr, "Print work directory", que
podemos traducir como "Visualiza el directorio actual". Para ver a qué
directorio nos conectamos después del login, podemos escribir:

$directory = ftp_pwd($stream);

en el que $stream es siempre la variable que hemos utilizado para la


conexión con "ftp_connect()".
ftp_cdup e ftp_chdir

Estas dos funciones sirven respectivamente para moverse en el directorio


superior y para moverse hacia un determinado directorio dentro del servidor.
La primera se utiliza con sintaxis:

$var = ftp_cdup($stream);

La segunda, en cambio:

$newdir = ftp_chdir($stream, "nuevo_directorio");

Si, por ejemplo, en el login estamos en el directorio "/" y queremos movernos


a "/var/wwwdata" podemos escribir:

$newdir = ftp_chdir($stream, "/var/wwwdata");

ftp_mkdir e ftp_rmdir

Estas dos funciones invocan el mando "mkdir "(crea un directorio) y "rmdir"


(quita un directorio). La primera devuelve el nombre del nuevo directorio, la
segunda sólo los valores true o false. Podemos crear un pequeño buqle y
escribir:

$mydir = ftp_chdir($stream, "/var/wwwdata/");


# Posicionarse en "/var/wwwdata".
$newdir = ftp_mkdir($stream, "prueba")
# Crear un directorio "prueba" como subdirectorio de "/var/wwwdata"
$deleted_dir = ftp_rmdir($stream, $newdir);
# Borrar el directorio creado
# Controlarlo todo:
if ($deleted_dir == "1") {
print "Operación llevada a cabo con éxito.\n";
} else {
print "Algo no ha salido bien.\n";
}

Obviamente el ejemplo no tiene mucho sentido en una verdadera conexión


(¿por qué crear un directorio y borrarlo en seguida?), pero se ha propuesto
para comprender cómo utilizar mejor estas dos funciones.

ftp_nlist

Esta función es igual al mando "dir", es deicr, el mando utilizado para ver los
nombres de los archivos que están en un directorio. La sintaxis es:

$list = ftp_nlist($stream, directory);

Por ejemplo, podemos ir al directorio "/var/wwwdata" y leer los archivos con:

$newdir = "/var/wwwdata";
$list = ftp_nlist($stream, $newdir);

Los resultados están en un array, por lo tanto, 'echo "$list"' no tendría ningún
sentido.

ftp_get

Función que invoca el mando GET, para bajar un archivo del servidor remoto.
Tenemos que especificar para la función, además del conocido stream, el
nombre del archivo local, el nombre del archivo remoto y las modalidades de
trasaldo (FTP_ASCII o FTP_BINARY). La sintaxis completa es:

$file = ftp_get($stream, local_filename, remote_filename, mode);

Por ejemplo, si queremos bajar del servidor el archivo "data.txt"


(supongamos que estamos ya en el directorio que lo incluye) introduciéndolo
en el directorio "/tmp" con nombre "file.txt" in ASCII mode, escribiremos:

$file = ftp_get($stream, "/tmp/file.txt", "data.txt", FTP_ASCII);

Para ver si la operación ha tenido éxito o no, podemos actuar de dos formas:
controlar si efectivamente el archivo está en nuestro disco o controlar el valor
de la variable $file: si tiene valor "1" entonces la operación se ha llevado a
cabo, si tiene valor "0" ningún archivo se habrá bajado en nuestro disco.

ftp_put

Esta función hace exáctamente lo contrario de "ftp_put()", es decir, carga un


archivo en el servidor. Su sintaxis es:

$file = ftp_put($stream, remote_filename, local_filename, mode);

Las opciones son iguales a las anteriores, por lo tanto, podemos poner el
ejemplo contrario al anterior: cargamos el archivo local "/tmp/file.txt" en el
directorio remoto (ya estamos en este directorio) con el nombre "data.txt".
Todo en ASCII mode obviamente:
$file = ftp_put ($stream, "data.txt", "/tmp/file.txt", FTP_ASCII);

También aquí podemos controlarlo de dos formas: evaluando el valor de $file


o invocando la función "ftp_nlist()" para ver si entre los archivos está también
"data.txt".

ftp_sise

Devuelve el tamaño de un archivo. La sintaxis es:

$size = ftp_size($stream, remote_filename);

Vovliendo a los ejemplos hechos anteriormente, vamos a conocer el tamaño


del archivo "data.txt", que está en el directorio en el que estamos
actualmente; será suficiente con escribir:

$size = ftp_size($stream, "data.txt");

de modo que la variable $size incluya el tamaño del archivo "data.txt".

ftp_mdtm

Devuelve la fecha del último cambio de un archivo, devolviéndola como Unix


timestamp. La sintaxis es:

$date = ftp_mdtm($stream, remote_filename);

Por ejemplo, si queremos saber la fecha del último cambio del archivo
"data.txt" podemos escribir:

$date = ftp_mdtm($stream, "data.txt");

También en este caso, la variable "$data" incluye la fecha del último cambio
del archivo o el valor "-1" si fracasa (archivo inexistente o casos parecidos).

ftp_rename e ftp_delete

Como queda claro por los nombres, estas dos funciones sirven para volver a
nombrar un archivo y para borrarlo. La primera tiene la sintaxis:

$name = ftp_rename($stream, oldname, newname);

en el que "oldname" es el nombre originario del archivo y "newname" es el


nuevo nombre que queremos asignar al archivo.
Por ejemplo, para volver a nombrar el archivo "data.txt" en "dati.dat"
podemos escribir:

$name = ftp_rename($stream, "data.txt", "datos.dat");

La variable $name incluirá "1" si la operación ha tenido éxisto, "0" si no lo ha


tenido (archivo inexistente o casos parecidos).

La función "ftp_delete(),en cambio, se utiliza con sintaxis:

£delete = ftp_delete($stream, file);

Por ejemplo, para eliminar el archivo "datos.dat" que están en "current-


directory" podemos escribir:

$delete = ftp_delete ($stream, "datos.dat");


También en este caso la variable puede incluir el valor "1" (el archivo ha sido
eliminado) o "0" (algo no ha funcionado).

ftp_quit

Llegados a este punto, nuestro trabajo en el servidor se ha acabado y


podemos dejar de conectarnos utilizando la función "ftp_quit()" que tiene una
sintaxis muy simple:

$quit = ftp_quit($stream).

Siempre es aconsejable invocar esta función en lugar de cerrar el programa


en ejecución, sobre todo para respetar al servidor.

Funciones relacionadas con el


networking

Esta familia de funciones que analizaremos por encima, se refiere al trabajo


en red y trata sobre todo de los protocolos, direcciones, etc. Por supuesto no
es fundamental para los script de simple creación de páginas dinámicas, sin
embargo puede ser útil conocerla.

gethostbyaddr e gethostbyname

Estas dos funciones permiten, respectivamente, conseguir el nombre de un


huésped partiendo de su dirección IP y conseguir la dirección IP asociada a
un nombre de dominio.
Las sintaxis para las dos funciones son:

$hostname = gethostbyaddr(IP_address);
$hostaddress = gethostbyname(hostname);

Por ejemplo, pongamos que "www.server.com" tenga la dirección IP


123.456.78.9 que nosotros conocemos, pero queremos que sea un script
PHP quien lo reconozca.
Escribiremos, por lo tanto:

$hostname = gethostbyaddr("123.456.78.9");
$hostaddress = gethostbyname("http://www.host.com");
print "$hostname tiene dirección IP $hostaddress.\n";

Obviamente un script de este tipo es inútil, ya que conocemos los datos, sin
embargo lo hemos propuesto sólo para subrayar las características de las
dos funciones.

getservbyname

Esta función nos permite conseguir el número de la puerta a la que está


asociado un determinado servicio. La sintaxis de la función es:

$porta = getservbyname(service, protocol);

Por ejemplo, queriendo saber a qué puerta está asociado el protocolo ftp,
podemos escribir:

$ftp_port = getservbyname("ftp", "tcp");


que, muy probablemente, nos devolverá la puerta 21 (la de default para el
FTP).

Estandár POSIX

El PHP pone a disposición muchas funciones POSIX-compliant, como


aparece definido en el estándar document IEEE 1003.1. Estas funciones nos
permiten intrducir una interacción completa con el sistema para mejorar la
escritura de nuestros script. Vamos a ver cuáles son las funciones más
importantes de este grupo.

posix_kill

Envía un signal a un determinado PID, devolviendo FALSE si el PID no está


asociado a ningún proceso, verdadero en el caso opuesto. Su sintaxis es:

posix_kill(PID, SIG)

en la que PID es el pid del proceso al que queremos enviar el signal y SIG
es, supuestamente, el signal. Por ejemplo, si queremos enviar un signal de
kill a Netscape (pid 1234), podemos escribir:

$pid = "1234";
$signal = posix_kill($pid, KILL);

Más detalles se pueden encontrar en la manpage de kill(2).

posix_getpid

Utilizar la función que acabamos de describir trabajando desde un script es


muy difícil porque, como no tenemos acceso a la shell, no podemos conocer
el PID asociado a una determinada aplicación. Sin embargo, el PHP nos
echa un cable con la función posix_getpid que permite introducir en una
variable el PID de un proceso. La sintaxis es:

$pid = posix_getpid($application);

en la que application es, obviamente, la aplicación de la que nos interesa el


PID. Utilizando esta función con la anterior, podemos escribir algo parecido
a:

$pid = posix_getpid("netscape");
$signal = posix_kill($pid, KILL);

posix_getppid

La función posix_getppid() devuelve el padre del proceso que estamos


utilizando. Por ejemplo, escribiendo unas dos líneas de código como las
siguientes:

$parent = posix_getppid();
echo $parent;

visualizaremos en la pantalla el padre del proceso que acabamos de


ejecutar: en nuestro caso, como hemos ejecutado el mando desde una shell,
el PID se referirá sólo a la shell.

posix_getuid, posix_geteuid, posix_getgid, posix_getegid

estas cuatro funciones son muy parecidas y devuelven respectivamente:

 Real user ID del proceso;


 Effective user ID del proceso;
 Real GID del proceso;
 Effective GID del proceso.

Podemos poner un ejemplo que las visualice todas:

$UID = posix_getuid();
echo "UID = $UID\n";
$EUID = posix_geteuid();
echo "EUID = $EUID\n";
$GID = posix_getgid();
echo "GID = $GID\n";
$EGID = posix_getegid();
echo "EGID = $EGID\n";

posix_getlogin

Esta función nos permite recuperar el nombre de login del usuario que
ejecuta el script. Por ejemplo, podemos escribir:

$login = posix_getlogin("/usr/sbin/apache");
echo $login;

para conseguir que el nombre del usuario que ejecuta el script se visualice
en la pantalla.

posix_uname

esta función es párecida al "uname" de los sistemas Posix-compliant y


devuelve informaciones sobre el sistema. Estas informaciones están
organizadas en un array que incluye las claves:

 sysname
 nodename
 release
 version
 machine

Por ejemplo, ejecutando un script del tipo:

$uname = posix_uname();
while (list($key, $value) = each ($uname)) {
echo "$key -> $value\n";
}

se obtiene el resultado:

sysname -> Linux


nodename -> scatolinux
release -> 2.2.14
version -> #11 mar lug 4 00:06:07 CEST 2000
machine -> i586
posix:getpwname

esta función nos permite tener determinadas informaciones sobre un usuario


del sistema partiendo de su ID. De la misma forma, la función
"posix_getpwuid()" da las mismas informaciones partiendo de su ID. Un
ejemplo podría ser algo parecido a:

$user = posix_getpwnam("edo");
while (list($info, $value) = each($user)) {
echo "$info -- $value\n";
}

que devuelve:

name -- nombre_usuario
passwd -- x
uid -- NUM
gid -- NUM
gecos -- ,,,
dir -- /home/nombre_usuario

en la que "nombre_usuario" es el nombre del usuario y


"/home/nombre_usuario" es su directorio principal, NUM son los dos atributos
numéricos asociados al UID y a GID y gecos son informaciones adicionales
sobre el usuario, si las introducimos (nombre completo, etc.).

posix_getrlimit

Esta función devuelve un array que incluye los límites de los recursos del
sistema: sin analizar las voces, vamos a ver un ejemplo:

$resources = posix_getrlimit();
while (list($key, $value) = each ($resources)) {
echo "$key -> $value\n";
}

que devolverá un output del tipo:

soft core -> 0


hard core -> unlimited
soft data -> unlimited
hard data -> unlimited
soft stack -> 8388608
hard stack -> unlimited
soft totalmem -> unlimited
hard totalmem -> unlimited
soft rss -> unlimited
hard rss -> unlimited
soft maxproc -> 256
hard maxproc -> 256
soft memlock -> unlimited
hard memlock -> unlimited
soft cpu -> unlimited
hard cpu -> unlimited
soft filesize -> unlimited
hard filesize -> unlimited
soft openfiles -> 1024
hard openfiles -> 1024

Las extensiones
En los capítulos anteriores hemos visto las principales funciones referidas al
lenguaje para la creación de nuestras páginas dinámicas. La diferencia entre
esas funciones y la familia de las que veremos a continuación es esencial.
Las primeras se encuentran directamente en el motor (built-in), las segundas
están en las bibliotecas añadidas que se tienen que instalar en el sistema de
forma específica.

En primer lugar, intentamos comprender el mecanismo para cargar


dinámicamente estas bibliotecas. Si abrimos el archivo "php3.ini" veremos un
párrafo dedicado a las "Extension", es decir, extensiones en el mismo
lenguaje. Para ser más claros podemos decir que éstas son un conjunto de
bibliotecas que se invocan cuando se ejecuta un script como ocurre para
cargar los módulos con un servidor de la red.
La sintaxis para cargar estas extensiones de lenguaje es muy simple: una
vez instalada la biblioteca en el sistema, no nos queda que añadir en el
archivo php3.ini la línea:

extension=biblioteca

Llegados a este punto tenemos que diferenciar entre los sistemas Unix y los
sistemas Windows. Para las dos sintaxis el procedimiento es el mismo, pero,
por supuesto, el nombre de las bibliotecas y sus extensiones no lo es. En los
sistemas Windows, una biblioteca se reconoce por la extensión ".dll",
mientras que para Unix las extensiones son ".so". Por lo tanto, según el
sistema, tendremos que utilizar el nombre correcto para la biblioteca y, sobre
todo, la extensión correcta. Obviamente, para los que tengan los dos
sistemas instalados y consigan ver los dos está claro que las dll no se
pueden cargar en un sistema Unix y viceversa.
Cuando escribimos el nombre de la biblioteca que queremos cargar, no
tenemos que detenernos en el recorrido completo, es necesario sólo el
nombre de la misma, por ejemplo "pgsql.so" para las bases de datos
Postgres. Esto porque, en el mismo archivo, hay otra línea de configuración
que define en qué directorio están estas biblioteca. Leyendo el archivo
php3.ini podéis ewncontrar la línea "extension_dir = directory" que le dirá al
motor la locación estándar de las bibliotecas. Por lo tanto, cuando
especificamos con "extension" una biblioteca que quremos cargar para
ejecutar un script, de hecho se juntan "extension_dir" y "extension". Si, por
ejemplo, "extension_dir" es "/usr/lib/php3" y hemos impostado
"extension=pgsql.so", el PHP sabrá que para cargar la biblioteca "pgsql.so"
tendrá que buscarla en "/usr/lib/php3/pgsql.so".

Además, con "extension= ...." es posible especificar no sólo una biblioteca


sino toda la serie de las bibliotecas que nos hagan falta. Por ejemplo,
podemos tener algo parecido como:

extension=pgsql.so
extension=mysql.so
extension=gd.so
extension=imap.so
extension=ldap.do
extension=xml.so

etc. Como podéis ver en la segunda línea, es posible especificar también dos
o más bibliotecas para un mismo "campo". En este caso hay dos bibliotecas
para dos bases de datos (Postgres e mySQL) que, además de no interferir la
una con la otra, podrían teóricamente ser utilizadas a la vez, siempre que
esto sea útil.
Si intentamos invocar una función no built-in en un script, el script visualiza
un mensaje de error que nos avisa de que estamos intentando utilizar una
función que no está reconocida. Por ejemplo, para las bases de datos se
tienen que cargar las extensiones como hemos dicho antes y, sólo después
de haber dado este paso, será posible utilizar las funciones relacionadas sin
arriesgarnos a que salgan mensajes de error, siempre que se hayan utilizado
de forma correcta.

El porqué de las extensiones

Llegados a este punto, habrá alguien que se está preguntando para qué
sirven estas bibliotecas añadidas (a veces muy importantes e incluso
esenciales) que se tienen que bajar, instalar e invocar indirectamente. La
explicación es simple: para no sobrecargar demasiado el motor. Éste ya tiene
muchas funciones built-in, que podemos definir como funciones "principales"
para el lenguaje, aunque algunas puedan perecer poco útiles. Imaginaos que
el motor tuviera también todas las funciones que se refieren a todas las
bases de datos que soporta. Tendría otras cien (o más) funciones, y esto no
sería malo si el 95% de estas funciones no se quedara inutilizado. De hecho
¿quién necesita trabajar con el PHP y unas diez bases de datos diferentes?
Es mejor instalar la extensión para la base de datos que se tiene que utilizar
en lugar de sobrecargar el motor con funciones que no vamos a utilizar
nunca. Además, pensad en las funciones de la biblioteca GD. Sin duda son
interesantes por los resultados que permite alcanzar, sin embargo ¿quién los
utiliza realmente? Es más simple tener todas estas informaciones en un
archivo separado y dejar que éste se instale y sea utilizado cuando
realmente sea necesario.

Si os dais cuenta, es lo que ocurre con todos los lenguajes de programación.


Existen las primitivas (que podemos definir como las funciones esenciales y
built-in en un sistema) y las funciones externas que se invocan cuando se
necesitan. Si comparamos los lenguajes de scripting con el Perl, por ejemplo,
podemos observar que éste tiene muchas funciones built-in en el intérprete,
a las que se añaden infinitos módulos que el programador puede utilizar en
sus propias creaciones.

Introducción a PHP y base de datos

Muchos sabrán que uno de los campos en los que el PHP da lo mejor de sí
es la interacción con las bases de datos SQL. En las guías prácticas que de
las páginas precedentes, habéis visto como interactuar con una base de
datos mySQL: aquí veremos las bases teóricas, con ejemplos cuando lo
necesitemos, para la conexión y la interacción con una base de datos
PostgreSQL.

Por lo tanto analizaremos todas las funciones que el PHP nos pone a
disposición para poder trabajar en red con una base de datos y no cómo
crear una base de datos. Nos puede resultar útil el seminario de Lucio
Benfante publicado en nuestras páginas.

Supongamos que hemos creado una base de datos "agenda" que incluye la
tabla "direcciones". Si lanzamos el mando "SELECT * FROM direcciones"
obtenemos:

Éstos son los datos con los que trabajaremos, pero antes hagamos veamos
las funciones que están a disposición del PHP para la interacción con la base
de datos PostgreSQL.

Configuraciones antes de empezar

En primer lugar, tenemos que estar seguros de que hemos instalado en el


sistema la biblioteca PHP que permite la interacción con la base de datos.
Esto lo conseguimos instalando el paquete y, si cabe, dando instrucciones al
motor sobre la locación en la que tiene que ir a buscar esta biblioteca.
Con respecto al paquete éste se llama, en los sistemas Linux, "php3-pgsql",
pero podría tener otros nombres en otros sistemas. Normalmente tenéis que
buscar (teóricamente incluso en el sitio PHP) el paquete que permite
conectarse a las bases de datos PostgreSQL directamente desde del script
PHP.
Una vez instalado tendréis que localizar la biblioteca que se ha escrito para
este fin, que en mi sistema se carga en:

/usr/lib/php3/apache/pgsql.so.

Obviamente, ésta cambiará no sólo de arquitectura a arquitectura, sino


también de sistema a sistema. Por lo tanto, mucho cuidado y no olvidéis este
paso o, a cada conexión con una base de datos, os saldrá un aviso diciendo
que habéis invocado una función no implementada en PHP (el mensaje de
error es algo parecido a "Call tu unsupported function nombre_función()").
Abramos un paréntesis: si habéis echado un vistazo al manula PHP, os
habréis dado cuenta de que hay muchísimas funciones (algunas las vimos
en las páginas anteriores), entre las que hay algunas que son propias para la
interacción con las bases de datos. Sin embargo, muchas de estas
funciones, por supuesto, no se implementan directamente en el motor y se
tienen que cargar en runtime siguiendo determinadas instrucciones. Cuando
decimos "por supuesto" nos referimos a que sería inútil sobrecargar el motor
con todas las bases de datos que posiblemente no utilicemos nunca.

Dicho esto podemos pasar al archivo de configuración del php, añadiendo el


directorio en el que está la biblioteca que acabamos de cargar de forma que
el motor la pueda utilizar. Para hacerlo será necesario localizar la línea que
empieza por:

extension_dir

Como podemos ver en su descripción, entendemos enseguida que en este


directorio están los módulos que hay que utilizar. Por lo tanto Modifiquémosla
de la siguiente forma:
extension_dir = /path/perl/i/nuovos/módulos

que, por ejemplo, en mi sistema será:

extension_dir = /usr/lib/php3/apache

Ahora ya estamos seguros de que conseguiremos utilizar las funciones


referidas a las bases de datos sin problemas de ejecución de los script.
Veamos ya las funciones utilizando los ejemplos que sean necesarios y
haciendo referencia a las guías prácticas al PHP para los demás ejemplos.

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 una 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.
¿Y ahora qué?

Esperamos que hasta aquí os hayamos ofrecido una buena visión de


conjunto de las funciones del PHP que se pueden utilizar con el Postgres. No
hemos visto las funciones menos importantes por una razón muy simple:
pensamos que es más oportuno, por el momento, comenzar con un rodaje
inicial del tema que, de todos modos, os capacite para poder operar. Si, más
adelante, el tema os interesa, cada uno por su cuenta puede profundizar en
el mismo.

Otra cuestión es la de la elección de la base de datos. El que escribe trabaja


con Postgres, por lo tanto la elección es obligada. Para los que utilizáis otros
database, sabed que las funciones, aunque con nombres diferentes, se
comportan en el 90% de los casos del mismo modo que se ha descrito aquí.
La sintaxis es la misma, los resultados son los mismos, lo único que cambia
es el nombre de las funciones; por ejemplo, para Oracle8 los nombres de las
funciones serán OCI... así encontraréis OCIExecute, OCIRowcount etc.
Encontraréis además funciones con un nombre ligeramente cambiado pero
que se explica por sí mismo. Con Oracle8 no tendréis la función OCIConnect
sino OCILogon, y lo mismo con las demás funciones. Resumiendo y como
hemos dicho antes, se puede trabajar con la mayoría de los database que
trabajan con PHP.

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.

Autentificación con PHP


Con el PHP y la ayuda de su función "header" es posible programar las
páginas protegidas sin utilizar los archivos .htaccess o las autorizaciones del
servidor.
Bastará simplemente con enviar un header particular al browser antes de
pasarle el output para que, en una página, se pidan username y password
para el acceso. Para empezar, hay que copiar este código en un archivo y
hay que invocarlo a través del browser:

$username = "tribilín";
$pwd = "secreta";

if(!isset($PHP_AUTH_USER)) {
Header("WWW-Authenticate: Basic realm=\"Zona protegida\"");
Header("HTTP/1.0 401 Unauthorized");
echo "Imposibile ejecutar la autorización\n";
exit;
} else {
if (($PHP_AUTH_USER == $username) && ($PHP_AUTH_PW == $pwd)) {
echo "Autorización ejecutada para $username.";
} else { echo "Autorización fracasada.";}
}

De esta forma, fijamos "tribilín" como nombre del usuario y "secreta" como
contraseña. Si los datos introducidos por el usuario en la autorización
corresponden a éstos, la autorización se lleva a cabo, si no fracasa.

Pero ¿cómo funciona todo esto?


Empecemos por el funcionamiento del script que acabamos de presentar.
En primer lugar, hay que controlar si se ha fijado la variable
PHP_AUTH_USER, es decir, el nombre del usuario que entra en la página
protegida. Si existe, posiblemente el usuario se autorice antes y, por esta
razón, se "recuerda". De todas formas, tanto si el usuario se ha autorizado
anteriormente como si es su primera visita a la página, se controla que el
nombre del usuario y la contraseña introducida en la autorización sean
excáctamente $username y $pwd. Si coinciden es posible visualizar el output
de la autorización que se ha llevado a cabo (lo que hemos fijado como
"Autorización llevada a cabo para $username"); si no se da un mensaje de
error (en nuestro caso "Autorización fracasada"). Si, en cambio, no existe
$PHP_AUTH_USER, se envía un header para la autorización (el código 401)
que muestra al usuario la instrucción que le pide username y password.
Cuando se han introducido, se ejecutará el bloque que hemos descrito arriba
y, si el usuario decide no autorizarse, se le muestra una página que incluye el
texto "Imposibile ejecutar la autorización", que se puede personalizar.

La función que controla todo este proceso es "header()", que se utiliza para
mandar un header al browser que ha enviado la solicitud. Como lo que se
envía es un header, es necesario que éste se envíe antes de cualquier otro
output. La función es muy simple: vamos a ver unos ejemplos:

 si quisiéramos enviar un header que vuelva a mandar el browser a una


determinada locación, podemos escribir:

header("Location: http://www.htmlpoint.com");

 si, en cambio, quisiéramos enviar un mensaje de página inexistente o una


instrucción para que el browser no utilice la cache, podríamos escribir
respectivamente:

header("http:/1.0 404 Not Found");


header("Pragma: no-cache");
Llegados a este punto, habéis entendido cómo se vuelve a localizar con PHP
sin la ayuda de archivos como .htaccess o archivos parecidos. Por supuesto
podéis mejorar los ejemplos que hemos propuesto para implementarlos con
éxito en vuestras páginas Web.

Ajustar un archivo

Este apartado está dedicado a presentar algunos ejemplos iniciales para enfrentarse al mundo
Php.
Son bastante simples, pero se pueden combinar entre ellos y, con un poco de fantasía, se
pueden obtener resultados efectivos para nuestras páginas.

Puede ser útil a todos los webmaster introducir al final de cada archivo de su propio sitio una
línea de información sobre el autor (nombre, apellidos, email).
Para hacerlo acudimos a la instrucción INCLUDE de Php.
Introduciendo el siguiente código al final de vuestras páginas se cargará automátivamente un
código html incluido en el archivo /path/codice.txt:

<? include("/path/codice.txt"); ?>


el contenido del archivo /path/código.txt podría ser:
<hr size="1">
Página redactada por <a href="http://mail.katamail.com/mail/compose/!1!
marialozano/4ee357215d3341c064bbd820b1a6a828?
to=stain@dei.unipd.it">Alberto Mucignat</a>
Sucesivamente veremos las particularidades específicas de la instrucción INCLUDE y de su
"símil" REQUIRE.

Contador en cada página

Podemos introducir un contador en nuestras páginas que se modifique cada


vez que se visualizan. El código tiene que ser:

<?
if (!file_exists("/path/counter.txt")):
$file=fopen("/path/counter.txt","w");
$num=0;
else:
$file=fopen("/path/counter.txt","r+");
$num=fgets($file,20);
endif;
$num++;
print("Visitors: ".$num);
fputs($file,$num);
fclose($file);
?>
El contador no tiene en cuenta las visitas del mismo usuario durante la
misma sesión. Para contabilizar estas visitas del usuario hay que aprender a
configurar los COOKIES o esperar la nueva versión Php 4, para tener a
disposición todas estas funciones. Están a disposición con las variables
SESSION.
Incluso hay unas bibliotecas que implementan las funciones relacionadas a
las variables de sesión.

Cargar una imagen

Puede que se quiera visualizar, cada vez que se abra una página, una
imagen diferente. Un código simple que gestione esta necesidad puede ser:

<?
$num=rand(1,10);
print("<img src="\"images/img".$num.".gif"\">");
?>
Obviamente hay que nombrar las imágenes como images/img1.gif,
images/img2.gif, etc.
Otra posibilidad es visualizar una imagen diferente según el día de la
semana en la que el visitador solicita la página. Las páginas tienen que
llamarse images/Mon.gif, images/Tue.gif, etc. y el código podría ser:

<?
$img=date("D");
print("<img src="\"images/".$img.".gif"\">");
?>
Podéis pasar un buen rato jugando de acuerdo con vuestra fantasía.

Enviar email

Con Php es posible mandar email deesde una página de la red.


En primer lugar hay que crear una página que llamamos "master", con un
FORM para enviar los datos y una página "slave" que reciba los datos y
envíe el email.
Por lo que se refiere a la sintaxis de un form, ver seminario html.
La página "master" tiene que tener en su interior un código de este tipo:

<FORM ACTION="send.php3" METHOD="POST">


Nombre y Apellidos:<BR>
<INPUT TYPE="text" NAME="name" SIZE="20"
MAXLENGTH="30"><BR>
Email:<BR>
<INPUT TYPE="text" NAME="email" SIZE="20"
MAXLENGTH="30"><BR>
Títolo:<BR>
<INPUT TYPE="text" NAME="subject" SIZE="20"
MAXLENGTH="30"><BR>
Texto del email:<BR>
<INPUT TYPE="textarea" NAME="text" ROWS="60" COLS="10"
MAXLENGTH="200"><BR>
<INPUT TYPE="submit" VALUE="ENVIAR">
</FORM>
En el archivo send.php3 (nuestro archivo "slave") tendremos que incluir el
siguiente código Php:

<?
if (isset($email)):
# la dirección electrónica a la que enviar el email
$target="info@sito.it";
mail($target,$subject,"Nombre: ".$nombre."\nTítulo: ".
$subject."\n\n".$text);
endif;
?>

Cómo gestionar un sitio

Algunas de las aplicaciones más importantes de Php permiten a los webmaster gestionar sus
sitios de forma eficaz y sin demasiado trabajo.
Un problema en los sitios con muchas páginas es que se tienen que hacer pequeños cambios
gráficos con la correspondeinte actualización de todos los archivos. Este es un trabajo
considerable para el webmaster.
Para esto sirven los programas Dreamweaver que permiten la creacción de las llamadas
templates. Las plantillas son archivos "tipo" que representan la estructura esencial (y común) de
todos los archivos de un sitio. Las plantillas permiten gestionar el diseño de un sitio simplemente
estableciendo los atributos comunes a las páginas de un sitio.
En Php es útil usar sistemas de este tipo, facilitados por el lenguaje de programación.

Dos instrucciones importantes para estos sistemas son INCLUDE y REQUIRE.


La instrucción INCLUDE (ya la vimos anteriormente), cuando se introduce en una página web,
permite incluir un deterninado archivo.
La instrucción REQUIRE se diferencia sólo en que, si se introduce en un ciclo, incluye el archivo
sólo una vez antes de devolver la página al usuario.
Esto nos permite, por ejemplo, gestionar unas anuncios publicitarios (banner). El método es
simple. En primer lugar tenemos que conseguir que todas las páginas de nuestro sitio tengan en
su interior la siguiente línea:
<? if (file_exists("/path/banner.inc")): require("/path/banner.inc"); endif; ?>
en el archivo banner.inc puede haber un código Php que devuleve una imagen con un enlace
externo y, al mismo tiempo, hace otras operaciones útiles (en el caso de anuncios publicitarios:
seleccionar random, cuenta de las impression, etc).

Pero volvamos a los banner e intentemos redactar todo el archivo del sitio para que Php los
pueda utilizar:

<? include("/path/header.inc"); ?>

<!--- Html Code --->

<? include("/path/footer.inc"); ?>


De esta forma es suficiente crear los archivos header.inc e footer.inc y ya está.El archivo header
podría incluir las siguientes líneas:

<HTML>
<HEAD>
<TITLE>My Site</TITLE>
<META NAME="author" CONTENT="Alberto Mucignat">
<META NAME="description" CONTENT="Éste es mi sitio redactado en Php">
</HEAD>

<BODY BGCOLOR="RED">
<CENTER><B><H2>My Site</H2></B></CENTER>
<HR SIZE="1">
El archivo footer.inc podría incluir las líneas:

<CENTER>
<HR SIZE="1">
Sitio realizado por <A HREF="http://mail.katamail.com/mail/compose/!1!
marialozano/4ee357215d3341c064bbd820b1a6a828?
to=stain@dei.unipd.it">Alberto Mucignat</A>
</CENTER>
</BODY>
</HTML>
De esta forma cada actualización de la gráfica de nuestro sitio es fácil e inmediata. Realmente
basta con modificar los archivos header.inc y footer.inc para que todas las páginas del sitio se
actualicen automáticamente.

Otra utilidad en la gestión de sitios es la realización de las llamadas "restricted areas", es decir,
áreas reservadas que necesitan una contraseña para acceder.
Para conseguirlo basta con crear un archivo index.php en el directorio del sitio protegido e
introducir el form:

<FORM ACTION="main.php3" METHOD="post">


Introducir contraseña:<BR>
<INPUT TYPE="contraseña" NAME="pwd" SIZE="20" MAXLENGTH="30"><BR>
<INPUT TYPE="submit" VALUE="ENTRAR">
</FORM>
El archivo main.php3 es el que controla la contraseña e incluye el código:

<? if ((isset($pwd)) AND ($pwd=="pass128")): ?>

<!--- Restricted area - Html code --->

<? else: ?>

<!--- Error message --->

<? endif; ?>


Para estar más seguros, la contraseña se puede memorizar en un archivo y el código se
convierte en:

<? if ((isset($pwd)) AND ($pwd==include("passwd.txt")): ?>


En el caso de los sistemas unix/linux es posible criptar la contraseña con la instrucción CRIPT y
en este caso, si el archivo passwd.txt incluye la contraseña anteriormente criptada, la sintaxis
es:
<? if ((isset($pwd)) AND (crypt($pwd)==include("passwd.txt")): ?>
Éstos son sólo algunas de las astucias que se pueden utilizar cuando se redactan y se
gestionan los sitios web. El consejo es seguir utlizando la fantasía buscando nuevas estratégias
y soluciones.

Php y bases de datos

La utilización más importante de Php se da en las preguntas que plantean


las bases de datos que están en el servidor.
Php permite al programador tanto relacionarse con algunas de las bases de
datos más importantes del mundo de la programación:
 PostgreSQL
 MySql
 Oracle
 Adabas
 filePro
 ODBC

como con otros menos conocidos.


En particular, la conexión ODBC permite relacionarse con bases de datos
tipo Access.
La utilización de las instrucciones para la conexión a las bases de datos no
tiene nada que ver con el conocimiento de los mismos. El lenguaje SQL sirve
para formualr las preguntas y para saber el significado de índices, claves,
relaciones, etc.
En resumidas cuentas, un webmaster que quiere organizar un sistema que
prevea la consultación de una base de datos a través del web, en la mayoría
de los casos tiene que conocer muy bien la estructura misma de la base de
datos, incluso el significado de los datos que hay en la misma.

Por lo que se refiere a SQL, el lenguaje estándar para hacer preguntas en


las bases de datos, hay muchos seminarios y manuales en la red. Lo único
que diré es que con la palabra pregunta o query nos referimos a una serie de
instrucciones que cualquier base de datos pone en marcha devolviendo una
serie de tuple (en general, líneas o partes de líneas de una o más tablas de
una base de datos).
En este seminario consideramos las operaciones en una base de datos de
tipo MySQL y damos por descontado el conocimiento de la misma base de
datos. Al lector atento no le resultará difícil transformar las operaciones
explicadas para transladarlas a su base de datos preferida.

De modo práctico las operaciones Php en las bases de datos podrían


dividirse en tres niveles:

 abrir/cerrar conexiones
 enviar preguntas SQL
 leer los resultados de una query

Las operaciones abrir/cerrar una conexión a una base de datos sirven para
abrir/cerrar una conexión con la base de datos elegida con el fin de hacer
operaciones como leer/escribir y transmitir los datos en formato html.
Para abrir/cerrar una conexión en MySql tenemos las instrucciones:

mysql_connect(host,login,password)
mysql_close()
Para mandar preguntas se puede utilizar la instrucción:

mysql_db_query(database,query,ID_database)
Para leer los resultados se usan unas instrucciones que veremos
suvcesivamente.

Una primera búsqueda

Para llevar a cabo nuestra primera búsqueda en la base de datos hágamoslo


mediante el ejemplo: saber la existencia, la configuración y el significado del
contenido de una tabla llamada Anuncios.
La tabla Anuncios incluye los campos:

 ID [clave primaria]
 Nombre [nombre del autor del anuncio]
 Email [email]
 Texto [texto del anuncio]

Una búsqueda dentro de la tabla podría hacerse con el siguiente código:

<?
$db=mysql_connect("localhost","","") or die("Error en la
conexión a MySql");
$result=mysql_db_query("base de datos_anuncios","SELECT *
FROM Anuncios",$db);
mysql_close();
?>
Estas instrucciones permiten memorizar en la variable $result todos los
anuncios que están en la tabla Anuncios.
Para escribirlos se necesita primero hacer la operación:

$row=mysql_fetch_row($result);
y después, la primera línea del resultado estará disponible en la variable
array $row. Para escribir el resultado será necesaria una línea del tipo:

print($row[1]."/".$row[2]."/".$row[3]."/".$row[4]."/");
Para saber el número de líneas del resultado de una pregunta basta con usar
la instrucción:

$num_rows=mysql_num_rows($result);
Otra operación muy útil es la que devuelve el número de campos en el grupo
de resultados de la pregunta que se acaba de hacer:

$num=mysql_num_fields($result);
Llegados a este punto estamos listos para formular preguntas más
complejas. Por ejemplo, después de haber creado un form que devuelva en
la variable $cadena una palabra que hay que buscar, se puede escribir:
$sql="SELECT * FROM Anuncios WHERE Texto LIKE '%".
$cadena."%'"
$result=mysql_db_query("db_anuncios",$sql,$db);
$result estará compuesto por todos los anuncios que incluyen la palabra
memorizada en $cadena.

Un sitio de anuncios

Al final de la última lección veíamos la construcción de una base de datos de


anuncios y su posible consulta a través de las páginas web.
Ahora vamos a ver cómo solucionar el problema y cómo construir un sitio
que permita tanto la introducción como la búsqueda.
La tabla Anuncios que memoriza los anuncios se ha descrito e incluye los
campos:

 ID [clave primaria]
 Nombre [nombre del autor del anuncio]
 Email [email]
 Texto [texto del anuncio]

Pasemos a la práctica no olvidando que el instrumento necesario para enviar


datos de un archivo html/php3 a otro es el form, como hemos descrito en las
lecciones anteriores.

Para que funcione todo vamos a crear unos archivos:

 show.php3 [mostrar los anuncios]


 insert.php3 [introducir un anuncio]
 search.php3 [buscar una o más palabras en la base de datos]

Introducir un anuncio

Supongamos que recibimos unos datos de un form con las variables


$nombre,$email,$texto. Para introducir un nuevo anuncio es suficiente con
hacer las siguientes operaciones:

<?
# datos que hay que modificar según la base de datos
$host="localhost";
$user="";
$pass="";

$db=mysql_connect($host,$user,$pass) or die ("Error durante la


conexión a la base de datos");
$sql="INSERT INTO Anuncios (Nombre,Email,Texto) VALUES('".
$nombre."','".$email."','".$texto."')";
mysql_db_query("db_anuncios",$sql,$db);
mysql_close();
?>
En este caso la base de datos introduce automáticamente una clave única
que marca el anuncio en el ID de la tabla Anuncios.
Obviamente también se pueden hacer unas operaciones de control referidas
a la validez de la dirección email o para controlar si algunos campos no son
nulos.

Mostrar los anuncios

Para mostrar los anuncios de la base de datos basta introducir el siguiente


código:

<?
# datos que hay que modificar según la base de datos
$host="localhost";
$user="";
$pass="";

$db=mysql_connect($host,$user,$pass) or die ("Error durante la


conexión al database");
$sql="SELECT * FROM Anuncios";
$result=mysql_db_query("db_anuncios",$sql,$db);
while ($row=mysql_fetch_array($result) {
print("<B>Nombre</B>: <A HREF="\"".$row["Email"]."\">".
$row["Nombre"]."</A><BR>");
print("<B>Texto del anuncio</B>:<BR>");
print(htmlentities($row["Texto"])."<BR>");
print("<HR SIZE=\"1\">");
}
mysql_close();
?>
La función htmlentities() permite "traducir" las letras que llevan acento y los
demás caracteres parrticulares con código html, para que los varios browser
las visualicen correctamente.

Búsqueda de un anuncio

Para la búsqueda de un anuncio particular, pensemos en recibir una cadena


$str de un form, que $str contenga una serie de palabras que hay que
buscar, separadas por espacios.
El siguiente código permite buscar y visualizar los resultados:

<?
# datos que hay que modificar según la base de datos
$host="localhost";
$user="";
$pass="";

$db=mysql_connect($host,$user,$pass) or die ("Error durante la


conexión al database");
$sql="SELECT * FROM Anuncios ";
$where="";
$words=explode(" ",$str);
$j=0;
while (isset($words[$j])) {
$where=$where."Texto LIKE '%".$words[$j]."%'";
if (isset($words[$j+1])):
$where=$where." OR ";
endif;
$j++;
}
$result=mysql_db_query("db_anuncios",$sql.$where,$db);
while ($row=mysql_fetch_array($result) {
print("<B>Nombre</B>: <A HREF="\"".$row["Email"]."\">".
$row["Nombre"]."</A><BR>");
print("<B>Texto del anuncio</B>:<BR>");
print(htmlentities($row["Texto"])."<BR>");
print("<HR SIZE=\"1\">");
}
mysql_close();
?>
Obviamente las variantes son muchas y cada uno puede divertirse a su
antojo.
Si sólo queremos dar una pista para crear un sistema de este tipo, creemos
que ya hemos escrito bastante. Lo único que queremos subrayar es que para
pasar de un código de una base de datos a otro es necesario que el
programador realice una traducción muy cuidada, porque es posible que las
operaciones necesiten un número diferente de operadores dependiendo de
la base de datos.