Wie debuggen Sie PHP-Skripte? [geschlossen]

Wie debuggen Sie PHP- Skripte?

Mir ist das grundlegende Debuggen bekannt, z. B. die Verwendung der Fehlerberichterstattung. Das Debuggen von Haltepunkten in PHPEclipse ist ebenfalls sehr nützlich.

Was ist der beste (in Bezug auf schnelle und einfache) Weg, um in phpStorm oder einer anderen IDE zu debuggen?

Versuchen Sie Eclipse PDT, um eine Eclipse-Umgebung mit Debugging-Funktionen wie den von Ihnen erwähnten einzurichten. Die Möglichkeit, in den Code einzusteigen, ist eine viel bessere Möglichkeit zum Debuggen als die alte Methode von var_dump und das Drucken an verschiedenen Stellen, um festzustellen, wo Ihr Ablauf schief geht. Wenn alles andere fehlschlägt , obwohl und alles , was ich habe , ist SSH und Vim ich noch var_dump()/ die()zu finden , wo der Code nach Süden geht.

Sie können Firephp als Add-On zu Firebug verwenden, um PHP in derselben Umgebung wie Javascript zu debuggen.

Ich benutze auch Xdebug, das bereits erwähnt wurde, um PHP zu profilieren.

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

Xdebug und das DBGp-Plugin für Notepad ++ für die Hochleistungs-Fehlersuche, FirePHP für leichtes Material. Schnell und dreckig? Nichts geht über dBug .

XDebug ist für die Entwicklung unerlässlich. Ich installiere es vor jeder anderen Erweiterung. Es gibt Ihnen Stapelspuren für jeden Fehler und Sie können die Profilerstellung einfach aktivieren.

Für einen kurzen Blick auf eine Datenstruktur verwenden var_dump(). Nicht verwenden, print_r()da Sie es umgeben müssen <pre>und jeweils nur eine Variable gedruckt wird.

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

Für eine echte Debugging-Umgebung ist Komodo IDE das Beste, was ich gefunden habe, aber es kostet $$.

PhpEd ist wirklich gut. Sie können Funktionen betreten / überschreiten / verlassen. Sie können Ad-hoc-Code ausführen, Variablen überprüfen und Variablen ändern. Es ist unglaublich.

1) Ich benutze print_r (). In TextMate habe ich ein Snippet für 'pre', das sich dahingehend erweitert:

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

2) Ich verwende Xdebug, konnte aber die GUI auf meinem Mac nicht richtig zum Laufen bringen. Es wird zumindest eine lesbare Version des Stack-Trace ausgedruckt.

Ich habe das Zend Studio (5.5) zusammen mit der Zend Platform verwendet . Das gibt ordentliches Debuggen, Haltepunkte / Überspringen des Codes usw., wenn auch zu einem Preis.

Ehrlich gesagt eine Kombination aus print und print_r (), um die Variablen auszudrucken. Ich weiß, dass viele andere fortgeschrittenere Methoden bevorzugen, aber ich finde, dass dies am einfachsten zu verwenden ist.

Ich werde sagen, dass ich das erst richtig verstanden habe, als ich an der Uni Mikroprozessor-Programmierung durchgeführt habe und nicht einmal dies nutzen konnte.

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

Es gibt einen guten Artikel über Zend Developer Zone (die Installation unter Linux scheint nicht einfacher zu sein) und sogar ein Firefox-Plugin , das ich nie benutzt habe.

Ich benutze Netbeans mit XDebug. Auf der Website finden Sie Dokumente zur Konfiguration. http://php.netbeans.org/

Ich verwende Netbeans mit XDebug und dem Easy XDebug FireFox Add-on

Das Add-On ist wichtig, wenn Sie MVC-Projekte debuggen, da XDebug normalerweise in Netbeans ausgeführt wird, indem die DBUG-Sitzung über die URL registriert wird. Wenn das Add-On in FireFox installiert ist, legen Sie die Eigenschaften Ihres Netbeans-Projekts fest -> Konfiguration ausführen -> Erweitert und wählen "Webbrowser nicht öffnen". Sie können jetzt Ihre Haltepunkte festlegen und die Debugging-Sitzung wie gewohnt mit Strg-F5 starten . Öffnen Sie FireFox und klicken Sie mit der rechten Maustaste auf das Add-On-Symbol in der rechten unteren Ecke, um die Überwachung auf Haltepunkte zu starten. Wenn der Code den Haltepunkt erreicht, wird er gestoppt und Sie können Ihre Variablenzustände und den Aufrufstapel überprüfen.

