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

08-06-2019
|

Pregunta

¿Cómo se depura? PHP ¿guiones?

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

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

Solución

Intentar Eclipse PDT para configurar un entorno Eclipse que tenga funciones de depuración como las que mencionaste.La capacidad de ingresar al código es una manera mucho mejor de depurar que el método anterior 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.

Otros consejos

Puede utilizar Firephp, un complemento de Firebug, para depurar PHP en el mismo entorno que JavaScript.

yo también uso xdebug mencionado anteriormente para crear perfiles de 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 búsqueda de errores pesados, FirePHP para cosas livianas.¿Rápido y sucio?Nada supera dBug.

XDepurar es esencial para el desarrollo.La instalo antes que cualquier otra extensión.Le brinda seguimiento de la pila sobre cualquier error y puede habilitar la creación de perfiles fácilmente.

Para un vistazo rápido al uso de una estructura de datos var_dump().no usar print_r() porque tendrás que rodearlo de <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 IDE de Komodo pero cuesta $$.

PhpEd es realmente bueno.Puede entrar/salir/entrar 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) Utilizo 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 el Estudio Zend (5.5), Juntos con Plataforma Zend.Eso proporciona una depuración adecuada, puntos de interrupción/paso por encima del código, etc., aunque tiene 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 este me parece el más fácil de usar.

Diré que no aprecié esto completamente hasta que hice algo de programación de microprocesadores en la Universidad y ni siquiera pude usar 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 Zona de desarrolladores Zend (la instalación en Linux no parece más fácil) e incluso un Complemento de Firefox, que nunca usé.

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

Utilizo Netbeans con XDebug y el Complemento Easy XDebug Firefox

El complemento es esencial cuando depuras proyectos MVC, porque la forma normal en que XDebug se ejecuta en Netbeans es registrar la sesión de dbug a través de la URL.Con el complemento instalado en Firefox, puede configurar las propiedades de su proyecto Netbeans -> Ejecutar configuración -> Avanzado y seleccionar "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 derecho en el ícono de complemento en la esquina inferior derecha para comenzar a monitorear los puntos de interrupción.Cuando el código alcance el punto de interrupción, se detendrá y podrá inspeccionar los estados de las 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 normalmente 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 resolverlos, uso la función de depuración de mi IDE (PhpEd).A diferencia de otros IDE que he usado, PhpEd prácticamente no requiere configuración.La única razón por la que no lo uso ante los problemas que encuentro es que es penosamente 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 de PhpEd, nuevamente, es que no requiere configuración, lo cual me ha resultado 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 necesitas para armar tu lógica.

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

NÓTESE BIEN:¿Saben que pueden pasar verdadero como segundo argumento para 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 suelo encontrar el error.log en la carpeta tmp y colóquelo en la terminal con el comando...

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

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

$this->log('xxxx');

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

print_r(debug_backtrace());

o algo así :-)

Komodo IDE funciona bien con xdebug, incluso para la depuración remota.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 al proyecto Komodo, puede establecer puntos de interrupción con un clic del mouse tal como lo configurarí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 tengas que asignar la URL remota con un script php en tu espacio de trabajo) que una configuración de depuración local que es bastante fácil de configurar si estás en un escritorio MAC o Linux. .

Nusphere también es un buen depurador para php.nusfera

Existen muchas técnicas de depuración de PHP que pueden ahorrarle innumerables horas de codificación.Una técnica de depuración eficaz pero básica es simplemente activar el informe de errores.Otra técnica un poco más avanzada implica el uso de declaraciones impresas, que pueden ayudar a identificar errores más difíciles al mostrar lo que realmente está sucediendo 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().

Utilizo 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 lleva entre 2 y 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_dumpalgunas 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/vigilancia son muy útiles (si no son necesarias)

PHP DBG

El depurador PHP interactivo paso a paso implementado como un módulo SAPI que puede brindarle un control total sobre el entorno sin afectar la funcionalidad o el rendimiento de su código.Su objetivo es ser una plataforma de depuración liviana, potente y fácil de usar para PHP 5.4+ y se envía lista para usar 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
Agnóstico de SAPI: fácilmente integrado
Soporte de archivos de configuración PHP
JIT Super Globals: ¡crea el tuyo propio!
Soporte readline opcional: operación cómoda del terminal
Soporte de depuración remota: GUI de Java incluida
Operación fácil

Vea 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 de su código):

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

Luego, todos los errores le brindarán información como seguimiento, contexto del código, argumentos de función, variables del 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
comete errores lo más estricto 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 incorrectos
resaltado de sintaxis
¡se ve hermosa!
personalización
encenderlo y apagarlo manualmente
ejecutar secciones específicas sin informes de errores
ignorar archivos, lo que le permite evitar resaltar el código en el seguimiento de su pila
archivos de solicitud;¡Estos tienen prioridad cuando ocurre un error!

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

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

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

DTrace

Si su sistema admite 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 ser el predeterminado, este comando puede ayudarle a depurar el script PHP en poco 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 que se ha agregado el siguiente alias a su RC archivos (por ej. ~/.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); }"'

puedes rastrear tu 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, hazlo ejecutable (chmod +x dtruss-php.d) y correr:

#!/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:

Correr: sudo dtruss-php.d.
En otra terminal ejecute: php -r "phpinfo();".

Para probar eso, puedes ir a cualquier docroot con index.php y ejecute el servidor PHP incorporado mediante:

php -S localhost:8080

Después de eso puedes acceder al sitio en http://localhost:8080/ (o elija 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 forma predeterminada, en Linux probablemente necesite dtrace4linux o comprobar si hay algún otro alternativas.

Ver: Usando PHP y DTrace en php.net

SistemaTap

Alternativamente, verifique el seguimiento de SystemTap instalando el paquete de desarrollo SystemTap SDT (p. ej. yum install systemtap-sdt-devel).

Aquí hay un script de ejemplo (all_probes.stp) para rastrear todos los puntos principales de sondeo estático de PHP durante la ejecución de un script PHP 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: Uso de SystemTap con sondas estáticas PHP DTrace en php.net

+1 para print_r().Úselo para vaciar 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 subcosas.

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

Tampoco puede superar phpdebug (verificar fuenteForge) con "memoria_get_usage ();" y "memoria_get_peak_usage ();" para encontrar las áreas problemáticas.

Los depuradores integrados donde puedes observar los valores de cambio de variables a medida que avanzas en el código son realmente geniales.Sin embargo, requieren la configuración del 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.

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

Por lo general, creo 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ática.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow