Wie debuggen Sie PHP-Skripte? [geschlossen]

403

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?

Andrey Adamovich
quelle
40
Ich glaube das ist eine großartige Frage! Wenn Sie nicht wissen, wie Sie mit dem PHP-Debugging umgehen sollen, wissen Sie nicht einmal, wie Sie Ihre Frage formulieren sollen, und wissen nicht, wie Sie präziser vorgehen sollen. Es mag also nicht den Regeln von Stack entsprechen, aber es hilft uns Anfängern sehr!
Mihaela
1
Ab PHP5.4 wurde der neue Debugger für die Befehlszeilenschnittstelle namens phpdbg ( phpdbg.com ) eingeführt. PHP5.6 wird mit Standard-PHPDBG geliefert.
Ganesh Patil
1
Schon mal was von XDebug gehört? :)
Pratik

Antworten:

145

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.

John Downey
quelle
35
Sie sollten diese Funktion verwenden: kill ($ data) {die (var_dump ($ data)); } Es spart die Eingabe von 10 Zeichen, die beste Funktion, die ich je geschrieben habe :)
AlexMorley-Finch
2
Versuchen Sie github.com/tomasfejfar/enhanced-dump :)
Tomáš Fejfar
2
Gibt es eine Möglichkeit, den "var_dump" zu verschönern?
RPDeshaies
6
@ AlexMorley-Finch Ich erhebe Sie zukill($data) { echo "<pre>"; var_dump($data); echo "</pre>"; exit; }
Francisco Presencia
2
Der Link kann über das unglaubliche Webarchiv "wiederhergestellt" werden. Die letzte Überprüfung erfolgte am 7. Mai '15.
Gruber
80

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.

No.
quelle
3
Und hier ist eine Kurzanleitung zur Verwendung von FirePHP: sitepoint.com/debug-php-firebug-firephp
Mihaela
38

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;
        }
    }
}
Eisberg
quelle
2
Vielen Dank. Das hat mir den Tag gerettet. (Ich musste nur das E_STRICT entfernen)
Sec
4
assert_callcackheh
Madbreaks
32

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 .

djn
quelle
Das DBGp-Plugin funktioniert nicht mit der aktuellen Version von Notepad ++ / xdebug und es gibt keine Pläne, dies zu beheben. Sie können meine Diskussion mit dem Schöpfer hier
Joe
26

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 $$.

Julio César
quelle
19

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.

monk.e.boy
quelle
4
Ich habe PhpEd verwendet und habe im Vergleich zu einer echten IDE wie NetBeans oder Eclipse keine freundlichen Worte dafür. Dieser Kommentar fügt der Frage auch nichts Nützliches hinzu. -1
Siliconrockstar
Ich habe die meisten IDEs (einschließlich Zend, NetBeans und Eclipse) vor dem Kauf von PhpED Professional ausprobiert, weil es mit anderthalb Meilen das Beste war. Dies war vor ein paar Jahren, also haben sich die anderen vielleicht seitdem verbessert, aber zu der Zeit waren die meisten von ihnen schmerzhaft langsam, weil sie in Java geschrieben wurden. Ich verstehe nicht, wie jemand "keine freundlichen Worte dafür" haben kann, wenn (für mich) es so eindeutig das Beste war, dass die Entscheidung ein Kinderspiel war.
lm713
17

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.

jlleblanc
quelle
Ich bin sicher, Sie meinen Echo "</ pre>"; am Ende aber.
Altermativ
9
Sie können der Funktion auch 'true' übergeben, damit die Zeichenfolge zurückgegeben wird. Es bedeutet, dass Sie dies tun können:echo '<pre>', print_r($var, true), '</pre>';
DisgruntledGoat
16

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.

Michael Stum
quelle
16

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.

Teifion
quelle
Ich bin froh, dass Sie sowohl print als auch print_r erwähnt haben. Ich verwende einen Basisdruck, um festzustellen, ob der Code bis zu einem bestimmten Punkt ausgeführt wurde, was zur Eingrenzung des Problems beiträgt.
Brad
Ich benutze sowohl print als auch var_dump (). Ich verwende print, um Debug-Meldungen und -Informationen anzuzeigen, und var_dump, um den Status von Variablen im Verlauf anzuzeigen.
Joshua K
14

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.

Christian Lescuyer
quelle
2
Es ist nicht nur frustrierend zu installieren. Das Konfigurieren von Xdebug für die Arbeit mit Eclipse kann ein Albtraum sein. Ich konnte Xdebug unter CentOS 5 installieren, aber EclipsePDT + Xdebug möchte nicht zusammenarbeiten :(
Jahangir
11

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.

Jannie Theunissen
quelle
10

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();
Ken
quelle
9

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

Toby Allen
quelle
8

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.

Karim
quelle
2
Der PHPEd-Debugger wurde tatsächlich von demselben Typ geschrieben, der auch PHPEd geschrieben hat, und ich bin mir ziemlich sicher, dass es sich nicht um Open Source handelt. Zumindest wird PHPEd nicht mit der Quelle ausgeliefert, sondern kompiliert .so und .dll.
Artem Russakovskii
4

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.

Ross
quelle
3

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>";
Nathan Strong
quelle
2
Ich verpacke das einfach in eine Funktion namens Debug. Also kann ich debuggen ($ var);
jdelator
3

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.

MintDeparture
quelle
2

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 .

amit
quelle
2

Nusphere ist auch ein guter Debugger für PHP Nusphere

Mufaddal
quelle
2

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();
shekh danishuesn
quelle
1

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

Dan Grover
quelle
und als Schwanz -f ... funktioniert
super
1

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.

Brendon-Van-Heyzen
quelle
1

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).

Petr Peller
quelle
1

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:

PHP DBG - Stepthrough Debugging - Screenshot

PHP DBG - Stepthrough Debugging - Screenshot

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:

PHP-Fehler |  Verbessern Sie die Fehlerberichterstattung für PHP - Screenshot der Rückverfolgung PHP-Fehler |  Verbessern Sie die Fehlerberichterstattung für PHP - Screenshot der Rückverfolgung PHP-Fehler |  Verbessern Sie die Fehlerberichterstattung für PHP - Screenshot der Rückverfolgung

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

Kenorb
quelle
0

+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

Polsonby
quelle
Eine erweiterte Version finden Sie hier devarticles.in/php/useful-function-to-output-debug-data-in-php
Arvind K.
Hier ist eine verfeinerte Version devarticles.in/php/useful-function-to-output-debug-data-in-php
Arvind K.
0

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.

Eric Lamb
quelle
0

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.

Michael Luton
quelle
0

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.

Joshi Spawnbrood
quelle