Die Ausgabepufferung ist sehr nützlich, wenn Sie Ihre Ausgabe nicht durcheinander bringen möchten. Ich mache das in einem Einzeiler, den ich nach Belieben kommentieren / kommentieren kann

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

PhpEdit hat einen eingebauten Debugger, aber ich benutze normalerweise echo (); und print_r (); die altmodische Art !!

Für die wirklich schwierigen Probleme, die zu zeitaufwändig wären, um mit print_r / echo herauszufinden, verwende ich die Debugging-Funktion meiner IDE (PhpEd). Im Gegensatz zu anderen IDEs, die ich verwendet habe, erfordert PhpEd so gut wie kein Setup. Der einzige Grund, warum ich es nicht für Probleme benutze, ist, dass es schmerzhaft langsam ist. Ich bin nicht sicher, ob Langsamkeit spezifisch für PhpEd oder einen PHP-Debugger ist. PhpEd ist nicht kostenlos, aber ich glaube, es verwendet trotzdem einen der Open-Source-Debugger (wie XDebug). Der Vorteil von PhpEd ist wiederum, dass es kein Setup erfordert, was ich in der Vergangenheit als ziemlich langweilig empfunden habe.

Manuelles Debuggen ist für mich im Allgemeinen schneller - var_dump()und bietet debug_print_backtrace()alle Tools, mit denen Sie Ihre Logik aktivieren können.

Nun, bis zu einem gewissen Grad hängt es davon ab, wohin die Dinge nach Süden gehen. Das ist das erste, was ich zu isolieren versuche, und dann verwende ich nach Bedarf echo / print_r ().

NB: Ihr wisst, dass ihr als zweites Argument true an print_r () übergeben könnt und die Ausgabe zurückgibt, anstatt sie zu drucken? Z.B:

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

Ich benutze oft CakePHP, wenn Rails nicht möglich ist. Um Fehler zu debuggen, finde ich das normalerweise error.logim tmp-Ordner und beschließe es im Terminal mit dem Befehl ...

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

Es gibt Ihnen einen laufenden Dialog von Kuchen über das, was gerade passiert, was ziemlich praktisch ist, wenn Sie etwas in der Mitte des Codes ausgeben möchten, den Sie verwenden können.

$this->log('xxxx');

Dies kann Ihnen normalerweise eine gute Vorstellung davon geben, was los / falsch ist.

print_r (debug_backtrace ());

oder etwas ähnliches :-)

Komodo IDE funktioniert gut mit xdebug, auch für das Remore-Debugging. Es erfordert ein Minimum an Konfiguration. Alles, was Sie brauchen, ist eine Version von PHP, die Komodo lokal verwenden kann, um den Code auf einem Haltepunkt zu durchlaufen. Wenn Sie das Skript in ein Komodo-Projekt importiert haben, können Sie mit einem Mausklick Haltepunkte festlegen, wie Sie es in Eclipse für das Debuggen eines Java-Programms festlegen würden. Remote-Debugging ist offensichtlich schwieriger, damit es ordnungsgemäß funktioniert (möglicherweise müssen Sie die Remote-URL mit einem PHP-Skript in Ihrem Arbeitsbereich zuordnen) als ein lokales Debugging-Setup, das auf einem MAC- oder Linux-Desktop recht einfach zu konfigurieren ist .

Nusphere ist auch ein guter Debugger für PHP Nusphere

Es gibt viele PHP-Debugging-Techniken, mit denen Sie beim Codieren unzählige Stunden sparen können. Eine effektive, aber grundlegende Debugging-Technik besteht darin, die Fehlerberichterstattung einfach zu aktivieren. Eine weitere, etwas fortgeschrittenere Technik ist die Verwendung von Druckanweisungen, mit deren Hilfe schwer fassbare Fehler lokalisiert werden können, indem angezeigt wird, was tatsächlich auf dem Bildschirm angezeigt wird. PHPeclipse ist ein Eclipse-Plug-In, das häufig auftretende Syntaxfehler hervorheben und in Verbindung mit einem Debugger zum Festlegen von Haltepunkten verwendet werden kann.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

