Wie kann man Debuggen von PHP-Skripten?[geschlossen]

Question

Wie prüfst du PHP Skripte?

Ich bin mir bewusst, basic debugging wie die Verwendung der Fehler-Reporting.Der Haltepunkt debugging in PHPEclipse ist auch ganz nützlich.

Was ist das beste (in Bezug auf schnelle und einfache) Möglichkeit zum Debuggen in phpStorm oder jede andere IDE?

Answer 1

Versuchen Sie es Eclipse PDT einrichten einer Eclipse-Umgebung, in der debugging-Funktionen wie du Sie erwähnt hast.Die Fähigkeit, den Schritt in die code ist eine viel bessere Art und Weise zu Debuggen, dann die alte Methode der var_dump und Druck auf verschiedene Punkte zu sehen, wo Ihre flow schief geht.Wenn alles andere fehlschlägt, obwohl alle, die ich habe, SSH und vim habe ich noch var_dump()/die() um herauszufinden, wo der code geht nach Süden.

Answer 2

Sie können hier FirePHP ein add-on firebug Debuggen von php in der gleichen Umgebung wie javascript.

Ich benutze auch Xdebug bereits erwähnt, für die Profilerstellung php.

Answer 3

Dies ist meine kleine debug-Umgebung:

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 und die DBGp-plugin für Notepad++ für heavy-duty-bug-Jagd, hier FirePHP für leichte Sachen.Quick and dirty?Nothing beats dBug.

Answer 5

XDebug wichtig für die Entwicklung.Ich es installieren, bevor andere Erweiterung.Es gibt Sie stack-traces auf jegliche Fehler, und Sie können die Profilerstellung leicht.

Für einen schnellen Blick auf eine Datenstruktur verwenden var_dump().Nicht verwenden print_r() da müssen Sie umgeben Sie es mit <pre> und es druckt nur eine var zu einer Zeit.

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

Für ein echtes debugging-Umgebung, die besten, die ich gefunden habe ist Komodo-IDE - aber es kostet $$.

Answer 6

PhpEd ist wirklich gut.Sie können step in/over/out-Funktionen.Sie können die Ausführung von ad-hoc-code, überprüfen Variablen, Variablen zu ändern.Es ist erstaunlich.

Answer 7

1) ich benutze print_r().In TextMate, ich habe ein snippet für 'pre', die erweitert diese:

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

2) ich benutze Xdebug, aber nicht in der Lage zu Holen Sie sich die GUI, Recht auf Arbeit, auf meinem Mac.Es zumindest druckt eine lesbare version der stack-trace.

Answer 8

Ich habe die Zend Studio (5.5), zusammen mit Zend Platform.Das gibt richtigen Debuggen, breakpoints/stepping über die code-etc., obwohl zu einem Preis.

Answer 9

In aller Ehrlichkeit, eine Kombination von print-und print_r() zum drucken der Variablen.Ich weiß, dass viele lieber verwenden andere fortgeschrittene Methoden, aber ich finde diese am einfachsten zu verwenden.

Ich werde sagen, dass ich nicht wirklich schätzen, bis ich habe einige Mikroprozessor-Programmierung an der Uni und war nicht in der Lage zu verwenden, auch diese.

Answer 10

Xdebug, by Derick Rethans, ist sehr gut.Ich habe es vor einiger Zeit und fand es war nicht so einfach zu installieren.Sobald Sie fertig sind, werden Sie nicht verstehen, wie Sie es geschafft haben, ohne es :-)

Es ist ein guter Artikel auf Zend Developer Zone (Installation unter Linux scheint nicht einfacher wird) und sogar ein Firefox-plugin, die ich noch nie verwendet.

Answer 11

Ich benutze Netbeans mit XDebug.Check it out auf seine website für Google docs, wie Sie es.http://php.netbeans.org/

Answer 12

Ich benutze Netbeans mit XDebug und der Einfach XDebug FireFox Add-on

