Jak debugujesz skrypty PHP? [Zamknięte]

Jak debugujesz skrypty PHP ?

Mam świadomość podstawowego debugowania, takiego jak korzystanie z Raportowania błędów. Debugowanie punktu przerwania w PHPEclipse jest również bardzo przydatne.

Jaki jest najlepszy (pod względem szybkiego i łatwego) sposób debugowania w phpStorm lub innym IDE?

Wypróbuj Eclipse PDT, aby skonfigurować środowisko Eclipse z funkcjami debugowania, o których wspomniałeś. Możliwość wkroczenia do kodu jest znacznie lepszym sposobem debugowania niż stara metoda var_dump i drukowanie w różnych punktach, aby sprawdzić, gdzie popełnisz błąd. Kiedy wszystko inne zawodzi i wszystko, co mam, to SSH i vim wciąż var_dump()/ szukam, die()gdzie kod idzie na południe.

Możesz użyć Firephp jako dodatku do firebuga do debugowania php w tym samym środowisku co javascript.

Używam również Xdebug wspomnianego wcześniej do profilowania php.

Oto moje małe środowisko do 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 trudnego wykrywania błędów, FirePHP do lekkich rzeczy. Szybko i brudno? Nic nie przebije dBug .

XDebug jest niezbędny do rozwoju. Instaluję go przed jakimkolwiek innym rozszerzeniem. Daje to stos śladów po każdym błędzie i można łatwo włączyć profilowanie.

Dla szybkiego spojrzenia na użycie struktury danych var_dump(). Nie używaj, print_r()ponieważ będziesz musiał go otoczyć, <pre>a drukuje tylko jeden var na raz.

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

Dla prawdziwego środowiska do debugowania najlepsze, jakie znalazłem, to Komodo IDE, ale kosztuje $$.

PhpEd jest naprawdę dobry. Możesz wejść / wyjść / wyjść z funkcji. Możesz uruchamiać kod ad-hoc, sprawdzać zmienne, zmieniać zmienne. To jest niesamowite.

1) Używam print_r (). W TextMate mam fragment wstępny, który rozwija się do tego:

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

2) Używam Xdebug, ale nie byłem w stanie sprawić, aby GUI działało bezpośrednio na moim komputerze Mac. Drukuje przynajmniej czytelną wersję śladu stosu.

Korzystałem z Zend Studio (5.5) wraz z platformą Zend . Daje to prawidłowe debugowanie, punkty przerwania / przeskakiwanie kodu itp., Choć za pewną cenę.

Szczerze mówiąc, połączenie print i print_r () do wydrukowania zmiennych. Wiem, że wielu woli używać innych, bardziej zaawansowanych metod, ale uważam to za najłatwiejsze w użyciu.

Powiem, że nie doceniłem tego w pełni, dopóki nie zacząłem programować mikroprocesorów w Uni i nie byłem w stanie z tego skorzystać.

Xdebug , autor: Derick Rethans, jest bardzo dobry. Użyłem go jakiś czas temu i okazało się, że nie był tak łatwy do zainstalowania. Gdy skończysz, nie zrozumiesz, jak sobie z tym poradziłeś :-)

Jest dobry artykuł na temat Zend Developer Zone (instalacja w Linuksie nie wydaje się łatwiejszy), a nawet wtyczki Firefox , z której nigdy nie korzystałem.

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

Używam Netbeans z XDebug i dodatkiem Easy XDebug FireFox

Dodatek jest niezbędny podczas debugowania projektów MVC, ponieważ normalnym sposobem działania XDebug w Netbeans jest rejestrowanie sesji dbug za pośrednictwem adresu URL. Po zainstalowaniu dodatku w FireFox ustawiłbyś właściwości projektu Netbeans -> Uruchom konfigurację -> Zaawansowane i wybierz „Nie otwieraj przeglądarki internetowej”. Teraz możesz ustawić punkty przerwania i rozpocząć sesję debugowania z Ctrl-F5 jak zwykle . Otwórz FireFox i kliknij prawym przyciskiem myszy ikonę dodatku w prawym dolnym rogu, aby rozpocząć monitorowanie punktów przerwania. Kiedy kod osiągnie punkt przerwania, zatrzyma się i będziesz mógł sprawdzić stany zmiennych i stos wywołań.

Buforowanie danych wyjściowych jest bardzo przydatne, jeśli nie chcesz popsuć danych wyjściowych. Robię to w jednej linijce, którą mogę komentować / komentować do woli

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

PhpEdit ma wbudowany debugger, ale zwykle używam echo (); i print_r (); staroświecki sposób !!

W przypadku naprawdę trudnych problemów, które byłyby zbyt czasochłonne, aby użyć print_r / echo, aby dowiedzieć się, że korzystam z funkcji debugowania mojego IDE (PhpEd). W przeciwieństwie do innych IDE, których używałem, PhpEd nie wymaga prawie żadnej konfiguracji. jedynym powodem, dla którego nie używam go do żadnych problemów, jakie napotykam, jest to, że jest boleśnie powolny. Nie jestem pewien, czy powolność jest specyficzna dla PhpEd lub jakiegokolwiek debugera php. PhpEd nie jest darmowy, ale uważam, że i tak używa jednego z debuggerów typu open source (jak wspomniano wcześniej o XDebug). Zaletą PhpEd jest to, że nie wymaga konfiguracji, co w przeszłości uważałem za bardzo nudne.

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

Cóż, do pewnego stopnia zależy to od tego, dokąd zmierzają rzeczy na południe. To pierwsza rzecz, którą próbuję wyizolować, a następnie w razie potrzeby użyję echo / print_r ().

NB: Wiecie, że możecie przekazać true jako drugi argument print_r () i zwróci on wynik zamiast go wydrukować? Na przykład:

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

Często używam CakePHP, gdy Railsy nie są możliwe. Aby debugować błędy, zwykle znajduję error.logfolder tmp i ogoniam go w terminalu poleceniem ...

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

Daje ci uruchamianie okna dialogowego z ciasta, co się dzieje, co jest dość przydatne, jeśli chcesz wypisać coś do środka kodu, którego możesz użyć.

$this->log('xxxx');

Zwykle daje to dobry obraz tego, co się dzieje / źle.

print_r (debug_backtrace ());

czy jakoś tak :-)

Komodo IDE działa dobrze z xdebug, nawet w przypadku debugowania remore. Wymaga minimalnej ilości konfiguracji. Wszystko czego potrzebujesz to wersja php, której Komodo może używać lokalnie, aby przejść przez kod w punkcie przerwania. Jeśli masz skrypt zaimportowany do projektu komodo, możesz ustawić punkty przerwania za pomocą kliknięcia myszy, tak jak ustawić go w środowisku zaćmienia w celu debugowania programu Java. Zdalne debugowanie jest oczywiście trudniejsze, aby działało poprawnie (być może trzeba zmapować zdalny adres URL za pomocą skryptu php w obszarze roboczym) niż lokalna konfiguracja debugowania, która jest dość łatwa do skonfigurowania, jeśli używasz komputera Mac lub Linux .

Nusphere jest również dobrym debuggerem dla php nusphere

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 w zlokalizowaniu bardziej nieuchwytnych błędów poprzez wyświetlenie tego, co faktycznie dzieje się na ekranie. PHPeclipse to wtyczka 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 punktów przerwania.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

i również używane

error_log();
console_log();

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

