Manual de PHP para Principiantes (Parte7)

ESTRUCTURAS DE CONTROL

Todo archivo de comandos PHP se compone de una serie de sentencias. Una sentencia puede ser una asignación, una llamada a función, un bucle, una sentencia condicional e incluso una sentencia que no haga nada (una sentencia vacía). Las sentencias normalmente acaban con punto y coma. Además, las sentencias se pueden agrupar en grupos de sentencias encapsulando un grupo de sentencias con llaves. Un grupo de sentencias es también una sentencia. En este capítulo se describen los diferentes tipos de sentencias.
if
La construcción if es una de las más importantes características de muchos lenguajes, incluido PHP. Permite la ejecución
condicional de fragmentos de código. PHP caracteriza una estructura if que es similar a la de C:
if (expr)
sentencia
Como se describe en la sección sobre expresiones, expr se evalúa a su valor condicional. Si expr se evalúa como TRUE,
PHP ejecutará la sentencia, y si se evalúa como FALSE - la ignorará.
El siguiente ejemplo mostraría a es mayor que b si $a fuera mayor que $b:
if ($a > $b)
print "a es mayor que b";
A menudo, se desea tener más de una sentencia ejecutada de forma condicional. Por supuesto, no hay necesidad de encerrar cada sentencia con una cláusula if. En vez de eso, se pueden agrupar varias sentencias en un grupo de sentencias. Por ejemplo, este código mostraría a es mayor que b si $a fuera mayor que $b, y entonces asignaría el valor de $a a $b:
if ($a > $b) {
print "a es mayor que b";
$b = $a;
}
Las sentencias if se pueden anidar indefinidamente dentro de otras sentencias if, lo cual proporciona una flexibilidad
completa para ejecuciones condicionales en las diferentes partes de tu programa.
else
A menudo queremos ejecutar una sentencia si se cumple una cierta condicion, y una sentencia distinta si la condición no se cumple. Esto es para lo que sirve else. else extiende una sentencia if para ejecutar una sentencia en caso de que la expresión en la sentencia if se evalúe como FALSE. Por ejemplo, el siguiente código mostraría a es mayor que b si $a fuera mayor que $b, y a NO es mayor que b en cualquier otro caso:
if ($a > $b) {
print "a es mayor que b";
} else {
print "a NO es mayor que b";
}
La sentencia else se ejecuta solamente si la expresión if se evalúa como FALSE, y si hubiera alguna expresión elseif -
sólo si se evaluaron también a FALSE (Ver elseif).
elseif
elseif, como su nombre sugiere, es una combinación de if y else. Como else, extiende una sentencia if para ejecutar
una sentencia diferente en caso de que la expresión if original se evalúa como FALSE. No obstante, a diferencia de else, ejecutará esa expresión alternativa solamente si la expresión condicional elseif se evalúa como TRUE. Por ejemplo, el siguiente código mostraría a es mayor que b, a es igual a b o a es menor que b:
if ($a > $b) {
print "a es mayor que b";
} elseif ($a == $b) {
print "a es igual que b";
} else {
print "a es mayor que b";
}
Puede haber varios elseifs dentro de la misma sentencia if. La primera expresión elseif (si hay alguna) que se evalúe
como true se ejecutaría. En PHP, también se puede escribir ’else if’ (con dos palabras) y el comportamiento sería idéntico al de un ’elseif’ (una sola palabra). El significado sintáctico es ligeramente distinto (si estas familiarizado con C, es el mismo comportamiento) pero la línea básica es que ambos resultarían tener exactamente el mismo comportamiento.
La sentencia elseif se ejecuta sólo si la expresión if precedente y cualquier expresión elseif precedente se evalúan
como FALSE, y la expresión elseif actual se evalúa como TRUE.