Das add-on ist von wesentlicher Bedeutung, wenn Sie die debug-MVC-Projekten, weil der normale Weg, XDebug läuft in Netbeans ist die Registrierung der dbug session über die url.Mit dem add-on installiert sich in FireFox, legen Sie Ihre Netbeans-Projekt-Eigenschaften -> Ausführen-Configuratuion - > "Erweitert" und wählen Sie "Nicht Öffnen Web-Browser" können Sie nun Ihre Pause Punkte und die debugging-Sitzung starten mit Strg-F5, als üblich.Öffnen Sie FireFox und klicken Sie auf den Add-on-Symbol in der rechten unteren Ecke, starten Sie die überwachung für Haltepunkte.Wenn der code der Haltepunkt erreicht wird, Stoppt und Sie können überprüfen Ihre variable Staaten und call-stack.

Answer 13

Output buffering ist sehr nützlich, wenn Sie nicht wollen, um mess up Ihrem Ausgang.Ich mache das in einem one-liner, die ich kommentieren/kommentieren wird

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

Answer 14

PhpEdit hat einen eingebauten debugger, aber ich in der Regel am Ende mit echo();und print_r();auf die altmodische Weise!!

Answer 15

Für die wirklich gritty Probleme, das wäre zu zeitaufwendig zu verwenden print_r/echo, um herauszufinden, ich meine IDE (PhpEd) - debugging-Funktion.Im Gegensatz zu anderen IDEs, die ich verwendet habe, PhpEd erfordert ziemlich viel, kein setup.der einzige Grund, warum ich nicht es verwenden, für alle Probleme, die ich zu stoßen, ist, dass es schmerzhaft langsam.Ich bin nicht sicher, dass die Langsamkeit ist spezifisch für PhpEd oder jede php-debugger.PhpEd ist nicht kostenlos, aber ich glaube, dass es verwendet den open-source-Debugger (wie XDebug bereits erwähnt) sowieso.Der Vorteil mit PhpEd, wieder, ist, dass es erfordert keine Einrichtung, die ich gefunden habe, wirklich ziemlich langwierig in der Vergangenheit.

Answer 16

Manuelle debugging ist im Allgemeinen schneller für mich - var_dump() und debug_print_backtrace() sind alle Werkzeuge, die Sie brauchen, um arm Sie Ihre Logik mit.

Answer 17

Nun, zu einem gewissen Grad hängt es davon ab, wo die Dinge gehen nach Süden.Das ist die erste Sache, die ich versuche zu isolieren, und dann werde ich nutzen, echo/print_r() als notwendig.

NB:Sie wissen, Jungs, dass können Sie true übergeben, als zweites argument auf print_r() und es werde die Ausgabe anstatt zu drucken?E. g.:

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

Answer 18

Ich habe oft verwenden, CakePHP, wenn Schienen ist nicht möglich.Zu debug-Fehler, die ich in der Regel finden die error.log im tmp-Ordner und Schwanz es im terminal mit dem Befehl...

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

Es geben die Sie ausführen dialog von Kuchen, was Los ist, das ist ziemlich praktisch, wenn Sie möchten, um die Ausgabe etwas zu Mitte der code, den Sie verwenden können.

$this->log('xxxx');

Diese können in der Regel geben Sie eine gute Idee, was Los ist/falsch.

Answer 19

print_r( debug_backtrace() );

oder so ähnlich :-)

Answer 20

Komodo-IDE-funktioniert gut mit xdebug, auch für die entfernten Debuggen.Es braucht minimale Menge an Konfiguration.Alles, was Sie brauchen, ist eine version von php, die Komodo verwenden können lokal für Schritt durch den code auf einen Haltepunkt.Wenn Sie das Skript importiert komodo-Projekt, dann können Sie die Haltepunkte mit einem Mausklick, wie Sie es in eclipse zum Debuggen eines java-Programms.Remote-debugging ist natürlich mehr schwierig, um es richtig funktioniert ( Sie müssen möglicherweise anzeigen der remote-url mit einem php-script in Ihrem Arbeitsbereich ) als eine lokale debugging setup ist ziemlich einfach zu konfigurieren, wenn Sie auf einem MAC-oder einem linux-desktop.

Answer 21

Nusphere ist auch ein guter debugger für php nusphere

Answer 22

