¿Cómo depurar scripts PHP? [cerrado]

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

También uso Xdebug mencionado anteriormente para perfilar php.

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;
        }
    }
}

Xdebug y el complemento DBGp para Notepad++ para la caza de errores de alta resistencia, FirePHP para cosas ligeras. Rápido y sucio? Nada supera dBug .

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

Para una mirada rápida a una estructura de datos use var_dump(). No uses print_r() porque tendrás que rodearlo con <pre> y solo imprime un var a la vez.

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

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

PhpED es realmente bueno. Puede entrar/pasar / salir de funciones. Puede ejecutar código ad-hoc, inspeccionar variables, cambiar variables. Es increíble.

1) Uso print_r (). En TextMate, tengo un fragmento para 'pre'que se expande a esto:

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

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

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.

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

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

Xdebug, de Derick Rethans, es muy bueno. Lo usé hace algún tiempo y descubrí que no era tan fácil de instalar. Una vez que hayas terminado, no entenderás cómo te las arreglaste sin él: -)

Hay un buen artículo sobre Zend Developer Zone (instalar en Linux no parece más fácil) e incluso un Firefox plugin, que nunca he utilizado.

Uso Netbeans con XDebug. Échale un vistazo en su sitio web para obtener documentos sobre cómo configurarlo. http://php.netbeans.org /

Uso Netbeans con XDebug y el Complemento para FireFox Easy XDebug

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ía sus propiedades del proyecto Netbeans -> Ejecutar Configuratuion -> Avanzado y seleccione "No abrir navegador Web" Ahora puede establecer sus puntos de interrupción e iniciar la sesión de depuración con Ctrl-F5 como de costumbre. Abre FireFox y haga clic con el botón derecho en el icono de complemento en la esquina inferior derecha para comenzar a monitorear los puntos de interrupción. Cuando el código alcanza el punto de interrupción, se detendrá y podrá inspeccionar los estados variables y la pila de llamadas.

El almacenamiento en búfer de salida es muy útil si no desea 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();

PHPEdit tiene un depurador integrado, pero normalmente termino usando echo (); y print_r (); ¡a la antigua usanza!!

Para los problemas realmente arenosos que tomarían demasiado tiempo para usar print_r/echo para descubrir que uso la función de depuración de mi IDE (PhpED). A diferencia de otros IDE que he usado, PhpED no requiere prácticamente ninguna configuración. la única razón por la que no lo uso para cualquier problema que encuentre es que es dolorosamente lento. No estoy seguro de que la lentitud sea específica de PhpED o cualquier depurador php. PhpED no es gratuito, pero creo que utiliza uno de los depuradores de código abierto (como XDebug mencionado anteriormente) Por cierto. El beneficio con PhpED, una vez más, es que no requiere ninguna configuración que he encontrado realmente bastante tedioso en el pasado.

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

Bueno, hasta cierto punto depende de dónde vayan las cosas al 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á la salida en lugar de imprimirla? Por ejemplo:

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

A menudo uso CakePHP cuando Rails no es posible. Para depurar errores suelo encontrar el error.log en la carpeta tmp y seguirlo en el terminal con el comando...

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

Le da un diálogo de ejecución de cake de lo que está pasando, lo cual es bastante útil, si desea generar algo en el código medio que puede usar.

$this->log('xxxx');

Esto generalmente le puede dar una buena idea de lo que está pasando/mal.

Print_r (debug_backtrace ());

O algo así :-)

Komodo IDE funciona bien con xdebug, incluso para la depuración de 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 atravesar el código en un punto de interrupción. Si tiene el script importado en el proyecto komodo, puede establecer puntos de interrupción con un clic del ratón como lo establecería dentro de eclipse para depurar un programa java. La depuración remota es obviamente más difícil para que funcione correctamente ( es posible que tenga que mapear la url remota con un script php en su espacio de trabajo) que una configuración de depuración local que es bastante fácil de configurar si está en un escritorio MAC o linux.

Nusphere también es un buen depurador para php nusphere

Hay muchas técnicas de depuración de PHP que pueden ahorrarle incontables horas al codificar. Una técnica de depuración efectiva pero básica es simplemente activar el informe de errores. Otra técnica un poco más avanzada implica el uso de instrucciones de impresión, que pueden ayudar a identificar 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 errores de sintaxis comunes y se puede usar junto con un depurador para establecer interrupción.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

