Академический Документы
Профессиональный Документы
Культура Документы
Introducción al lenguaje
<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
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>
</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).
</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.
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.
?>
<script language="php">
echo ("Yo soy un script PHP\n");
</script>
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:
Variables
$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>
Variables de Apache;
Variables de ambiente;
Variables PHP.
Variables de Apache
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:
Variables PHP
Para terminar, vamos a ver las variables que el mismo PHP nos pone a
disposición:
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
__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;
<?
echo "Línea ", __LINE__ . " del file " ,__FILE__;
?>
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() ).
Integer;
Floating Point number;
String;
Array;
Object.
Integer
$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.
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:
$num = 10;
$string = "El número es $num";
$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\"";
\n -> newline
\r -> carriage return
\t -> tabulación
\\ -> backslash
\$ -> símbolo 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.
$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";
$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.
$a = array(
"nombre" => "Mario",
"apellido" => "Rossi",
"email" => "mario@rossi.com",
);
$a = array(
"primero" => array(
"nombre" => "Mario",
"apellido" => "Rossi",
"email" => "mario@rossi.com",
),
"segundo" => array(
"nombre" => "Marco",
"apellido" => "Verdi",
"email" => "mario@verdi.com",
)
);
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();
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
$a + $b -> sumar
$a - $b -> restar
$a * $b -> multiplicar
$a / $b -> dividir
$a % $b -> resto
precision = 14
$a = 12;
$b = 5;
$c = $a / $b;
echo $c;
Asignación
$a = 2;
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
$a--
como los dos anteriores, pero se decrementa el valor;
Estructuras de control
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 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
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
Esto visualizará los números entre "0" y"10". En las tres expresiones entre
paréntesis hemos definido que:
SWITCH
switch ($i) {
case 0:
echo "\$i vale 0";
break;
case 1:
echo "\$i vale 1";
break;
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.
$num = -3.4;
$aa = abs($a);
echo $aa, "\n";
devolverá 3.4
$arg = 1;
$arc_cos = acos($arg);
echo "$arc_cos\n";
devolverá 0.
$path = "/var/www/php/index.php3";
$base = basename($file);
echo "$basename\n";
devolverá "index.php3";
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:
devolverá 7.41;
devolverá "-3";
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";
$dir = "/var/www/";
chdir($dir);
checkdate: controla que una fecha sea válida. Para que sea válida una
fecha tiene que tener:
chgrp(filename, grupo);
$carácter = chop($string);
echo "$carácter\n";
$file = "prueba.txt";
chown($file, $user);
$ascii= "0126";
$char = chr($ascii);
echo "$char\n";
devolverá:
Ést
o es u
n cur
so pa
ra apr
ender
el l
engua
je
php
$file = "prueba.txt";
copy($file, "$file.bak");
$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(string, salt);
$arr[0] = "abc";
$arr[1] = "def";
$arr[2] = "ghi";
$current = current($arr);
echo $current;
visualizará "abc";
$bin = decbin(10);
echo $bin, "\n";
if (defined($num)) {
echo "\$num se ha definido\n";
} else {
die ("\$num no se ha definido; imposibile seguir adelante\n");
}
$path = "/home/yourname/public_html";
echo(dirname($path));
echo(diskfreespace("/"));
que devuelve:
y el resultado:
0 => nombre
1 => valor
2 => nombre2
3 => valor2
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.
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.
if (condición) {
ejecutar el bloque;
} else {
exit;
}
echo exp(3);
devolverá: 20.0855369...
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.
<
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";
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;
$filename = "/tmp/prueba.txt";
$group = filegroup($filename);
echo "$filename pertenece al gruppo $group\n";
$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;
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(filename, mode);
Por ejemplo, para abrir un archivo local sólo para leerlo tendremos que escribir:
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("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.;
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.
$a = 10;
echo isset($a), "\n";
echo isset($b), "\n";
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:
que devolverá "1". Esta función es útil pata retomar todas las claves de los
array asociativos complejos;
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();
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.
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);
$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);
phpinfo();
rename("oldname", "newname");
$num = range(0,10);
shuffle($num);
while (list(,$número) = each($num)) {
echo "$número ";
}
$linea = "fulano||mengano||zutano";
list ($uno, $dos, $tres) = split("\|\|", $línea, 3);
print "1 => $uno\n2 => $dos\n3 => $tres\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;
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í.
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.
apache_lookup_uri
$array = apache_lookup_uri($url);
$uri = "http://localhost";
$array = apache_lookup_uri("$uri");
while ( list ( $header, $valor ) = each( $array ) ) {
echo "$header: $valor<br>\n";
}
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();
$headers = getallheaders();
while (list($header, $value) = each($headers)) {
echo "$header: $value<br>\n";
}
virtual
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");
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".
en el que:
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:
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:
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
$stream = ftp_connect("ftp://ftp.host.com");
ftp_login
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);
$var = ftp_cdup($stream);
La segunda, en cambio:
ftp_mkdir e ftp_rmdir
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:
$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:
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
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);
ftp_sise
ftp_mdtm
Por ejemplo, si queremos saber la fecha del último cambio del archivo
"data.txt" podemos escribir:
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:
ftp_quit
$quit = ftp_quit($stream).
gethostbyaddr e gethostbyname
$hostname = gethostbyaddr(IP_address);
$hostaddress = gethostbyname(hostname);
$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
Por ejemplo, queriendo saber a qué puerta está asociado el protocolo ftp,
podemos escribir:
Estandár POSIX
posix_kill
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);
posix_getpid
$pid = posix_getpid($application);
$pid = posix_getpid("netscape");
$signal = posix_kill($pid, KILL);
posix_getppid
$parent = posix_getppid();
echo $parent;
$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
sysname
nodename
release
version
machine
$uname = posix_uname();
while (list($key, $value) = each ($uname)) {
echo "$key -> $value\n";
}
se obtiene el resultado:
$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
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";
}
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.
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".
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.
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.
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.
/usr/lib/php3/apache/pgsql.so.
extension_dir
extension_dir = /usr/lib/php3/apache
Funciones
Ahora podemos empezar el análisis de las funciones que pueden ser útiles
para nuestros script.
pg_connect
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
$desconexión = pg_Close($conexión);
pg_DBname
$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
pg_Fetch_Array
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:
pg_NumFields e pg_NumRows
Como veis, hemos complicado la query pero el resto del código es muy fácil
de entender.
¿Y ahora qué?
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
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>.
if (isset ($cookie) ) {
while (list ($nombre, $valor) = each ( $cookie ) ) {
echo "$nombre = $value\n";
}
}
$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.
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:
header("Location: http://www.htmlpoint.com");
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:
<?
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.
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
<?
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;
?>
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.
Pero volvamos a los banner e intentemos redactar todo el archivo del sitio para que Php los
pueda utilizar:
<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:
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.
ID [clave primaria]
Nombre [nombre del autor del anuncio]
Email [email]
Texto [texto del anuncio]
<?
$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
ID [clave primaria]
Nombre [nombre del autor del anuncio]
Email [email]
Texto [texto del anuncio]
Introducir un anuncio
<?
# datos que hay que modificar según la base de datos
$host="localhost";
$user="";
$pass="";
<?
# datos que hay que modificar según la base de datos
$host="localhost";
$user="";
$pass="";
Búsqueda de un anuncio
<?
# datos que hay que modificar según la base de datos
$host="localhost";
$user="";
$pass="";