JTagua

Inicio » PHP » Estructuras de control

Category Archives: Estructuras de control

Anuncios

Tutorial PHP(38): require, require_once

require

(PHP 4, PHP 5)

require es idéntico a include excepto que en caso de fallo producirá un error fatal de nivel E_COMPILE_ERROR. En otras palabras, éste detiene el script mientras que include sólo emitirá una advertencia (E_WARNING) lo cual permite continuar el script.

Véase la documentación de include para más información.

require_once

(PHP 4, PHP 5)

La sentencia require_once es idéntica a require excepto que PHP verificará si el archivo ya ha sido incluido y si es así, no se incluye (require) de nuevo.

Ver la documentación de include_once para información sobre el comportamiento de _once, y como difiere de sus hermanos no _once.

Anuncios

Tutorial PHP(39): goto.

goto

(PHP 5 >= 5.3.0)

El operador goto puede ser usado para saltar a otra sección en el programa. El punto de destino es especificado mediante una etiqueta seguida de dos puntos y la instrucción es dada como goto seguida de la etiqueta del destino deseado. Este goto no es completamente sin restricciones. La etiqueta de destino debe estar dentro del mismo fichero y contexto, lo que significa que no se puede saltar fuera de una función o método, ni se puede saltar dentro de uno. Tampoco se puede saltar dentro de cualquier clase de estructura de bucle o switch. Se puede saltar fuera de estos y un uso común es utilizar un goto en lugar de un break multi-nivel.

Ejemplo #1 Ejemplo de goto

<?php
 goto a;
 echo 'Foo';
 a: echo 'Bar';
?>

El resultado del ejemplo sería:

Bar

Ejemplo #2 Ejemplo de goto en un bucle

<?php
 for($i=0,$j=50; $i<100; $i++) {
   while($j--) {
     if($j==17) goto end; 
  }   }
 echo "i = $i";
end: echo 'j alcanzó 17';
?>

El resultado del ejemplo sería:

j alcanzó 17

Ejemplo #3 Esto no funcionará

<php
 goto loop;
 for($i=0,$j=50; $i<100; $i++) {  
 while($j--) {   
  loop:
   }
 } echo "$i = $i";
?>

El resultado del ejemplo sería:

Fatal error: ‘goto’ into loop or switch statement is disallowed in script on line 2
(Error fatal: ‘goto’ hacia el interior de un bucle o sentencia switch no esta permitido en el script en la línea 2)

Nota: El operador goto está disponible a partir de PHP 5.3.

Tutorial PHP(37): include, include_once

include

(PHP 4, PHP 5)

La sentencia include incluye y evalúa el archivo especificado.

La siguiente documentación también se aplica a require.

Los archivos son incluidos con base en la ruta de acceso dada o, si ninguna es dada, el include_path especificado. Si el archivo no se encuentra en el include_path, include finalmente verificará en el propio directorio del script que hace el llamado y en el directorio de trabajo actual, antes de fallar. El constructor include emitirá una advertencia si no puede encontrar un archivo, éste es un comportamiento diferente al de require, el cual emitirá un error fatal..

Si una ruta es definida — ya sea absoluta (comenzando con una letra de unidad o \ en Windows o / en sistemas Unix/Linux) o relativa al directorio actual (comenzando con . o ..) — el include_path será ignorado por completo. Por ejemplo, si un nombre de archivo comienza con ../, el interprete buscará en el directorio padre para encontrar el archivo solicitado.

Para más información sobre como PHP maneja la inclusión de archivos y la ruta de accesos para incluir, ver la documentación de include_path.

Cuando se incluye un archivo, el código que contiene hereda el ámbito de las variables de la línea en la cual ocurre la inclusión. Cualquier variable disponible en esa línea del archivo que hace el llamado, estará disponible en el archivo llamado, desde ese punto en adelante. Sin embargo, todas las funciones y clases definidas en el archivo incluido tienen el ámbito global.

Ejemplo #1 Ejemplo básico de include

vars.php
<?php
$color&nbsp;=&nbsp;'verde';
$fruta&nbsp;=&nbsp;'manzana';
?>

test.php
<?php
echo&nbsp;"Una&nbsp;$fruta&nbsp;$color";&nbsp;//&nbsp;Una
include&nbsp;'vars.php';
echo&nbsp;"Una&nbsp;$fruta&nbsp;$color";&nbsp;//&nbsp;Una&nbsp;manzana&nbsp;verde
?>

