ejemplos - php short tags

¿Cómo depurar scripts PHP?

Question

¿Cómo depurar scripts PHP ?

Soy consciente de la depuración básica, como el uso del Informe de errores. La depuración de punto de interrupción en PHPEclipse también es bastante útil.

¿Cuál es la mejor manera (en términos de rápida y fácil) de depurar en phpStorm o cualquier otro IDE?

Answer 1

phpdbg.com

El Depurador de PHP de Paso Intermedio Interactivo implementado como un módulo SAPI que puede brindarle un control completo sobre el entorno sin afectar la funcionalidad o el rendimiento de su código. Pretende ser una plataforma de depuración liviana, potente y fácil de usar para PHP 5.4+ y se entrega de fábrica con PHP 5.6.

Las características incluyen:

• Paso a paso de depuración
• Puntos de interrupción flexibles (método de clase, función, archivo: línea, dirección, código de operación)
• Fácil acceso a PHP con evaluación incorporada ()
• Fácil acceso al código actualmente en ejecución
• API de usuario
• SAPI Agnóstico - Fácilmente Integrado
• Soporte de archivos de configuración de PHP
• JIT Super Globals - Establece el tuyo!
• Soporte opcional de línea de lectura - Operación cómoda de la terminal
• Soporte de depuración remota - GUI de Java incluida
• Operación fácil

Ver las capturas de pantalla:

Página de inicio: phpdbg.com

Error de PHP - Mejor informe de errores para PHP

Esta es una biblioteca muy fácil de usar (en realidad un archivo) para depurar sus scripts PHP.

Lo único que debe hacer es incluir un archivo como se muestra a continuación (al principio en su código):

require(''php_error.php'');
/php_error/reportErrors();

Luego, todos los errores le darán información tal como retroceso, contexto de código, argumentos de función, variables de servidor, etc. Por ejemplo:

Las características incluyen:

• Trivial de usar, es solo un archivo.
• Errores mostrados en el navegador para solicitudes normales y ajaxy
• Las solicitudes de AJAX están en pausa, lo que le permite volver a ejecutarlas automáticamente
• comete errores lo más estrictos posible (fomenta la calidad del código y tiende a mejorar el rendimiento)
• Fragmentos de código en todo el seguimiento de la pila
• proporciona más información (como firmas de funciones completas)
• corrige algunos mensajes de error que son simplemente erróneos
• resaltado de sintaxis
• ¡se ve hermosa!
• personalización
• encenderlo y apagarlo manualmente
• Ejecutar secciones específicas sin informe de errores
• ignore los archivos que le permiten evitar el código resaltado en su seguimiento de pila
• archivos de aplicación; estos son priorizados cuando un error ataca!

Página de inicio: http://phperror.net/

GitHub: https://github.com/JosephLenton/PHP-Error

Mi fork (con arreglos adicionales): https://github.com/kenorb-contrib/PHP-Error

DTrace

Si su sistema admite el rastreo dinámico de DTrace (instalado de forma predeterminada en OS X) y su PHP se compila con las sondas DTrace habilitadas ( --enable-dtrace ) que deberían estar de forma predeterminada, este comando puede ayudarlo a depurar el script PHP sin tiempo :

sudo dtrace -qn ''php*:::function-entry { printf("%Y: PHP function-entry:/t%s%s%s() in %s:%d/n", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2); }''

Por lo tanto, dado el siguiente alias se ha agregado a sus archivos rc (por ejemplo, ~/.bashrc , ~/.bash_aliases ):

alias trace-php=''sudo dtrace -qn "php*:::function-entry { printf(/"%Y: PHP function-entry:/t%s%s%s() in %s:%d/n/", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2); }"''

puede rastrear su script con un alias fácil de recordar: trace-php .

Aquí hay un script dtrace más avanzado, simplemente guárdelo en dtruss-php.d , dtruss-php.d en ejecutable ( chmod +x dtruss-php.d ) y ejecute:

#!/usr/sbin/dtrace -Zs
# See: https://github.com/kenorb/dtruss-lamp/blob/master/dtruss-php.d
#pragma D option quiet
php*:::compile-file-entry
{
printf("%Y: PHP compile-file-entry:/t%s (%s)/n", walltimestamp, basename(copyinstr(arg0)), copyinstr(arg1));
}
php*:::compile-file-return
{
printf("%Y: PHP compile-file-return:/t%s (%s)/n", walltimestamp, basename(copyinstr(arg0)), basename(copyinstr(arg1)));
}
php*:::error
{
printf("%Y: PHP error message:/t%s in %s:%d/n", walltimestamp, copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2);
}
php*:::exception-caught
{
printf("%Y: PHP exception-caught:/t%s/n", walltimestamp, copyinstr(arg0));
}
php*:::exception-thrown
{
printf("%Y: PHP exception-thrown:/t%s/n", walltimestamp, copyinstr(arg0));
}
php*:::execute-entry
{
printf("%Y: PHP execute-entry:/t%s:%d/n", walltimestamp, basename(copyinstr(arg0)), (int)arg1);
}
php*:::execute-return
{
printf("%Y: PHP execute-return:/t%s:%d/n", walltimestamp, basename(copyinstr(arg0)), (int)arg1);
}
php*:::function-entry
{
printf("%Y: PHP function-entry:/t%s%s%s() in %s:%d/n", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2);
}
php*:::function-return
{
printf("%Y: PHP function-return:/t%s%s%s() in %s:%d/n", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2);
}
php*:::request-shutdown
{
printf("%Y: PHP request-shutdown:/t%s at %s via %s/n", walltimestamp, basename(copyinstr(arg0)), copyinstr(arg1), copyinstr(arg2));
}
php*:::request-startup
{
printf("%Y, PHP request-startup:/t%s at %s via %s/n", walltimestamp, basename(copyinstr(arg0)), copyinstr(arg1), copyinstr(arg2));
}

^{Página de inicio: dtruss-lamp en GitHub}

Aquí está el uso simple:

1. Ejecutar: sudo dtruss-php.d .
2. En otro terminal, ejecute: php -r "phpinfo();" .

Para probarlo, puede ir a cualquier docroot con index.php y ejecutar el servidor incorporado de PHP por:

php -S localhost:8080

Después de eso, puede acceder al sitio en http://localhost:8080/ (o elegir el puerto que más le convenga). Desde allí acceda a algunas páginas para ver el resultado del seguimiento.

Nota: Dtrace está disponible en OS X de manera predeterminada, en Linux probablemente necesite dtrace4linux o dtrace4linux otras alternatives .

Ver: Usando PHP y DTrace en php.net

SystemTap

También puede verificar el seguimiento de SystemTap instalando el paquete de desarrollo de SystemTap SDT (por ejemplo, yum install systemtap-sdt-devel ).

Aquí está el script de ejemplo ( all_probes.stp ) para rastrear todos los puntos de la sonda estática de PHP durante la duración de un script PHP en ejecución con SystemTap:

probe process("sapi/cli/php").provider("php").mark("compile__file__entry") {
printf("Probe compile__file__entry/n");
printf(" compile_file %s/n", user_string($arg1));
printf(" compile_file_translated %s/n", user_string($arg2));
}
probe process("sapi/cli/php").provider("php").mark("compile__file__return") {
printf("Probe compile__file__return/n");
printf(" compile_file %s/n", user_string($arg1));
printf(" compile_file_translated %s/n", user_string($arg2));
}
probe process("sapi/cli/php").provider("php").mark("error") {
printf("Probe error/n");
printf(" errormsg %s/n", user_string($arg1));
printf(" request_file %s/n", user_string($arg2));
printf(" lineno %d/n", $arg3);
}
probe process("sapi/cli/php").provider("php").mark("exception__caught") {
printf("Probe exception__caught/n");
printf(" classname %s/n", user_string($arg1));
}
probe process("sapi/cli/php").provider("php").mark("exception__thrown") {
printf("Probe exception__thrown/n");
printf(" classname %s/n", user_string($arg1));
}
probe process("sapi/cli/php").provider("php").mark("execute__entry") {
printf("Probe execute__entry/n");
printf(" request_file %s/n", user_string($arg1));
printf(" lineno %d/n", $arg2);
}
probe process("sapi/cli/php").provider("php").mark("execute__return") {
printf("Probe execute__return/n");
printf(" request_file %s/n", user_string($arg1));
printf(" lineno %d/n", $arg2);
}
probe process("sapi/cli/php").provider("php").mark("function__entry") {
printf("Probe function__entry/n");
printf(" function_name %s/n", user_string($arg1));
printf(" request_file %s/n", user_string($arg2));
printf(" lineno %d/n", $arg3);
printf(" classname %s/n", user_string($arg4));
printf(" scope %s/n", user_string($arg5));
}
probe process("sapi/cli/php").provider("php").mark("function__return") {
printf("Probe function__return: %s/n", user_string($arg1));
printf(" function_name %s/n", user_string($arg1));
printf(" request_file %s/n", user_string($arg2));
printf(" lineno %d/n", $arg3);
printf(" classname %s/n", user_string($arg4));
printf(" scope %s/n", user_string($arg5));
}
probe process("sapi/cli/php").provider("php").mark("request__shutdown") {
printf("Probe request__shutdown/n");
printf(" file %s/n", user_string($arg1));
printf(" request_uri %s/n", user_string($arg2));
printf(" request_method %s/n", user_string($arg3));
}
probe process("sapi/cli/php").provider("php").mark("request__startup") {
printf("Probe request__startup/n");
printf(" file %s/n", user_string($arg1));
printf(" request_uri %s/n", user_string($arg2));
printf(" request_method %s/n", user_string($arg3));
}