Y también se utiliza

error_log();
console_log();

+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 el código fuente.

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

También var_dump (thing thing) - esto es muy útil para ver el tipo de subtemas

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

Uso zend studio para eclipse con el depurador integrado. Todavía es lento en comparación con la depuración con eclipse pdt con xdebug. Con suerte solucionarán esos problemas, la velocidad ha mejorado con respecto a las versiones recientes, pero aún así, pasar por alto las cosas toma 2-3 segundos. La barra de herramientas de zend Firefox realmente facilita las cosas (depurar la página siguiente, la página actual, etc.). También proporciona un generador de perfiles que comparará su código y proporcionará gráficos circulares, tiempo de ejecución, etc.

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

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

PHP DBG

El Depurador interactivo de PHP implementado como un módulo SAPI que puede darle un control completo sobre el entorno sin afectar la funcionalidad o el rendimiento de su código. Su objetivo es ser una plataforma de depuración ligera, potente y fácil de usar para PHP 5.4+ y se envía fuera de la caja con PHP 5.6.

Las características incluyen:

• Depuración paso a paso
• Puntos de interrupción Flexibles (Método de Clase, Función, Archivo:Línea, Dirección, Opcode)
• Fácil acceso a PHP con eval ()
• Fácil Acceso al Código Actualmente en Ejecución
• Userland API
• SAPI Agnóstico-Fácilmente integrado
• Soporte de Archivos de configuración PHP
• JIT Super Globals-Establecer Su Propio!!
• Soporte Opcional readline-Operación Cómoda del Terminal
• Soporte de depuración remota-Interfaz Gráfica de usuario de Java incluido
• Fácil manejo

Ver el capturas de pantalla:

Página de Inicio: http://phpdbg.com/

Error de PHP - Mejor reporte 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 necesita hacer es incluir un archivo como se muestra a continuación (al principio de su código):

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

Entonces todos los errores le darán información como backtrace, 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 AJAX se pausan, lo que le permite volver a ejecutarlas automáticamente
• hace que los errores sean lo más estrictos posible (fomenta la calidad del código y tiende a mejorar el rendimiento)
• fragmentos de código a través de toda la traza de la pila
• proporciona más información (como firmas de función completas)
• corrige algunos mensajes de error que son simplemente incorrectos
• resaltado de sintaxis
• se ve bonito!
• personalización
• enciéndelo y apágalo manualmente
• ejecute secciones específicas sin informes de errores
• ignorar archivos que le permite evitar resaltar código en su seguimiento de pila
• archivos de aplicación; estos se priorizan cuando error huelgas!

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

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

DTrace

Si su sistema soporta DTrace dynamic tracing (instalado por defecto en OS X) y su PHP está compilado con las sondas DTrace habilitadas (--enable-dtrace) que deberían estar por defecto, este comando puede ayuda a depurar 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); }'

Así que dado el siguiente alias se ha añadido a sus archivos rc (e. g.~/.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, hágalo 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 otra ejecución de terminal: php -r "phpinfo();".

Para probar eso, puedes ir a cualquier docroot con index.php y ejecutar PHP builtin server por:

php -S localhost:8080

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

Nota: Dtrace está disponible en OS X de forma predeterminada, en Linux probablemente necesite dtrace4linux o busque algún otro alternativas.

Ver: Usando PHP y DTrace en php.net

SystemTap

Alternativamente, compruebe si hay seguimiento de SystemTap instalando el paquete de desarrollo SystemTap SDT (por ejemplo, yum install systemtap-sdt-devel).

Aquí hay un script de ejemplo (all_probes.stp) para rastrear todos los puntos de prueba estáticos del núcleo de PHP a lo largo de 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

Ver: Usando SystemTap con PHP DTrace Sondas estáticas en php.net

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 el error ocurrió initally; sabes que no siempre es la línea/archivo que php te dice, ¿verdad?), IDE brace matching (para resolver" Parse error: syntax error, unexpected end end " issues), e print_r (); exit; dumps (los programadores reales ven el source ;p).

Tampoco puedes vencer a phpdebug (check sourceforge) con " memory_get_usage ();" y " memory_get_peak_usage ();" para encuentra las áreas problemáticas.

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

Un print_r es fácil de escribir y está garantizado para funcionar en cualquier configuración.

Normalmente encuentro crear una función de registro personalizada capaz de guardar en el 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 semiautomatizada.