Cum pot obține mesaje de eroare utile în PHP? (Programare, Php, Depanare, Gestionarea Erorilor)

Candidasa a intrebat.

Destul de des încerc să execut un script PHP și primesc înapoi un ecran gol. Nici un mesaj de eroare; doar un ecran gol. Cauza ar fi putut fi o simplă eroare de sintaxă (paranteză greșită, punct și virgulă lipsă), sau un apel de funcție eșuat, sau cu totul altceva.

Este foarte dificil să ne dăm seama ce a mers prost. Am ajuns să comentez codul, să introduc declarații „echo” peste tot, etc. încercând să restrâng problema. Dar cu siguranță trebuie să existe o modalitate mai bună, nu?

Există o modalitate de a face ca PHP să producă un mesaj de eroare util, așa cum face Java?

Comentarii

  • coding.smashingmagazine.com/2011/11/30/11/30/… –  > Por Alex.
  • Vezi și stackoverflow.com/q/1475297/632951 –  > Por Pacerier.
  • @JuannStrauss, Asta e subestimare. Și când în cele din urmă vedeți erorile, se spune T_PAAMAYIM_NEKUDOTAYIM. Sau poate „trebuie să fie o instanță de integer, integer dat”. –  > Por Pacerier.
  • Tutorial pe această temă: code2real.blogspot.com/2015/06/… –  > Por Elevul.
44 răspunsuri
Darryl Hein

Pentru erorile de sintaxă, trebuie să activezi afișarea erorilor în php.ini. În mod implicit acestea sunt dezactivate deoarece nu doriți ca un „client” să vadă mesajele de eroare. Verificați această pagină din documentația PHP pentru informații despre cele 2 directive: error_reporting și display_errors. display_errors este probabil cea pe care doriți să o modificați. Dacă nu puteți modifica php.ini, puteți adăuga următoarele linii la un fișier .htaccess:

php_flag  display_errors        on
php_value error_reporting       2039

Este posibil să doriți să luați în considerare utilizarea valorii E_ALL (așa cum a menționat Gumbo) pentru versiunea dvs. de PHP pentru error_reporting pentru a obține toate erorile. Mai multe informații

Alte 3 articole: (1) Puteți verifica fișierul jurnal de erori, deoarece acesta va avea toate erorile (cu excepția cazului în care jurnalizarea a fost dezactivată). (2) Adăugarea următoarelor 2 linii vă va ajuta să depanați erorile care nu sunt erori de sintaxă:

error_reporting(-1);
ini_set('display_errors', 'On');

(3) O altă opțiune este să utilizați un editor care verifică dacă există erori atunci când tastați, cum ar fi PhpEd. PhpEd vine, de asemenea, cu un depanator care poate oferi informații mai detaliate. (Depanatorul PhpEd este foarte asemănător cu xdebug și se integrează direct în editor, astfel încât să folosiți 1 program pentru a face totul).

Cartman’s link este, de asemenea, foarte bun: http://www.ibm.com/developerworks/library/os-debug/

Comentarii

    27

  • 2039 este valoarea lui E_ERROR | E_WARNING | E_PARSE | E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_COMPILE_WARNING | E_USER_ERROR | E_USER_WARNING | E_USER_NOTICE. A se vedea docs.php.net/manual/it/errorfunc.constants.php –  > Por Gumbo.
  • Îmi place opțiunea de fișier .htaccess. Mă ajută să depanez într-o zonă care nu face parte din site-ul public. Mulțumesc mult pentru acest sfat! –  > Por jacekn.
  • Aș adăuga că înregistrarea erorilor în fișier (și căutarea lor acolo) este cea mai bună soluție. Nu vă bazați pe afișarea erorilor pe pagină – acestea o pot strica, puteți uita să activați raportarea erorilor pentru site-ul de producție și acest lucru vă va cauza probleme în viitor –  > Por Ivan Yarych.
Eljakim

Următoarele activează toate erorile:

ini_set('display_startup_errors', 1);
ini_set('display_errors', 1);
error_reporting(-1);

Consultați, de asemenea, următoarele linkuri

Comentarii

    29

  • Cel mai bine este să faceți aceste modificări la nivelul fișierului .ini. Activarea raportării erorilor din cadrul unui script este inutilă, deoarece nu va ajuta în cazul erorilor de sintaxă sau al altor erori fatale care opresc faza de compilare. Scriptul este omorât cu mult înainte de a începe să se execute și de a ajunge la suprascrierile de raportare. –  > Por Marc B.
  • Aveți dreptate, într-adevăr. Nu am observat că mutarea se face pe propriul server. –  > Por Eljakim.
  • Rulați phpinfo() pentru a găsi fișierul php.ini corect. Căutați Fișier de configurare încărcat linie. –  > Por borrible.
  • Dacă sunteți în căutarea unor erori care apar în timpul fazei de compilare, verificați jurnalele apache, care se află adesea la /var/log/apache2/error.log –  > Por csi.
  • Acest răspuns va eșua pe php7 atunci când este activată tastatura strictă, deoarece al doilea parametru din ini_set este un șir de caractere. –  > Por PeeHaa.
m4dm4x1337

Următorul cod ar trebui să afișeze toate erorile:

<?php

// ----------------------------------------------------------------------------------------------------
// - Display Errors
// ----------------------------------------------------------------------------------------------------
ini_set('display_errors', 'On');
ini_set('html_errors', 0);

// ----------------------------------------------------------------------------------------------------
// - Error Reporting
// ----------------------------------------------------------------------------------------------------
error_reporting(-1);

// ----------------------------------------------------------------------------------------------------
// - Shutdown Handler
// ----------------------------------------------------------------------------------------------------
function ShutdownHandler()
{
    if(@is_array($error = @error_get_last()))
    {
        return(@call_user_func_array('ErrorHandler', $error));
    };

    return(TRUE);
};

register_shutdown_function('ShutdownHandler');

