Come fare il debug di script PHP?[chiuso]

Question

Come fare il debug PHP script?

Sono consapevole di debug di base come l'utilizzo di Segnalazione errori.Il punto di interruzione in debug PHPEclipse è anche molto utile.

Qual è il migliore (in termini di facile e veloce) modo per eseguire il debug in phpStorm o qualsiasi altro IDE?

Answer 1

Provare Eclipse PDT per l'installazione di un ambiente Eclipse che ha funzionalità di debug come hai accennato.La capacità di eseguire il codice è un modo molto migliore per eseguire il debug quindi il vecchio metodo di var_dump e di stampa in vari punti per vedere dove il vostro flusso va storto.Quando tutto il resto fallisce, e se tutto quello che ho è l'SSH e vim ho ancora var_dump()/die() per trovare il codice va a sud.

Answer 2

È possibile utilizzare Firephp un add-on per firebug per eseguire il debug di php nello stesso ambiente javascript.

Io uso anche Xdebug accennato in precedenza, per la profilatura di php.

Answer 3

Questo è il mio piccolo ambiente di debug:

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

Answer 4

Xdebug e il DBGp plugin per Notepad++ per applicazioni pesanti di caccia di bug, FirePHP per roba leggera.Rapido e sporco?Niente batte dBug.

Answer 5

XDebug è essenziale per lo sviluppo.Ho installarlo prima di qualsiasi altra estensione.Ti dà le tracce dello stack su qualsiasi errore e non è possibile attivare la profilatura facilmente.

Per un rapido sguardo a una struttura di dati da utilizzare var_dump().Non utilizzare print_r() perché avrete a che la circondano con <pre> e non solo stampe un var a un tempo.

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

Per un vero e proprio ambiente di debug il migliore che ho trovato è Komodo IDE ma il costo è di $$.

Answer 6

PhpEd è veramente buono.Si può fare un passo in/oltre/di funzioni.È possibile eseguire ad-hoc codice, ispezionare le variabili, cambiamento di variabili.È sorprendente.

Answer 7

1) io uso print_r().In TextMate, ho un frammento di 'pre' che si espande a questo:

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

2) io uso Xdebug, ma non sono stati in grado di ottenere la GUI di lavorare sul mio Mac.Almeno stampe una versione leggibile della traccia dello stack.

Answer 8

Ho usato il Zend Studio (5.5), insieme con Zend Platform.Che dà il debug corretta, i punti di interruzione/scavalcando il codice ecc.... anche se a un prezzo.

Answer 9

In tutta onestà, una combinazione di stampa e print_r() per stampare le variabili.So che molti preferiscono usare altri metodi più avanzati, ma trovo che questo sia il più facile da usare.

Devo dire che non ho pienamente apprezzare questo fino a quando ho fatto un po ' a Microprocessore, programmazione all'Uni e non è stato possibile utilizzare anche questo.

Answer 10

Xdebug, da Derick Rethans, è molto buona.Io l'ho usato qualche tempo fa e l'ho trovato non era così facile da installare.Una volta fatto, non capisco come hai fatto senza di essa :-)

C'è un bell'articolo su Zend Developer Zone (installazione su Linux non sembra più facile) e anche un Plugin per Firefox, che non ho mai utilizzato.

Answer 11

Io uso Netbeans con XDebug.Check it out al suo sito web per la documentazione su come configurarlo.http://php.netbeans.org/

Answer 12

Io uso Netbeans con XDebug e il Facile XDebug Add-on di FireFox

L'add-on è essenziale quando si esegue il debug di progetti di MVC, perché il modo normale di XDebug corre in Netbeans è quello di registrare il dbug sessione tramite l'url.Con l'add-on installati in FireFox, è necessario impostare il vostro progetto Netbeans proprietà -> Esegui Configuratuion -> Avanzate " e selezionare "Non Aprire il Browser Web" È ora possibile impostare i punti di interruzione e di iniziare la sessione di debug con Ctrl-F5, come al solito.Aprire FireFox e fare clic destro l'Add-on icona nell'angolo in basso a destra per avviare il monitoraggio per i punti di interruzione.Quando il codice si raggiunge il punto di interruzione si fermerà e si può controllare il vostro variabile di membri e di stack di chiamate.

Answer 13

Il buffer di uscita è molto utile se non si vuole rovinare il vostro output.Faccio questo in un one-liner, che posso commentare il commento a volontà

 ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();

Answer 14

PhpEdit è dotato di un debugger, ma io di solito finiscono per l'uso di echo();e print_r();alla vecchia maniera!!

Answer 15

