Hoe doen jy debug PHP skrifte?[gesluit]

Question

Hoe doen jy debug PHP skrifte?

Ek is bewus van die basiese ontfouting soos met die Fout Verslagdoening.Die breekpunt ontfouting in PHPEclipse is ook baie nuttig.

Wat is die die beste (in terme van'n vinnige en maklik) manier om te ontfout in phpStorm of enige ander IDE?

Answer 1

Probeer Eclipse PDT vir die opstel van 'n Eclipse omgewing wat ontfouting funksies soos jy genoem het. Die vermoë om te stap in die kode is 'n baie beter manier om te ontfout dan die ou metode van var_dump en druk op verskeie punte om te sien waar jou vloei verkeerd gaan. Wanneer alle ander dinge misluk al en al wat ek het is SSH en vim ek nog var_dump() / die() om uit te vind waar die kode gaan suid.

Answer 2

Jy kan Firephp gebruik 'n add-on vir Firebug te ontfout php in dieselfde omgewing as javascript.

Ek het ook gebruik Xdebug vroeër genoem vir profilering PHP.

Answer 3

Dit is my klein debug omgewing:

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

Answer 4

Xdebug en die DBGp plugin vir Notepad ++ vir heavy duty fout jag, FirePHP vir liggewig dinge. Vinnige en vuil? Niks klop dBug .

Answer 5

XDebug is noodsaaklik vir ontwikkeling. Ek installeer dit voor al die ander uitbreiding. Dit gee jou die spore stapel op enige fout en jy kan profilering maklik moontlik te maak.

Vir 'n vinnige blik op 'n datastruktuur gebruik var_dump() . Moenie print_r() want jy het om dit te omring met <pre> en dit druk net een var op 'n slag.

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

Vir 'n ware debugging omgewing die beste wat ek gevind is Komodo IDE maar dit kos $$.

Answer 6

PhpEd is regtig 'n goeie. Jy kan stap in / oor / uit funksies. Jy kan ad hoc-kode uit te voer, te inspekteer veranderlikes, verandering veranderlikes. Dit is verbasend.

Answer 7

1) Ek gebruik print_r (). In TextMate, ek het 'n uittreksel vir 'pre' wat uitbrei na hierdie:

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

2) Ek gebruik Xdebug, maar is nie in staat om die GUI na regs werk op my Mac te kry. Dit ten minste druk uit 'n leesbare weergawe van die stapel spoor.

Answer 8

Ek het gebruik die Stuur Studio (5,5) , saam met Stuur platform . Dit gee behoorlike ontfouting, breek punte / versterking oor die kode ens, hoewel teen 'n prys.

Answer 9

In alle eerlikheid, 'n kombinasie van druk en print_r () te druk die veranderlikes. Ek weet dat baie verkies om ander meer gevorderde metodes gebruik, maar ek vind dit die maklikste om te gebruik.

Ek sal sê dat ek dit nie ten volle waardeer nie totdat ek het 'n bietjie Microprocessor ontwikkeling by Uni en was nie in staat om selfs gebruik dit.

Answer 10

Xdebug, deur Derick Rethans, is baie goed.Ek gebruik dit'n geruime tyd gelede en gevind dat dit was nie so maklik om te installeer.Sodra jy klaar is, sal jy nie verstaan nie hoe jy dit reggekry het sonder dat dit :-)

Daar is'n goeie artikel op Zend Ontwikkelaar Sone (die installering op die Linux lyk nie enige makliker) en selfs'n Firefox plugin, wat ek nooit gebruik nie.

Answer 11

Ek gebruik Netbeans met XDebug. Check dit uit by sy webwerf vir dokumente oor hoe om dit op te stel. http://php.netbeans.org/

Answer 12

Ek gebruik Netbeans met XDebug en die Maklik XDebug FireFox add- op

