PHP control ejecucion y funciones.
Las estructuras de control son las típicas: if, for, do, while, switch. La diferencia más importante con otros lenguajes es que en PHP se provee de sintaxis alternativa: estructurada (tipo C o PASCAL) y con delimitadores (tipo BASIC)
Control de la ejecución.
if … elseif … else
La intrucción if provee de ejecución condicional. Se puede acompañar de else y elseif.
if( $a > $b )
echo «a es mayor que b»;
elseif( $a == $b )
echo «a es igual a b»;
else
echo «a es menor que b»;
if( $a >= $b ) {
echo «a es mayor o igual que b»;
$mayor = $a;
} else {
echo «a es menor que b»;
$mayor = $b; }
La sintaxis alternativa es útil para imprimir convenientemente fragmentos de HTML. En este caso se termina cada condición con un ‘:’ (dos puntos) y la instrucción completa con endif;.
<H1>Listado de ventas</H1>
<% if( $orden == «fecha» ): %>
<P>Ordenadas por <B>fecha</B></P>
<% elseif ( $orden == «producto» ): %>
<P>Ordenadas según el <B>nombre</B> del producto</P>
<% endif; %>
while, do … while
while permite crear ciclos sencillos, mientras una expresión sea cierta. La expresión puede ser evaluada al comienzo o al final:
$a = 10;
echo «Cuenta regresiva …\n»;
while($a > 0) {
echo $a– .»\n»; # $a es impreso antes de disminuir su valor
} echo «Cero !!!»; # Cuando $a era cero, no fue impreso
$a = 10;
echo «Cuenta regresiva …\n»;
do {
echo $a– . «\n»;
} while( $a > 0 );
echo «Cero !!!»; # Cuando $a era cero, no fue impreso
La diferencia entre while y do … while es que en este último caso la condición es evaluada al final del ciclo, es decir, el ciclo se ejecuta al menos una vez.
La sintaxis alternativa es terminar el ciclo con endwhile; (nótese que se escribe todo junto).
while(expresion): instruccion1; .. instruccionN; endwhile;
for
Un ciclo de este tipo tiene la misma sintaxis que en otros lenguajes: for(inicio;condicion;incremento).
for($a=1;$a<=10;$a++) {
echo «Tabla del $a\n»;
for($b=1;$b<=10;$b++) {
echo «$a por $b es » . ($a * $b) . «\n»;
};
echo «—–\n»;
}
La sintaxis alterna es: for(): instr1; instr2; …; instrN; endfor;
foreach
Supongamos que debemos recorrer un arreglo, podemos hacerlo así:
for($i=0;$i<count($arreglo);$i++) {
echo $arreglo[$i] . «\n»;
}
O utilizar foreach, que crea internamente el iterador sobre el arreglo:
foreach( $arreglo as $elemento ) { echo $elemento . «\n»; };
[Nota para programadores PERL] Es equivalente al foreach $item ( @arr ) de Perl.
Si las llaves del arreglo no son números, es decir, si el arreglo es asociativo, se utiliza una construcción ligeramente diferente.
$tblApellidos[«juan»] = «perez»;
$tblApellidos[«pedro»] = «gonzalez»;
foreach( $tblApellidos as $nombre => $apellido ) { echo «$apellido, $nombre\n»; };
[Nota para programadores PERL] Es más conveniente que la construcción de perl foreach $key ( %hash ). Para obtener un iterador idéntico al de perl se podria usar foreach( array_keys($arreglo) as $key ).
break, continue
break sale del ciclo más interno que se esté ejecutando en ese momento. Puede recibir un parámetro que diga cuantos niveles «romper».
for($i=1;$i<=10;$i++) { for($j=1;$j<=10;$j++) { if( $j > $i ) break 2; … … } };
Un uso interesante de break es poder ejecutar una secuencia de acciones y abortarla a la mitad, sin utilizar ningún tipo de salto, sino sólo programación estructurada (algo así como un bloque try .. catch de Java)
do {
open( … ) or break;
read( … ) or break;
$ok = 1;
} while(0); # Ejecutar una sola vez
if( not $ok ) {
}
continue sirve para saltarse el resto de una ejecución en un ciclo, sin salir de él:
foreach( $arreglo as $elemento ) { if( es_especial($elemento=) ) continue; … … };
Funciones de usuario
Definiciones
Las funciones de usuario en PHP pueden definirse usando el keyword function(). Toda función debe ser definida sólo una vez, no pudiendo ser re-definida en el futuro. Hasta PHP 3.0 sólo puede usarse una función que haya sido definida antes de ser usada, pero en PGP 4.0 esta limitación ya no es efectiva.
function imprime_arreglo($arreglo) {
echo «<UL>n»;
foreach ( $arreglo as $item ) {
echo «<LI>item\n»;
};
echo «</UL>n»;
}
Las funciones pueden o no retornar algo. Ese algo puede ser cualquier cosa mientras se trata de un sólo valor. Para retornar múltiples valores es necesario retornar un arreglo y recibirlo usando list().
function imprime_archivo($archivo) {
$lineas = file( $archivo );
foreach( $lineas as $linea ){
echo htmlspecialchars($linea) . «\n»;
};
return count($lineas);
}
function stat_simple($archivo) {
return array( filesize($archivo), filectime($archivo) );
}
$arch = «prueba.txt»;
list( $size, $ctime ) = stat_simple( $arch );
$fecha_hora = date( «d/m/y h:i», $ctime );
echo «El archivo $arch pesa $size bytes y fue modificado el $fecha_hora»;
Argumentos
Los argumentos pueden ser cualquier número de argumentos, mezclando arreglos y escalares; todos ellos son pasados por valor, es decir, la función recibe una copia de los valores, sin poder modificar las variables originales.
function suma_rara($a,$b) {
$a–;
$b++;
return $a+$b;
} $x = 3;
$y = 5;
$resultado = suma_rara( $x, $y );
echo «$x + $y = $resultado\n»; # 3 + 5 = 8
Para pasar argumentos por referencia y por lo tanto poder modificarlos, se antepone un signo ampersand (&) al argumento en la función:
function elevar_al_cuadrado( &$a ) {
$a = $a * $a;
}; $x = 15;
elevar_al_cuadrado( $x );
echo $x; # 225
Se puede pasar una lista variable de argumentos a una función en PHP 4, mediante el uso de func_num_args() y func_get_args.
function variables() {
$argc = $func_num_args();
$argv = $func_get_args();
echo «Son $argc argumentos\n».
foreach( $argv as $num => $arg ) {
$type = gettype( $arg );
echo «Argumento $num, tipo $type, valor $arg\n»;
};
}
variables( «casa», 9, array( «k», 6, «x» ) );
Un argumento cualquiera puede tener asignado un valor por omisión. Los argumentos que tienen valores por omisión siempre deben ser los primeros de la lista de argumentos.
function ls ( $directorio = «.» ) {
$dirHandle=opendir($directorio);
while ($fname = readdir($dirHandle)) {
echo «$fname\n»;
} closedir($dirHandle);
}; ls(); # Lista directorio actual
ls(«/tmp»); # Lista el temporal
Alcance de variables
Fuera de una función, todas las variables pertenecen al mismo espacio de nombres, incluyendo todo tipo de archivos o módulos que sean incluídos.
Dentro de una función, las variables son locales a menos que se diga lo contrario usando global():
$archivo_datos = «datos.txt»;
function lee_archivo_mal() {
$arch = $archivo_datos;
return file( $arch );
};
function lee_archivo_bien_version_1() {
$arch = global( $archivo_datos );
return file( $arch ); }; function lee_archivo_bien_version_2() {
global( $archivo_datos ); # Importa el nombre al espacio
return file( $archivo_datos ); }; function lee_archivo_bien_version_3() {
return file( $GLOBALS[«archivo_datos»] );
};
[Nota para programadores PERL] En PHP es como si cada variable dentro de una función hubiera sido declarada con el operador my() de Perl.
Un último tipo de variable está constituído por las variables estáticas, que pertenecen a una función y no cambian de valor.
function corta_recursion();
static $numero_llamadas = 0; # Sólo se ejecuta una vez
$numero_llamadas++;
if( $numero_llamadas < 100 ) {
echo «Llamando recursivamente, nivel $numero_llamadas\n»;
corta_recursion();
}; }
Clases
Las clases son paquetes de variables y funciones (métodos de la clase).
class persona { # Las variables de la clase se declaran con ‘var’
var $nombre; var $apellido;
$nombre = $nom;
$apellido = $ape;
}; # Métodos function imprime() {
echo «$apellido, $nombre\n»;
}; };
$p1 = new persona( «Juan», «Perez» );
$p2 = new persona();
$p1->imprime();
$p2->imprime();
Las clases pueden ser extendidas. En este caso el constructor de la superclase debe ser llamado explícitamente si así se desea:
class usuario extends persona { var $userid;
function usuario($nom,$ape,$id) {
$userid = $id;
persona( $nom, $ape ); }; };
