Jak se vám ladit PHP skripty?

hlasů
405

Jak se vám ladit PHP skripty?

Jsem si vědom základní ladění, jako je pomocí zasílání zpráv o chybách. Zarážka ladění v PHPEclipse je také docela užitečné.

Jaký je nejlepší (pokud jde o rychlý a snadný) způsob, jak ladit v phpStorm nebo jakékoliv jiné IDE?

Položena 04/08/2008 v 00:18
zdroj uživatelem
V jiných jazycích...                            


30 odpovědí

hlasů
145

Zkuste Eclipse PDT nastavit prostředí Eclipse, který ladění funkcí, jako jste zmínil. Schopnost krok do kódu je mnohem lepší způsob, jak ladit pak starou metodu var_dump a tisknout na různých místech, aby zjistili, kde tok pokazí. Když všechno ostatní selže a když všechno, co mám, je SSH a vim pořád var_dump()/ die()zjistit, kde je kód pokračuje na jih.

Odpovězeno 04/08/2008 v 00:28
zdroj uživatelem

hlasů
80

Můžete použít Firephp add-on do Firebug ladit PHP ve stejném prostředí jako JavaScript.

Já také použít Xdebug již bylo zmíněno na profilování php.

Odpovězeno 05/08/2008 v 18:22
zdroj uživatelem

hlasů
38

To je můj malý ladění prostředí:

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;
        }
    }
}
Odpovězeno 29/06/2009 v 14:40
zdroj uživatelem

hlasů
32

Xdebug a DBGp plugin pro Notepad ++ pro těžké chyb lovu, FirePHP pro lehké věci. Rychle a špinavě? Nic se nevyrovná dBug .

Odpovězeno 15/09/2008 v 21:23
zdroj uživatelem

hlasů
26

Xdebug je zásadní pro rozvoj. Nainstalovat jsem to před jakýmkoliv jiným prodloužení. To vám dává stack stopy na jakékoli chyby a můžete povolit profilování snadno.

Pro rychlý pohled na využití datové struktury var_dump(). Nepoužívají print_r(), protože budete muset obklopit <pre>a vytiskne pouze jeden var najednou.

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

Pro skutečné ladění prostředí nejlepší, co jsem našel, je Komodo IDE ale stojí $$.

Odpovězeno 22/08/2008 v 16:43
zdroj uživatelem

hlasů
19

PhpEd je opravdu dobrý. Můžete vstoupit do / přes / out funkcí. Můžete spustit ad-hoc kód, zkontrolujte proměnné, změna proměnných. To je ůžasné.

Odpovězeno 05/02/2009 v 10:16
zdroj uživatelem

hlasů
17

1) I použít print_r (). V TextMate mám úryvek pro ‚pre‘, který expanduje na toto:

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

2) Já používám Xdebug, ale nebyli schopni se dostat do GUI pracovat přímo na počítači Mac. To alespoň vytiskne čitelnou verzi trasování zásobníku.

Odpovězeno 07/08/2008 v 01:25
zdroj uživatelem

hlasů
16

Ve vší počestnosti, kombinace tisku a print_r () pro vytištění proměnných. Vím, že mnozí raději použít jiné pokročilejší metody, ale zjistil jsem, to je nejjednodušší použít.

Nebudu říkat, že jsem se plně ocenit to, dokud jsem udělal nějaké programování v Uni mikroprocesorem a nebyl schopen používat i tento.

Odpovězeno 04/08/2008 v 22:28
zdroj uživatelem

hlasů
16

Použil jsem Zend Studio (5,5) , společně s Zend Platform . To dává správné ladění, Hraniční hodnoty / překročil kódu atd, i když za cenu.

Odpovězeno 04/08/2008 v 00:20
zdroj uživatelem

hlasů
14

Xdebug tím, Derick Rethans, je velmi dobrá. Použil jsem to před nějakou dobou a zjistil, že to není tak snadné instalaci. Až budete hotovi, nebude pochopit, jak se vám podařilo bez něj :-)

Tam je dobrý článek o Zend Developer Zone (instalace na Linux se nezdá být jednodušší) a dokonce Firefox plugin , který jsem nikdy použit.

Odpovězeno 04/08/2008 v 22:07
zdroj uživatelem

hlasů
11

I použít Netbeans s Xdebug a Easy Xdebug Firefox Add-on

Add-on má zásadní význam při ladění projektů MVC, protože normální způsob Xdebug běží v Netbeans je zaregistrovat relace dbug přes url. S add-on instalován FireFox, měli byste nastavit vlastnosti projektu NetBeans -> Spustit Configuratuion -> Advanced a vyberte možnost „Neotvírejte webového prohlížeče“ Nyní můžete nastavit body přerušení a spusťte ladicí relace pomocí Ctrl-F5 jako obvykle , Otevřená FireFox a pravým tlačítkem myši Add-On ikonu v pravém dolním rohu zahájit monitorování zarážky. Je-li kód dosáhne zarážky se zastaví a vy můžete kontrolovat své proměnlivé stavy a call-stack.

Odpovězeno 09/07/2010 v 04:14
zdroj uživatelem

hlasů
11

I použít Netbeans s Xdebug. Vyzkoušejte to na své webové stránky pro dokumenty o tom, jak ji nastavit. http://php.netbeans.org/

Odpovězeno 26/08/2008 v 16:04
zdroj uživatelem

hlasů
10

Výstup buffering je velmi užitečné, pokud nechcete, aby zkazit váš výstup. Dělám to v jedné vložky, které mohu vyjádřit / odkomentovat dle libosti

 ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();
Odpovězeno 22/10/2008 v 10:16
zdroj uživatelem

hlasů
9

PhpEdit má vestavěný debugger, ale obvykle skončit s použitím echo (); a print_r (); postaru !!

Odpovězeno 17/09/2008 v 11:14
zdroj uživatelem

hlasů
8

Pro opravdu kostrbatý problémů, které by bylo příliš časově náročné použít print_r / echo přijít na to, já používám (PhpEd) ladění funkci mého IDE. Na rozdíl od jiných IDE jsem použil, PhpEd vyžaduje skoro žádné nastavení. jediný důvod, proč nemám používat jej pro případné problémy I potkat je, že je bolestně pomalý. Nejsem si jistý, že pomalost je specifický pro PhpEd nebo jakékoliv php debugger. PhpEd není zdarma, ale domnívám se, že používá jeden z open-source ladicí (jako Xdebug výše zmíněných) tak jako tak. Výhodou s PhpEd opět je, že nevyžaduje žádné nastavení, které jsem našel opravdu docela únavné v minulosti.

Odpovězeno 22/08/2008 v 16:33
zdroj uživatelem

hlasů
4

Manuální ladění je obecně rychlejší pro mě - var_dump()a debug_print_backtrace()jsou všechny nástroje potřebné k aktivaci svou logiku s.

Odpovězeno 22/08/2008 v 16:36
zdroj uživatelem

hlasů
3

I často používají CakePHP když Rails není možné. Chcete-li ladit chyby obvykle najít error.logve složce tmp a ocas, v terminálu příkazem ...

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

To dá'S dialog jste běží od dortu, co se děje, což je docela vhod, pokud chcete výstup něco bude poloviny kódu můžete použít.

$this->log('xxxx');

To může obvykle vám dobrou představu o tom, co se děje / špatně.

Odpovězeno 10/05/2010 v 10:29
zdroj uživatelem

hlasů
3

No, do jisté míry záleží na tom, kde věci jdou na jih. To je první věc, kterou jsem se snaží izolovat, a pak budu používat echo / print_r () podle potřeby.

Pozn: Vy víte, že můžete předat pravý jako druhý argument print_r () a vrátíme výstup namísto tiskem? Např:

echo "<pre>".print_r($var, true)."</pre>";
Odpovězeno 18/09/2008 v 04:17
zdroj uživatelem

hlasů
2

Existuje mnoho PHP ladění techniky, které vám může ušetřit mnoho hodin při kódování. Účinné ale základní ladění technikou je prostě zapnout zasílání zpráv o chybách. Další poněkud pokročilá technika zahrnuje použití tiskového prohlášení, které mohou pomoci určit více nepolapitelný chyby tím, že zobrazuje, co se vlastně děje na obrazovce. PHPeclipse je Eclipse plug-in, který může zvýraznit společné syntaktické chyby a může být použit ve spojení s ladicí nastavit zarážky.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

a také používán

error_log();
console_log();
Odpovězeno 01/10/2015 v 11:16
zdroj uživatelem

hlasů
2

NuSphere je také dobrý debugger pro php NuSphere

Odpovězeno 29/05/2012 v 13:43
zdroj uživatelem

hlasů
2