Es gibt viele PHP-debugging-Techniken, die können sparen Sie unzählige Stunden bei der Codierung.Eine effektive, aber grundlegende debugging-Technik ist einfach zu schalten Sie die Fehlerberichterstattung.Eine andere, etwas mehr fortgeschrittene Technik umfasst die Verwendung von print-Anweisungen, die helfen können lokalisieren schwieriger Fehler durch die Anzeige, was ist eigentlich Los auf dem Bildschirm.PHPeclipse ist ein Eclipse-plug-in, die können markieren gemeinsame syntax-Fehler und kann verwendet werden in Verbindung mit einem debugger Haltepunkte zu setzen.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

und auch verwendet werden

error_log();
console_log();

Answer 23

In einer Produktionsumgebung, ich log, relevante Daten, um die server-Fehlerprotokoll mit error_log().

Answer 24

ich benutze zend studio für eclipse, mit dem eingebauten debugger.Seine immer noch langsam im Vergleich zu Debuggen mit eclipse pdt mit xdebug.Hoffentlich werden Sie fix die Probleme, die Geschwindigkeit hat sich verbessert in den letzten Versionen aber noch stepping über Dinge, die dauert 2-3 Sekunden.Das zend firefox-Symbolleiste macht die Sache einfach (debug nächsten Seite aktuelle Seite, etc).Auch ein profiler, der benchmark-code und bieten pie-charts, execution time, etc.

Answer 25

Die meisten Fehler können so leicht gefunden werden, indem Sie einfach var_dumping einige wichtige Variablen, aber natürlich ist es hängt davon ab, welche Art von Anwendung Sie entwickeln.

Für eine komplexere algorithmen der Schritt/breakpoint/Uhr-Funktionen sind sehr hilfreich (wenn nicht erforderlich)

Answer 26

- PHP-DBG

Die Interaktive Stepthrough PHP-Debugger implementiert als SAPI-Modul, die können geben Ihnen die vollständige Kontrolle über die Umgebung, ohne dabei die Funktionalität oder die Leistung Ihres Codes.Es zielt darauf ab, eine leichte, leistungsstarke, einfach zu bedienen debugging-Plattform für PHP 5.4+, und es ist versendet, out-of-box mit PHP 5.6.

Features beinhaltet:

• Stepthrough Debugging
• Flexiblen Haltepunkte (Klasse, Methode, Funktion, Datei:Zeile, Adresse, Opcode)
• Einfach Zugriff auf PHP mit gebaut-in eval()
• Leicht Zugang zu den Aktuell ausgeführten Code
• Userland-API
• SAPI-Agnostiker - Leicht Integriert
• PHP-Konfiguration-Datei-Unterstützung
• JIT-Super Globals - stellen Sie Ihre Eigenen!!
• Optional readline-Unterstützung - Bequem, Terminal Betrieb
• Remote-Debugging-Unterstützung - der mitgelieferte Java GUI
• Einfache Bedienung

Siehe screenshots:

Homepage: http://phpdbg.com/

PHP-Fehler - Better error reporting für PHP

Dies ist sehr einfach zu bedienen-Bibliothek (eigentlich eine Datei) zum Debuggen von PHP-Skripten.

Das einzige, was Sie tun müssen, ist, eine Datei wie unten (am Anfang auf Ihrem code):

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

Dann werden alle Fehler, geben Sie Informationen wie backtrace, code-Kontext, Funktion, Argumente, server-Variablen, etc.Zum Beispiel:

Features include:

• trivial zu verwenden, es ist nur eine Datei
• Fehler im browser angezeigt, für die normale und ajaxy-Anforderungen
• AJAX-Anfragen sind angehalten, so dass Sie automatisch erneut laufen zu lassen
• macht Fehler, so streng wie möglich (fördert die code-Qualität, und neigt, um die Leistung zu verbessern)
• code-snippets über das gesamte stack-trace
• enthält weitere Informationen (beispielsweise volle Funktion Unterschriften)
• behebt einige Fehler-Meldungen, die sind einfach nur falsch
• syntax-highlighting
• sieht hübsch!
• Anpassung
• manuell drehen es auf und off
• führen Sie bestimmte Abschnitte ohne Fehler reporting
• Dateien ignorieren, so dass Sie vermeiden highlighting-code in Ihrem stack-trace
• Anwendung Dateien;diese werden priorisiert, wenn ein Fehler Streiks!

