¿Cómo se depuran los scripts PHP? [cerrado]

¿Cómo se depuran los scripts PHP ?

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

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

Pruebe Eclipse PDT para configurar un entorno Eclipse que tenga características de depuración como usted mencionó. La capacidad de ingresar al código es una forma mucho mejor de depurar que el método anterior de var_dump e imprimir en varios puntos para ver dónde falla su 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.

Puede usar Firephp, un complemento de 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 búsqueda de errores de servicio pesado, FirePHP para cosas livianas. ¿Rápido y sucio? Nada supera a dBug .

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

Para un vistazo rápido a una estructura de datos, use var_dump(). No lo use print_r()porque tendrá que rodearlo <pre>y solo imprime una variable 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 / salir / salir de funciones. Puede ejecutar código ad-hoc, inspeccionar variables, cambiar variables. Es asombroso.

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 del seguimiento de la 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.

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

Diré que no aprecié completamente esto hasta que hice algo de programación de microprocesador en 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 complemento de Firefox , que nunca usé.

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

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, configuraría las propiedades de su proyecto Netbeans -> Ejecutar configuración -> Avanzado y seleccionaría "No abrir el navegador web". Ahora puede configurar sus puntos de interrupción 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 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 sus 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 incorporado, pero generalmente termino usando echo (); y print_r (); a la antigua usanza !!

Para los problemas realmente difíciles que llevarían demasiado tiempo usar print_r / echo para descubrir que uso la función de depuración de mi IDE (PhpEd). A diferencia de otros IDEs 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 encuentro es que es dolorosamente lento. No estoy seguro de que la lentitud sea específica de PhpEd o de cualquier depurador de php. PhpEd no es gratuito, pero creo que de todos modos utiliza uno de los depuradores de código abierto (como XDebug mencionado anteriormente). El beneficio con PhpEd, una vez más, es que no requiere ninguna configuración que he encontrado realmente bastante tediosa 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 van las cosas al sur. Es lo primero que intento 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>";

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

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

Le proporciona un diálogo en ejecución desde el pastel de lo que está sucediendo, lo cual es bastante útil, si desea generar algo a medio código que puede usar.

$this->log('xxxx');

Esto generalmente puede darle una buena idea de lo que está sucediendo / mal.

print_r (debug_backtrace ());

o algo así :-)

Komodo IDE funciona bien con xdebug, incluso para la depuración de eliminación. 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 la secuencia de comandos importada en el proyecto de Komodo, puede establecer puntos de interrupción con un clic del mouse tal como lo configuraría dentro de eclipse para depurar un programa de Java. Obviamente, la depuración remota es más difícil de hacer que funcione correctamente (puede que tenga que asignar 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

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 un poco más avanzada implica el uso de declaraciones de impresión, que pueden ayudar a identificar errores más difíciles de alcanzar al mostrar lo que realmente está pasando en la pantalla. PHPeclipse es un complemento de Eclipse que puede resaltar errores de sintaxis comunes y puede usarse 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();

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

Yo 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. Esperemos que solucionen esos problemas, la velocidad ha mejorado con respecto a los lanzamientos recientes, pero aún pasar de largo toma 2-3 segundos. La barra de herramientas zend firefox realmente facilita las cosas (depurar la página siguiente, 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 de paso / punto de interrupción / observación son muy útiles (si no es necesario)

PHP DBG

El Depurador PHP interactivo paso a paso 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. Su objetivo es ser una plataforma de depuración ligera, potente y fácil de usar para PHP 5.4+ y se envía de fábrica 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, código de operación)
• Fácil acceso a PHP con eval () incorporado
• Fácil acceso al código actualmente en ejecución
• API de usuario
• SAPI Agnostic - Fácilmente integrado
• Soporte de archivos de configuración de PHP
• JIT Super Globals - ¡¡Establezca la suya !!
• Soporte opcional de readline - Operación de terminal cómoda
• Soporte de depuración remota: paquete de GUI de Java
• Operación fácil

Ver las capturas de pantalla:

Página de inicio: http://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 como traza inversa, 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 simplemente son incorrectos
• 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 resaltar el código en su seguimiento de pila
• archivos de aplicación; ¡estos tienen prioridad cuando se produce un error!

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

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

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

DTrace

Si su sistema admite el seguimiento dinámico de DTrace (instalado de forma predeterminada en OS X) y su PHP está compilado con las sondas DTrace habilitadas ( --enable-dtrace), que debería estar por defecto, 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); }'

Entonces, 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); }"'

es posible trazar la secuencia de comandos con alias fácil de recordar: trace-php.

Aquí hay un script dtrace más avanzado, solo guárdelo, hágalo dtruss-php.dejecutable ( 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: lámpara dtruss en GitHub}

Aquí hay un uso simple:

1. Ejecute: sudo dtruss-php.d.
2. En otro terminal ejecutar: php -r "phpinfo();".

Para probar eso, puede ir a cualquier docroot con index.phpy ejecutar el servidor integrado PHP mediante:

php -S localhost:8080

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

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

Consulte: Uso de PHP y DTrace en php.net

SystemTap

Alternativamente, compruebe el 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 centrales de la sonda estática 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 sondas estáticas DTrace de PHP en php.net

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

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

También var_dump ($ thing): esto es muy útil para ver el tipo de subthings

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 se produjo el error inicialmente; ¿SABES que no siempre es la línea / archivo que php te dice?), Coincidencia de llaves IDE (para resolver "Error de análisis: error de sintaxis, problemas inesperados de $ end") e print_r (); salida; volcados (los programadores reales ven la fuente; p).

Tampoco puedes vencer a phpdebug (comprueba sourceforge) con "memory_get_usage ();" y "memory_get_peak_usage ();" para encontrar 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.

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, para que este tipo de depuración sea semiautomatizada.