Komodo IDE pracuje dobře s Xdebug i pro remore ladění. Je třeba minimální množství konfigurací. Vše, co potřebujete, je verze PHP, který Komodo lze použít místně krokovat kód na zarážce. Pokud jste skript importovány do Komodo projekt, pak si můžete nastavit zarážky s kliknutím myši, jak byste nastavené ho do zatmění při dohledávání java program. Vzdálené ladění je samozřejmě složitější, aby si to správně pracovat (možná budete muset mapovat URL vzdálené s php skript ve vaší pracovní ploše), než je místní nastavení ladění, což je docela snadné nastavit, pokud jste na MAC nebo Linux Desktop ,

Odpovězeno 22/08/2008 v 16:44
zdroj uživatelem

hlasů
2

print_r (debug_backtrace ());

nebo něco takového :-)

Odpovězeno 04/08/2008 v 00:32
zdroj uživatelem

hlasů
1

PHP DBG

Interaktivní Stepthrough PHP Debugger implementován jako SAPI modul, který může dát vám úplnou kontrolu nad prostředím bez vlivu na funkčnost nebo výkon vašeho kódu. Klade si za cíl být lehký, výkonný, snadno použitelný ladicí platformu pro PHP 5.4+ a je dodáván out-of-box s PHP 5.6.

Vlastnosti zahrnují:

  • Stepthrough Ladění
  • Flexibilní Breakpoints (Class Method, funkce, Soubor: Line, adresa, Opcode)
  • Snadný přístup k PHP s vestavěným eval ()
  • Snadný přístup k současné spouštění kódu
  • uživatelské aplikace API
  • SAPI Agnostic - snadno integrovat
  • Podpora souborů PHP konfigurace
  • JIT Super Globals - nastavit vlastní !!
  • Volitelné readline Support - Pohodlné Terminal Operation
  • Vzdálené ladění Podpora - Dodávaný Java GUI
  • snadná obsluha

Podívejte se na screenshoty:

PHP DBG - Stepthrough ladění - screenshot

PHP DBG - Stepthrough ladění - screenshot

Úvodní strana: http://phpdbg.com/

PHP Error - lepší chybová hlášení pro PHP

To je velmi snadné použití knihovny (vlastně soubor) ladit své PHP skripty.

Jediná věc, kterou musíte udělat, je zahrnout jeden soubor jak je uvedeno níže (na začátku vašeho kódu):

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

Pak všechny chyby vám poskytne informace, jako je backtrace, kód kontext, argumentů funkcí, proměnných server apod Například:

PHP chyby |  Zlepšit Zasílání zpráv o chybách pro PHP - snímek backtrace PHP chyby |  Zlepšit Zasílání zpráv o chybách pro PHP - snímek backtrace PHP chyby |  Zlepšit Zasílání zpráv o chybách pro PHP - snímek backtrace

Mezi vlastnosti patří:

  • triviální používat, je to jen jeden soubor
  • Chyby zobrazené v prohlížeči pro normální a ajaxy žádostí
  • Žádosti AJAX jsou pozastaveny, což vám umožní automaticky znovu spustit je
  • dělá chyby a co nejpřísnější (podporuje kvalitu kódu, a má tendenci ke zlepšení výkonu)
  • kousky kódu v rámci celého trasování zásobníku
  • poskytuje další informace (například úplná podpisy funkce)
  • opravuje některé chybové zprávy, které jsou prostě a jednoduše špatné
  • zvýrazňování syntaxe
  • Vypadá pěkně!
  • přizpůsobení
  • ručně zapnout a vypnout
  • spustit zvláštní oddíly bez zpráv o chybách
  • ignorovat souborů umožňuje, aby se zabránilo zvýraznění kód do vašich trasování zásobníku
  • Soubory aplikace; ty jsou upřednostněny pokud dojde k chybě stávky!

Úvodní strana: http://phperror.net/

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

My vidlice (s možností opravy): https://github.com/kenorb-contrib/PHP-Error

DTrace

Pokud váš systém podporuje Dtrace dynamické trasování (standardně nainstalován na OS X) a vaše PHP je sestaven s Dtrace sondami aktivní ( --enable-dtrace), která by měla být ve výchozím nastavení, lze tento příkaz vám pomůže ladění PHP skriptu s velmi krátkém čase:

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že s ohledem na následující alias byl přidán do vašeho rc souborů (např ~/.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); }"'

můžete sledovat své skript snadno zapamatovatelný alias: trace-php.

Zde je vyspělejší DTrace skript, stačí ji uložit do dtruss-php.d, aby byl spustitelný ( chmod +x dtruss-php.d) a spusťte:

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