Homepage: http://phperror.net/

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

Meine Gabel (mit extra behebt): https://github.com/kenorb-contrib/PHP-Error

DTrace

Wenn Ihr system unterstützt DTrace dynamic tracing (standardmäßig installiert unter OS X) und Ihre PHP kompiliert wird mit der DTrace probes aktiviert (--enable-dtrace), die sollte standardmäßig ist dieser Befehl kann Ihnen dabei helfen zu Debuggen im PHP-Skript mit keine Zeit:

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

Also, angesichts der folgenden alias Hinzugefügt wurde, in Ihren rc - Dateien (z.B. ~/.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); }"'

Sie können Spur Ihr Skript mit leicht zu merkenden alias: trace-php.

Hier ist mehr erweiterte dtrace-Skript, speichern Sie ihn einfach in dtruss-php.d, machen Sie es ausführbar (chmod +x dtruss-php.d), und starten Sie:

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

^{Homepage: dtruss-Lampe bei GitHub}

Hier ist die einfache Nutzung:

1. Ausführung: sudo dtruss-php.d.
2. Auf einem anderen terminal ausgeführt: php -r "phpinfo();".

Um zu testen, ob Sie gehen können, um mit docroot index.php und PHP laufen builtin server:

php -S localhost:8080

Danach können Sie auf der Website unter http://localhost:8080/ (oder wählen Sie, was port ist bequem für Sie).Von dort aus Zugriff auf einige Seiten zu sehen, die Ausgabe der Ablaufverfolgung.

Hinweis:Dtrace ist verfügbar unter OS X standardmäßig auf Linux werden Sie wahrscheinlich benötigen, dtrace4linux oder schauen Sie für einige andere alternativen.

Siehe: Mit Hilfe von PHP und DTrace am php.net

---

SystemTap

Alternativ prüfen SystemTap-tracing durch die Installation SystemTap-SDT-Entwicklung-Paket (z.B. yum install systemtap-sdt-devel).

Hier ist ein Beispiel script (all_probes.stp) für die Verfolgung aller Kern der PHP-statische Sonde Punkte während der Dauer der ein PHP-Skript mit 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));
}

Verwendung:

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

Siehe: Mit SystemTap mit PHP DTrace Statische Sonden am php.net

Answer 27

+1 für print_r().Verwenden Sie es zu erstellen, den Inhalt eines Objekts oder einer variable.Um Sie lesbarer zu machen, tun Sie es mit einem pre-tag, so brauchen Sie nicht zu "Quelltext anzeigen".

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

Auch var_dump($thing) - das ist sehr nützlich, um zu sehen, die Art von subthings

Answer 28

Je nach der Frage, die ich wie eine Kombination von error_reporting(E_ALL), gemischt mit echo-tests (die betreffende Zeile/Datei der Fehler passiert in die initial;WISSEN Sie, es ist nicht immer die Zeile/Datei php sagt dir, richtig?), IDE brace matching (auflösen "Parse-Fehler:syntax error, unexpected $end" - Fragen) und print_r();exit;- dumps (echte Programmierer den Quellcode anschauen ;p).

Sie können auch nicht schlagen phpdebug (check sourceforge) mit "memory_get_usage();" und "memory_get_peak_usage();" zu finden, das problem Bereichen.

Answer 29

Der integrierte Debugger, wo Sie beobachten können die Werte von Variablen ändern, wie Sie Schritt für Schritt durch code sind wirklich cool.Sie tun, jedoch, erfordern software-setup auf dem server, und eine gewisse Konfiguration auf dem client.Beide erfordern regelmäßige Wartung zu halten in gutem Zustand.

Ein print_r ist einfach zu schreiben und ist garantiert zu arbeiten in jedem setup.

Answer 30

In der Regel finde ich das erstellen einer benutzerdefinierten log-Funktion in der Lage zu speichern Sie Sie auf Datei, speichern von debug-Informationen an, und schließlich re-print auf einem gemeinsamen Fußzeile.

Sie können auch außer Kraft setzen, common Exception-Klasse, so dass diese Art des Debuggens ist semi-automatische.