Si la inclusión ocurre al interior de una función dentro del archivo que hace el llamado, entonces todo el código contenido en el archivo llamado se comportará como si hubiera sido definida dentro de esa función. Por lo tanto, seguirá el ámbito de las variables de esa función. Una excepción a esta regla son las constantes mágicas las cuales son evaluadas por el intérprete antes que ocurra la inclusión.

Ejemplo #2 Incluyendo dentro de funciones

<?php
function&nbsp;foo()
{
global&nbsp;$color;

include&nbsp;'vars.php';

echo&nbsp;"Una&nbsp;$fruta&nbsp;$color";
}

/*&nbsp;vars.php&nbsp;está&nbsp;en&nbsp;el&nbsp;ámbito&nbsp;de&nbsp;foo()&nbsp;así&nbsp;que&nbsp;*
*&nbsp;$fruta&nbsp;NO&nbsp;está&nbsp;disponible&nbsp;por&nbsp;fuera&nbsp;de&nbsp;éste&nbsp;&nbsp;*
*&nbsp;ámbito.&nbsp;$color&nbsp;sí&nbsp;está&nbsp;porque&nbsp;fue&nbsp;declarado&nbsp;*
*&nbsp;como&nbsp;global.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*/

foo();&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;Una&nbsp;manzana&nbsp;verde
echo&nbsp;"Una&nbsp;$fruta&nbsp;$color";&nbsp;&nbsp;&nbsp;//&nbsp;Una&nbsp;verde
?>

Cuando un archivo es incluido, el intérprete abandona el modo PHP e ingresa al modo HTML al comienzo del archivo objetivo y se reanuda de nuevo al final. Por esta razón, cualquier código al interior del archivo objetivo que deba ser ejecutado como código PHP, tendrá que ser encerrado dentro de etiquetas válidas de comienzo y terminación de PHP.

Si las “envolturas URL include” están activadas en PHP, se puede especificar el archivo a ser incluido usando una URL (vía HTTP u otra envoltura soportada – ver Protocolos y Envolturas soportados para una lista de protocolos) en lugar de una ruta de acceso local. Si el servidor objetivo interpreta el archivo objetivo como código PHP, las variables se pueden pasar al archivo incluido usando una string de petición como la usada con HTTP GET. Esto no es, en estricto rigor, lo mismo que haber incluido el archivo y que haya heredado el ámbito de variables del archivo padre; el script realmente está siendo ejecutado en el servidor remoto y el resultado entonces se incluye dentro del script local.

AdvertenciaVersiones de PHP para Windows anteriores a 4.3.0, no soportan el acceso remoto a archivos para esta función, no funcionará ni activando siquiera allow_url_fopen.

Ejemplo #3 include por medio de HTTP

<?php
/*&nbsp;Este&nbsp;ejemplo&nbsp;asume&nbsp;que&nbsp;www.example.com&nbsp;está&nbsp;configurado&nbsp;para&nbsp;interpretar&nbsp;archivos
*&nbsp;.php&nbsp;y&nbsp;no&nbsp;archivos&nbsp;.txt.&nbsp;Además,&nbsp;aquí&nbsp;'Funciona'&nbsp;quiere&nbsp;decir&nbsp;que&nbsp;las&nbsp;variables
*&nbsp;$foo&nbsp;y&nbsp;$bar&nbsp;están&nbsp;disponibles&nbsp;dentro&nbsp;del&nbsp;archivo&nbsp;incluido.&nbsp;*/

//&nbsp;No&nbsp;funciona;&nbsp;file.txt&nbsp;no&nbsp;puede&nbsp;ser&nbsp;manejado&nbsp;por&nbsp;www.example.com&nbsp;como&nbsp;PHP
include&nbsp;'http://www.example.com/file.txt?foo=1&bar=2';

//&nbsp;No&nbsp;funciona;&nbsp;busca&nbsp;por&nbsp;un&nbsp;archivo&nbsp;llamado&nbsp;'file.php?foo=1&bar=2'&nbsp;en&nbsp;el
//&nbsp;sistema&nbsp;de&nbsp;archivos&nbsp;local.
include&nbsp;'file.php?foo=1&bar=2';

//&nbsp;Si&nbsp;funciona.
include&nbsp;'http://www.example.com/file.php?foo=1&bar=2';

$foo&nbsp;=&nbsp;1;
$bar&nbsp;=&nbsp;2;
include&nbsp;'file.txt';&nbsp;&nbsp;//&nbsp;Funciona.
include&nbsp;'file.php';&nbsp;&nbsp;//&nbsp;Funciona.
?>

