eclipse - Wie debuggen Sie PHP-Skripte?

Translate

Wie debuggen Sie?PHPSkripte?

Mir ist das grundlegende Debuggen bekannt, z. B. die Verwendung der Fehlerberichterstattung. Der Haltepunkt beim DebuggenPHPEclipseist auch sehr nützlich.

Was ist derBeste(in Bezug auf schnelle und einfache) Möglichkeit, in phpStorm oder einer anderen IDE zu debuggen?

This question and all comments follow the "Attribution Required."

Alle Antworten

Translate

VersuchenEclipse PDTzum Einrichten einer Eclipse-Umgebung mit Debugging-Funktionen, wie Sie sie erwähnt haben. 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 und alles was ich habe ist SSH und vim ich immer nochvar_dump()/die()um herauszufinden, wohin der Code nach Süden geht.

Quelle
Pat
Translate

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

Ich benutze auchXdebugbereits erwähnt für die Profilerstellung von PHP.

Quelle
Translate

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;
        }
    }
}
Quelle
Regina Lee
Translate

Xdebug und das DBGp-Plugin für Notepad ++ für die Hochleistungs-Fehlersuche, FirePHP für leichtes Material. Schnell und dreckig? Nichts schlägtdBug.

Quelle
Translate

XDebugist wichtig für die Entwicklung. Ich installiere es vor jeder anderen Erweiterung. Sie erhalten Stapelspuren für jeden Fehler und können die Profilerstellung einfach aktivieren.

Für einen kurzen Blick auf eine Datenstruktur verwendenvar_dump(). Nicht benutzenprint_r()weil du es damit umgeben musst<pre>und es wird jeweils nur eine Variable gedruckt.

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

Für eine echte Debugging-Umgebung ist das Beste, was ich gefunden habeKomodo IDEaber es kostet $$.

Quelle
Ann Lee
Translate

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

Quelle
Translate

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.

Quelle
Monroe Lee
Translate

Ich habe das benutztZend Studio (5.5), zusammen mitZend-Plattform. Das gibt ordentliches Debuggen, Haltepunkte / Überspringen des Codes usw., wenn auch zu einem Preis.

Quelle
Truda Lee
Translate

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 Mikroprozessorprogrammierung durchgeführt habe und nicht einmal dies nutzen konnte.

Quelle
Alfred Lee
Translate

Xdebugvon 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 überZend Developer Zone(Installation unter Linux scheint nicht einfacher zu sein) und sogar aFirefox Plugin, die ich nie benutzt habe.

Quelle
Setlla Lee
Translate

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

Quelle
Henry Lee
Translate

Ich benutze Netbeans mit XDebug und demEinfaches XDebug FireFox Add-on

Das Add-On ist beim Debuggen von MVC-Projekten unerlässlich, da XDebug in Netbeans normalerweise ü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.

Quelle
Woodrow Lee
Translate

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();
Quelle
Queena Lee
Translate

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

Quelle
Ira Lee
Translate

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 so istschmerzlichschleppend. 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.

Quelle
Oscar Lee
Translate

Manuelles Debuggen ist für mich im Allgemeinen schneller -var_dump()unddebug_print_backtrace()sind alle Werkzeuge, mit denen Sie Ihre Logik ausrüsten können.

Quelle
Giles Lee
Translate

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>";
Quelle
Samuel Lee
Translate

Ich benutze oft CakePHP, wenn Rails nicht möglich ist. Um Fehler zu debuggen, finde ich normalerweise dieerror.logim tmp Ordner und verfolgen Sie 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 darauf ausgeben möchten, während Sie Code verwenden können.

$this->log('xxxx');

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

Quelle
Heloise Lee
Translate

print_r (debug_backtrace ());

oder etwas ähnliches :-)

Quelle
Betsy Lee
Translate

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 .

Quelle
Haley Lee
Translate

Nusphere ist auch ein guter Debugger für PHPNuskugel

Quelle
Paula Lee
Translate

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();
Quelle
Diana Lee
Translate

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

Quelle
Nicola Lee
Translate

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.

Quelle
Martha Lee
Translate

Die meisten Fehler können einfach gefunden werdenvar_dumpEs 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).

Quelle
Translate

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

Startseite: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 Error | Improve Error Reporting for PHP - screenshot of backtrace PHP Error | Improve Error Reporting for PHP - screenshot of backtrace PHP Error | Improve Error Reporting for PHP - screenshot of backtrace

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-Snippets ü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!

Startseite: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 unterstütztDTrace Dynamic Tracing(standardmäßig unter OS X installiert) und Ihr PHP wird mit aktivierten DTrace-Tests kompiliert (--enable-dtrace) Dieser Befehl sollte standardmäßig verwendet werden und hilft Ihnen, 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); }'

Aus diesem Grund wurde der folgende Alias zu Ihrem hinzugefügtrcDateien (z~/.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 es einfach indtruss-php.d, mach es ausführbar (chmod +x dtruss-php.d) und Renn:

#!/usr/sbin/dtrace -Zs
# See: /out/aHR0cHM6Ly9naXRodWIuY29tL2tlbm9yYi9kdHJ1c3MtbGFtcA==/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));
}

Startseite:Dtruss-Lampebei GitHub

Hier ist einfache Verwendung:

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

Um dies zu testen, können Sie mit zu jedem Docroot gehenindex.phpund führen Sie den eingebauten PHP-Server aus durch:

php -S localhost:8080

Danach können Sie auf die Site unter zugreifenhttp: // localhost: 8080 /(oder wählen Sie den für Sie geeigneten Anschluss). 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 wahrscheinlichdtrace4linuxoder suchen Sie nach einem anderenAlternativen.

Sehen:Verwenden von PHP und DTracebei php.net


SystemTap

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

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

Verwendung:

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

Sehen:Verwenden von SystemTap mit statischen PHP DTrace-Sondenbei php.net

Quelle
April Lee
Translate

+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

Quelle
Bess Lee
Translate

Abhängig vom Problem mag ich eine Kombination aus Fehlerberichterstattung (E_ALL) und 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.

Quelle
Duke Lee
Translate

Die integrierten Debugger, mit denen Sie die Werte der Variablenänderung beim Durchlaufen des Codes beobachten können, 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.

Quelle
Rose Lee
Translate

Normalerweise erstelle ich eine benutzerdefinierte Protokollfunktion, mit der ich Dateien speichern, Debug-Informationen speichern und schließlich in einer allgemeinen Fußzeile erneut drucken kann.

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

Quelle