Uso:

stap -c ''sapi/cli/php test.php'' all_probes.stp

Consulte: Uso de SystemTap con PHP DTrace Static Probes en php.net

Answer 2

+1 para print_r (). Úselo para volcar el contenido de un objeto o variable. Para hacerlo más legible, hazlo con una etiqueta pre para que no necesites ver la fuente.

echo ''<pre>'';
print_r($arrayOrObject);

También var_dump ($ cosa) - esto es muy útil para ver el tipo de subtítulos

Answer 3

1) Yo uso print_r (). En TextMate, tengo un fragmento de ''pre'' que se expande a esto:

echo "<pre>";
print_r();
echo "</pre>";

2) Uso Xdebug, pero no he podido hacer que la GUI funcione correctamente en mi Mac. Al menos imprime una versión legible de la traza de la pila.

Answer 4

A menudo uso CakePHP cuando Rails no es posible. Para depurar errores, normalmente encuentro el error.log en la carpeta tmp y lo error.log en el terminal con el comando ...

tail -f app/tmp/logs/error.log

Es un cuadro de diálogo de lo que está sucediendo, lo que es bastante útil, si desea darle algo a este código intermedio puede usarlo.

$this->log(''xxxx'');

Por lo general, esto le puede dar una buena idea de lo que está sucediendo o está mal.

Answer 5

Bueno, hasta cierto punto depende de hacia dónde van las cosas hacia el sur. Eso es lo primero que trato de aislar, y luego usaré echo / print_r () según sea necesario.

NB: ¿Saben que pueden pasar true como segundo argumento a print_r () y devolverá el resultado en lugar de imprimirlo? P.ej:

echo "<pre>".print_r($var, true)."</pre>";

Answer 6

Con toda honestidad, una combinación de print y print_r () para imprimir las variables. Sé que muchos prefieren usar otros métodos más avanzados, pero me parece que es el más fácil de usar.

Diré que no lo aprecié completamente hasta que hice algo de programación de microprocesador en la Uni y no pude usar ni siquiera esto.

Answer 7

Dependiendo del problema, me gusta una combinación de error_reporting (E_ALL) mezclado con pruebas de eco (para encontrar la línea / archivo ofensivo en el que ocurrió el error al principio; SABES que no siempre la línea / archivo php te dice ¿verdad?) (para resolver "Error de análisis: error de sintaxis, problemas inesperados de $ end") y print_r (); salida; volcados (los programadores reales ven la fuente; p).

Tampoco se puede vencer a phpdebug (verifique sourceforge) con "memory_get_usage ();" y "memory_get_peak_usage ();" Para encontrar las áreas problemáticas.

Answer 8

El IDE de Komodo funciona bien con xdebug, incluso para la depuración remore. Necesita una cantidad mínima de configuración. Todo lo que necesita es una versión de php que Komodo pueda usar localmente para recorrer el código en un punto de interrupción. Si tiene el script importado en el proyecto de Komodo, entonces puede establecer puntos de interrupción con un clic del mouse, tal como lo haría dentro de eclipse para depurar un programa java. La depuración remota es obviamente más complicada para que funcione correctamente (es posible que tenga que asignar la URL remota con un script php en su área de trabajo) que una configuración de depuración local que es bastante fácil de configurar si está en un MAC o en un escritorio Linux. .

