JTagua

Inicio » Posts tagged 'PHP'

Tag Archives: PHP

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.

Debug en PHP 5 con NetBeans 6.7 (Windows)

22/07/2009 20:33 / 18 comentarios en Debug en PHP 5 con NetBeans 6.7 (Windows)

REQUISITO PREVIO: NetBeans 6.7

Para poder depurar (hacer debug) en un programa escrito en PHP con NetBeans se requiere, como es obvio, como requisito previo , tener instalado NetBeans (en mi caso es NetBeans 6.7) con el plugin de PHP. (Ver entradas en el blog).

PRIMERA PARTE: Servidor HTTP e intérprete PHP.

Después, se necesita en primer lugar,  Apache HTTP Server y el intérprete PHP. Como es natural, si se desea trabajar con bases de datos, será necesario instalar un gestor de bases de datos, por ejemplo MySQL.

Existe un instalador llamado XAMPP,  que en su versión 1.7.1  contiene los siguientes elementos:

Los tres primeros componentes son necesarios si se desea desarrollar con PHP desde el IDE de NetBeans. Para administrar MySQL, puede usarse phpMyAdmin, sin embargo, yo prefiero las herramientas administrativas de MySQL originales, es decir, MySQL Workbench. (Ver entradas en el blog).

Como es lógico, si se desea depurar programas escritos en PHP en tiempo real tendremos que utilizar, entre otros, XDebug.

Para descargar XAMPP, vamos a la página principal arriba indicada

(más…)