¿Cómo se depuran los scripts PHP?

votos
405

¿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?

Publicado el 04/08/2008 a las 00:18
fuente por usuario
En otros idiomas...                            


30 respuestas

votos
145

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.

Respondida el 04/08/2008 a las 00:28
fuente por usuario

votos
80

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.

Respondida el 05/08/2008 a las 18:22
fuente por usuario

votos
38

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;
        }
    }
}
Respondida el 29/06/2009 a las 14:40
fuente por usuario

votos
32

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 .

Respondida el 15/09/2008 a las 21:23
fuente por usuario

votos
26

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 $$.

Respondida el 22/08/2008 a las 16:43
fuente por usuario

votos
19

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

Respondida el 05/02/2009 a las 10:16
fuente por usuario

votos
17

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.

Respondida el 07/08/2008 a las 01:25
fuente por usuario

votos
16

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.

Respondida el 04/08/2008 a las 22:28
fuente por usuario

votos
16

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.

Respondida el 04/08/2008 a las 00:20
fuente por usuario

votos
14

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é.

Respondida el 04/08/2008 a las 22:07
fuente por usuario

votos
11

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.

Respondida el 09/07/2010 a las 04:14
fuente por usuario

votos
11

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

Respondida el 26/08/2008 a las 16:04
fuente por usuario

votos
10

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();
Respondida el 22/10/2008 a las 10:16
fuente por usuario

votos
9

PhpEdit tiene un depurador incorporado, pero generalmente termino usando echo (); y print_r (); la manera antigua!

Respondida el 17/09/2008 a las 11:14
fuente por usuario

votos
8

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.

Respondida el 22/08/2008 a las 16:33
fuente por usuario

votos
4

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.

Respondida el 22/08/2008 a las 16:36
fuente por usuario

votos
3

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.

Respondida el 10/05/2010 a las 10:29
fuente por usuario

votos
3

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>";
Respondida el 18/09/2008 a las 04:17
fuente por usuario

votos
2

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();
Respondida el 01/10/2015 a las 08:16
fuente por usuario

votos
2

NuSphere es también un buen depurador de php NuSphere

Respondida el 29/05/2012 a las 13:43
fuente por usuario

votos
2

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. .

Respondida el 22/08/2008 a las 16:44
fuente por usuario

votos
2

print_r (debug_backtrace ());

o algo así :-)

Respondida el 04/08/2008 a las 00:32
fuente por usuario

votos
1

PHP DBG

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:

  • StepThrough Depuración
  • Los puntos de interrupción flexibles (método de las clases, función, del archivo: Línea, dirección, código de operación)
  • Fácil acceso a PHP con una función de eval ()
  • Fácil acceso a la ejecución actual Código
  • API de espacio de usuario
  • SAPI agnóstica - Facilidad de integración
  • Soporte de archivos de configuración de PHP
  • JIT Súper Globals - establecer su propio !!
  • Soporte opcional readline - Funcionamiento cómodo Terminal
  • Soporte depuración remota - liado GUI de Java
  • Operación fácil

Ver las capturas de pantalla:

PHP DBG - StepThrough Depuración - pantalla

PHP DBG - StepThrough Depuración - pantalla

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

PHP Error - Mejor notificación de error para PHP

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:

Error PHP |  Mejorar el informe de errores de PHP - captura de pantalla de traza Error PHP |  Mejorar el informe de errores de PHP - captura de pantalla de traza Error PHP |  Mejorar el informe de errores de PHP - captura de pantalla de traza

Las características incluyen:

  • un uso trivial, es un solo archivo
  • errores que aparezcan en el navegador para peticiones normales y AJAXy
  • peticiones AJAX se detuvieron, lo que le permite automáticamente volver a ejecutar
  • comete errores lo más estricta 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 función completa)
  • corrige algunos mensajes de error que son simplemente mal
  • resaltado de sintaxis
  • ¡se ve hermosa!
  • personalización
  • activar manualmente la activación y desactivación
  • ejecutar secciones específicas sin el informe de errores
  • ignorar los archivos que le permite evitar destacando código en el seguimiento de la pila
  • archivos de la aplicación; éstos son priorizados cuando ocurra 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 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:

  1. Ejecute: sudo dtruss-php.d.
  2. En otro terminal ejecutar: 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


SystemTap

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

Respondida el 21/03/2016 a las 09:34
fuente por usuario

votos
1

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)

Respondida el 10/05/2010 a las 10:18
fuente por usuario

votos
1

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.

Respondida el 17/08/2008 a las 19:38
fuente por usuario

votos
1

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

Respondida el 15/08/2008 a las 05:23
fuente por usuario

votos
1

+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

Respondida el 05/08/2008 a las 01:49
fuente por usuario

votos
0

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.

Respondida el 22/10/2008 a las 09:46
fuente por usuario

votos
0

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.

Respondida el 22/08/2008 a las 21:10
fuente por usuario

votos
0

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

Respondida el 06/08/2008 a las 16:46
fuente por usuario

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more