Como você depurar scripts PHP?

votos
405

Como você depurar PHP roteiros?

Estou ciente de depuração básica, como usando o Relatório de Erros. A depuração ponto de interrupção no PHPEclipse também é bastante útil.

Qual é o melhor (em termos de fácil e rápido) forma de depurar em phpStorm ou qualquer outro IDE?

Publicado 04/08/2008 em 00:18
fonte usuário
Em outras línguas...                            


30 respostas

votos
145

Tente Eclipse PDT para configurar um ambiente Eclipse que tem recursos de depuração como você mencionou. A capacidade de entrar no código é uma maneira muito melhor para depurar em seguida, o velho método de var_dump e imprimir em vários pontos para ver onde seu fluxo der errado. Quando tudo mais falhar embora e tudo o que tenho é SSH e vim eu ainda var_dump()/ die()para encontrar onde o código vai para o sul.

Respondeu 04/08/2008 em 00:28
fonte usuário

votos
80

Você pode usar FirePHP um add-on para o Firebug para php depuração no mesmo ambiente que javascript.

Eu também uso Xdebug mencionado anteriormente para perfilar php.

Respondeu 05/08/2008 em 18:22
fonte usuário

votos
38

Este é o meu pequeno ambiente de depuração:

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;
        }
    }
}
Respondeu 29/06/2009 em 14:40
fonte usuário

votos
32

Xdebug eo plugin DBGp para Notepad ++ para a caça dever bug pesado, FirePHP para o material leve. Rapido e sujo? Nada bate DBUG .

Respondeu 15/09/2008 em 21:23
fonte usuário

votos
26

XDebug é essencial para o desenvolvimento. Eu instalá-lo antes de qualquer outra extensão. Dá-lhe empilhar traços em qualquer erro e você pode ativar perfis facilmente.

Para um rápido olhar para um uso estrutura de dados var_dump(). Não use print_r()porque você vai ter que cercá-la com <pre>e só imprime um var de cada vez.

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

Para um ambiente de depuração real, o melhor que eu encontrei é Komodo IDE mas custa $$.

Respondeu 22/08/2008 em 16:43
fonte usuário

votos
19

PHPEd é realmente bom. Você pode entrar em / sobre / out de funções. Você pode executar código ad-hoc, inspecionar variáveis, variáveis ​​de mudança. É maravilhoso.

Respondeu 05/02/2009 em 10:16
fonte usuário

votos
17

1) eu uso print_r (). Em TextMate, eu tenho um trecho de 'pré' que se expande para o seguinte:

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

2) Eu uso Xdebug, mas não foram capazes de obter a GUI para trabalhar bem no meu Mac. É, pelo menos, imprime uma versão legível do rastreamento de pilha.

Respondeu 07/08/2008 em 01:25
fonte usuário

votos
16

Em toda a honestidade, uma combinação de impressão e print_r () para imprimir as variáveis. Sei que muitos preferem usar outros métodos mais avançados, mas eu encontrar este o mais fácil de usar.

Eu vou dizer que eu não apreciar plenamente este até que eu fiz alguma programação do microprocessador na Uni e não foi capaz de usar mesmo essa.

Respondeu 04/08/2008 em 22:28
fonte usuário

votos
16

Eu usei o Zend Studio (5,5) , juntamente com a Plataforma Zend . Isso dá a depuração adequada, pontos de interrupção / pisando sobre o código etc., embora a um preço.

Respondeu 04/08/2008 em 00:20
fonte usuário

votos
14

Xdebug , por Derick Rethans, é muito bom. Usei-o há algum tempo e descobriu que não era tão fácil de instalar. Assim que estiver pronto, você não vai entender como você conseguiu sem ele :-)

Há um bom artigo sobre Zend Developer Zone (instalando no Linux não parece mais fácil) e até mesmo um plugin do Firefox , que eu nunca utilizado.

Respondeu 04/08/2008 em 22:07
fonte usuário

votos
11

Eu uso Netbeans com XDebug eo Fácil XDebug Firefox Add-on

O add-on é essencial quando você depurar projetos MVC, porque a forma normal XDebug é executado no Netbeans é registrar a sessão DBUG através da url. Com o add-on instalado no Firefox, você deve definir suas propriedades projeto NetBeans -> Executar configuratuion -> Avançado e selecione "Não abrir o navegador Web" Agora você pode definir seus pontos de quebra e começar a sessão de depuração com Ctrl-F5 como de costume . Abra o Firefox e clique com o Add-on ícone no canto inferior direito para iniciar o monitoramento de pontos de interrupção. Quando o código atinge o ponto de interrupção ele vai parar e você pode inspecionar seus estados variáveis ​​e chamar-stack.

Respondeu 09/07/2010 em 04:14
fonte usuário

votos
11

Eu uso Netbeans com XDebug. Confira em seu site para docs sobre como configurá-lo. http://php.netbeans.org/

Respondeu 26/08/2008 em 16:04
fonte usuário

votos
10

buffer de saída é muito útil se você não quer estragar a sua saída. Eu faço isso em uma frase que eu posso comentar / descomentar à vontade

 ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();
Respondeu 22/10/2008 em 10:16
fonte usuário

votos
9

PHPEdit foi construído em um depurador, mas geralmente acabam usando eco (); e print_r (); à moda antiga !!

Respondeu 17/09/2008 em 11:14
fonte usuário

votos
8

Para os problemas realmente corajoso isso seria muito demorado para usar print_r / echo para descobrir o que eu uso depuração recurso de meu IDE (PHPEd). Ao contrário de outros IDEs que eu usei, PHPEd requer praticamente nenhuma configuração. a única razão que eu não usá-lo para todos os problemas que eu encontro é que é dolorosamente lento. Eu não tenho certeza de que a lentidão é específico para PHPEd ou qualquer depurador php. PHPEd não é livre, mas eu acredito que ele usa um dos depuradores de código aberto (como XDebug mencionados anteriormente) de qualquer maneira. O benefício com PHPEd, mais uma vez, é que ele não exige nenhuma configuração que eu encontrei realmente muito tedioso no passado.

Respondeu 22/08/2008 em 16:33
fonte usuário

votos
4

Depuração manual é geralmente mais rápido para mim - var_dump()e debug_print_backtrace()são todas as ferramentas que você precisa para armar a sua lógica com.

Respondeu 22/08/2008 em 16:36
fonte usuário

votos
3

Costumo usar CakePHP quando Rails não é possível. Para depurar erros Eu costumo encontrar o error.logna pasta tmp e cauda-lo no terminal com o comando ...

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

É dar de você de diálogo em execução a partir da torta do que está acontecendo, o que é muito útil, se você quiser imprimir algo a ele meados código que você pode usar.

$this->log('xxxx');

Isso geralmente pode lhe dar uma boa idéia do que está acontecendo / errado.

Respondeu 10/05/2010 em 10:29
fonte usuário

votos
3

Bem, até certo ponto, isso depende de onde as coisas estão indo para o sul. Essa é a primeira coisa que eu tentar isolar, e então eu vou usar echo / print_r (), se necessário.

NB: Vocês sabem que você pode passar verdadeira como um segundo argumento para print_r () e ele vai retornar a saída em vez de imprimi-lo? Por exemplo:

echo "<pre>".print_r($var, true)."</pre>";
Respondeu 18/09/2008 em 04:17
fonte usuário

votos
2

Há muitas técnicas PHP depuração que você pode economizar incontáveis ​​horas quando codificação. Uma técnica de depuração eficaz, mas básico é simplesmente ativar relatórios de erro. Outra técnica um pouco mais avançada envolve o uso de instruções de impressão, o que pode ajudar a identificar erros mais evasivo, exibindo o que realmente está acontecendo na tela. PHPEclipse é um plug-in que Eclipse pode destacar erros de sintaxe comuns e pode ser usado em conjunto com um depurador para definir pontos de interrupção.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

e também usadas

error_log();
console_log();
Respondeu 01/10/2015 em 11:16
fonte usuário

votos
2

Nusphere também é um bom depurador para php nusphere

Respondeu 29/05/2012 em 13:43
fonte usuário

votos
2

Komodo IDE funciona bem com xdebug, mesmo para a depuração remore. Ele precisa de uma quantidade mínima de configuração. Tudo que você precisa é uma versão do php que Komodo pode usar localmente para percorrer o código em um ponto de interrupção. Se você tiver o script importado para projeto de komodo, então você pode definir pontos de interrupção com um clique do mouse apenas como você configurá-lo dentro do Eclipse para depurar um programa java. Depuração remota é obviamente mais complicado para fazê-lo funcionar corretamente (você pode ter que mapear a url remoto com um script php no seu espaço de trabalho) do que uma configuração de depuração local, que é muito fácil de configurar se você estiver em um Mac ou um desktop linux .

Respondeu 22/08/2008 em 16:44
fonte usuário

votos
2

print_r (debug_backtrace ());

ou algo assim :-)

Respondeu 04/08/2008 em 00:32
fonte usuário

votos
1

PHP DBG

Interactive Stepthrough PHP Debugger implementado como um módulo SAPI que pode dar dar-lhe o controle completo sobre o meio ambiente, sem afetar a funcionalidade ou desempenho do seu código. Destina-se a ser um leve e poderoso, fácil de usar plataforma de depuração de PHP 5.4+ e é enviado para fora-de-caixa com PHP 5.6.

As características incluem:

  • Stepthrough depuração
  • Pontos de interrupção flexíveis (método da classe, função, arquivo: Line, Endereço, Opcode)
  • Fácil acesso a PHP com built-in eval ()
  • Fácil acesso a Atualmente execução de código
  • userland API
  • SAPI Agnostic - facilmente integrado
  • Configuração PHP Suporte Arquivo
  • JIT Super Globals - Definir sua própria !!
  • Suporte readline opcional - Operação Terminal Confortável
  • Apoio Remote Debugging - Pacote de GUI Java
  • Operação fácil

Veja as imagens:

PHP DBG - Stepthrough depuração - Screenshot

PHP DBG - Stepthrough depuração - Screenshot

Home page: http://phpdbg.com/

PHP Erro - Melhor relatório de erros para PHP

Isto é muito fácil de usar biblioteca (na verdade um arquivo) para depurar seus scripts PHP.

A única coisa que você precisa fazer é incluir um arquivo como abaixo (no início do seu código):

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

Em seguida, todos os erros vai lhe dar informações como backtrace, contexto de código, argumentos de função, variáveis ​​de servidor, etc. Por exemplo:

PHP Erro |  Melhorar o Relatório de erros de PHP - screenshot do registo de chamadas PHP Erro |  Melhorar o Relatório de erros de PHP - screenshot do registo de chamadas PHP Erro |  Melhorar o Relatório de erros de PHP - screenshot do registo de chamadas

Características incluem:

  • trivial de usar, ele é apenas um arquivo
  • erros exibidos no navegador para pedidos normais e ajax
  • solicitações de AJAX estão em pausa, permitindo-lhe automaticamente re-executá-los
  • comete erros tão rigorosas quanto possível (incentiva a qualidade do código, e tende a melhorar o desempenho)
  • trechos de código em toda a rastreamento de pilha
  • fornece mais informação (tais como assinaturas de função completas)
  • corrige algumas mensagens de erro que são simplesmente errado
  • realce de sintaxe
  • parece bonito!
  • costumização
  • desligá-lo manualmente e desligar
  • executar seções específicas sem relatório de erros
  • ignorar arquivos que lhe permite evitar destacando código em seu rastreamento de pilha
  • arquivos do aplicativo; estes são priorizados quando um greves de erro!

Home page: http://phperror.net/

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

Meu garfo (com correções extras): https://github.com/kenorb-contrib/PHP-Error

DTrace

Se o seu sistema suporta DTrace de rastreio dinâmico (instalado por padrão no OS X) e seu PHP é compilado com os testes do DTrace habilitados ( --enable-dtrace) que deveria ser por padrão, este comando pode ajudá-lo a script PHP depuração sem tempo:

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

Assim, dado o seguinte alias foi adicionado em seus rc arquivos (por exemplo ~/.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); }"'

você pode traçar seu roteiro com fácil de lembrar apelido: trace-php.

Aqui é script do DTrace mais avançado, apenas salvá-lo em dtruss-php.d, torná-lo executável ( chmod +x dtruss-php.d) e execute:

#!/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));
}