Die byvoeging is noodsaaklik wanneer jy MVC projekte te ontfout, omdat die normale manier XDebug loop in Netbeans is om die dbug sessie registreer via die url. Met dié byvoeging in FireFox geïnstalleer, sal jy jou Netbeans projek eienskappe stel -> Run Configuratuion -> Advanced en kies "Moenie Open Web Browser" Jy kan nou jou breek punte en begin die ontfouting sessie met Ctrl-F5 soos gewoonlik . Oop FireFox en regs-kliek dié byvoeging ikoon in die regter onderste hoek te begin monitering vir breek punte. Wanneer die kode die breekpunt bereik dit sal stop en jy kan inspekteer jou veranderlike state en noem-stapel.

Answer 13

Uitgawe buffer is baie nuttig as jy nie wil mors jou uitset. Ek doen dit in 'n one-liner wat ek kan nie kommentaar lewer / uncomment na willekeur

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

Answer 14

PhpEdit het 'n ingeboude in debugger, maar ek gewoonlik eindig met behulp van eggo (); en print_r (); die outydse manier !!

Answer 15

Vir die werklik gritty probleme wat te tydrowend om te gebruik print_r / eggo om uit te vind wat ek gebruik (PhpEd) debugging kenmerk my IDE se sou wees. In teenstelling met ander IDES wat ek gebruik, PhpEd vereis pretty much geen setup. die enigste rede waarom ek dit nie gebruik vir enige probleme wat ek teëkom is dat dit pynlik stadig. Ek is nie seker dat traagheid is spesifiek vir PhpEd of enige PHP debugger. PhpEd is nie gratis, maar ek glo dit maak gebruik van een van die open-source debug gers (soos XDebug voorheen genoem) in elk geval. Die voordeel met PhpEd, weer, is dat dit geen setup wat ek regtig mooi vervelige in die verlede gevind vereis.

Answer 16

Handleiding debugging is oor die algemeen vinniger vir my - var_dump() en debug_print_backtrace() is al die gereedskap wat jy nodig het om jou logika te bewapen met

.

Answer 17

Wel, tot 'n mate dit hang af van waar dinge suid gaan. Dit is die eerste ding wat ek probeer om te isoleer, en dan sal ek eggo / print_r () gebruik as wat nodig is.

Let wel: Julle weet dat U waaragtig kan slaag as 'n tweede argument te print_r () en dit sal die uitset in plaas terugkeer van die druk van dit? Bv:.

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

Answer 18

Ek gebruik dikwels CakePHP wanneer Rails is nie moontlik nie. Om debug foute ek gewoonlik vind die error.log in die gids tmp en stert dit in die terminale met die opdrag ...

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

Dit gee se jy hardloop dialoog van koek van wat aangaan, wat is redelik handig, as jy wil uitset iets om dit mid-kode wat jy kan gebruik.

$this->log('xxxx');

Dit kan gewoonlik gee jou 'n goeie idee van wat aangaan / verkeerd.

Answer 19

print_r (debug_backtrace ());

of iets soos dit: -)

Answer 20

Komodo IDE werk goed met xdebug, selfs vir die remore debugging. Dit moet minimum bedrag van opset. Al wat jy nodig het is 'n weergawe van PHP dat Komodo plaaslik kan gebruik om stap vir stap deur die kode op 'n breekpunt. As jy die script in Komodo projek het ingevoerde, dan kan jy breek punte met 'n muis-klik net hoe jy dit sou stel binne verduistering vir ontfouting n Java program stel. Afgeleë debugging is natuurlik moeiliker om dit te kry om korrek te werk (jy mag hê om die remote url kaart met 'n php script in jou werkspasie) as 'n plaaslike debugging opstel wat is redelik maklik om te instel as jy op 'n Mac of 'n Linux .

Answer 21

Nusphere is ook 'n goeie debugger vir PHP nusphere

Answer 22