Answer 9

El búfer de salida es muy útil si no quiere estropear su salida. Hago esto en una sola línea que puedo comentar / descomentar a voluntad

 ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();

Answer 10

En un entorno de producción, registro datos relevantes en el registro de errores del servidor con error_log ().

Answer 11

Este es mi pequeño entorno de depuración:

error_reporting(-1);
assert_options(ASSERT_ACTIVE, 1);
assert_options(ASSERT_WARNING, 0);
assert_options(ASSERT_BAIL, 0);
assert_options(ASSERT_QUIET_EVAL, 0);
assert_options(ASSERT_CALLBACK, ''assert_callcack'');
set_error_handler(''error_handler'');
set_exception_handler(''exception_handler'');
register_shutdown_function(''shutdown_handler'');
function assert_callcack($file, $line, $message) {
throw new Customizable_Exception($message, null, $file, $line);
}
function error_handler($errno, $error, $file, $line, $vars) {
if ($errno === 0 || ($errno & error_reporting()) === 0) {
return;
}
throw new Customizable_Exception($error, $errno, $file, $line);
}
function exception_handler(Exception $e) {
// Do what ever!
echo ''<pre>'', print_r($e, true), ''</pre>'';
exit;
}
function shutdown_handler() {
try {
if (null !== $error = error_get_last()) {
throw new Customizable_Exception($error[''message''], $error[''type''], $error[''file''], $error[''line'']);
}
} catch (Exception $e) {
exception_handler($e);
}
}
class Customizable_Exception extends Exception {
public function __construct($message = null, $code = null, $file = null, $line = null) {
if ($code === null) {
parent::__construct($message);
} else {
parent::__construct($message, $code);
}
if ($file !== null) {
$this->file = $file;
}
if ($line !== null) {
$this->line = $line;
}
}
}

Answer 12

Existen muchas técnicas de depuración de PHP que pueden ahorrarle innumerables horas al codificar. Una técnica de depuración efectiva pero básica es simplemente activar el informe de errores. Otra técnica ligeramente más avanzada implica el uso de declaraciones impresas, que pueden ayudar a detectar errores más difíciles de detectar al mostrar lo que realmente está pasando en la pantalla. PHPeclipse es un complemento de Eclipse que puede resaltar los errores de sintaxis comunes y se puede utilizar junto con un depurador para establecer puntos de interrupción.

display_errors = Off
error_reporting = E_ALL
display_errors = On

y también usado

error_log();
console_log();

Answer 13

He usado Zend Studio (5.5) , junto con Zend Platform . Eso proporciona una depuración adecuada, puntos de interrupción / paso sobre el código, etc., aunque a un precio.

Answer 14

La depuración manual generalmente es más rápida para mí: var_dump() y debug_print_backtrace() son todas las herramientas que necesitas para armar tu lógica.

Answer 15

La mayoría de los errores se pueden encontrar fácilmente simplemente var_dump algunas de las variables clave, pero obviamente depende del tipo de aplicación que desarrolles.

Para algoritmos más complejos, las funciones step / breakpoint / watch son muy útiles (si no son necesarias)

Answer 16

Los depuradores integrados en los que puede ver cómo cambian los valores de las variables a medida que avanza por el código son realmente geniales. Sin embargo, sí requieren una configuración de software en el servidor y una cierta cantidad de configuración en el cliente. Ambos requieren un mantenimiento periódico para mantenerse en buen estado de funcionamiento.

A print_r es fácil de escribir y se garantiza que funciona en cualquier configuración.

Answer 17

Nusphere también es un buen depurador para php nusphere

Answer 18

Para los problemas realmente difíciles que consumirían mucho tiempo para usar print_r / echo para darme cuenta, uso la función de depuración de mi IDE (PhpEd). A diferencia de otros IDEs que he usado, PhpEd requiere prácticamente ninguna configuración. La única razón por la que no lo uso para los problemas que encuentro es que es muy lento. No estoy seguro de que la lentitud sea específica de PhpEd o cualquier depurador de php. PhpEd no es gratis, pero creo que utiliza uno de los depuradores de código abierto (como XDebug mencionado anteriormente) de todos modos. El beneficio con PhpEd, una vez más, es que no requiere una configuración que he encontrado muy tediosa en el pasado.

