Jak debugować skrypty PHP? [zamknięte]

Możesz użyć Firephp dodatek do firebug do debugowania php w tym samym środowisku co javascript.

Używam również Xdebug do profilowania php.

To jest moje małe środowisko debugowania:

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 i wtyczka DBGp do Notepad++ do ciężkich błędów, FirePHP do lekkich rzeczy. Szybko i brudno? Nic nie bije dBug .

XDebug {[6] } jest niezbędny do rozwoju. Instaluję go przed jakimkolwiek innym rozszerzeniem. Daje ślady stosu na każdym błędzie i można łatwo włączyć profilowanie.

Do szybkiego spojrzenia na strukturę danych użyj var_dump(). Nie używaj print_r(), ponieważ będziesz musiał otoczyć go <pre> i wyświetla tylko jeden var na raz.

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

Dla prawdziwego środowiska debugowania najlepszy jaki znalazłem to Komodo IDE ale kosztuje $$.

PhpEd jest naprawdę dobry. Możesz przejść do/over / out of functions. Możesz uruchamiać kod ad-hoc, sprawdzać zmienne, zmieniać zmienne. To niesamowite.

1) używam print_r (). W TextMate mam fragment 'pre', który rozszerza się do tego:

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

2) używam Xdebug, ale nie udało mi się uruchomić GUI na moim Macu. Przynajmniej wyświetla czytelną wersję śladu stosu.

Użyłem Zend Studio (5.5) , razem z Zend Platform . Daje to prawidłowe debugowanie, punkty przerwania/przekroczenie kodu itp., choć w cenie.

Mówiąc szczerze, kombinacja print i print_r () do wypisania zmiennych. Wiem, że wielu woli używać innych bardziej zaawansowanych metod, ale uważam, że jest to najłatwiejsze w użyciu.

Powiem, że nie do końca to doceniłem, dopóki nie zrobiłem jakiegoś mikroprocesora w Uni i nie byłem w stanie użyć nawet tego.

Xdebug , autorstwa Dericka Rethansa, jest bardzo dobry. Użyłem go jakiś czas temu i stwierdziłem, że nie jest tak łatwy w instalacji. Kiedy skończysz, nie zrozumiesz, jak sobie poradziłeś bez niego: -)

Jest dobry artykuł na temat Zend Developer Zone (Instalacja na Linuksie nie wydaje się łatwiejsza), a nawet wtyczki do Firefoksa, której nigdy nie używałem.

Używam Netbeans z XDebug. Sprawdź na jego stronie internetowej, aby uzyskać dokumenty dotyczące konfiguracji. http://php.netbeans.org/

Używam Netbeans z XDebug i Easy Xdebug FireFox Add-on

Dodatek jest niezbędny podczas debugowania projektów MVC, ponieważ normalny sposób działania XDebug w Netbeans polega na zarejestrowaniu sesji dbug poprzez adres url. Z dodatkiem zainstalowanym w Firefoksie, można ustawić właściwości projektu Netbeans - > Uruchom Configuratuion - > zaawansowane i wybrać "NIE otwierać przeglądarki internetowej" można teraz ustawić punkty przerwania i rozpocząć sesję debugowania z Ctrl-F5 jak zwykle. Otwórz Firefoksa i kliknij prawym przyciskiem myszy ikonę dodatku w prawym dolnym rogu, aby rozpocząć monitorowanie punktów przerwania. Gdy kod osiągnie punkt przerwania, zatrzyma się i będzie można sprawdzić Stany zmiennych i stos wywołań.

Buforowanie wyjścia jest bardzo przydatne, jeśli nie chcesz zepsuć wyjścia. Robię to w jednym wierszu, który mogę skomentować / uncomment do woli

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

PhpEdit ma wbudowany debugger, ale zwykle kończę używając echo (); i print_r (); staromodny sposób!!

Dla naprawdę poważnych problemów, które byłyby zbyt czasochłonne, aby użyć print_r / echo, aby dowiedzieć się, że używam funkcji debugowania IDE (PhpEd). W przeciwieństwie do innych Idów, których używałem, PhpEd nie wymaga praktycznie żadnej konfiguracji. jedynym powodem, dla którego nie używam go do żadnych problemów, które napotkam, jest to, że jest boleśnie powolny. Nie jestem pewien, czy powolność jest specyficzna dla PhpEd lub jakiegokolwiek debuggera php. PhpEd nie jest darmowy, ale wydaje mi się, że używa jednego z debugerów open-source (jak wspomniany wcześniej XDebug) w każdym razie. Zaletą PhpEd jest to, że nie wymaga żadnej konfiguracji, która w przeszłości była bardzo uciążliwa.

Ręczne debugowanie jest dla mnie na ogół szybsze - var_dump() i debug_print_backtrace() to wszystkie narzędzia, których potrzebujesz, aby uzbroić swoją logikę.

Cóż, w pewnym stopniu to zależy od tego, gdzie sprawy idą na południe. To jest pierwsza rzecz, którą próbuję wyizolować, a następnie użyję echo / print_r () w razie potrzeby.

NB: wiecie, że można przekazać true jako drugi argument do print_r() i zwróci wyjście zamiast go drukować? Np.:

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

Często używam CakePHP, gdy Rails nie jest możliwy. Aby debugować błędy, zwykle znajduję error.log w folderze tmp i śledzę go w terminalu za pomocą polecenia...

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

Daje Ci uruchomione okno dialogowe z cake o tym, co się dzieje, co jest bardzo przydatne, jeśli chcesz wypisać coś do niego w środku kodu, którego możesz użyć.

$this->log('xxxx');

To zazwyczaj daje dobre wyobrażenie o tym, co się dzieje/źle.

Print_r (debug_backtrace ());

Albo coś w tym stylu: -)

Komodo IDE dobrze współpracuje z xdebug, nawet do debugowania remore. Wymaga minimalnej konfiguracji. Wszystko czego potrzebujesz to wersja php, której Komodo może użyć lokalnie, aby przejść przez KOD w punkcie przerwania. Jeśli skrypt został zaimportowany do projektu komodo, możesz ustawić punkty przerwania za pomocą kliknięcia myszką, tak jak byś ustawił go w eclipse do debugowania programu java. Zdalne debugowanie jest oczywiście trudniejsze, aby poprawnie działało ( być może będziesz musiał zmapować zdalny adres url ze skryptem php w przestrzeni roboczej) niż lokalna konfiguracja debugowania, która jest dość łatwa do skonfigurowania, jeśli jesteś na komputerze MAC lub pulpicie Linuksa.

Nusphere jest również dobrym debugerem dla php

Istnieje wiele technik debugowania PHP, które mogą zaoszczędzić niezliczone godziny podczas kodowania. Skuteczną, ale podstawową techniką debugowania jest po prostu włączenie raportowania błędów. Inna nieco bardziej zaawansowana technika polega na użyciu instrukcji print, które mogą pomóc wskazać bardziej nieuchwytne błędy, wyświetlając to, co faktycznie dzieje się na ekranie. PHPeclipse jest wtyczką Eclipse, która może wyróżniać typowe błędy składniowe i może być używana w połączeniu z debuggerem do ustawiania punkty przerwania.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

A także używane

error_log();
console_log();

+ 1 dla print_r (). Użyj go do zrzutu zawartości obiektu lub zmiennej. Aby uczynić go bardziej czytelnym, zrób to za pomocą znacznika pre, aby nie trzeba było wyświetlać źródła.

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

Również var_dump ($thing) - jest to bardzo przydatne, aby zobaczyć Typ subthings

W środowisku produkcyjnym loguję odpowiednie dane do dziennika błędów serwera za pomocą error_log ().

Używam zend studio dla eclipse z wbudowanym debuggerem. Jego nadal powolny w porównaniu do debugowania z Eclipse pdt z xdebug. Mam nadzieję, że naprawią te problemy, szybkość poprawiła się w ostatnich wydaniach, ale nadal przeskakiwanie nad rzeczami zajmuje 2-3 sekundy. Pasek narzędzi zend firefox naprawdę ułatwia sprawy (debugowanie następnej strony, bieżącej strony itp.). Zapewnia również profiler, który porównuje Twój kod i zapewnia wykresy kołowe, czas wykonania itp.

Większość błędów można łatwo znaleźć po prostu var_dump w niektórych kluczowych zmiennych, ale oczywiście zależy to od rodzaju aplikacji, którą tworzysz.

Dla bardziej złożonych algorytmów funkcje step / breakpoint/watch są bardzo pomocne (jeśli nie są konieczne)

PHP DBG

Interaktywny Debugger Stepthrough PHP zaimplementowany jako moduł SAPI, który może dać ci pełną kontrolę nad środowiskiem bez wpływu na funkcjonalność lub wydajność Twojego kodu. Ma być lekką, wydajną i łatwą w użyciu platformą debugowania dla PHP 5.4+ i jest dostarczana z pudełka z PHP 5.6.

Funkcje obejmują:

• Debugowanie Krok Po Kroku
• Elastyczne Punkty Przerwania (Metoda Klasy, Funkcja, Plik: Line, Address, Opcode)
W tym celu należy wykonać następujące czynności:]}
• łatwy dostęp do aktualnie wykonywanego kodu
• Userland API
• SAPI agnostyk-łatwo zintegrowany
• Obsługa plików konfiguracyjnych PHP
• JIT Super Globals-Ustaw swój własny!!
• Opcjonalne wsparcie readline-wygodna obsługa terminala
• obsługa zdalnego debugowania-dołączone GUI Javy
• Łatwa Obsługa