Daar is baie PHP ontfoutingstegnieke dat jy ontelbare ure kan red wanneer kodering. 'N effektiewe, maar basiese debugging tegniek is om net draai op fout verslagdoening. Nog 'n effens meer gevorderde tegniek behels die gebruik van gedrukte state, wat kan help om vas te stel meer ontwykende foute deur die vertoon van wat werklik aangaan op die skerm. PHPeclipse is 'n Eclipse plug-in wat algemeen sintaksfoute kan uitlig en kan gebruik word in samewerking met 'n debugger om inspeksiepunte stel.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

en ook gebruik

error_log();
console_log();

Answer 23

In 'n produksie-omgewing, ek teken relevante inligting aan die bediener se fout log met error_log ().

Answer 24

Ek gebruik Stuur studio vir verduistering met die gebou in debugger. Sy nog stadig in vergelyking met ontfouting met verduistering PDT met xdebug. Hopelik sal hulle dié probleme op te los, het die spoed verbeter oor die afgelope vrystellings, maar nog steeds versterking oor dinge neem 2-3 sekondes. Die Stuur Firefox toolbar maak regtig dinge maklik (debug volgende bladsy, huidige bladsy, ens). Ook dit bied 'n profiler wat maatstaf jou kode en verskaf pie-kaarte, uitvoering tyd, ens.

Answer 25

Die meeste van foute kan maklik gevind word deur eenvoudig var_dumping sommige van sleutelveranderlikes, maar dit hang natuurlik af van watter soort program wat jy ontwikkel.

Vir 'n meer komplekse algoritmes die stap / breekpunt / horlosie funksies is baie nuttig (indien nie nodig)

Answer 26

PHP DBG

Die Interaktiewe Stepthrough PHP Debugger geïmplementeer as'n SAPI module wat kan gee gee jy volle beheer oor die omgewing sonder om die impak van die funksie of die uitvoering van jou kode.Dit het ten doel om'n liggewig, kragtige, maklik om te gebruik ontfouting platform vir PHP 5.4+ en dit is verskeep uit-van-die-boks met PHP 5.6.

Kenmerke sluit in:

• Stepthrough Ontfouting
• Buigsaam Breekpunte (Klas Metode, Funksie, Lêer:Lyn, Adres, Opcode)
• Maklike Toegang tot PHP met ingeboude-in eval()
• Maklike Toegang tot Tans die Uitvoering van Kode
• Userland API
• SAPI Agnostikus - Maklik Geïntegreer word
• PHP Konfigurasie Lêer Ondersteuning
• JIT Super Globals - Stel Jou Eie!!
• Opsionele readline Ondersteuning - Gemaklik Terminale Werking
• Remote Debugging Ondersteuning - Bundel Java GUI
• Maklike Werking

Sien die screenshots:

Tuisblad: http://phpdbg.com/

PHP Fout - Beter fout verslagdoening vir PHP

Dit is baie maklik om te gebruik biblioteek (eintlik'n lêer) te ontfout jou PHP skrifte.

Die enigste ding wat jy hoef te doen is om aan te sluit in een lêer hieronder (aan die begin op jou code):

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

Dan is al die foute sal gee jou inligting soos terugsoektog, kode konteks, funksie argumente, bediener veranderlikes, ens.Byvoorbeeld:

Kenmerke sluit in:

• triviale om te gebruik, dit is net een lêer
• foute in die leser vertoon vir normale en ajaxy versoeke
• AJAX versoeke is gestop, sodat jy outomaties weer uit te voer hulle
• maak foute as streng as moontlik (moedig kode gehalte, en is geneig om prestasie te verbeter)
• kode brokkies oor die hele stapel spoor
• bied meer inligting (soos die volle funksie handtekeninge)
• fixes'n fout boodskappe wat net plain verkeerd
• accentuering
• lyk mooi!
• aanpassing
• hand draai dit op en af
• hardloop spesifieke afdelings sonder fout verslagdoening
• ignoreer lêers, sodat jy om te verhoed dat die klem kode in jou stapel spoor
• aansoek lêers;hierdie is geprioritiseer wanneer'n fout stakings!

Tuisblad: http://phperror.net/

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

My vurk (met ekstra fixes): https://github.com/kenorb-contrib/PHP-Error

DTrace

As jou stelsel ondersteun DTrace dinamiese opsporing (geïnstalleer deur die standaard op OS X) en jou PHP is saamgestel met die DTrace probes in staat gestel (--enable-dtrace) wat moet by verstek, is hierdie opdrag kan jou help om te ontfout PHP script met geen tyd:

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 gegewe die volgende alias is bygevoeg in jou rc lêers (bv. ~/.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); }"'