Advertencia de seguridad

El archivo remoto puede ser procesado en el servidor remoto (dependiendo de la extensión del archivo y del hecho de si el servidor remoto corre PHP o no) pero aun así tiene que producir un script PHP válido, porque será procesado en el servidor local. Si el archivo desde el servidor remoto debe ser procesado allá y entregar la salida solamente, readfile() es la mejor función para usar. De lo contrario, debe tenerse especial cuidado para asegurar que el script remoto produce un código válido y deseado.

Ver también Archivos remotos, fopen() y file() para información relacionada.

Manejando retornos: include devuelve FALSE en caso de falla y eleva una advertencia. Inclusiones exitosas, a menos que sea reemplazado por el archivo incluido, devolverá 1. Es posible ejecutar una sentencia return dentro de un archivo incluido con el fin de terminar el procesamiento en ese archivo y volver a script que lo llamó. Además, es posible retornar valores desde los archivos incluidos. Se puede tomar el valor de la llamada “include” de la misma forma como se haría con una función normal. Esto no es, sin embargo, posible si se incluyen archivos remotos, a menos que la salida del archivo remoto tenga unas etiquetas válidas de inicio y terminación de PHP (igual que con cualquier archivo local). Se pueden declarar las variables necesarias dentro de esas etiquetas y serán introducidas en cualquiera sea el punto del archivo en el cual fue incluido.

Debido a que include es un constructor especial del lenguaje, los paréntesis no son necesarios en torno a su argumento. Se debe tener cuidado cuando se compara el valor de retorno.

Ejemplo #4 Comparando el valor de retorno de include

<?php
//&nbsp;no&nbsp;funciona,&nbsp;evaluado&nbsp;como&nbsp;include(('vars.php')&nbsp;==&nbsp;'OK'),&nbsp;es&nbsp;decir&nbsp;include('')
if&nbsp;(include('vars.php')&nbsp;==&nbsp;'OK')&nbsp;{
echo&nbsp;'OK';
}

//&nbsp;si&nbsp;funciona
if&nbsp;((include&nbsp;'vars.php')&nbsp;==&nbsp;'OK')&nbsp;{
echo&nbsp;'OK';
}
?>

Ejemplo #5 include y la sentencia return

return.php
<?php
$var&nbsp;=&nbsp;'PHP';
return&nbsp;$var;
?>

noreturn.php
<?php
$var&nbsp;=&nbsp;'PHP';
?>

testreturns.php
<?php
$foo&nbsp;=&nbsp;include&nbsp;'return.php';
echo&nbsp;$foo;&nbsp;//&nbsp;muestra&nbsp;'PHP'
$bar&nbsp;=&nbsp;include&nbsp;'noreturn.php';
echo&nbsp;$bar;&nbsp;//&nbsp;muestra&nbsp;1
?>

$bar tiene el valor 1 debido a que el include fue exitoso. Nótese la diferencia entre los ejemplos anteriores. El primero usa return dentro del archivo incluido, mientras que el otro no. Si el archivo no se pueden incluir, se retorna FALSE y se emite un E_WARNING.

Si hay funciones definidas en el archivo incluido, se pueden utilizar en el archivo principal independientemente que hayan return antes o después. Si el archivo se incluye dos veces, PHP 5 arrojará un error fatal ya que las funciones ya han sido declaradas, mientras que PHP 4 no se queja acerca de las funciones definidas después de un return. Se recomienda el uso de include_once en lugar de comprobar si el archivo ya estaba incluido y hacer el retorno de forma condicionada dentro del archivo incluido.

Otra forma de “incluir” un archivo PHP en una variable es capturar la salida mediante el uso de Funciones de control de salida con include. Por ejemplo:

Ejemplo #6 Usando buffering de salida para incluir un archivo PHP dentro de una cadena

<?php
$string&nbsp;=&nbsp;get_include_contents('somefile.php');

function&nbsp;get_include_contents($filename)&nbsp;{
if&nbsp;(is_file($filename))&nbsp;{
ob_start();
include&nbsp;$filename;
return&nbsp;ob_get_clean();
}
return&nbsp;false;
}
?>

Con el fin de incluir archivos de forma automática dentro de scripts, véase también las opciones de configuración auto_prepend_file and auto_append_file en php.ini.