Answer 19

PhpEd es realmente bueno. Puedes entrar / salir / salir de las funciones. Puede ejecutar código ad-hoc, inspeccionar variables, cambiar variables. Es asombroso.

Answer 20

PhpEdit tiene un depurador incorporado, pero normalmente termino usando echo (); y print_r (); la manera pasada de moda !!

Answer 21

Por lo general, encuentro crear una función de registro personalizada capaz de guardar en un archivo, almacenar información de depuración y, finalmente, volver a imprimir en un pie de página común.

También puede anular la clase de excepción común, de modo que este tipo de depuración sea semiautomático.

Answer 22

Pruebe Eclipse PDT para configurar un entorno Eclipse que tenga funciones de depuración como las que mencionó. La capacidad de ingresar en el código es una forma mucho mejor de depurar que el antiguo método de var_dump e imprimir en varios puntos para ver dónde falla el flujo. Sin embargo, cuando todo lo demás falla y todo lo que tengo es SSH y vim, todavía var_dump() / die() para encontrar dónde va el código hacia el sur.

Answer 23

Puede usar un complemento de Firephp para firebug para depurar php en el mismo entorno que javascript.

También uso Xdebug mencionado anteriormente para perfilar php.

Answer 24

Uso Netbeans con XDebug y el complemento Easy XDebug FireFox

El complemento es esencial cuando depura proyectos MVC, porque la forma normal en que XDebug se ejecuta en Netbeans es registrar la sesión dbug a través de la url. Con el complemento instalado en FireFox, establecerá las propiedades de su proyecto Netbeans -> Ejecutar configuración -> Avanzado y seleccionará "No abrir navegador web". Ahora puede configurar sus puntos de ruptura e iniciar la sesión de depuración con Ctrl-F5 como de costumbre. . Abra FireFox y haga clic con el botón derecho en el icono del complemento en la esquina inferior derecha para comenzar a monitorear los puntos de interrupción. Cuando el código llegue al punto de interrupción, se detendrá y podrá inspeccionar los estados variables y la pila de llamadas.

Answer 25

Uso zend studio para eclipse con el depurador incorporado. Todavía es lento en comparación con la depuración con eclipse pdt con xdebug. Esperamos que solucionen esos problemas, la velocidad ha mejorado con respecto a los lanzamientos recientes, pero aún así el paso de las cosas toma 2-3 segundos. La barra de herramientas de zend firefox realmente facilita las cosas (depura la página siguiente, la página actual, etc.). También proporciona un generador de perfiles que evaluará su código y proporcionará gráficos circulares, tiempo de ejecución, etc.

Answer 26

Xdebug y el complemento DBGp para Notepad ++ para la caza de errores de uso intensivo, FirePHP para cosas ligeras. ¿Rápido y sucio? Nada mejor que dBug .

Answer 27

Yo uso Netbeans con XDebug. Compruébelo en su sitio web para obtener documentación sobre cómo configurarlo. http://php.netbeans.org/

Answer 28

print_r (debug_backtrace ());

o algo así :-)

Answer 29

XDebug es esencial para el desarrollo. Lo instalo antes que cualquier otra extensión. Le proporciona seguimientos de pila en cualquier error y puede habilitar la creación de perfiles fácilmente.

Para ver rápidamente una estructura de datos, use var_dump() . No use print_r() porque tendrá que rodearlo con <pre> y solo imprime una var a la vez.

<?php var_dump(__FILE__, __LINE__, $_REQUEST); ?>

Para un entorno de depuración real, lo mejor que he encontrado es el IDE de Komodo, pero cuesta $$.

Answer 30

Xdebug , por Derick Rethans, es muy bueno. Lo usé hace un tiempo y descubrí que no era tan fácil de instalar. Una vez que haya terminado, no entenderá cómo se las arregló sin él :-)

Hay un buen artículo sobre Zend Developer Zone (la instalación en Linux no parece ser más fácil) e incluso un complemento de Firefox , que nunca usé.