Sintaxis Alternativa de Estructuras de Control
PHP ofrece una sintaxis altenativa para alguna de sus estructuras de control; a saber, if, while, for, y switch. En cada
caso, la forma básica de la sintaxis alternativa es cambiar abrir-llave por dos puntos (:) y cerrar-llave por endif;,
endwhile;, endfor;, or endswitch;, respectivamente.
<?php if ($a==5): ?>
A es igual a 5
<?php endif; ?>
En el ejemplo de arriba, el bloque HTML "A = 5"se anida dentro de una sentencia if escrita en la sintaxis alternativa. El bloque HTML se mostraría solamente si $a fuera igual a 5.
La sintaxis alternativa se aplica a else y también a elseif. La siguiente es una estructura if con elseif y else en el
formato alternativo:
if ($a == 5):
print "a es igual a 5";
print "...";
elseif ($a == 6):
print "a es igual a 6";
print "!!!";
else:
print "a no es ni 5 ni 6";
endif;
Mirar también while, for, e if para más ejemplos.

while
Los bucles while son los tipos de bucle más simples en PHP. Se comportan como su contrapartida en C. La forma básica de una sentencia while es:
while (expr) sentencia
El significado de una sentencia while es simple. Le dice a PHP que ejecute la(s) sentencia(s) anidada(s) repetidamente,
mientras la expresión while se evalúe como TRUE. El valor de la expresión es comprobado cada vez al principio del bucle, así que incluso si este valor cambia durante la ejecución de la(s) sentencia(s) anidada(s), la ejecución no parará hasta el fin de la iteración (cada vez que PHP ejecuta las sentencias en el bucle es una iteración). A veces, si la expresión while se evalúa como FALSE desde el principio de todo, la(s) sentencia(s) anidada(s) no se ejecutarán ni siquiera una vez.
Como con la sentencia if, se pueden agrupar multiples sentencias dentro del mismo bucle while encerrando un grupo de sentencias con llaves, o usando la sintaxis alternativa:
while (expr): sentencia ... endwhile;
Los siguientes ejemplos son idénticos, y ambos imprimen números del 1 al 10:
/* ejemplo 1 */
$i = 1;
while ($i <= 10) {
print $i++; /* el valor impreso sería
$i antes del incremento
(post-incremento) */
}
/* ejemplo 2 */
$i = 1;
while ($i <= 10):
print $i;
$i++;
endwhile;
do..while
Los bucles do..while son muy similares a los bucles while, excepto que las condiciones se comprueban al final de cada
iteración en vez de al principio. La principal diferencia frente a los bucles regulares while es que se garantiza la ejecución de la primera iteración de un bucle do..while (la condición se comprueba sólo al final de la iteración), mientras que puede no ser necesariamente ejecutada con un bucle while regular (la condición se comprueba al principio de cada iteración, si esta se evalúa como FALSE desde el principio la ejecución del bucle finalizará inmediatamente).
Hay una sola sintaxis para los bucles do..while:
$i = 0;
do {
print $i;
} while ($i>0);

