¿Cómo se depuran los scripts PHP ?
Soy consciente de la depuración básica, como el uso de informes 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 manera rápida y fácil) para depurar en phpStorm o cualquier otro IDE?
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.
Pruebe Eclipse PDT para configurar un entorno Eclipse que tenga funciones de depuración como las que mencionó. La capacidad de ingresar al 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 fluye el flujo. Sin embargo, cuando todo lo demás falla, y todo lo que tengo es SSH y VM todavía var_dump()/ die()para encontrar dónde va el código al sur.
print_r (debug_backtrace ());
o algo así :-)
Xdebug , de Derick Rethans, es muy bueno. Lo usé hace un 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 (la instalación en Linux no parece ser más fácil) e incluso un complemento de Firefox , que nunca utilicé.
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 me parece que es el más fácil de usar.
Diré que no lo aprecié completamente hasta que hice una programación de microprocesador en Uni y no pude usar ni siquiera esto.
+1 para print_r (). Úselo para descargar los contenidos 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 subprocesos
Puedes usar Firephp como add-on para firebug para depurar php en el mismo entorno que javascript.
También uso Xdebug mencionado anteriormente para perfilar php.
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 php te dice ¿verdad?), IDE corchete coincidencia (para resolver problemas de "Parse error: error de sintaxis, $ end inesperado") e print_r (); salida; vertederos (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
1) Yo uso print_r (). En TextMate, tengo un fragmento para 'pre' que se expande a esto:
echo "<pre>";
print_r();
echo "</pre>";
2) Utilizo Xdebug, pero no he podido hacer que la GUI funcione correctamente en mi Mac. Al menos imprime una versión legible del rastro de la pila.
En un entorno de producción, registro datos relevantes en el registro de errores del servidor con error_log ().
utilizo zend studio para eclipse con el depurador incorporado. Todavía es lento en comparación con la depuración con eclipse pdt con xdebug. Es de esperar que solucionen esos problemas, la velocidad ha mejorado con respecto a los lanzamientos recientes, pero aún así, los pasos tardan entre 2 y 3 segundos. La barra de herramientas zend firefox realmente facilita las cosas (depurar 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.
Para los problemas realmente rudos que consumiría demasiado tiempo para usar print_r / echo para descubrir, utilizo 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 utiliza uno de los depuradores de código abierto (como XDebug anteriormente mencionado) de todos modos. El beneficio con PhpEd, una vez más, es que no requiere configuración que he encontrado realmente bastante tediosa en el pasado.
La depuración manual generalmente es más rápida para mí, var_dump()y debug_print_backtrace()son todas las herramientas con las que necesita armar su lógica.
XDebug es esencial para el desarrollo. Lo instalo antes de cualquier otra extensión. Le da rastros de pila en cualquier error y puede habilitar el perfil fácilmente.
Para una mirada rápida a una estructura de datos, use var_dump(). No lo use print_r()porque tendrá que rodearlo <pre>y solo imprime una varita por vez.
<?php var_dump(__FILE__, __LINE__, $_REQUEST); ?>
Para un entorno de depuración real, lo mejor que he encontrado es Komodo IDE, pero cuesta $$.
IDE de Komodo funciona bien con xdebug, incluso para la depuración de remore. Necesita una cantidad mínima de configuración. Todo lo que necesitas 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 sobre cómo se configuraría dentro de eclipse para depurar un programa de Java. La depuración remota es obviamente más complicada para que funcione correctamente (es posible que deba 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 se encuentra en un escritorio MAC o Linux. .
Los depuradores integrados en los que puede ver los valores de cambio de variable a medida que avanza en el código son realmente geniales. Sin embargo, requieren 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.
Yo uso Netbeans con XDebug. Compruébelo en su sitio web para obtener información sobre cómo configurarlo. http://php.netbeans.org/
Xdebug y el complemento DBGp para Notepad ++ para la búsqueda de errores pesados, FirePHP para cosas livianas. ¿Rápido y sucio? Nada es mejor que dBug .
PhpEdit tiene un depurador incorporado, pero generalmente termino usando echo (); y print_r (); la manera antigua!
Bueno, hasta cierto punto, depende de dónde van 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 puede pasar cierto como segundo argumento a print_r () y devolverá el resultado en lugar de imprimirlo? P.ej:
echo "<pre>".print_r($var, true)."</pre>";
Por lo general, creo que crea una función de registro personalizada capaz de guardar en archivos, almacenar información de depuración y eventualmente 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 semiautomatizado.
El buffer de salida es muy útil si no quieres estropear tu salida. Lo hago de una sola línea y puedo comentar / descomentar a voluntad
ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();
PhpEd es realmente bueno. Puede entrar / salir / salir de funciones. Puede ejecutar código ad-hoc, inspeccionar variables, cambiar variables. Es asombroso.
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;
}
}
}
La mayor parte de los errores se pueden encontrar fácilmente simplemente var_dumping algunas de las variables clave, pero, obviamente, depende de qué tipo de aplicación a desarrollar.
Por unos algoritmos más complejos los / punto de interrupción funciones escalonadas / relojes son muy útiles (si no es necesario)
A menudo uso CakePHP cuando los disipadores no es posible. Para depurar los errores por lo general encuentran el error.logen la carpeta tmp y la cola en el terminal con el comando ...
tail -f app/tmp/logs/error.log
Se dan de que en ejecución de diálogo de la torta de lo que está pasando, que es bastante práctico, si desea dar salida a algo que a mediados código que puede utilizar.
$this->log('xxxx');
Esto por lo general le puede dar una buena idea de lo que está pasando / incorrecto.
Yo uso Netbeans con XDebug y el fácil XDebug de Firefox
El add-on es esencial cuando se depura proyectos MVC, debido a la forma normal XDebug ejecuta en Netbeans es registrar la sesión DBUG través de la URL. Con el complemento instalado en Firefox, debería definir las propiedades del proyecto de Netbeans -> Ejecutar Configuratuion -> Avanzado y seleccione "No se abra un explorador Web" Ahora puede establecer sus puntos de ruptura y empezar la sesión de depuración con Ctrl-F5 como de costumbre . Abre Firefox y haga clic en el icono de complemento en la esquina inferior derecha para iniciar la supervisión de los puntos de interrupción. Cuando el código alcanza el punto de interrupción se detendrá y se puede inspeccionar sus estados variables y la pila de llamadas.
NuSphere es también un buen depurador de php NuSphere
Hay muchas técnicas de depuración de PHP que le pueden ahorrar incontables horas al codificar. Una técnica efectiva pero básico depuración es simplemente activar el informe de error. Otra técnica un poco más avanzada implica el uso de declaraciones de impresión, que pueden ayudar a identificar los errores más difíciles de alcanzar por mostrar lo que realmente está sucediendo en la pantalla. PHPEclipse es un plug-in que Eclipse puede resaltar errores de sintaxis común y puede ser utilizado en conjunción con un depurador para establecer puntos de interrupción.
display_errors = Off
error_reporting = E_ALL
display_errors = On
y también se utiliza
error_log();
console_log();
El interactivo StepThrough depurador de PHP implementa como un módulo SAPI, la cual puede dar le dan un control completo sobre el medio ambiente sin afectar la funcionalidad o el rendimiento de su código. Su objetivo es ser un fácil ligera, potente, utilizar la plataforma de depuración de PHP 5.4+ y de su envío fuera de la caja con PHP 5.6.
Las características incluyen:
Ver las capturas de pantalla:
Página de inicio: http://phpdbg.com/
Esto es muy fácil de utilizar la biblioteca (en realidad un archivo) para depurar sus scripts PHP.
Lo único que tiene que hacer es incluir un archivo de la siguiente manera (en el comienzo de su código):
require('php_error.php');
\php_error\reportErrors();
A continuación, todos los errores que darán información como el trazado inverso, el contexto de código, los argumentos de funciones, variables de servidor, etc. Por ejemplo:
Las características incluyen:
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
Si el sistema es compatible Dtrace seguimiento dinámico (instalado por defecto en OS X) y su PHP está compilado con las sondas DTrace habilitados ( --enable-dtrace) que debe ser por defecto, este comando se puede ayudar a la depuración de 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, dada la siguiente alias se ha añadido en sus rc archivos (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í está la escritura dtrace más avanzada, simplemente guardarlo en dtruss-php.d, hacerlo ejecutable ( chmod +x dtruss-php.d) y ejecutar:
#!/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-lámpara en GitHub
Aquí está un uso sencillo:
sudo dtruss-php.d.php -r "phpinfo();".Para probar esto, puede ir a cualquier docroot con index.phpy ejecutar el servidor PHP incorporado por:
php -S localhost:8080
Después de que se puede acceder al sitio en http: // localhost: 8080 / (o elegir cualquier puerto es conveniente para usted). A partir de ahí acceder a algunas páginas para ver la salida de rastreo.
Nota: Dtrace está disponible en OS X de forma predeterminada, en Linux es probable que tenga dtrace4linux o detectar algunas otras alternativas .
Véase: Uso de PHP y DTrace en php.net
Alternativamente comprobar para el rastreo de SystemTap mediante la instalación de paquete de desarrollo SystemTap SDT (por ejemplo yum install systemtap-sdt-devel).
Aquí es ejemplo de script ( all_probes.stp) para el rastreo de todos los puntos de la sonda estática núcleo de PHP durante toda la duración de una secuencia de comandos PHP se ejecuta 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 sondas DTrace PHP estáticas en php.net