// ----------------------------------------------------------------------------------------------------
// - Error Handler
// ----------------------------------------------------------------------------------------------------
function ErrorHandler($type, $message, $file, $line)
{
    $_ERRORS = Array(
        0x0001 => 'E_ERROR',
        0x0002 => 'E_WARNING',
        0x0004 => 'E_PARSE',
        0x0008 => 'E_NOTICE',
        0x0010 => 'E_CORE_ERROR',
        0x0020 => 'E_CORE_WARNING',
        0x0040 => 'E_COMPILE_ERROR',
        0x0080 => 'E_COMPILE_WARNING',
        0x0100 => 'E_USER_ERROR',
        0x0200 => 'E_USER_WARNING',
        0x0400 => 'E_USER_NOTICE',
        0x0800 => 'E_STRICT',
        0x1000 => 'E_RECOVERABLE_ERROR',
        0x2000 => 'E_DEPRECATED',
        0x4000 => 'E_USER_DEPRECATED'
    );

    if([email protected]_string($name = @array_search($type, @array_flip($_ERRORS))))
    {
        $name = 'E_UNKNOWN';
    };

    return(print(@sprintf("%s Error in file xBB%sxAB at line %d: %s
", $name, @basename($file), $line, $message)));
};

$old_error_handler = set_error_handler("ErrorHandler");

// other php code

?>

Singura modalitate de a genera o pagină goală cu acest cod este atunci când aveți o eroare în gestionarul de închidere. Am copiat și lipit acest lucru din propriul meu cms fără să-l testez, dar sunt sigur că funcționează.

Comentarii

  • Primesc o pagină goală cu acest cod. Ce vrei să spui prin „ai o eroare în shutdown handler” și ce ar trebui să fac pentru a rezolva problema? –  > Por Paolo M.
  • @PaoloM, El spune că este o eroare în funcția ShutdownHandler de mai sus. Practic, acesta este un hack de stopare în loc de gestionarea corectă a erorilor. –  > Por Pacerier.
  • Mulțumesc, a fost util, dar cum pot dezactiva E_NOTICE erorile în această funcție? –  > Por MajAfy.
  • Aceasta este soluția corectă, dar aveți grijă la discursul informațiilor atunci când apare eroarea… (preferați înregistrarea în jurnal în loc de ecou către utilizatori) – –  > Por Sam Jason Braddock.
  • Folosesc acest lucru atunci când Symfony nu poate prinde corect erorile fatale. –  > Por COil.
Tomalak

Puteți include următoarele linii în fișierul pe care doriți să îl depanați:

error_reporting(E_ALL);
ini_set('display_errors', '1');

Acest lucru înlocuiește setările implicite din php.ini, care fac doar ca PHP să raporteze erorile în jurnal.

Comentarii

  • Este adevărat. În acest caz, valorile trebuie setate direct în ini – pentru un mediu de dezvoltare pur și simplu, acest lucru poate fi oricum preferabil. –  > Por Tomalak.
James Anderson

Erorile și avertismentele apar de obicei în ....logsphp_error.log sau ....logsapache_error.log în funcție de setările php.ini.

De asemenea, erorile utile sunt deseori direcționate către browser, dar, deoarece nu sunt html valid, nu sunt afișate.

Așadar, "tail -f” fișierele de jurnal și, atunci când obțineți un ecran alb, utilizați opțiunile de meniu „view” -> „source” ale IEs pentru a vizualiza rezultatul brut.

Comentarii

  • Din păcate, și „Vizualizare sursă pagină” nu afișează nimic. –  > Por Matthew Scharley.
  • Erorile de analiză ar trebui să fie vizibile în jurnalul de erori al Apache, indiferent de setările pe care le aveți în altă parte. Dacă nu aveți control asupra serverului, atunci obținerea jurnalului de erori Apache ar putea fi dificilă, dar vă sugerez să discutați cu furnizorul dvs. și există modalități de a vă expune jurnalul de erori. În afară de asta, pot doar să vă sugerez ceea ce au făcut și alții – verificați-vă codul pentru erori de analiză pe serverul de dezvoltare local înainte de a-l implementa în producție. De asemenea, un IDE de validare, cum ar fi PDT de la Eclipse, ar putea fi de mare ajutor. –  > Por Guss.
  • Revenind la acest aspect, am avut recent o problemă de stack overflow care nu genera nicio eroare, nici măcar în jurnale și nu s-a manifestat ca atare până când nu am instalat xdebug în server. Gah. –  > Por Matthew Scharley.
  • Dacă nu puteți modifica php.ini, creați un fișier .htaccess cu php_flag display_errors 1 în el. –  > Por Tom.
Madara’s Ghost

Configurația PHP

2 intrări în php.ini dictează ieșirea erorilor:

  1. display_errors
  2. error_reporting

În producție, display_errors este de obicei setat la Off (Ceea ce este un lucru bun, deoarece afișarea erorilor pe site-urile de producție nu este, în general, de dorit!).

Cu toate acestea, în dezvoltare, ar trebui să fie setată la On, pentru ca erorile să fie afișate. Verificați!

error_reporting (începând cu PHP 5.3) este setat în mod implicit la E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED (ceea ce înseamnă că totul este afișat cu excepția notificărilor, a standardelor stricte și a notificărilor de depreciere). În caz de îndoială, setați-o la E_ALL pentru a afișa toate erorile. Verificați!

Whoa whoa whoa! Fără verificare! Nu-mi pot schimba php.ini!

Ce păcat. De obicei, gazdele partajate nu permit modificarea fișierului lor php.ini, și astfel, această opțiune este din păcate indisponibilă. Dar nu vă temeți! Avem alte opțiuni!

Configurație în timp de execuție

În scriptul dorit, putem modifica intrările php.ini în runtime! Adică, se va executa atunci când scriptul va rula! Drăguț!

<strong><a href="http://il1.php.net/manual/en/function.error-reporting.php" rel="noreferrer">error_reporting</a></strong>(E_ALL);
<strong><a href="http://php.net/ini_set" rel="noreferrer">ini_set</a></strong>("display_errors", "On");

Aceste două linii vor avea același efect ca și modificarea intrărilor php.ini de mai sus! Minunat!

Tot primesc o pagină goală/500 de eroare!

Asta înseamnă că scriptul nici măcar nu a rulat! Asta se întâmplă de obicei când ai o eroare de sintaxă!

În cazul erorilor de sintaxă, scriptul nici măcar nu ajunge la execuție. Nu reușește la momentul compilării, ceea ce înseamnă că va folosi valorile din php.ini, care, dacă nu le modificaseți, s-ar putea să nu permită afișarea erorilor.

Jurnalele de erori

În plus, PHP înregistrează în mod implicit erorile. În cazul găzduirii partajate, acesta poate fi într-un dosar dedicat sau în același dosar cu scriptul incriminat.

Dacă aveți acces la fișierul php.ini, îl puteți găsi în secțiunea error_log intrare.

Comentarii

  • Pentru configurația de execuție, este posibil să puteți pune acele linii într-un fișier separat & include fișierul php cu eroarea. –  > Por JustinCB.
FDisk

Întotdeauna folosesc această sintaxă în partea de sus a scriptului php.

ini_set('error_reporting', E_ALL);
ini_set('display_errors', 'On');  //On or Off

Comentarii

  • Îmi pare rău, dar -1 pentru că nu am citit celelalte răspunsuri deja postate. De acest lucru se ocupă în .htaccess, așa cum am menționat deja de mai multe ori. –  > Por Matthew Scharley.
  • De obicei, „găzduirea gratuită” ignoră .htaccess.  > Por FDisk.
gnarf

Există o extensie foarte utilă numită „xdebug” care va face ca rapoartele dumneavoastră să fie mult mai frumoase.

Comentarii

  • Într-adevăr, aceasta este o foarte util instrument de depanare – face ca mesajele de eroare să fie mult mai abundente, cu urme complete de stivă și descărcări de variabile și tot ce trebuie. –  > Por hbw.
  • Da. Și apoi folosiți ceva de genul pluginului VimDebugger pentru a parcurge codul și a afla unde nu merge bine. –  > Por Sander Marechal.
  • NetBeans cu xdebug aici. Este atât de grozav. Sunt nou în PHP (de obicei ASP.NET) și am emis declarații echo înainte. –  > Por Some Canuck.
hakre

Pentru o depanare rapidă și practică, în mod normal, sugerez aici pe SO:

error_reporting(~0); ini_set('display_errors', 1);

să fie pus la începutul scriptului care se află sub semnul rezolvării problemelor. Acest lucru nu este perfect, varianta perfectă este să activați și asta în php.ini și că înregistrați erorile în PHP pentru a prinde erorile de sintaxă și de pornire.

Setările prezentate aici afișează toate erorile, notificările și avertismentele, inclusiv cele stricte, indiferent de versiunea PHP.

Următoarele lucruri de luat în considerare:

  • Instalați Xdebug și activați remote-debugging cu IDE-ul dumneavoastră.

Vedeți și:

Eduardo Oliveira

Este posibil să se înregistreze un cârlig pentru a face vizibilă ultima eroare sau avertisment.

function shutdown(){
  var_dump(error_get_last());
}

register_shutdown_function('shutdown');

Adăugarea acestui cod la începutul index.php vă va ajuta să depanați problemele.

Comentarii

  • Acest lucru este aur pur pentru cei care au rămas blocați în webhosts care nu arată nici o eroare, dar permite accesul zero log –  > Por Rafael Mena Barreto.
Rich Bradshaw

Dacă sunteți super cool, ați putea încerca:

$test_server = $_SERVER['SERVER_NAME'] == "127.0.0.1" || $_SERVER['SERVER_NAME'] == "localhost" || substr($_SERVER['SERVER_NAME'],0,3) == "192";

ini_set('display_errors',$test_server);
error_reporting(E_ALL|E_STRICT);

Acest lucru va afișa erorile doar atunci când rulezi local. De asemenea, vă oferă variabila test_server pentru a o utiliza în alte locuri, dacă este cazul.

Orice erori care se întâmplă înainte ca scriptul să ruleze nu vor fi prinse, dar pentru 99% din erorile pe care le fac, asta nu este o problemă.

Comentarii

  • Dacă faceți diferența între mediul local și cel de producție, ar trebui pur și simplu să activați sau să dezactivați erorile la nivel global (în php.ini) și nu în codul care poate fi și cod de producție. Dacă aveți nevoie să depanați un site web de producție în mediul de producție și doriți doar să puteți vizualiza erorile, utilizați $_SERVER['REMOTE_HOST'] pentru a verifica dacă clientul este, ei bine, dumneavoastră. –  > Por Jaap Haagmans.
Kld

În partea de sus a paginii alegeți un parametru

error_reporting(E_ERROR | E_WARNING | E_PARSE);

Sherif

Aceasta este o problemă de configurare încărcată vs. configurare în timp de execuție

Este important să recunoaștem că o eroare de sintaxă sau o eroare de parse se întâmplă în timpul procesului de compilare sau parsing ceea ce înseamnă că PHP se va retrage înainte de a avea ocazia să execute ceva din codul dumneavoastră. Așadar, dacă modificați codul de execuție PHP display_errors în timpul execuției (acest lucru include orice, de la utilizarea ini_set în codul dvs. până la utilizarea fișierului .htaccess, care este un fișier de configurare în timpul execuției), atunci doar opțiunea implicită setările de configurare încărcate sunt în joc.

Cum să evitați întotdeauna WSOD în dezvoltare

Pentru a evita un WSOD, doriți să vă asigurați că fișierul de configurare încărcat are display_errors on și error_reporting setat la -1 (acesta este echivalentul E_ALL, deoarece se asigură că toți biții sunt activați, indiferent de versiunea de PHP pe care o executați.). Nu codificați în hardcode valoarea constantă a lui E_ALL, deoarece această valoare se poate schimba între diferitele versiuni ale PHP.

Configurația încărcată este fie configurația dvs. php.ini fie fișierul apache.conf sau httpd.conf sau fișierul virtualhost. Aceste fișiere sunt citite doar o singură dată în timpul etapei de pornire (când porniți pentru prima dată apache httpd sau php-fpm, de exemplu) și sunt anulate doar de modificările de configurare în timpul execuției. Asigurați-vă că display_errors = 1 și error_reporting = -1 în fișierul de configurare încărcat vă asigură că nu veți vedea niciodată un fișier WSOD indiferent de o eroare de sintaxă sau de parse care apare înainte de o modificare în timpul execuției, cum ar fi ini_set('display_errors', 1); sau error_reporting(E_ALL); poate avea loc.

Cum să găsiți fișierele de configurare încărcate (php.ini)

Pentru a localiza fișierul (fișierele) de configurare încărcat(e), trebuie doar să creați un nou fișier PHP care să conțină doar următorul cod…

<?php
phpinfo();

Apoi îndreptați-vă browserul acolo și căutați Fișier de configurare încărcat și Fișiere .ini suplimentare analizate, care se află de obicei în partea de sus a fișierului phpinfo() și vor include calea absolută către toate fișierele de configurare încărcate.

Dacă vedeți (none) în loc de fișier, înseamnă că nu aveți un fișier php.ini în Calea fișierului de configurare (php.ini). Deci, puteți descărcați fișierul php.ini inclus în PHP de aici și copiați-l în calea fișierului de configurare ca php.ini, apoi asigurați-vă că utilizatorul php are suficiente permisiuni pentru a citi din acel fișier. Va trebui să reporniți httpd sau php-fpm pentru a-l încărca. Nu uitați, acesta este dezvoltare php.ini de dezvoltare care vine la pachet cu sursa PHP. Așa că vă rugăm să nu îl folosiți în producție!


Nu faceți acest lucru în producție

Acesta este într-adevăr cel mai bun mod de a evita un WSOD în dezvoltare. Oricine vă sugerează să puneți ini_set('display_errors', 1); sau error_reporting(E_ALL); în partea de sus a scriptului PHP sau să folosiți .htaccess, așa cum ați făcut aici, nu vă va ajuta să evitați un WSOD atunci când apare o eroare de sintaxă sau de parse (ca în cazul dvs. aici) dacă fișierul de configurare încărcat are display_errors dezactivat.

Mulți oameni (și instalații de stoc de PHP) vor folosi un fișier production-ini care are display_errors dezactivat în mod implicit, ceea ce duce de obicei la aceeași frustrare pe care ați experimentat-o aici. Deoarece PHP îl are deja dezactivat atunci când pornește, apoi întâlnește o eroare de sintaxă sau de parse și se blochează fără a avea nimic de ieșit. Vă așteptați ca aplicația dvs. ini_set('display_errors',1); din partea de sus a scriptului PHP ar fi trebuit să evite acest lucru, dar nu va conta dacă PHP nu vă poate analiza codul, deoarece acesta nu va fi ajuns niciodată în timpul de execuție.

Ram

Pentru a persista acest lucru și a-l face confortale, puteți edita fișierul php.ini. Acesta este de obicei stocat în /etc/php.ini sau /etc/php/php.ini, dar mai local php.ini‘s îl pot suprascrie, în funcție de instrucțiunile de configurare ale furnizorului dumneavoastră de găzduire. Verificați o phpinfo() pentru Loaded Configuration File în partea de sus, pentru a fi sigur care dintre ele este încărcat ultimul.

Căutați display_errors în acel fișier. Ar trebui să existe doar 3 instanțe, dintre care 2 sunt comentate.

Schimbați linia necomentată în:

display_errors = stdout

Abuzer Firdousi
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

Eli

Nu știu dacă vă va ajuta, dar iată o bucată din fișierul meu standard de configurare pentru proiectele php. Am tendința de a nu depinde prea mult de configurile apache chiar și pe propriul server.

Nu am niciodată problema cu dispariția erorilor, așa că poate ceva de aici îți va da o idee.

Editat pentru a arăta APPLICATON_LIVE

/*
APPLICATION_LIVE will be used in process to tell if we are in a development or production environment.  It's generally set as early as possible (often the first code to run), before any config, url routing, etc.
*/

if ( preg_match( "%^(www.)?livedomain.com$%", $_SERVER["HTTP_HOST"]) ) {
    define('APPLICATION_LIVE', true);
} elseif ( preg_match( "%^(www.)?devdomain.net$%", $_SERVER["HTTP_HOST"]) ) {
    define('APPLICATION_LIVE', false);
} else {
    die("INVALID HOST REQUEST (".$_SERVER["HTTP_HOST"].")");
    // Log or take other appropriate action.
}


/*
--------------------------------------------------------------------
DEFAULT ERROR HANDLING
--------------------------------------------------------------------
Default error logging.  Some of these may be changed later based on APPLICATION_LIVE.
*/
error_reporting(E_ALL & ~E_STRICT);
ini_set ( "display_errors", "0");
ini_set ( "display_startup_errors", "0");
ini_set ( "log_errors", 1);
ini_set ( "log_errors_max_len", 0);
ini_set ( "error_log", APPLICATION_ROOT."logs/php_error_log.txt");
ini_set ( "display_errors", "0");
ini_set ( "display_startup_errors", "0");

if ( ! APPLICATION_LIVE ) {
    // A few changes to error handling for development.
    // We will want errors to be visible during development.
    ini_set ( "display_errors", "1");
    ini_set ( "display_startup_errors", "1");
    ini_set ( "html_errors", "1");
    ini_set ( "docref_root", "http://www.php.net/");
    ini_set ( "error_prepend_string", "<div style='color:red; font-family:verdana; border:1px solid red; padding:5px;'>");
    ini_set ( "error_append_string", "</div>");
}

Comentarii

  • @Eli, Acest lucru are totuși o suprataxă de execuție, pentru fiecare cerere de pagină. –  > Por Pacerier.
  • up 1 pentru conceptul care trece cu vederea setările de depanare indiferent de modul în care este configurat serverul, bun în timp ce se implementează sau se menține (în curs de dezvoltare) –  > Por justnajm.
Yan.Zero
error_reporting(E_ALL | E_STRICT);
ini_set('display_errors', 1);
ini_set('html_errors', 1);

În plus, puteți obține informații mai detaliate cu xdebug.

Comentarii

  • Xdebug poate fi activat din php.ini –  > Por jewelhuq.
Ondřej Šotek

Vă recomand Nette Tracy pentru o mai bună vizualizare a erorilor și excepțiilor în PHP:

Comentarii

  • Tracy are grijă de setarea corectă a tuturor opțiunilor de afișare a erorilor și de raportare a erorilor pentru a oferi o ieșire în astfel de situații, așa cum este descrisă în postul original… Deci, acest instrument este deosebit de util pentru adresarea întrebătorului „Poate cineva să recomande sfaturi, instrumente și tehnici bune de depanare PHP?”. –  > Por Jan Drábek.
Ólafur Waage
error_reporting(E_ALL | E_STRICT);

Și activați afișarea erorilor în php.ini

soulmerge

Puteți înregistra propriul dvs. gestionarul de erori în PHP. Aruncând toate erorile într-un fișier ar putea să vă ajute în aceste cazuri obscure, de exemplu. Rețineți că funcția dvs. va fi apelată, indiferent de valoarea curentă error_reporting este setat. Exemplu foarte simplu:

function dump_error_to_file($errno, $errstr) {
    file_put_contents('/tmp/php-errors', date('Y-m-d H:i:s - ') . $errstr, FILE_APPEND);
}
set_error_handler('dump_error_to_file');

Sinteza codului

Cele două linii cheie de care aveți nevoie pentru a obține erori utile din PHP sunt:

ini_set('display_errors',1);
 error_reporting(E_ALL);

După cum au subliniat și alți colaboratori, acestea sunt dezactivate în mod implicit din motive de securitate. Ca un sfat util – atunci când vă configurați site-ul, este util să faceți un comutator pentru diferitele medii, astfel încât aceste erori să fie activate în mod implicit în mediile locale și de dezvoltare. Acest lucru poate fi realizat cu următorul cod (de preferat în fișierul index.php sau în fișierul de configurare, astfel încât acesta să fie activ de la început):

switch($_SERVER['SERVER_NAME'])
{
    // local
    case 'yourdomain.dev':
    // dev
    case 'dev.yourdomain.com':
        ini_set('display_errors',1);
        error_reporting(E_ALL);
    break;
    //live
    case 'yourdomain.com':
        //...
    break;
}

Rich Bradshaw

FirePHP poate fi, de asemenea, util.

Comentarii

  • Trebuie să remarc că FirePHP este un proiect mort de când FireBug a fost integrat în Consola Firefox. ChromePHP este un fel de succesor acolo, dar nu în întregime. –  > Por Machavity.
user577803

deschideți php.ini, asigurați-vă că este setat la:

display_errors = On

restart your server.

user1681048

De asemenea, poate doriți să încercați PHPStorm ca editor de cod. Acesta va găsi multe erori PHP și alte erori de sintaxă chiar în timp ce tastați în editor.

Ashutosh Jha

dacă sunteți un utilizator ubuntu, atunci accesați terminalul și rulați această comandă

sudo tail -50f /var/log/apache2/error.log

unde se vor afișa cele 50 de erori recente. Există un fișier de erori error.log pentru apache2 care înregistrează toate erorile.

Daniel Sorichetti

Pentru a activa raportarea completă a erorilor, adăugați acest lucru la scriptul dvs:

error_reporting(E_ALL);

Acest lucru face ca și avertismentele minime să apară. Și, pentru orice eventualitate:

ini_set('display_errors', '1');

Va forța afișarea erorilor. Acest lucru ar trebui să fie dezactivat în serverele de producție, dar nu și atunci când dezvoltați.

Comentarii

  • Ca și în cazul răspunsului lui Tomalak, acest lucru nu funcționează pentru erorile de sintaxă. –  > Por Darryl Hein.
user3176739

„ERORILE” sunt cele mai utile lucruri pentru ca dezvoltatorii să-și cunoască greșelile și să le rezolve pentru ca sistemul să funcționeze perfect.

PHP oferă unele dintre cele mai bune modalități de a cunoaște dezvoltatorii de ce și unde bucata lor de cod primește erori, astfel încât, cunoscând aceste erori, dezvoltatorii își pot îmbunătăți codul în multe feluri.

Cele mai bune moduri de a scrie următoarele două linii în partea de sus a scriptului pentru a obține toate mesajele de eroare:

error_reporting(E_ALL);
ini_set("display_errors", 1);

O altă modalitate de a utiliza instrumente de depanare precum xdebug în IDE-ul dumneavoastră.

Ayman Hourieh

Puteți activa raportarea completă a erorilor (inclusiv notificări și mesaje stricte). Unii oameni consideră că acest lucru este prea verbos, dar merită încercat. Setați error_reporting la E_ALL | E_STRICT în fișierul php.ini.

error_reporting = E_ALL | E_STRICT

E_STRICT vă va notifica cu privire la funcțiile depreciate și vă va oferi recomandări despre cele mai bune metode de a face anumite sarcini.

Dacă nu doriți notificări, dar considerați utile alte tipuri de mesaje, încercați să excludeți notificările:

error_reporting = (E_ALL | E_STRICT) & ~E_NOTICE

De asemenea, asigurați-vă că display_errors este activată în php.ini. Dacă versiunea dvs. de PHP este mai veche de 5.2.4, setați-o pe On:

display_errors = "On"

Dacă versiunea dvs. este 5.2.4 sau mai nouă, utilizați:

display_errors = "stderr"

jmucchiello

În afară de error_reporting și de setarea ini display_errors, puteți obține erori SYNTAX din fișierele jurnal ale serverului web. Când dezvolt PHP, încarc în editor jurnalele serverului web al sistemului meu de dezvoltare. Ori de câte ori testez o pagină și obțin un ecran alb, fișierul jurnal se învecheste și editorul meu mă întreabă dacă doresc să îl reîncarc. Când o fac, sar la partea de jos și apare eroarea de sintaxă. De exemplu:

[Sun Apr 19 19:09:11 2009] [error] [client 127.0.0.1] PHP Parse error:  syntax error, unexpected T_ENCAPSED_AND_WHITESPACE, expecting T_STRING or T_VARIABLE or T_NUM_STRING in D:\webroot\test\test.php on line 9

AVKurov

Pentru cei care folosesc nginx și au un ecran alb chiar și pentru fișierul cu <?php echo 123;. În cazul meu nu am avut această opțiune necesară pentru PHP în fișierul de configurare nginx:

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

Această opțiune nu era în fișierul fastcgi_params, deci PHP nu funcționa și nu existau erori în jurnale.

Comentarii

  • Am avut aceeași problemă și eu și se datorează faptului că din fișierul de configurare implicit Nginx lipsește această linie . –  > Por Salem.
Lewis LaCook

Încercați să setați nivelul de raportare a erorilor în fișierele php actuale. Sau, așa cum au sugerat și alții, verificați setările serverului – ar putea fi ceva în php.ini sau o restricție în ceea ce privește gazda dumneavoastră. Nu vă bazați doar pe .htaccess. De asemenea, atunci când depanați probleme, imprimați toate variabilele pe care le considerați suspecte.

Comentarii

  • Nu am acces la php.ini. Iar când apar aceste erori, este o eroare de sintaxă, așa că print_r nu ajută. –  > Por Matthew Scharley.
  • Dacă nu aveți acces la php.ini, nu ar trebui să dezvoltați pe acel server. Folosiți un hosting partajat pentru producție, iar pentru dezvoltare mașina locală. –  > Por carl.
  • Și când apar erori în producție? Cu toții am vrea să credem că nu se întâmplă, dar se întâmplă. –  > Por Matthew Scharley.
  • Dacă aveți o eroare de parse în producție, ceva nu este în regulă cu modelul de dezvoltare. 🙂 Dacă aveți o eroare diferită, oricum nu doriți ca acea eroare să fie afișată utilizatorului + ar trebui să aveți un mecanism adecvat de tratare a erorilor. –  > Por carl.
  • V-aș sugera să descărcați apache XAMP sau WAMPserver și să configurați un mediu de dezvoltare pe PC. Dacă mediul stației de lucru este la fel de constrâns ca și mediul serverului, ați putea folosi portableapps.com/apps/development/xampp care nu necesită drepturi de administrator sau privilegii speciale pentru a fi instalat și rulat. –  > Por James Anderson.
prea mult php

Sunteți sigur că PHP preia de fapt ‘display_errors‘ din .htaccess? Verificați ieșirea din phpinfo() pentru a fi sigur.

De asemenea, ar trebui să vă asigurați că nu ați folosit ‘@‘, care ar putea reduce la tăcere erorile dacă ați folosit „@include …” sau „@some_function(…)”, undeva în stack trace.

Comentarii

  • Așa este. display_errors este dezactivată în configurația la nivelul întregului server, dar afișează erori mai puțin importante, cum ar fi neconcordanța numărului de parametri, etc. Nu am folosit @ deloc în acest proiect și, în general, tind să îl evit tocmai din acest motiv. –  > Por Matthew Scharley.
  • Ar trebui să verificați, de asemenea, dacă display_errors nu este modificat de un script PHP undeva. –  > Por prea mult php.
  • Am construit acest cadru de la zero, așa că nu, nu este (dacă nu cumva ceva din nucleu îl schimbă din anumite motive…) –  > Por Matthew Scharley.
  • Dacă apelați o funcție nedefinită (pentru a genera o eroare fatală), vedeți acel mesaj de eroare? –  > Por prea mult php.
Phil

În plus față de toate răspunsurile minunate de aici, aș dori să fac o mențiune specială pentru bibliotecile MySQLi și PDO.

Pentru a…

  1. Să vedeți întotdeauna erorile legate de baza de date și
  2. Evitați să verificați tipurile de returnare pentru metode pentru a vedea dacă ceva nu a mers bine

Cea mai bună opțiune este să configurați bibliotecile pentru a să arunce excepții.

MySQLi

Adăugați acest lucru în partea de sus a scriptului dvs.

mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);

Aceasta este cel mai bine plasată înainte de a utiliza new mysqli() sau mysqli_connect().

PDO

Setați PDO::ATTR_ERRMODE la PDO::ERRMODE_EXCEPTION pe instanța de conexiune. Puteți face acest lucru fie în constructorul

$pdo = new PDO('driver:host=localhost;...', 'username', 'password', [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
]);

fie după creare

$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

mario

Acest răspuns vă este adus de către departamentul departamentului de redundanță.

  1. ini_set() / php.ini / .htaccess / .user.ini

    Setările display_errors și error_reporting au fost acoperite suficient de mult acum. Dar doar pentru a recapitula când să folosiți care opțiune:

    • ini_set() și error_reporting() se aplică numai pentru erori de execuție.
    • php.ini ar trebui să fie editate în primul rând pentru configurațiile de dezvoltare. (Serverul web și versiunea CLI au adesea php.ini-uri diferite)
    • .htaccess stegulețele funcționează doar pentru configurații datate (Găsește un nou hoster! Serverele bine administrate sunt mai ieftine.)
    • .user.ini sunt php.ini-uri parțiale pentru configurații moderne (FCGI/FPM)

    Și ca alternativă rudimentară pentru erori de execuție puteți folosi adesea:

    set_error_handler("var_dump");   // ignores error_reporting and `@` suppression
    
  2. error_get_last()

    Poate fi folosit pentru a prelua ultima notificare/aviz/error din timpul execuției, atunci când error_display este dezactivat.

  3. $php_errormsg

    Este o variabilă superlocală, care conține, de asemenea, ultimul mesaj PHP în timpul execuției.

  4. isset() begone!

    Știu că acest lucru îi va nemulțumi pe mulți oameni, dar isset și empty ar trebui să nu fi folosit de către noii veniți. Puteți adăuga suprimarea anunțului după ați verificat dacă codul dvs. funcționează. Dar niciodată înainte.

    Multe dintre întrebările de genul „ceva nu funcționează” pe care le primim în ultima vreme sunt rezultatul unor greșeli de scriere de genul: „Ceva nu funcționează”:

    if(isset($_POST['sumbit']))
    #                  ↑↑
    

    Nu veți primi nicio notificare utilă dacă codul dvs. este presărat cu isset/empty/array_keys_exists. Uneori este mai bine să folosiți @, astfel încât notificările și avertismentele să ajungă cel puțin în jurnale.

  5. assert_options(ASSERT_ACTIVE|ASSERT_WARNING);

    Pentru a obține avertismente pentru assert() secțiuni. (Destul de neobișnuit, dar codul mai competent ar putea conține unele).

    PHP7 necesită zend.assertions=1 în php.ini, de asemenea.

  6. declare(strict_types=1);

    Îndoirea PHP într-un limbaj strict tipizat nu va rezolva o mulțime de erori de logică, dar este cu siguranță o opțiune în scopuri de depanare.

  7. PDO / MySQLi

    Și @Phil a menționat deja opțiunile de raportare a erorilor PDO/MySQLi. Opțiuni similare există, desigur, pentru alte API-uri de baze de date.

  8. json_last_error() + json_last_error_msg

    Pentru analizarea JSON.

  9. preg_last_error()

    Pentru regexen.

  10. CURLOPT_VERBOSE

    Pentru a depana cererile curl, aveți nevoie de CURLOPT_VERBOSE cel puțin.

  11. shell/exec()

    De asemenea, execuția comenzilor shell nu va produce erori de una singură. Aveți întotdeauna nevoie de 2>&1 și să aruncați o privire la $errno.

Yogi Ghorecha

Gestionarea erorilor în PHP

Uneori, aplicația dvs. nu se va executa așa cum ar trebui, rezultând o eroare. Există o serie de motive care pot cauza erori, de exemplu:

Este posibil ca serverul Web să nu mai aibă spațiu pe discUn utilizator ar fi putut introduce o valoare invalidă într-un câmp de formularFilele sau înregistrările din baza de date pe care încercați să le accesați ar putea să nu existeAplicația ar putea să nu aibă permisiunea de a scrie într-un fișier de pe discServiciul pe care aplicația trebuie să-l acceseze ar putea fi temporar indisponibilAceste tipuri de erori sunt cunoscute ca erori de execuție, deoarece apar în momentul în care scriptul este executat. Ele sunt distincte de erorile de sintaxă care trebuie corectate înainte ca scriptul să fie executat.

O aplicație profesională trebuie să aibă capacitățile necesare pentru a gestiona cu grație astfel de erori de execuție. De obicei, acest lucru înseamnă informarea mai clară și mai precisă a utilizatorului cu privire la problemă.

Înțelegerea nivelurilor de eroare

De obicei, atunci când există o problemă care împiedică un script să ruleze corect, motorul PHP declanșează o eroare. Fiecare eroare este reprezentată de o valoare întreagă și de o constantă asociată. Tabelul următor enumeră câteva dintre nivelurile de eroare comune:

Motorul PHP declanșează o eroare ori de câte ori întâlnește o problemă cu scriptul dumneavoastră, dar puteți, de asemenea, să declanșați dumneavoastră înșivă erori pentru a genera mesaje de eroare mai ușor de utilizat. În acest fel, vă puteți face aplicația mai sofisticată. Următoarea secțiune descrie câteva dintre metodele comune utilizate pentru gestionarea erorilor în PHP:

Gestionarea de bază a erorilor utilizând funcția die()

<?php // Try to open a non-existent file
     $file = fopen("sample.txt", "r");
?>

În cazul în care fișierul nu există, este posibil să primiți o eroare ca aceasta:Avertizare: fopen(sample.txt) [function.fopen]: nu a reușit să deschidă fluxul: No such file or directory in C:wampwwwprojecttest.php on line 2

Dacă urmăm câțiva pași simpli, putem împiedica utilizatorii să primească un astfel de mesaj de eroare:

<?php
if(file_exists("sample.txt")){
    $file = fopen("sample.txt", "r");
} else{
    die("Error: The file you are trying to access doesn't exist.");
}
?>

Acum, dacă rulați scriptul de mai sus, veți primi un mesaj de eroare ca acesta: Eroare: Fișierul pe care încercați să îl accesați nu există.

După cum puteți vedea, prin implementarea unei simple verificări simple dacă fișierul există sau nu înainte de a încerca să-l acceseze, putem genera un mesaj de eroare care este mai semnificativ pentru utilizator.

Funcția die() utilizată mai sus afișează pur și simplu mesajul de eroare personalizat și termină scriptul curent dacă fișierul „sample.txt” nu este găsit.

Crearea unui gestionar de erori personalizat

Puteți crea propria funcție de gestionare a erorilor pentru a trata eroarea de execuție generată de motorul PHP. Gestionarul de erori personalizat vă oferă o mai mare flexibilitate și un control mai bun asupra erorilor, poate inspecta eroarea și decide ce să facă cu ea, poate afișa un mesaj utilizatorului, poate înregistra eroarea într-un fișier sau într-o bază de date sau o poate trimite prin e-mail, poate încerca să rezolve problema și să continue, poate ieși din execuția scriptului sau poate ignora eroarea cu totul.

Funcția personalizată de gestionare a erorilor trebuie să fie capabilă să gestioneze cel puțin doi parametri (errno și errstr), însă poate accepta opțional încă trei parametri (errfile, errline și errcontext), după cum se descrie mai jos:

Iată un exemplu de funcție simplă de tratare a erorilor personalizată. Această funcție de gestionare, customError(), este declanșată ori de câte ori apare o eroare, indiferent cât de banală ar fi. Apoi transmite detaliile erorii către browser și oprește execuția scriptului.

<?php
// Error handler function
function customError($errno, $errstr){
    echo "<b>Error:</b> [$errno] $errstr";
}
?>

Trebuie să spuneți PHP-ului să utilizeze funcția dvs. personalizată de gestionare a erorilor – trebuie doar să apelați funcția încorporată set_error_handler(), trecând numele funcției.

<?php
// Error handler function
function customError($errno, $errstr){
    echo "<b>Error:</b> [$errno] $errstr";
}

// Set error handler
set_error_handler("customError");

// Trigger error
echo($test);
?>

Înregistrarea erorilor

Înregistrați mesajele de eroare într-un fișier text

Puteți, de asemenea, să înregistrați detaliile erorii în fișierul jurnal, astfel:

<?php
function calcDivision($dividend, $divisor){
    if($divisor == 0){
        trigger_error("calcDivision(): The divisor cannot be zero", E_USER_WARNING);
        return false;
    } else{
        return($dividend / $divisor);
    }
}
function customError($errno, $errstr, $errfile, $errline, $errcontext){
    $message = date("Y-m-d H:i:s - ");
    $message .= "Error: [" . $errno ."], " . "$errstr in $errfile on line $errline, ";
    $message .= "Variables:" . print_r($errcontext, true) . "r
";

    error_log($message, 3, "logs/app_errors.log");
    die("There was a problem, please try again.");
}
set_error_handler("customError");
echo calcDivision(10, 0);
echo "This will never be printed.";
?>

Declanșarea unei erori

Deși motorul PHP declanșează o eroare ori de câte ori întâlnește o problemă cu scriptul dumneavoastră, totuși, puteți declanșa și dumneavoastră erori. Acest lucru vă poate ajuta să vă faceți aplicația mai robustă, deoarece poate semnala eventualele probleme înainte ca acestea să se transforme în erori grave.

Pentru a declanșa o eroare din cadrul scriptului dumneavoastră, apelați funcția trigger_error(), trecând mesajul de eroare pe care doriți să îl generați:

trigger_error("There was a problem.");

Luați în considerare următoarea funcție care calculează împărțirea a două numere.

<?php
function calcDivision($dividend, $divisor){
    return($dividend / $divisor);
}

// Calling the function
echo calcDivision(10, 0);
?>

Dacă se trece o valoare de zero (0) ca parametru $divisor, eroarea generată de motorul PHP va arăta cam așa: Avertizare: Division by zero in C:wampwwwproiecttest.php on line 3

Acest mesaj nu pare foarte informativ. Luați în considerare următorul exemplu care utilizează funcția trigger_error() pentru a genera eroarea.

<?php
function calcDivision($dividend, $divisor){
    if($divisor == 0){
        trigger_error("The divisor cannot be zero", E_USER_WARNING);
        return false;
    } else{
        return($dividend / $divisor);
    }
}

// Calling the function
echo calcDivision(10, 0);
?>

Acum, scriptul generează acest mesaj de eroare: Avertizare: Divizorul nu poate fi zero în C:wampwwwproiecterror.php pe linia 4

După cum puteți vedea, mesajul de eroare generat de cel de-al doilea exemplu explică mai clar problema în comparație cu cel precedent.

Denegen

Unele aplicații se ocupă singure de aceste instrucțiuni, apelând ceva de genul următor:

error_reporting(E_ALL & ~E_DEPRECATED); or error_reporting(0);

Și, astfel, suprascriind setările .htaccess.

Quamis

utilizând @inexistent_function_call(); în codul dvs. va face ca intepreterul să moară în liniște și să întrerupă analizarea scriptului. Ar trebui să verificați dacă există funcții invalide și să încercați să nu folosiți operatorul de suprimare a erorilor (@ char )

anarcat

Am văzut, de asemenea, astfel de erori atunci când fastcgi_params sau fastcgi.conf nu este inclus în mod corespunzător în configurația serverului. Așa că soluția pentru mine a fost o prostie:


include /etc/nginx/fastcgi_params;

Mi-a luat un oră pentru a afla asta…

Aamnah

Puteți, de asemenea, să rulați fișierul în Terminal (linie de comandă) astfel: php -f filename.php.

Acest lucru rulează codul dvs. și vă oferă aceeași ieșire în cazul în care apar erori pe care le-ați vedea în fișierul error.log. Se menționează eroarea și numărul liniei.

kris

Activarea raportării erorilor este soluția corectă, însă nu pare să aibă efect în programul care o activează, ci doar în programele incluse ulterior.

Astfel, eu creez întotdeauna un fișier/program (pe care de obicei îl numesc „genwrap.php”) care are în esență același cod ca și soluția populară de aici (adică activează raportarea erorilor) și tot atunci include și pagina pe care vreau de fapt să o apelez.

Există 2 pași pentru a implementa această depanare;

Unul – creați genwrap.php și puneți acest cod în el:

<?php
error_reporting(-1);
ini_set('display_errors', 'On');

include($_REQUEST['page']);
?>

Doi – schimbați link-ul către programul/pagina pe care doriți să o depanați pentru a trece prin genwrap.php,

De exemplu: schimbați:

$.ajax('dir/pgm.php?param=val').done(function(data) { /* ... */

în

$.ajax('dir/genwrap.php?page=pgm.php&param=val').done(function(data) { /* ... */

Vladimir Ramik

În plus față de foarte multe răspunsuri excelente de mai sus, ați putea implementa următoarele două funcții în proiectele dumneavoastră. Acestea vor prinde fiecare eroare nesintaxică înainte de ieșirea aplicației/scriptului. în interiorul funcțiilor puteți face un backtrace și să înregistrați sau să redați publicului un mesaj plăcut „Site is under maintenance”.

Erori fatale:

register_shutdown_function

http://php.net/manual/en/function.register-shutdown-function.php

Erori:

set_error_handler

http://php.net/manual/en/function.set-error-handler.php

Backtracing:

debug_backtrace

http://php.net/manual/en/function.debug-backtrace.php

Manjeet Kumar Nai

puneți acest cod în codul dumneavoastră…

error_reporting(-1);
ini_set('display_errors', 'On');

StudioX

Mi-am rezolvat întreaga problemă 500 în felul următor:

A. Verificați parametrii php.ini

  1. php.ini >> error_reporting = E_ALL | E_STRICT
  2. php.ini >> display_errors = On
  3. php.ini >> display_startup_errors = Off

B. Actualizați parametrii managerului IIS

  1. IIS Manager >> Error Pages >> 500 >> Edit feature settings >> erori detaliate

în acest pas, obțineți erori 500 de genul acesta și fără încărcare html.

  1. IIS Manager >> FastCGI Settings >> php-cgi.exe >> standard error mode >> IgnoreAndReurn200

în acest pas, puteți vedea pagina html care include erori php ca aceasta.

ȘI GATA 🙂

Milan Babuškov

Dacă eroarea se află în codul PHP, puteți utiliza funcția error_reporting() în cadrul codului dvs. pentru a seta la raportarea tuturor.

Cu toate acestea, acest lucru nu gestionează situația în care PHP se blochează. Informațiile despre acest lucru sunt disponibile doar în jurnalele serverului. Poate că nu aveți acces la acestea, dar mulți furnizori de găzduire cu care am lucrat au o modalitate de a vă permite să le accesați. De exemplu, abordarea care îmi place cel mai mult este aceea de a crea fișierul error_log în directorul curent în care se află .php. Încearcă să cauți acolo sau contactează-ți furnizorul de găzduire în legătură cu acest lucru.