El bucle de arriba se ejecutaría exactamente una sola vez, después de la primera iteración, cuando la condición se
comprueba, se evalúa como FALSE ($i no es más grande que 0) y la ejecución del bucle finaliza.
Los usuarios avanzados de C pueden estar familiarizados con un uso distinto del bucle do..while, para permitir parar la ejecución en medio de los bloques de código, encapsulandolos con do..while(0), y usando la sentencia break. El
siguiente fragmento de código demuestra esto:
do {
if ($i < 5) {
print "i no es lo suficientemente grande";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
print "i es correcto";
...procesa i...
} while(0);
No se preocupes si no entiende esto completamente o en absoluto. Se pueden codificar archivos de comandos e incluso archivos de comandos potentes sin usar esta ’propiedad’.

for
Los bucles for son los bucles más complejos en PHP. Se comportan como su contrapartida en C. La sintaxis de un bucle
for es:
for (expr1; expr2; expr3) sentencia
La primera expresión (expr1) se evalúa (ejecuta) incondicionalmente una vez al principio del bucle.
Al comienzo de cada iteración, se evalúa expr2 . Si se evalúa como TRUE, el bucle continúa y las sentencias anidadas se
ejecutan. Si se evalúa como FALSE, la ejecución del bucle finaliza.
Al final de cada iteración, se evalúa (ejecuta) expr3.
Cada una de las expresiones puede estar vacía. Que expr2 esté vacía significa que el bucle debería correr indefinidamente
(PHP implicitamente lo considera como TRUE, al igual que C). Esto puede que no sea tan inútil como se podría pensar,
puesto que a menudo se quiere salir de un bucle usando una sentencia break condicional en vez de usar la condición de for.
Considera los siguientes ejemplos. Todos ellos muestran números del 1 al 10:
/* ejemplo 1 */
for ($i = 1; $i <= 10; $i++) {
print $i;
}
/* ejemplo 2 */
for ($i = 1;;$i++) {
if ($i > 10) {
break;
}
print $i;

}
/* ejemplo 3 */
$i = 1;
for (;;) {
if ($i > 10) {
break;
}
print $i;
$i++;
}
/* ejemplo 4 */
for ($i = 1; $i <= 10; print $i, $i++) ;
Por supuesto, el primer ejemplo parece ser el mas elegante (o quizás el cuarto), pero uno puede descubrir que ser capaz de
usar expresiones vacías en bucles for resulta útil en muchas ocasiones.
PHP también soporta la "sintaxis de dos puntos"alternativa para bucles for.
for (expr1; expr2; expr3): sentencia; ...; endfor;
Otros lenguajes poseen una sentencia foreach para traducir un array o una tabla hash. PHP3 no posee tal construcción;
PHP4 sí (ver foreach). En PHP3, se puede combinar while con las funciones list() y each() para conseguir el mismo efecto.
Mirar la documentación de estas funciones para ver un ejemplo.

foreach
PHP4 (PHP3 no) incluye una construcción foreach, tal como perl y algunos otros lenguajes. Esto simplemente da un
modo fácil de iterar sobre arrays. Hay dos sintaxis; la segunda es una extensión menor, pero útil de la primera:
foreach(expresion_array as $value) sentencia
foreach(expresion_array as $key => $value) sentencia
La primera forma recorre el array dado por expresion_array. En cada iteración, el valor del elemento actual se asigna a $value y el puntero interno del array se avanza en una unidad (así en el siguiente paso, se estará mirando el elemento siguiente).
La segunda manera hace lo mismo, salvo que la clave del elemento actual será asignada a la variable $key en cada
iteración.
Nota: Cuando foreach comienza su primera ejecución, el puntero interno a la lista (array) se reinicia automáticamente
al primer elemento del array. Esto significa que no se necesita llamar a reset() antes de un bucle foreach.
Nota: Hay que tener en cuanta queforeach con una copia de la lista (array) especificada y no la lista en si, por ello el
puntero de la lista no es modificado como en la construcción each.

Puede haber observado que las siguientes son funcionalidades idénticas:
reset( $arr );
while( list( , $value ) = each( $arr ) ) {
echo "Valor: $value<br>\n";
}
foreach( $arr as $value ) {
echo "Valor: $value<br>\n";
}
Las siguientes también son funcionalidades idénticas:
reset( $arr );
while( list( $key, $value ) = each( $arr ) ) {
echo "Key: $key; Valor: $value<br>\n";
}
foreach( $arr as $key => $value ) {
echo "Key: $key; Valor: $value<br>\n";
}
Algunos ejemplos más para demostrar su uso:
/* foreach ejemplo 1: sólo valor*/
$a = array(1, 2, 3, 17);
foreach($a as $v) {
print "Valor actual de \$a: $v.\n";
}
/* foreach ejemplo 2: valor (con clave impresa para ilustrar) */
$a = array(1, 2, 3, 17);
$i = 0; /* sólo para propósitos demostrativos */
foreach($a as $v) {
print "\$a[$i] => $k.\n";
}
/* foreach ejemplo 3: clave y valor */
$a = array(
"uno" => 1,
"dos" => 2,
"tres" => 3,
"diecisiete" => 17
);
foreach($a as $k => $v) {
print "\$a[$k] => $v.\n";
}

break

break escapa de la estructuras de control iterante (bucle) actuales for, while, o switch.
break accepta un parámetro opcional, el cual determina cuantas estructuras de control hay que escapar.
$arr = array (’one’, ’two’, ’three’, ’four’, ’stop’, ’five’);
while (list (, $val) = each ($arr)) {
if ($val == ’stop’) {
break; /* You could also write ’break 1;’ here. */
}
echo "$val<br>\n";
}
/* Using the optional argument. */
$i = 0;
while (++$i) {
switch ($i) {
case 5:
echo "At 5<br>\n";
break 1; /* Exit only the switch. */
case 10:
echo "At 10; quitting<br>\n";
break 2; /* Exit the switch and the while. */
default:
break;
}
}

continue
continue se usa dentro de la estructura del bucle para saltar el resto de la iteración actual del bucle y continuar la
ejecución al comienzo de la siguiente iteración.
continue accepta un parámetro opcional, el cual determina cuantos niveles (bluces) hay que saltar antes de continuar con la ejecución.
while (list($key,$value) = each($arr)) {
if ($key % 2) { // salta los miembros impares
continue;
}
do_something_odd ($value);
}
$i = 0;
while ($i++ < 5) {
echo "Outer<br>\n";
while (1) {
echo " Middle<br>\n";
while (1) {
echo " Inner<br>\n";
continue 3;
}
echo "This never gets output.<br>\n";
}
echo "Neither does this.<br>\n";
}
125
Capítulo 11. Estructuras de Control

switch
La sentencia switch es similar a una serie de sentencias IF en la misma expresión. En muchas ocasiones, se quiere
comparar la misma variable (o expresión) con nuchos valores diferentes, y ejecutar una parte de código distinta
dependiendo de a qué valor es igual. Para ello sirve la sentencia switch.
Los siguientes dos ejemplos son dos modos distintos de escribir la misma cosa, uno usa una serie de sentencias if, y el
otro usa la sentencia switch:
if ($i == 0) {
print "i es igual a 0";
}
if ($i == 1) {
print "i es igual a 1";
}
if ($i == 2) {
print "i es igual a 2";
}
switch ($i) {
case 0:
print "i es igual a 0";
break;
case 1:
print "i es igual a 1";
break;
case 2:
print "i es igual a 2";
break;
}
Es importante entender cómo se ejecuta la sentencia switch para evitar errores. La sentencia switch ejecuta línea por línea (realmente, sentencia a sentencia). Al comienzo, no se ejecuta código. Sólo cuando se encuentra una
sentencia case con un valor que coincide con el valor de la expresión switch PHP comienza a ejecutar las sentencias. PHP continúa ejecutando las sentencias hasta el final del bloque switch, o la primera vez que vea una sentencia break. Si no se escribe una sentencia break al final de una lista de sentencias case, PHP seguirá ejecutando las sentencias del siguiente case. Por ejemplo:
switch ($i) {
case 0:
print "i es igual a 0";
case 1:
print "i es igual a 1";
case 2:
print "i es igual a 2";
}
Aquí, si $i es igual a 0, ¡PHP ejecutaría todas las sentecias print! Si $i es igual a 1, PHP ejecutaría las últimas dos
sentencias print y sólo si $i es igual a 2, se obtendría la conducta ’esperada’ y solamente se mostraría ’i es igual a 2’. Así, es importante no olvidar las sentencias break (incluso aunque pueda querer evitar escribirlas intencionadamente en ciertas
circunstancias).
En una sentencia switch, la condición se evalúa sólo una vez y el resultado se compara a cada sentencia case. En una sentencia elseif, la condición se evalúa otra vez. Si tu condición es más complicada que una comparación simple y/o está en un bucle estrecho, un switch puede ser más rápido.

La lista de sentencias de un case puede también estar vacía, lo cual simplemente pasa el control a la lista de sentencias del siguiente case.
switch ($i) {
case 0:
case 1:
case 2:
print "i es menor que 3, pero no negativo";
break;
case 3:
print "i es 3";
}
Un case especial es el default case. Este case coincide con todo lo que no coincidan los otros case. Por ejemplo:
switch ($i) {
case 0:
print "i es igual a 0";
break;
case 1:
print "i es igual a 1";
break;
case 2:
print "i es igual a 2";
break;
default:
print "i no es igual a 0, 1 o 2";
}
La expresión case puede ser cualquier expresión que se evalúe a un tipo simple, es decir, números enteros o de punto flotante y cadenas de texto. No se pueden usar aquí ni arrays ni objetos a menos que se conviertan a un tipo simple.
La sintaxis alternativa para las estructuras de control está también soportada con switch. Para más información, ver
Sintaxis alternativa para estructuras de control.
switch ($i):
case 0:
print "i es igual 0";
break;
case 1:
print "i es igual a 1";
break;
case 2:
print "i es igual a 2";
break;
default:
print "i no es igual a 0, 1 o 2";
endswitch;
require()
La sentencia require() se sustituye a sí misma con el archivo especificado, tal y como funciona la directiva #include de C.

Un punto importante sobre su funcionamiento es que cuando un archivo se incluye con include() o se requiere con
require()), el intérprete sale del modo PHP y entra en modo HTML al principio del archivo referenciado, y vuelve de
nuevo al modo PHP al final. Por esta razón, cualquier código dentro del archivo referenciado que debiera ser ejecutado como código PHP debe ser encerrado dentro de etiquetas válidas de comienzo y fin de PHP.
require() no es en realidad una función de PHP; es más una construcción del lenguaje. Está sujeta a algunas reglas distintas de las de funciones. Por ejemplo, require() no esta sujeto a ninguna estructura de control contenedora. Por otro lado, no devuelve ningún valor; intentar leer un valor de retorno de una llamada a un require() resulta en un error del intérprete.
A diferencia de include(), require() siempre leerá el archivo referenciado, incluso si la línea en que está no se ejecuta
nunca. Si se quiere incluir condicionalmente un archivo, se usa include(). La sentencia conditional no afecta a require().
No obstante, si la línea en la cual aparece el require() no se ejecuta, tampoco se ejecutará el código del archivo
referenciado.
De forma similar, las estructuras de bucle no afectan la conducta de require(). Aunque el código contenido en el archivo referenciado está todavía sujeto al bucle, el propio require() sólo ocurre una vez.
Esto significa que no se puede poner una sentencia require() dentro de una estructura de bucle y esperar que incluya el contenido de un archivo distinto en cada iteración. Para hacer esto, usa una sentencia include().
require( ’header.inc’ );
When a file is require()ed, the code it contains inherits the variable scope of the line on which the require() occurs. Any
variables available at that line in the calling file will be available within the called file. If the require() occurs inside a
function within the calling file, then all of the code contained in the called file will behave as though it had been defined
inside that function.
If the require()ed file is called via HTTP using the fopen wrappers, and if the target server interprets the target file as PHP
code, variables may be passed to the require()ed file using an URL request string as used with HTTP GET. This is not
strictly speaking the same thing as require()ing the file and having it inherit the parent file’s variable scope; the script is
actually being run on the remote server and the result is then being included into the local script.
/* This example assumes that someserver is configured to parse .php
* files and not .txt files. Also, ’works’ here means that the variables
* $varone and $vartwo are available within the require()ed file. */
/* Won’t work; file.txt wasn’t handled by someserver. */
require ("http://someserver/file.txt?varone=1&vartwo=2");
/* Won’t work; looks for a file named ’file.php?varone=1&vartwo=2’
* on the local filesystem. */
require ("file.php?varone=1&vartwo=2");
/* Works. */
require ("http://someserver/file.php?varone=1&vartwo=2");
$varone = 1;
$vartwo = 2;
require ("file.txt"); /* Works. */
require ("file.php"); /* Works. */
En PHP3, es posible ejecutar una sentencia return dentro de un archivo referenciado con require(), en tanto en cuanto
esa sentencia aparezca en el ámbito global del archivo requerido (require()). No puede aparecer dentro de ningún bloque
(lo que siginifica dentro de llaves({})). En PHP4, no obstante, esta capacidad ha sido desestimada. Si se necesita esta
funcionalidad, véase include().
Ver tambien include(), require_once(), include_once(), readfile(), y virtual().