kan jy die spoor van jou script maklik om te onthou alias: trace-php.

Hier is meer gevorderde dtrace script, net stoor dit in dtruss-php.d, maak dit uitvoerbare (chmod +x dtruss-php.d) en hardloop:

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

^{Tuisblad: dtruss-lamp op GitHub}

Hier is eenvoudige gebruik:

1. Hardloop: sudo dtruss-php.d.
2. Op'n ander terminale hardloop: php -r "phpinfo();".

Om te toets, kan jy gaan na enige docroot met index.php en hardloop PHP ingeboude bediener deur:

php -S localhost:8080

Na wat jy kan toegang tot die webwerf by http://localhost:8080/ (of kies watter hawe is gerieflik vir jou).Van daar toegang tot'n paar bladsye om te sien die spoor uitset.

Let daarop:Dtrace is beskikbaar op OS X by verstek, op Linux jy waarskynlik nodig het dtrace4linux of gaan vir'n paar ander alternatiewe.

Sien: Met behulp van PHP en DTrace by php.net

---

SystemTap

Alternatiewelik kyk vir SystemTap opsporing deur die installering van SystemTap SDT ontwikkeling pakket (bv. yum install systemtap-sdt-devel).

Hier is'n voorbeeld script (all_probes.stp) vir die opsporing van al die kern PHP statiese sonde punte regdeur die duur van'n PHP script met 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));
}

Gebruik:

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

Sien: Met behulp van SystemTap met PHP DTrace Statiese Probes by php.net

Answer 27

1 vir print_r (). Gebruik dit om te stort uit die inhoud van 'n voorwerp of veranderlike. Om dit meer leesbaar te maak, doen dit met 'n pre tag sodat jy nie nodig het om bron te besigtig.

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

Ook var_dump ($ ding) - dit is baie nuttig om die tipe van subthings sien

Answer 28

Na gelang van die probleem wat ek graag 'n kombinasie van error_reporting (E_ALL) gemeng met eggo toetse (die gewraakte lyn vind / lêer die fout gebeur in initally;? Jy weet dit is nie altyd die lyn / lêer PHP vertel jy regs), IDE stut wat ooreenstem (om op te los "Parseerfout: syntax error, onverwagte $ einde" kwessies), en print_r (); uitgang; stortingsterreine (werklike programmeerders sien die bron; p).

Jy kan ook nie phpdebug (check source) met klop "memory_get_usage ();" en "memory_get_peak_usage ();" om die probleemgebiede te vind.

Answer 29

Die geïntegreerde debug gers waar jy die waardes van veranderlike verandering kan kyk as jy stap vir stap deur kode is regtig cool. Hulle het egter vereis sagteware ingestel is op die bediener en 'n sekere bedrag van opset op die kliënt. Beide van wat vereis periodiese onderhoud in 'n goeie werkende toestand te hou.

'n print_r is maklik om te skryf en is gewaarborg om te werk in 'n opstel van.

Answer 30

Gewoonlik vind ek 'n persoonlike log funksie het om te red op lêer, winkel debug inligting, en uiteindelik weer druk op 'n gemeenskaplike voet.

Jy kan ook ignoreer algemene uitsondering klas, sodat hierdie tipe van debugging is semi-outomatiese.