używam Zend Studio do zaćmienia z wbudowanym debuggerem. Wciąż jest powolny w porównaniu do debugowania za pomocą eclipse pdt z xdebug. Miejmy nadzieję, że rozwiążą te problemy, prędkość poprawiła się w porównaniu z ostatnimi wydaniami, ale nadal przechodzenie przez rzeczy zajmuje 2-3 sekundy. Pasek narzędzi Zend Firefox naprawdę naprawdę ułatwia (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 niektóre kluczowe zmienne, ale oczywiście zależy to od rodzaju tworzonej aplikacji.

W przypadku bardziej złożonych algorytmów funkcje krok / punkt przerwania / zegarek są bardzo pomocne (jeśli nie są konieczne)

PHP DBG

Interaktywny debugger PHP Stepthrough 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ą do debugowania dla PHP 5.4+ i jest dostarczany w standardzie z PHP 5.6.

Funkcje obejmują:

• Debugowanie krokowe
• Elastyczne punkty przerwania (metoda klasy, funkcja, plik: linia, adres, kod operacyjny)
• Łatwy dostęp do PHP z wbudowanym eval ()
• Łatwy dostęp do aktualnie wykonywanego kodu
• Interfejs użytkownika Userland
• SAPI Agnostic - łatwa integracja
• Obsługa plików konfiguracyjnych PHP
• JIT Super Globals - Ustaw własne !!
• Opcjonalne wsparcie readline - wygodna obsługa terminalu
• Obsługa zdalnego debugowania - pakiet GUI Java
• Łatwa operacja

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.

Jedyne, co musisz zrobić, to dołączyć jeden plik jak poniżej (na początku kodu):

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

Następnie wszystkie błędy dostarczą informacji takich jak ślad, kontekst kodu, argumenty funkcji, zmienne serwera itp. Na przykład:

Dodatki zawarte:

• prosty w użyciu, to tylko jeden plik
• błędy wyświetlane w przeglądarce dla żądań normalnych i ajaxy
• Żądania AJAX są wstrzymane, co pozwala na ich automatyczne ponowne uruchomienie
• sprawia, że ​​błędy są możliwie najostrzejsze (poprawia jakość kodu i ma tendencję do zwiększania wydajności)
• fragmenty kodu w całym śladzie stosu
• zapewnia więcej informacji (takich jak podpisy pełnych funkcji)
• naprawia niektóre komunikaty o błędach, które są po prostu błędne
• Podświetlanie składni
• wygląda ślicznie!
• dostosowywanie
• ręcznie włącz i wyłącz
• uruchom określone sekcje bez zgłaszania błędów
• zignoruj ​​pliki, dzięki czemu unikniesz podświetlania kodu w śladzie stosu
• pliki aplikacji; są one traktowane priorytetowo, gdy pojawi się błąd!

Strona główna: 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 dynamiczne śledzenie DTrace (instalowane domyślnie w OS X), a Twój PHP jest kompilowany z włączonymi sondami DTrace ( --enable-dtrace), które powinny być domyślnie, to polecenie może pomóc 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 biorąc pod uwagę następujące alias został dodany do swoich rc plików (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żna prześledzić swój skrypt z łatwym do zapamiętania alias: trace-php.

Oto bardziej zaawansowany skrypt dtrace, po prostu zapisz go w programie dtruss-php.d, chmod +x dtruss-php.duruchom go ( ) 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: lampa dtruss na GitHub}

Oto proste użycie:

1. Run: sudo dtruss-php.d.
2. Na innej perspektywie terminala: php -r "phpinfo();".

Aby to przetestować, możesz przejść do dowolnego docroota index.phpi uruchomić wbudowany serwer PHP poprzez:

php -S localhost:8080

Następnie możesz uzyskać dostęp do witryny pod adresem http: // localhost: 8080 / (lub wybrać port, który jest dla Ciebie odpowiedni). Stamtąd przejdź do niektórych stron, aby zobaczyć wyniki śledzenia.

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

Zobacz: Korzystanie z PHP i DTrace na php.net

SystemTap

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

Oto przykładowy skrypt ( all_probes.stp) do śledzenia wszystkich podstawowych statycznych punktów sondy PHP podczas trwania działającego skryptu PHP za pomocą 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));
}

Stosowanie:

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

Zobacz: Używanie SystemTap z statycznymi sondami PHP DTrace na php.net

+1 dla print_r (). Użyj go, aby zrzucić zawartość obiektu lub zmiennej. Aby uczynić go bardziej czytelnym, zrób to z tagiem wstępnym, aby nie trzeba było przeglądać źródła.

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

Również var_dump ($ thing) - jest to bardzo przydatne, aby zobaczyć rodzaj podtytułów

W zależności od problemu podoba mi się kombinacja raportowania błędów (E_ALL) zmieszana z testami echa (aby znaleźć obrażającą linię / plik, w którym początkowo wystąpił błąd; WIESZ, że nie zawsze php linii / pliku mówi ci dobrze?), Dopasowanie nawiasów klamrowych IDE (aby rozwiązać „Błąd analizy: błąd składni, nieoczekiwane problemy z $ end”) i print_r (); wyjście; zrzuty (prawdziwi programiści przeglądają źródło; p).

Nie można także pokonać phpdebug (sprawdź sourceforge) za pomocą „memory_get_usage ();” i „memory_get_peak_usage ();” znaleźć obszary problemowe.

Zintegrowane debuggery, w których można obserwować zmiany wartości zmiennych podczas przechodzenia przez kod, są naprawdę fajne. Wymagają one jednak konfiguracji oprogramowania na serwerze i pewnej konfiguracji na kliencie. Oba wymagają okresowej konserwacji, aby zachować sprawność.

Print_r jest łatwy do napisania i gwarantuje działanie w dowolnej konfiguracji.

Zwykle tworzę niestandardową funkcję dziennika, która może zapisywać w pliku, przechowywać informacje debugowania i ewentualnie ponownie drukować na wspólnej stopce.

Możesz również zastąpić wspólną klasę wyjątków, aby ten typ debugowania był półautomatyczny.