Home page: dtruss-lâmpada no GitHub

Aqui é o uso simples:

  1. Execute: sudo dtruss-php.d.
  2. Em outra corrida terminal: php -r "phpinfo();".

Para testar isso, você pode ir a qualquer docroot com index.phpe executar o servidor embutido PHP por:

php -S localhost:8080

Depois disso, você pode acessar o site em http: // localhost: 8080 / (ou escolher qualquer porta é conveniente para você). De lá acessar algumas páginas para ver a saída de rastreamento.

Nota: Dtrace está disponível no OS X por padrão, no Linux você provavelmente precisará dtrace4linux ou verificar se há algumas outras alternativas .

Veja: Utilizando PHP e DTrace em php.net


SystemTap

Alternativamente verificar se há rastreamento SystemTap instalando pacote de desenvolvimento SystemTap SDT (por exemplo yum install systemtap-sdt-devel).

Aqui está um exemplo de roteiro ( all_probes.stp) para rastrear todos os pontos de sonda estática núcleo do PHP durante toda a duração de um script PHP rodando com 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

Veja: Usando SystemTap com PHP DTrace estáticos Sondas em php.net

Respondeu 21/03/2016 em 12:34
fonte usuário

votos
1

A maioria dos erros podem ser facilmente encontrados por simplesmente var_dumping algumas das variáveis-chave, mas, obviamente, depende de que tipo de aplicação que você desenvolve.

Por algoritmos mais complexos os breakpoint / funções STEP / relógio são muito útil (se não for necessário)

Respondeu 10/05/2010 em 10:18
fonte usuário

votos
1

eu uso estúdio Zend para eclipse com construído no depurador. Sua ainda lento em comparação com a depuração com pdt eclipse com xdebug. Esperemos que eles vão corrigir esses problemas, a velocidade melhorou ao longo dos últimos lançamentos, mas ainda passando por cima de coisas leva 2-3 segundos. A barra de ferramentas firefox zend realmente torna as coisas fáceis (debug página seguinte, página atual, etc). Também fornece um perfil que vai comparar o seu código e fornecem pie-charts, o tempo de execução, etc.

Respondeu 17/08/2008 em 19:38
fonte usuário

votos
1

Em um ambiente de produção, eu registrar os dados relevantes para o log de erro do servidor com error_log ().

Respondeu 15/08/2008 em 05:23
fonte usuário

votos
1

1 para print_r (). Use-o para despejar o conteúdo de um objeto ou variável. Para torná-lo mais legível, fazê-lo com uma tag de pré para que você não precisa ver fonte.

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

Também var_dump ($ coisa) - isto é muito útil para ver o tipo de subthings

Respondeu 05/08/2008 em 01:49
fonte usuário

votos
0

Normalmente eu encontrar criar uma função de log personalizado capaz de salvar em arquivo, informação da loja de depuração, e, eventualmente, voltar a imprimir em um rodapé comum.

Você também pode substituir classe de exceção comum, para que este tipo de depuração é semi-automatizado.

Respondeu 22/10/2008 em 09:46
fonte usuário

votos
0

Os depuradores integradas onde você pode assistir os valores de mudança variável como você percorrer o código é muito legal. Eles, no entanto, precisar de configuração de software no servidor e uma certa quantidade de configuração no cliente. Ambos os quais requerem manutenção periódica para manter em bom estado de funcionamento.

A print_r é fácil de escrever e é garantido que funcione em qualquer configuração.

Respondeu 22/08/2008 em 21:10
fonte usuário

votos
0

Dependendo do assunto que eu gosto de uma combinação de error_reporting (E_ALL) misturado com testes de eco (para encontrar a linha ofensiva / arquivar o erro aconteceu no initally, você sabe que não é sempre o php line / arquivo informa certo?), Correspondente IDE cinta (para resolver "Parse erro: erro de sintaxe, inesperado $ fim" questões), e print_r (); Saída; dumps (programadores reais ver a fonte; p).

Você também não pode bater phpdebug (verifique sourceforge) com "memory_get_usage ();" e "memory_get_peak_usage ();" para encontrar as áreas problemáticas.

Respondeu 06/08/2008 em 16:46
fonte usuário

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