Per davvero grintoso problemi che sarebbero troppo lunghe da usare print_r/echo capire io uso il mio IDE (PhpEd) funzionalità di debug.A differenza di altri Ide che ho usato, PhpEd richiede praticamente nessuna impostazione.l'unica ragione per cui io non lo uso per qualsiasi problema che incontro è che è dolorosamente lento.Io non sono sicuro che la lentezza è specifico per PhpEd o qualsiasi php debugger.PhpEd non è libera, ma credo che si usi open-source debugger (come XDebug in precedenza) comunque.Il vantaggio con PhpEd, di nuovo, è che non richiede installazione, che ho trovato abbastanza noioso in passato.

Answer 16

Manuale di debug è generalmente più veloce di me - var_dump() e debug_print_backtrace() sono tutti gli strumenti necessari per armare la logica con.

Answer 17

Bene, in una certa misura dipende da dove le cose stanno andando a sud.Questa è la prima cosa cerco di isolare, e allora io uso eco/print_r() come necessario.

NB:Voi sapete che è possibile passare vero come secondo argomento print_r() e restituire l'output invece di stamparlo?E. g.:

echo "<pre>".print_r($var, true)."</pre>";

Answer 18

Io uso spesso CakePHP quando Rails non è possibile.Per eseguire il debug di errori di solito trovo la error.log nella cartella tmp e la coda da terminale con il comando...

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

Non dare in esecuzione di dialogo torta di quello che sta succedendo, che è molto utile, se si desidera mostrare qualcosa a metà di codice che è possibile utilizzare.

$this->log('xxxx');

Questo di solito può dare una buona idea di quello che sta succedendo/sbagliato.

Answer 19

print_r( debug_backtrace() );

o qualcosa di simile :-)

Answer 20

Komodo IDE funziona bene con xdebug, anche per le remore di debug.Ha bisogno di importo minimo di configurazione.Tutto ciò che serve è una versione di php che di Komodo possibile utilizzare localmente per il passaggio attraverso il codice in un punto di interruzione.Se hai lo script importati in komodo progetto, quindi è possibile impostare i punti di interruzione con un clic del mouse solo come impostare all'interno di eclipse per il debug di un programma java.Il debug remoto è ovviamente più difficile per farlo funzionare correttamente, si potrebbe avere la mappa l'url remoto con uno script php nella vostra area di lavoro ) di un locale in debug del programma di installazione che è abbastanza facile da configurare, se siete su un MAC o un linux desktop.

Answer 21

Nusphere è anche un buon debugger per php nusphere

Answer 22

Ci sono molte tecniche di debug PHP che si può risparmiare innumerevoli ore di codifica.Un efficace, ma di base tecnica di debug, è sufficiente attivare la segnalazione di errori.Un altro leggermente più avanzata tecnica comporta l'uso di istruzioni di stampa, che consente di individuare più sfuggente bug mediante la visualizzazione di ciò che è in realtà andando sullo schermo.PHPeclipse è un plug-in di Eclipse che può evidenziare comuni di errori di sintassi e può essere utilizzato in combinazione con un debugger per impostare i punti di interruzione.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

e anche usato

error_log();
console_log();

Answer 23

In un ambiente di produzione, I log dei dati rilevanti per il log degli errori del server con error_log().

Answer 24

io uso zend studio for eclipse con il costruito nel debugger.La sua ancora lento rispetto per il debug con eclipse pdt con xdebug.Speriamo che risolvere i problemi, la velocità è migliorata negli ultimi rilasci, ma ancora scavalcare le cose ci vogliono 2-3 secondi.Zend barra degli strumenti di firefox davvero rende le cose facili (debug pagina successiva pagina corrente, ecc).Inoltre, esso fornisce un profiler che benchmark di codice e di fornire grafici a torta, tempo di esecuzione, etc.

Answer 25

La maggior parte dei bug può essere trovato con facilità semplicemente var_dumping alcune variabili chiave, ma ovviamente dipende dal tipo di applicazione che si sviluppano.

Per una algoritmi più complessi, il passo/punto di interruzione/funzioni dell'orologio sono molto utile (se non necessario)

Answer 26

PHP DBG

Interactive Stepthrough PHP Debugger implementato come un SAPI il modulo, che può dare dare il controllo completo dell'ambiente senza compromettere la funzionalità o le prestazioni del vostro codice.Essa mira ad essere un peso leggero, potente, facile da usare piattaforma di debug di PHP 5.4+ e spedito out-of-box con PHP 5.6.

Caratteristiche include:

• Stepthrough Di Debug
• Flessibile Di Rottura (Metodo Di Una Classe, Di Funzione, Di File:Linea, L'Indirizzo, Il Codice Operativo)
• Facile Accesso a PHP con built-in funzione eval()
• Facile Accesso al corso di Esecuzione del Codice
• Userland API
• SAPI Agnostici Facilmente Integrato
• File di Configurazione di PHP Supporto
• JIT Super Globals - Impostare il Tuo!!
• Opzionale readline Supporto Confortevole Funzionamento del Terminale
• Il Debug remoto di Supporto - in Bundle Java GUI
• Il Funzionamento Facile

Vedi screenshot:

Home page: http://phpdbg.com/

Errore di PHP - Meglio di segnalazione di errore di PHP

Questo è molto facile da usare libreria (in realtà un file) per eseguire il debug di script PHP.

L'unica cosa che devi fare è quello di includere un file come di seguito (all'inizio del tuo codice):

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