Nota: Puesto que esto es una construcción del lenguaje y no una función, no puede ser llamada usando funciones variables.

Ver también require, require_once, include_once, get_included_files(), readfile(), virtual() y include_path.

 

include_once

(PHP 4, PHP 5)

La sentencia include_once incluye y evalúa el fichero especificado durante la ejecución del script. Es un comportamiento similar al de la sentencia include, siendo la única diferencia que si el código del fichero ya ha sido incluido, no se volverá a incluir. Como su nombre lo indica, será incluido sólo una vez.

include_once puede ser usado en casos donde el mismo fichero podría ser incluido y evaluado más de una vez durante una ejecución particular de un script, así que en este caso, puede ayudar a evitar problemas como la redefinición de funciones, reasignación de valores de variables, etc.

Ver la documentación de include para información sobre como trabaja esta función.

Nota:

Con PHP 4, la funcionalidad _once difiere entre sistemas operativos insensibles a mayúsculas y minúsculas (como Windows) así que por ejemplo:

Ejemplo #1 include_once con un SO insensible a mayúsculas y minúsculas en PHP 4

<?php
include_once&nbsp;"a.php";&nbsp;//&nbsp;esto&nbsp;incluirá&nbsp;a.php
include_once&nbsp;"A.php";&nbsp;//&nbsp;esto&nbsp;incluirá&nbsp;a.php&nbsp;otra&nbsp;vez!&nbsp;(sólo&nbsp;PHP&nbsp;4)
?>

Este comportamiento cambió en PHP 5, así que por ejemplo con Windows primero se normaliza la ruta de acceso para que C:\PROGRA~1\A.php sea identificado igual que C:\Program Files\a.php y el fichero sea incluido sólo una vez.

TutoriaL PHP(36): return.

28/12/2013 21:20 / Deja un comentario

return

(PHP 4, PHP 5)

Si se llama desde una función, la sentencia return inmediatamente termina la ejecución de la función actual, y devuelve su argumento como el valor de la llamada a la función. return también pondrá fin a la ejecución de una sentencia eval() o a un archivo de script.

Si se llama desde el ámbito global, entonces la ejecución del script actual se termina. Si el archivo script actual fue incluido o requerido con include o require, entonces el control es pasado de regreso al archivo que hizo el llamado. Además, si el archivo script actual fue incluido con include, entonces el valor dado a return será retornado como el valor de la llamada include. Si return es llamado desde dentro del fichero del script principal, entonces termina la ejecución del script. Si el archivo script actual fue nombrado por las opciones de configuración auto_prepend_file o auto_append_file en php.ini, entonces se termina la ejecución de ese archivo script.

Para más información, ver Retornando valores.

 

Nota: Cabe señalar que dado que return es un constructor del lenguaje y no una función, los paréntesis que rodean su argumentos no son necesarios. Es común no utilizarlos, y en realidad se debería hacer así a fin de que PHP tenga menos trabajo que hacer en este caso.

Nota: Si no se suministra un parámetro, entonces el paréntesis debe omitirse y NULL será retornado. Llamadas a return con paréntesis pero sin argumentos resultarán en un error del intérprete.

Nota: Nunca se deben usar paréntesis al rededor de la variable de retorno cuando se retorna por referencia, ya que esto no funcionará. Sólo se pueden retornar variables por referencia, no el resultado de una sentencia. Si se utiliza return ($a); entonces no se está retornando una variable, sino el resultado de la expresión ($a) (el cual es, por supuesto, el valor de $a).

Titulo PHP(35): declare.

28/12/2013 19:35 / Deja un comentario

declare

(PHP 4, PHP 5)

El constructor declare es usado para fijar directivas de ejecución para un bloque de código. La sintaxis de declare es similar a la sintaxis de otros constructores de control de flujo:

declare (directive)
statement

La sección directive permite que el comportamiento de declare sea configurado. Actualmente, sólo dos directivas están reconocidas: ticks (Ver abajo para más información sobre la directiva ticks) y encoding (Ver abajo para más información sobre la directiva encoding ).

Nota: La directiva encoding fue agregada en PHP 5.3.0

La parte statement del bloque declare será ejecutada – como se ejecuta y que efectos secundarios ocurran durante la ejecución puede depender de la directiva fijada en el bloque directive.

El constructor declare también se puede utilizar en el alcance global, afectando a todo el código que le sigue (sin embargo, si el archivo con el declare fue incluido entonces no afectará al archivo padre).

<?php
// estos son lo mismo:

// se puede usar ésto:
declare(ticks=1) {
// script entero aquí
}

// o se puede usar ésto:
declare(ticks=1);
// script entero aquí
?>

Ticks

Un tick es un evento que ocurre para cada sentencia tickable N de bajo nivel ejecutada por el intérprete dentro del bloque declare. El valor para N se especifica usando ticks=N dentro del bloque de declare de la sección directive.

No todas las sentencias son tickable. Por lo general, expresiones de condición y expresiones de argumento no son tickables.

Los eventos que ocurren en cada tick se especifican mediante la register_tick_function(). Ver el ejemplo abajo para más detalles. Tener en cuenta que más de un evento puede ocurrir por cada tick.

Ejemplo #1 Ejemplo de uso del tick

declare(ticks=1);

// Una función llamada en cada evento tick
function tick_handler()
{
echo "tick_handler() llamado\n";
}

register_tick_function('tick_handler');

$a = 1;

if ($a > 0) {
$a += 2;
print($a);
}
?>

Ejemplo #2 Ejemplo de uso de ticks

<?php
function tick_handler()
{
echo "tick_handler() llamado\n";
}

$a = 1;
tick_handler();

if ($a > 0) {
$a += 2;
tick_handler();
print($a);
tick_handler();
}
tick_handler();
?>

Véase también register_tick_function() y unregister_tick_function().

Encoding

Una codificación de script puede ser especificada para cada script usando la directiva encoding.

Ejemplo #3 Declarando un encoding para el script

<?php
declare(encoding='ISO-8859-1');
// código aquí
?>
PrecauciónCuando se combina con espacios de nombres, la única sintaxis legal para declarar es declare(encoding=’…’); donde es el valor del encoding. declare(encoding=’…’) {} resultará en un error de análisis cuando se combina con espacios de nombres.

El valor declarado de encoding es ignorado en PHP 5.3 a menos que php esté compilado con –enable-zend-multibyte.

Tener en cuenta que PHP no expone si –enable-zend-multibyte fue utilizado para compilar PHP que no sea por phpinfo().

Ver también zend.script_encoding.

Tutorial PHP(34): continue.

28/12/2013 19:25 / Deja un comentario

continue

(PHP 4, PHP 5)

continue se utiliza dentro de las estructuras iterativas para saltar el resto de la iteración actual del bucle y continuar la ejecución en la evaluación de la condición, y luego comenzar la siguiente iteración.

Nota: Tenga en cuenta que en PHP la sentencia switch se considera una estructura iterativa para los propósitos de continue.

continue acepta un argumento numérico opcional, que indica a cuántos niveles de bucles encerrados se ha de saltar al final. El valor por omisión es 1, por lo que salta al final del bucle actual.

<?php
while (list($clave, $valor) = each($arr)) {
    if (!($clave % 2)) { // saltar los miembros impares
        continue;
    }
    hacer_algo($valor);
}

$i = 0;
while ($i++ < 5) {
    echo "Exterior<br />\n";
    while (1) {
        echo "Medio<br />\n";
        while (1) {
            echo "Interior<br />\n";
            continue 3;
        }
        echo "Esto nunca se imprimirá.<br />\n";
    }
    echo "Ni esto tampoco.<br />\n";
}
?>

Omitir el punto y coma después del continue puede llevar a confusión. He aquí un ejemplo de lo que no se debe hacer.

<?php
for ($i = 0; $i < 5; ++$i) {
    if ($i == 2)
        continue
    print "$i\n";
}
?>

Se esperaría que el resultado fuera:

0
1
3
4

pero la salida de este script será:

2

debido a que continue print “$i\n”; se evalúa completo como una sola expresión, y así print se llama solamente cuando $i == 2 es verdadero. (El valor de retorno de print es pasado a continue como el argumento numérico.)

Registro de cambios para continue
5.4.0 continue 0; ya no es válido. En versiones anteriores era interpretado de la misma manera que continue 1;.
5.4.0 Se eliminó la posibilidad de pasar variables (por ejemplo, $num = 2; continue $num;) como el argumento numérico.

Tutorial PHP(33): switch.

28/12/2013 13:40 / Deja un comentario

switch

(PHP 4, PHP 5)

La sentencia switch es similar a una serie de sentencias IF en la misma expresión. En muchas ocasiones, es posible que se quiera comparar la misma variable (o expresión) con muchos valores diferentes, y ejecutar una parte de código distinta dependiendo de a que valor es igual. Para esto es exactamente la expresión switch.

Nota: Cabe señalar que a diferencia de algunos otros lenguajes, la sentencia continue se aplica a switch y actúa de manera similar a break. Si se tiene un switch dentro de un bucle y se desea continuar a la siguiente iteración de del ciclo exterior, se utiliza continue 2.

Nota:

Tener en cuenta que switch/case hace comparaciones flexibles.

Los dos ejemplos siguientes son dos formas diferentes de escribir lo mismo, uno con una serie de sentencias if y elseif, y el otro usando la sentencia switch:

Ejemplo #1 Estructura switch

<?php
if ($i == 0) {
    echo "i es igual a 0";
} elseif ($i == 1) {
    echo "i es igual a 1";
} elseif ($i == 2) {
    echo "i es igual a 2";
}

switch ($i) {
    case 0:
        echo "i es igual a 0";
        break;
    case 1:
        echo "i es igual a 1";
        break;
    case 2:
        echo "i es igual a 2";
        break;
}
?>

Ejemplo #2 Estrutura switch permite el uso de strings

<?php
switch ($i) {
    case "manzana":
        echo "i es una manzana";
        break;
    case "barra":
        echo "i es una barra";
        break;
    case "pastel":
        echo "i es un pastel";
        break;
}
?>

Es importante entender cómo la sentencia switch es ejecutada con el fin de evitar errores. La sentencia switch ejecuta línea por línea (en realidad, sentencia por sentencia). Al principio, ningún código es ejecutado. Sólo cuando una sentencia case es encontrada con un valor que coincide con el valor de la sentencia switch, PHP comienza a ejecutar la sentencias. PHP continúa ejecutando las sentencias hasta el final del bloque switch, o hasta la primera vez que vea una sentencia break. Si no se escribe una sentencia break al final de la lista de sentencias de un caso, PHP seguirá ejecutando las sentencias del caso siguiente. Por ejemplo:

<?php
switch ($i) {
    case 0:
        echo "i es igual a 0";
    case 1:
        echo "i es igual a 1";
    case 2:
        echo "i es igual a 2";
}
?>

Aquí, si $i es igual a 0, PHP ejecutaría todas las sentencias echo! Si $i es igual a 1, PHP ejecutaría las últimas dos sentencias echo. Se obtendría el comportamiento esperado (se mostraría ‘i es igual a 2’) sólo si $i es igual a 2. Por lo tanto, es importante no olvidar las sentencias break (aunque es posible que se desee evitar proporcionarlas a propósito bajo determinadas circunstancias).

En una sentencia switch, la condición es evaluada sólo una vez y el resultado es comparado con cada una de las sentencias case. En una sentencia elseif, la condición es evaluada otra vez. Si la condición es más complicada que una simple comparación y/o está en un bucle estrecho, un switch puede ser más rápido.

La lista de sentencias para un caso también puede estar vacía, lo cual simplemente pasa el control a la lista de sentencias para el siguiente caso.

<?php
switch ($i) {
case 0:
case 1:
case 2:
    echo "i es menor que 3 pero no negativo";
    break;
case 3:
    echo "i es 3";
}
?>

Un caso especial es el default. Este caso coincide con cualquier cosa que no se haya correspondido por los otros casos. Por ejemplo:

<?php
switch ($i) {
    case 0:
        echo "i es igual a 0";
        break;
    case 1:
        echo "i es igual a 1";
        break;
    case 2:
        echo "i es igual a 2";
        break;
    default:
       echo "i no es igual a 0, 1 ni 2";
}
?>

La expresión case puede ser cualquier expresión que se evalúa como un tipo simple, es decir, entero o números de punto flotante y strings. Los arrays u objetos no se pueden utilizar aquí a menos que sean desreferenciados a un tipo simple.

La sintaxis alternativa para las estructuras de control es compatible con los switch. Para obtener más información, consulte Sintaxis alternativa de estructuras de control.

<?php
switch ($i):
    case 0:
        echo "i es igual a 0";
        break;
    case 1:
        echo "i es igual a 1";
        break;
    case 2:
        echo "i es igual a 2";
        break;
    default:
        echo "i no es igual a 0, 1 ni 2";
endswitch;
?>

Es posible utilizar un punto y coma en lugar de dos puntos después de un caso como:

<?php
switch($beer)
{
    case 'tuborg';
    case 'carlsberg';
    case 'heineken';
        echo 'Buena elección';
    break;
    default;
        echo 'Por favor haga una nueva selección...';
    break;
}
?>