Úvodní strana: dtruss lampa na GitHub

Zde je jednoduché použití:

  1. Spustit: sudo dtruss-php.d.
  2. V jiném terminálu běhu: php -r "phpinfo();".

Chcete-li vyzkoušet to, že můžete jít na jakékoliv docroot se index.phpa spouštět PHP vestavěný server:

php -S localhost:8080

Poté můžete přístup k webu na adrese http: // localhost: 8080 / (nebo zvolit libovolnou port je vhodný pro vás). Odtud přístup k některým stránky vidět výstup trasování.

Poznámka: Dtrace je k dispozici na Mac OS X ve výchozím nastavení v systému Linux budete pravděpodobně potřebovat dtrace4linux nebo kontrolovat některé další alternativy .

Viz: Používání PHP a DTrace v php.net


SystemTap

Případně zkontrolujte SystemTap sledování instalací vývojového balíku SystemTap SDT (např yum install systemtap-sdt-devel).

Zde je příklad skriptu ( all_probes.stp) pro sledování všech bodů statické sondy jádra PHP po celou dobu trvání běžícího PHP skriptu s 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));
}

Používání:

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

Viz: Používání SystemTap s PHP DTrace statických sond na php.net

Odpovězeno 21/03/2016 v 12:34
zdroj uživatelem

hlasů
1

Nejvíce chyb lze snadno nalézt pouhým var_dumping některé z klíčových proměnných, ale to samozřejmě záleží na tom, jakou aplikaci vyvíjet.

U složitějších algoritmů step / zarážka / watch funkce jsou velmi užitečné (ne-li to nutné)

Odpovězeno 10/05/2010 v 10:18
zdroj uživatelem

hlasů
1

i použití Zend Studio pro zatmění se zabudovaným v debuggeru. Jeho stále pomalý ve srovnání s ladění s Eclipse PDT s Xdebug. Doufejme, že bude opravit tyto problémy, rychlost se zlepšila v posledních verzích, ale stále překračoval věcí trvá 2-3 sekund. Zend toolbar firefox opravdu dělá věci jednoduše (ladění další stránky, aktuální stránka, atd.) Také poskytuje profiler, který bude referenční kód a poskytují Pie-grafy, čas spuštění, atd

Odpovězeno 17/08/2008 v 19:38
zdroj uživatelem

hlasů
1

V produkčním prostředí, se přihlásím relevantní data do protokolu chyb serveru s error_log ().

Odpovězeno 15/08/2008 v 05:23
zdroj uživatelem

hlasů
1

1 pro print_r (). Použijte ji na skládku mimo obsah objektu nebo proměnné. Aby to bylo čitelné, to s předem značkou, takže nemusíte pro zobrazení zdroj.

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

Také var_dump ($ věc) - to je velmi užitečné, kdyby se typ subthings

Odpovězeno 05/08/2008 v 01:49
zdroj uživatelem

hlasů
0

Obvykle jsem si vytvořit vlastní funkci log schopni ušetřit na soubor, obchod ladění informace, a nakonec re-print na společném zápatí.

Můžete také přepsat společnou třídu výjimky, takže tento typ ladění je poloautomatické.

Odpovězeno 22/10/2008 v 09:46
zdroj uživatelem

hlasů
0

Integrované debuggers kde můžete sledovat hodnoty proměnné změny, jak si krok prostřednictvím kódu jsou opravdu cool. Nemají však vyžadují instalaci softwaru na serveru a určitou konfiguraci na straně klienta. Obě které vyžadují pravidelnou údržbu, aby se v dobrém stavu.

Print_r je snadné psát a je zaručeno, že pracovat v jakémkoliv nastavení.

Odpovězeno 22/08/2008 v 21:10
zdroj uživatelem

hlasů
0

V závislosti na problému se mi líbí kombinace error_reporting (E_ALL) smíchané s testy echo (najít problematický řádek / soubor chyba nastala v initally, víš, že to není vždy line / soubor php vám řekne, že jo?), IDE Brace Matching (k vyřešení "Parse error: syntaktická chyba, nečekaný konec $" otázek) a print_r (); výstup; skládky (skutečné programátory zobrazit zdrojový kód, p).

Také nelze porazit phpdebug (check sourceforge) s "memory_get_usage ();" a "memory_get_peak_usage ();" najít problémové oblasti.

Odpovězeno 06/08/2008 v 16:46
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more