und auch verwendet

error_log();
console_log();

In einer Produktionsumgebung protokolliere ich relevante Daten mit error_log () im Fehlerprotokoll des Servers.

Ich benutze Zend Studio für Eclipse mit dem eingebauten Debugger. Es ist immer noch langsam im Vergleich zum Debuggen mit Eclipse PDF mit Xdebug. Hoffentlich werden sie diese Probleme beheben. Die Geschwindigkeit hat sich gegenüber den letzten Versionen verbessert, aber das Übergehen dauert 2-3 Sekunden. Die zend Firefox-Symbolleiste macht die Sache wirklich einfach (Debuggen der nächsten Seite, der aktuellen Seite usw.). Außerdem bietet es einen Profiler, der Ihren Code bewertet und Kreisdiagramme, Ausführungszeit usw. bereitstellt.

Die meisten Fehler können einfach gefunden werden var_dump Eingeben einiger Schlüsselvariablen gefunden werden, aber es hängt natürlich davon ab, welche Art von Anwendung Sie entwickeln.

Für komplexere Algorithmen sind die Step / Breakpoint / Watch-Funktionen sehr hilfreich (falls nicht erforderlich).

PHP DBG

Der als SAPI-Modul implementierte interaktive Stepthrough-PHP-Debugger bietet Ihnen die vollständige Kontrolle über die Umgebung, ohne die Funktionalität oder Leistung Ihres Codes zu beeinträchtigen. Es soll eine leichte, leistungsstarke und benutzerfreundliche Debugging-Plattform für PHP 5.4+ sein und wird sofort mit PHP 5.6 ausgeliefert.

Eigenschaften umfasst:

• Stepthrough-Debugging
• Flexible Haltepunkte (Klassenmethode, Funktion, Datei: Zeile, Adresse, Opcode)
• Einfacher Zugriff auf PHP mit integriertem eval ()
• Einfacher Zugriff auf aktuell ausgeführten Code
• Userland API
• SAPI Agnostic - Einfach zu integrieren
• Unterstützung für PHP-Konfigurationsdateien
• JIT Super Globals - Stellen Sie Ihre eigenen ein !!
• Optionale Readline-Unterstützung - Komfortabler Terminalbetrieb
• Remote-Debugging-Unterstützung - Gebündelte Java-GUI
• Einfache Operation

Siehe die Screenshots:

Homepage: http://phpdbg.com/

PHP-Fehler - Bessere Fehlerberichterstattung für PHP

Dies ist eine sehr einfach zu verwendende Bibliothek (eigentlich eine Datei) zum Debuggen Ihrer PHP-Skripte.

Das einzige, was Sie tun müssen, ist, eine Datei wie folgt einzufügen (am Anfang Ihres Codes):

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

Dann geben Ihnen alle Fehler Informationen wie Backtrace, Codekontext, Funktionsargumente, Servervariablen usw. Zum Beispiel:

Features sind:

• trivial zu bedienen, es ist nur eine Datei
• Fehler, die im Browser für normale und Ajaxy-Anfragen angezeigt werden
• AJAX-Anforderungen werden angehalten, sodass Sie sie automatisch erneut ausführen können
• macht Fehler so streng wie möglich (fördert die Codequalität und verbessert tendenziell die Leistung)
• Code-Schnipsel über den gesamten Stack-Trace
• bietet weitere Informationen (z. B. Signaturen mit voller Funktion)
• behebt einige Fehlermeldungen, die einfach falsch sind
• Satzstellung markieren
• sieht gut aus!
• Anpassung
• manuell ein- und ausschalten
• Führen Sie bestimmte Abschnitte ohne Fehlerberichterstattung aus
• Ignorieren Sie Dateien, um zu vermeiden, dass Code in Ihrem Stack-Trace hervorgehoben wird
• Anwendungsdateien; Diese werden priorisiert, wenn ein Fehler auftritt!

Homepage: http://phperror.net/

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

Meine Gabel (mit zusätzlichen Korrekturen): https://github.com/kenorb-contrib/PHP-Error