Tutorial PHP(32): continue.

28/12/2013 10:06 / Deja un comentario

Tutorial PHP(30): foreach

28/12/2013 09:57 / Deja un comentario

foreach

(PHP 4, PHP 5)

El constructor foreach proporciona un modo sencillo de iterar sobre arrays. foreach funciona sólo sobre arrays y objetos, y emitirá un error al intentar usarlo con una variable de un tipo diferente de datos o una variable no inicializada. Existen dos sintaxis:

foreach (expresión_array as $valor)
sentencias
foreach (expresión_array as $clave => $valor)
sentencias

La primera forma recorre el array dado por expresión_array. En cada iteración, el valor del elemento actual se asigna a $valor y el puntero interno del array avanza una posición (así en la próxima iteración se estará observando el siguiente elemento).

La segunda forma además asigna la clave del elemento actual a la variable $clave en cada iteración.

También es posible personalizar la iteración de objetos.

Nota:

Cuando foreach inicia su ejecución, el puntero interno del array se pone automáticamente en el primer elemento del array. Esto significa que no es necesario llamar la función reset() antes de un bucle foreach.

Ya que foreach depende el puntero de array interno, cambiar éste dentro del bucle puede conducir a un comportamiento inesperado.

Para poder modificar directamente los elementos del array dentro de bucle, se ha de anteponer & a $valor. En este caso el valor será asignado por referencia.

<?php
$array = array(1, 2, 3, 4);
foreach ($array as &$valor) {  
   $valor = $valor * 2;
    } // $array ahora es array(2, 4, 6, 8)
unset($valor); // rompe la referencia con el último elemento
?

Referenciar $valor sólo es posible si el array iterado puede ser referenciado (es decir, si es una variable). El siguiente código no funcionará:

<?php
 foreach (array(1, 2, 3, 4) as &$valor) {  
   $valor = $valor * 2;
 }
?

Advertencia

La referencia del $valor y el último elemento del array permanecen aún después del bucle foreach. Se recomienda destruirlos con unset().

Nota:

foreach no soporta la capacidad de suprimir mensajes de error usando ‘@’.

Se puede haber notado que las siguientes construcciones son funcionalmente idénticas:

<?php
$array = array("uno", "dos", "tres");
reset($array);
while (list(, $valor) = each($array)) {
    echo "Valor: $valor<br />\n";
}

foreach ($array as $valor) {
    echo "Valor: $valor<br />\n";
}
?>

Las siguientes construcciones también son funcionalmente idénticas:

<?php
$array = array("uno", "dos", "tres");
reset($array);
while (list($clave, $valor) = each($array)) {
    echo "Clave: $clave; Valor: $valor<br />\n";
}

foreach ($array as $clave => $valor) {
    echo "Clave: $clave; Valor: $valor<br />\n";
}
?>

Algunos ejemplos más para demostrar su uso:


<?php
/* Ejemplo 1 de foreach: sólo el valor */

$a = array(1, 2, 3, 17);

foreach ($a as $v) {
    echo "Valor actual de \$a: $v.\n";
}

/* Ejemplo 2 de foreach: valor (con su notación de acceso manual impreso con fines ilustrativos) */

$a = array(1, 2, 3, 17);

$i = 0; /* sólo para efectos ilustrativos */

foreach ($a as $v) {
    echo "\$a[$i] => $v.\n";
    $i++;
}

/* Ejemplo 3 de foreach: clave y valor */

$a = array(
    "uno" => 1,
    "dos" => 2,
    "tres" => 3,
    "diecisiete" => 17
);

foreach ($a as $k => $v) {
    echo "\$a[$k] => $v.\n";
}

/* Ejemplo 4 de foreach: arrays multidimensionales */
$a = array();
$a[0][0] = "<span class="hiddenGrammarError" pre="">a";
$a</span>[0][1] = "b";
$a[1][0] = "y";
$a[1][1] = "z";

foreach ($a as $v1) {
    foreach ($v1 as $v2) {
        echo "$v2\n";
    }
}

/* Ejemplo 5 de foreach: arrays dinámicos */

foreach (array(1, 2, 3, 4, 5) as $v) {
    echo "$v\n";
}
?>

Utilizando arrays anidados con list()

(PHP 5 >= 5.5.0)

PHP 5.5 añade la posibilidad de recorrer un array de arrays y utilizar el array interior en las variables del bucle proporcionando list() como el valor.