Quindi tutti gli errori dare informazioni come il backtrace, il codice di contesto, gli argomenti della funzione, le variabili del server, etc.Per esempio:

Le caratteristiche includono:

• semplice da usare, è solo un file
• errori visualizzati nel browser per la normale e ajaxy richieste
• Le richieste AJAX sono in pausa, permettendo automaticamente ri-correre
• fa errori come stretto possibile (favorisce la qualità del codice, e tende a migliorare le prestazioni)
• frammenti di codice per tutta la traccia dello stack
• fornisce ulteriori informazioni (ad esempio di funzione completa di firme)
• corregge alcuni messaggi di errore che sono semplicemente sbagliato
• l'evidenziazione della sintassi
• sembra piuttosto!
• personalizzazione
• manualmente accendere e spegnere
• eseguire specifiche sezioni senza segnalazione di errore
• ignorare i file che consente di evitare l'evidenziazione del codice in stack trace
• i file di applicazione;queste sono le priorità, quando un errore colpisce!

Home page: http://phperror.net/

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

La mia forcella (con possibilità di correzioni): https://github.com/kenorb-contrib/PHP-Error

DTrace

Se il vostro sistema supporta DTrace di analisi dinamica (installato di default su OS X) e il PHP è compilato con l'DTrace sonde abilitato (--enable-dtrace che dovrebbe essere per impostazione predefinita, questo comando può aiutare a eseguire il debug di script PHP con il 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); }'

Così, dato il seguente alias è stato aggiunto nel vostro rc file (ad es. ~/.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); }"'

è possibile tracciare il tuo script con facile da ricordare alias: trace-php.

Qui è più avanzato dtrace script, basta salvare in dtruss-php.d, renderlo eseguibile (chmod +x dtruss-php.d) ed eseguire:

#!/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-lampada su GitHub}

Qui è semplice utilizzo:

1. Eseguire: sudo dtruss-php.d.
2. Su un altro terminale, eseguire: php -r "phpinfo();".

Per fare una prova, si può andare a qualsiasi docroot con index.php e di eseguire codice PHP builtin server:

php -S localhost:8080

Dopo di che si può accedere al sito http://localhost:8080/ (o scegliere qualsiasi porta è conveniente per voi).Da lì accedere ad alcune pagine per vedere l'output della traccia.

Nota:Dtrace è disponibile su OS X per impostazione predefinita, su Linux, probabilmente avete bisogno di dtrace4linux o per qualche altro alternative.

Vedere: Utilizzando PHP e DTrace a php.net

---

SystemTap

In alternativa, controllare per SystemTap l'analisi di installare SystemTap SDT pacchetto di sviluppo (ad es. yum install systemtap-sdt-devel).

Qui è un esempio di script (all_probes.stp) per la tracciabilità di tutte core PHP sonda statici punti per tutta la durata di esecuzione di 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));
}

Utilizzo:

stap -c 'sapi/cli/php test.php' all_probes.stp

Vedere: Utilizzando SystemTap con PHP DTrace Statico Sonde a php.net

Answer 27

+1 per print_r().Si usa per dump il contenuto di un oggetto o di una variabile.Per renderlo più leggibile, farlo con un tag pre, quindi non hai bisogno di vedere il codice sorgente.

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

Anche var_dump($cosa) - questo è molto utile per vedere il tipo di subthings

Answer 28

A seconda del problema che come una combinazione di error_reporting(E_ALL) mescolato con echo test (per trovare la riga incriminata/file l'errore è accaduto in inizialmente;SAI che non sempre la linea/file php si dice giusto?), IDE corrispondenza tra parentesi graffe (per risolvere "errore di Analisi:errore di sintassi, unexpected $end" problemi), e print_r();uscita;discariche (i veri programmatori vista la fonte ;p).

Si può anche battere phpdebug (controllare su sourceforge) con "memory_get_usage();" e "memory_get_peak_usage();" per trovare le aree di problema.

Answer 29

Il debugger integrato, dove è possibile guardare i valori della variabile cambia come passaggio attraverso il codice sono davvero cool.Essi, tuttavia, richiedono che il software di installazione sul server e una certa quantità di configurazione del client.Entrambi richiedono una manutenzione periodica per mantenere in buono stato di funzionamento.

Un print_r è facile da scrivere e non è garantito per funzionare in qualsiasi installazione.

Answer 30

Di solito trovo creare un registro personalizzato funzione in grado di salvare su file, archivio di informazioni di debug, e, infine, ri-stampa su un piè di pagina.

È anche possibile eseguire l'override di Eccezione comuni di classe, in modo che questo tipo di debug è semi-automatizzato.