Zobacz zrzuty ekranu:

Strona główna: http://phpdbg.com/

Błąd PHP - lepsze raportowanie błędów dla PHP

Jest to bardzo łatwa w użyciu biblioteka (właściwie plik) do debugowania skryptów PHP.

Jedyną rzeczą, którą musisz zrobić, to dołączyć jeden plik jak poniżej (na początku kodu):

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

Wtedy wszystkie błędy dadzą ci informacje, takie jak backtrace, kontekst kodu, argumenty funkcji, zmienne serwera itp. Na przykład:

Funkcje obejmują:

• trywialny w użyciu, to tylko jeden plik
• błędy wyświetlane w przeglądarce dla żądań normalnych i ajaxy
Dzięki temu można je automatycznie uruchamiać ponownie.]}
• sprawia, że błędy są tak surowe, jak to możliwe (zachęca do jakości kodu i ma tendencję do poprawy wydajności)
• fragmenty kodu przez cały ślad stosu
• dostarcza więcej informacji (takich jak pełne sygnatury funkcji)
• naprawia niektóre komunikaty o błędach, które są po prostu błędne
• podświetlanie składni
Wygląda pięknie!
• Personalizacja
• ręczne włączanie i wyłączanie
• uruchamiaj określone sekcje bez raportowania błędów
• ignoruj pliki pozwalające uniknąć podświetlania kodu w śledzeniu stosu
• pliki aplikacji; są one ustalane priorytetowo, gdy błąd uderza!

Strona domowa: http://phperror.net/

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

Mój widelec (z dodatkowymi poprawkami): https://github.com/kenorb-contrib/PHP-Error

DTrace

Jeśli Twój system obsługuje DTrace dynamic tracing (zainstalowany domyślnie na OS X), A PHP jest skompilowane z włączonymi sondami DTrace (--enable-dtrace), co powinno być domyślnie, to polecenie może pomoc w debugowaniu skryptu PHP bez czasu:

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

Tak więc w plikach RC dodano następujący alias (np. ~/.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); }"'

Możesz śledzić swój skrypt za pomocą łatwego do zapamiętania aliasu: trace-php.

Tutaj jest bardziej zaawansowany skrypt dtrace, po prostu zapisz go do dtruss-php.d, wykonywalny (chmod +x dtruss-php.d) i uruchom:

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

^{Strona główna: dtruss-lamp at GitHub}

Oto prosty sposób użycia:

1. Run: sudo dtruss-php.d.
2. na innym terminalu: php -r "phpinfo();".

php -S localhost:8080

Następnie możesz wejść na stronę pod adresem http://localhost:8080/ (lub wybierz dogodny dla Ciebie port). Stamtąd uzyskaj dostęp do niektórych stron, aby zobaczyć wyjście śledzenia.

Uwaga: Dtrace jest domyślnie dostępny na OS X, na Linuksie prawdopodobnie potrzebujesz dtrace4linux lub sprawdź inne alternatywy .

Zobacz: używanie PHP i DTrace w php.net

SystemTap

Alternatywnie sprawdź śledzenie SystemTap, instalując pakiet programistyczny SystemTap SDT (np. yum install systemtap-sdt-devel).

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

Użycie:

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

Zobacz: Using SystemTap with PHP DTrace Sondy statyczne w php.net

W zależności od problemu Lubię kombinację error_reporting (E_ALL) zmieszaną z testami echo (aby znaleźć obrażającą linię/plik błąd wystąpił w initally; wiesz, że nie zawsze linia/plik PHP mówi ci dobrze?), IDE brace matching (aby rozwiązać problem "parse error: syntax error, unexpected $end") oraz print_r (); exit; dumps (prawdziwi Programiści przeglądają źródło ;p).

Nie można również pokonać phpdebug (sprawdź sourceforge) z "memory_get_usage ();" i "memory_get_peak_usage ();" do znajdź obszary problemowe.

Zintegrowane debuggery, w których możesz obserwować zmiany wartości zmiennej podczas przechodzenia przez KOD, są naprawdę fajne. Wymagają one jednak konfiguracji oprogramowania na serwerze i pewnej ilości konfiguracji na kliencie. Oba wymagają okresowej konserwacji, aby utrzymać dobry stan techniczny.

Print_r jest łatwy do napisania i gwarantuje działanie w każdej konfiguracji.

Zazwyczaj znajduję funkcję tworzenia niestandardowego dziennika, która może zapisywać w pliku, przechowywać informacje o debugowaniu i ostatecznie ponownie wydrukować na wspólnej stopce.

Możesz także nadpisać typową klasę wyjątków, tak aby ten typ debugowania był półautomatyczny.