Por ejemplo:

<?php
$array = [
    [1, 2],
    [3, 4],
];

foreach ($array as list($a, $b)) {
    // $a contiene el primer elemento del array interior,
    // y $b contiene el segundo elemento.
    echo "A: $a; B: $b\n";
}
?>

El resultado del ejemplo sería:

A: 1; B: 2
A: 3; B: 4

Puedes proporcionar menos elementos a list() de los que hay en el array interior, en cuyo caso los elementos sobrantes del array serán descartados:

<?php
$array = [
    [1, 2],
    [3, 4],
];

foreach ($array as list($a)) {
    // Observa que no hay $b en este caso.
    echo "$a\n";
}
?>

El resultado del ejemplo sería:

1
3

Se generará un notice si no hay suficientes elementos en el array para completar el list():

<?php
$array = [
    [1, 2],
    [3, 4],
];

foreach ($array as list($a, $b, $c)) {
    echo "A: $a; B: $b; C: $c\n";
}
?>

El resultado del ejemplo sería:

Notice: Undefined offset: 2 in example.php on line 7
A: 1; B: 2; C:

Notice: Undefined offset: 2 in example.php on line 7
A: 3; B: 4; C:

Tutorial PHP(29): for

28/12/2013 09:41 / Deja un comentario

(PHP 4, PHP 5)

Los bucles for son los más complejos en PHP. Se comportan como sus homólogos en C. La sintaxis de un bucle for es:

for (expr1; expr2; expr3)
sentencia

La primera expresión (expr1) es evaluada (ejecutada) una vez incondicionalmente al comienzo del bucle.

En el comienzo de cada iteración, se evalúa expr2. Si se evalúa como TRUE, el bucle continúa y se ejecutan la/sy sentencia/s anidada/s. Si se evalúa como FALSE, finaliza la ejecución del bucle.

Al final de cada iteración, se evalúa (ejecuta) expr3.

Cada una de las expresiones puede estar vacía o contener múltiples expresiones separadas por comas. En expr2, todas las expresiones separadas por una coma son evaluadas, pero el resultado se toma de la última parte. Que expr2 esté vacía significa que el bucle debería ser corrido indefinidamente (PHP implícitamente lo considera como TRUE, como en C). Esto puede no ser tan inútil como se pudiera pensar, ya que muchas veces se debe terminar el bucle usando una sentencia condicional break en lugar de utilizar la expresión verdadera del for.

Considere los siguientes ejemplos. Todos ellos muestran los números del 1 al 10:

<?php
/* ejemplo 1 */

for ($i = 1; $i <= 10; $i++) {
    echo $i;
}

/* ejemplo 2 */

for ($i = 1; ; $i++) {
    if ($i > 10) {
        break;
    }
    echo $i;
}

/* ejemplo 3 */

$i = 1;
for (; ; ) {
    if ($i > 10) {
        break;
    }
    echo $<span class="hiddenGrammarError" pre="for ">i;
    $i</span>++;
}

/* ejemplo 4 */

for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);
?>

Por supuesto, el primer ejemplo parece ser el mejor (o quizás el cuarto), pero se puede observar que la posibilidad de usar expresiones vacías en los bucles for resulta útil en muchas ocasiones.

PHP también admite la sintaxis alternativa de los dos puntos para bucles for.

for (expr1; expr2; expr3):
sentencia

endfor;

Es una cosa común a muchos usuarios iterar por medio de arrays como en el siguiente ejemplo.

<?php
/*
* Este es un array con algunos datos que se quieren modificar
* cuando se recorra el bucle for.
*/
$people = array(
    array('name' => 'Kalle', 'salt' => 856412),
    array('name' => 'Pierre', 'salt' => 215863)
);

for($i = 0; $i < count($people); ++$i) {
    $people[$i]['salt'] = mt_rand(000000, 999999);
}
?>

El código anterior puede ser lento, debido a que el tamaño del array se capta en cada iteración. Dado que el tamaño nunca cambia, el bucle ser fácilmente optimizado mediante el uso de una variable intermedia para almacenar el tamaño en lugar de llamar repetidamente a count():

<?php
$people = array(
    array('name' => 'Kalle', 'salt' => 856412),
    array('name' => 'Pierre', 'salt' => 215863)
);

for($i = 0, $size = count($people); $i < $size; ++$i) {
    $people[$i]['salt'] = mt_rand(000000, 999999);
}
?>