DTrace

Wenn Ihr System die dynamische DTrace-Ablaufverfolgung unterstützt (standardmäßig unter OS X installiert) und Ihr PHP mit aktivierten DTrace-Tests ( --enable-dtrace) kompiliert ist, die standardmäßig aktiviert sein sollten, kann dieser Befehl Ihnen helfen, das PHP-Skript ohne Zeitaufwand zu debuggen:

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

So gegeben folgend Alias wurde von Ihnen hinzugefügt rc - Dateien (zB ~/.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 Ihr Skript mit einem leicht zu merkenden Alias ​​verfolgen : trace-php.

Hier ist ein erweitertes dtrace-Skript. Speichern Sie dtruss-php.des einfach in , machen Sie es ausführbar ( chmod +x dtruss-php.d) und führen Sie es aus:

#!/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-lamp bei GitHub}

Hier ist einfache Verwendung:

1. Führen Sie aus : sudo dtruss-php.d.
2. Auf einem anderen Terminal ausführen : php -r "phpinfo();".

Um dies zu testen, können Sie zu jedem Docroot gehen index.phpund den in PHP integrierten Server ausführen, indem Sie:

php -S localhost:8080

Danach können Sie auf die Site unter http: // localhost: 8080 / zugreifen. (oder den für Sie geeigneten Port auswählen). Von dort aus können Sie auf einige Seiten zugreifen, um die Trace-Ausgabe anzuzeigen.

Hinweis: Dtrace ist standardmäßig unter OS X verfügbar. Unter Linux benötigen Sie wahrscheinlich dtrace4linux oder suchen nach anderen Alternativen .

Siehe: Verwenden von PHP und DTrace auf php.net

SystemTap

Alternativ können Sie die SystemTap-Ablaufverfolgung überprüfen, indem Sie das SystemTap SDT-Entwicklungspaket installieren (z yum install systemtap-sdt-devel. B. ).

Hier ist ein Beispielskript ( all_probes.stp) zum Verfolgen aller statischen Kernprüfpunkte von PHP während der Dauer eines laufenden PHP-Skripts 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));
}

Verwendungszweck:

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

Siehe: Verwenden von SystemTap mit statischen PHP DTrace-Sonden auf php.net

+1 für print_r (). Verwenden Sie diese Option, um den Inhalt eines Objekts oder einer Variablen auszugeben. Um die Lesbarkeit zu verbessern, verwenden Sie ein Pre-Tag, damit Sie die Quelle nicht anzeigen müssen.

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

Auch var_dump ($ thing) - dies ist sehr nützlich, um die Art der Unterthemen zu sehen

Abhängig vom Problem mag ich eine Kombination aus Fehlerberichterstattung (E_ALL) gemischt mit Echotests (um die fehlerhafte Zeile / Datei zu finden, in der der Fehler ursprünglich aufgetreten ist; Sie wissen, dass es nicht immer die Zeile / Datei ist, die PHP Ihnen sagt, oder?), IDE-Klammerübereinstimmung (um "Analysefehler: Syntaxfehler, unerwartete $ end" -Probleme zu beheben) und print_r (); Ausfahrt; Dumps (echte Programmierer sehen die Quelle; p).

Sie können phpdebug (check sourceforge) auch nicht mit "memory_get_usage ();" und "memory_get_peak_usage ();" die Problembereiche zu finden.

Die integrierten Debugger, in denen Sie die Werte der Variablenänderung beobachten können, während Sie den Code durchlaufen, sind wirklich cool. Sie erfordern jedoch ein Software-Setup auf dem Server und eine gewisse Konfiguration auf dem Client. Beide erfordern eine regelmäßige Wartung, um einen einwandfreien Zustand zu gewährleisten.

Ein print_r ist einfach zu schreiben und funktioniert garantiert in jedem Setup.

Normalerweise finde ich eine benutzerdefinierte Protokollfunktion erstellen, die in der Lage ist, Dateien zu speichern, Debug-Informationen zu speichern und schließlich in einer allgemeinen Fußzeile erneut zu drucken.

Sie können auch die allgemeine Ausnahmeklasse überschreiben, sodass diese Art des Debuggens halbautomatisch ist.