include()
La sentencia include() incluye y evalúa el archivo especificado.
Si "URL fopen wrappers"esta activada en PHP (como está en la configuración inicial), se puede especificar el fichero que se va a incluir usando una URL en vez de un fichero local (con su Path) Ver Ficheros remotos y fopen() para más
información.
Un punto importante sobre su funcionamiento es que cuando un archivo se incluye con include() o se requiere con
require(), el intérprete sale del modo PHP y entra en modo HTML al principio del archivo referenciado, y vuelve de nuevo al modo PHP al final. Por esta razón, cualquier código dentro del archivo referenciado que debiera ser ejecutado como código PHP debe ser encerrado dentro de etiquetas válidas de comienzo y fin de PHP.
Esto sucede cada vez que se encuentra la sentencia include(), así que se puede usar una sentencia include() dentro de una estructura de bucle para incluir un número de archivos diferentes.
$archivos = array (’primero.inc’, ’segundo.inc’, ’tercero.inc’);
for ($i = 0; $i < count($archivos); $i++) {
include $archivos[$i];
}
include() difiere de require() en que la sentencia include se re-evalúa cada vez que se encuentra (y sólo cuando está siendo ejecutada), mientras que la sentencia require() se reemplaza por el archivo referenciado cuando se encuentra por primera vez, se vaya a evaluar el contenido del archivo o no (por ejemplo, si está dentro de una sentencia if cuya condición evaluada es falsa).
Debido a que include() es una construcción especial del lenguaje, se debe encerrar dentro de un bloque de sentencias si está dentro de un bloque condicional.
/* Esto es ERRÓNEO y no funcionará como se desea. */
if ($condicion)
include($archivo);
else
include($otro);
/* Esto es CORRECTO. */
if ($condicion) {
include($archivo);
} else {
include($otro);
}
En ambos, PHP3 y PHP4, es posible ejecutar una sentencia return dentro de un archivo incluido con include(), para
terminar el procesado de ese archivo y volver al archivo de comandos que lo llamó. Existen algunas diferencias en el modo en que esto funciona, no obstante. La primera es que en PHP3, return no puede aparecer dentro de un bloque a menos que sea un bloque de función, en el cual return se aplica a esa función y no al archivo completo. En PHP4, no obstante, esta restricción no existe. También, PHP4 permite devolver valores desde archivos incluidos con include(). Se puede capturar el valor de la llamada a include() como se haría con una función normal. Esto genera un error de intérprete en PHP3.
Ejemplo 11-1. include() en PHP3 y PHP4
Asumamos la existencia del siguiente archivo (llamado test.inc) en el mismo directorio que el archivo principal:
<?php
echo "Antes del return <br>\n";
if ( 1 ) {
129
Capítulo 11. Estructuras de Control
return 27;
}
echo "Después del return <br>\n";
?>
Asumamos que el archivo principal (main.html) contiene lo siguiente:
<?php
$retval = include( ’test.inc’ );
echo "El archivo devolvió: ’$retval’<br>\n";
?>
Cuando se llama a main.html en PHP3, generará un error del intérprete en la linea 2; no se puede capturar el valor de un
include() en PHP3. En PHP4, no obstante, el resultado será:
Antes del return
El archivo devolvió: ’27’
Ahora, asumamos que se ha modificado main.html para que contenga lo siguiente:
<?php
include( ’test.inc’ );
echo "De vuelta en main.html<br>\n";
?>
En PHP4, la salida será:
Antes del return
De vuelta en main.html
No obstante, PHP3 dará la siguiente salida:
Antes del return
27De vuelta en main.html
Parse error: parse error in /home/torben/public_html/phptest/main.html on line 5
El error del intérprete es resultado del hecho de que la sentencia return está encerrada en un bloque de no-función dentro de test.inc. Cuando el return se mueve fuera del bloque, la salida es:
Antes del return 27De vuelta en main.html El ’27’ espúreo se debe al hecho de que PHP3 no soporta devolver valores con return desde archivos como ese.
When a file is include()ed, the code it contains inherits the variable scope of the line on which the include() occurs. Any
variables available at that line in the calling file will be available within the called file. If the include() occurs inside a
function within the calling file, then all of the code contained in the called file will behave as though it had been defined
inside that function.
If the include()ed file is called via HTTP using the fopen wrappers, and if the target server interprets the target file as PHP
code, variables may be passed to the include()ed file using an URL request string as used with HTTP GET. This is not
strictly speaking the same thing as include()ing the file and having it inherit the parent file’s variable scope; the script is
actually being run on the remote server and the result is then being included into the local script.
/* This example assumes that someserver is configured to parse .php
* files and not .txt files. Also, ’works’ here means that the variables
* $varone and $vartwo are available within the include()ed file. */
/* Won’t work; file.txt wasn’t handled by someserver. */
130
Capítulo 11. Estructuras de Control
include ("http://someserver/file.txt?varone=1&vartwo=2");
/* Won’t work; looks for a file named ’file.php?varone=1&vartwo=2’
* on the local filesystem. */
include ("file.php?varone=1&vartwo=2");
/* Works. */
include ("http://someserver/file.php?varone=1&vartwo=2");
$varone = 1;
$vartwo = 2;
include ("file.txt"); /* Works. */
include ("file.php"); /* Works. */
See also require(), require_once(), include_once(), readfile(), and virtual().
require_once()
The require_once() statement replaces itself with the specified file, much like the C preprocessor’s #include works, and
in that respect is similar to the require() statement. The main difference is that in an inclusion chain, the use of
require_once() will assure that the code is added to your script only once, and avoid clashes with variable values or
function names that can happen.
For example, if you create the following 2 include files utils.inc and foolib.inc
Ejemplo 11-2. utils.inc
<?php
define(PHPVERSION, floor(phpversion()));
echo "GLOBALS ARE NICE\n";
function goodTea() {
return "Oolong tea tastes good!";
}
?>
Ejemplo 11-3. foolib.inc
<?php
require ("utils.inc");
function showVar($var) {
if (PHPVERSION == 4) {
print_r($var);
} else {
dump_var($var);
}
}
// bunch of other functions ...
?>
And then you write a script cause_error_require.php
Ejemplo 11-4. cause_error_require.php
<?php
require("foolib.inc");
131
Capítulo 11. Estructuras de Control
/* the following will generate an error */
require("utils.inc");
$foo = array("1",array("complex","quaternion"));
echo "this is requiring utils.inc again which is also\n";
echo "required in foolib.inc\n";
echo "Running goodTea: ".goodTea()."\n";
echo "Printing foo: \n";
showVar($foo);
?>
When you try running the latter one, the resulting ouptut will be (using PHP 4.01pl2):
GLOBALS ARE NICE
GLOBALS ARE NICE
Fatal error: Cannot redeclare causeerror() in utils.inc on line 5
By modifying foolib.inc and cause_errror_require.php to use require_once() instead of require() and renaming
the last one to avoid_error_require_once.php, we have:
Ejemplo 11-5. foolib.inc (fixed)
...
require_once("utils.inc");
function showVar($var) {
...
Ejemplo 11-6. avoid_error_require_once.php
...
require_once("foolib.inc");
require_once("utils.inc");
$foo = array("1",array("complex","quaternion"));
...
And when running the latter, the output will be (using PHP 4.0.1pl2):
GLOBALS ARE NICE
this is requiring globals.inc again which is also
required in foolib.inc
Running goodTea: Oolong tea tastes good!
Printing foo:
Array
(
[0] => 1
[1] => Array
(
[0] => complex
[1] => quaternion
)
)
Also note that, analogous to the behavior of the #include of the C preprocessor, this statement acts at "compile time", e.g.
when the script is parsed and before it is executed, and should not be used for parts of the script that need to be inserted
dynamically during its execution. You should use include_once() or include() for that purpose.

For more examples on using require_once() and include_once(), look at the PEAR code included in the latest PHP source code distributions.
See also: require(), include(), include_once(), get_required_files(), get_included_files(), readfile(), and virtual().
include_once()
The include_once() statement includes and evaluates the specified file during the execution of the script. This is a behavior
similar to the include() statement, with the important difference that if the code from a file has already been included, it will not be included again.
As mentioned in the require_once() description, the include_once() should be used in the cases in which the same file
might be included and evaluated more than once during a particular execution of a script, and you want to be sure that it is included exactly once to avoid problems with function redefinitions, variable value reassignments, etc.
For more examples on using require_once() and include_once(), look at the PEAR code included in the latest PHP source code distributions.
See also: require(), include(), require_once(), get_required_files(), get_included_files(), readfile(), and virtual().

Paginas del Manual

01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11

Opine en este Foro