Molto spesso cercherò di eseguire uno script PHP e di recuperare uno schermo vuoto. Nessun messaggio di errore; solo uno schermo vuoto. La causa potrebbe essere stata un semplice errore di sintassi (parentesi errata, punto e virgola mancante) o una chiamata di funzione non riuscita o qualcos'altro.

È molto difficile capire cosa è andato storto. Finisco per commentare il codice, inserire dichiarazioni "echo" ovunque, ecc., Cercando di restringere il problema. Ma sicuramente ci deve essere un modo migliore, giusto?

C'è un modo per far sì che PHP produca un utile messaggio di errore, come fa Java?

Per errori di sintassi, è necessario abilitare la visualizzazione degli errori in php.ini. Per impostazione predefinita, questi sono disattivati ​​perché non si desidera che un "cliente" visualizzi i messaggi di errore. Controlla questa pagina nella documentazione di PHP per informazioni sulle 2 direttive: error_reportinge display_errors. display_errorsè probabilmente quello che vuoi cambiare. Se non riesci a modificare php.ini, puoi anche aggiungere le seguenti righe a un file .htaccess:

php_flag  display_errors        on
php_value error_reporting       2039

Puoi prendere in considerazione l'utilizzo del valore di E_ALL (come menzionato da Gumbo) per la tua versione di PHP per error_reportingottenere tutti gli errori. Ulteriori informazioni

3 altri elementi: (1) È possibile controllare il file di registro degli errori poiché avrà tutti gli errori (a meno che la registrazione non sia stata disabilitata). (2) L'aggiunta delle seguenti 2 righe ti aiuterà a eseguire il debug di errori che non sono errori di sintassi:

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

(3) Un'altra opzione è quella di utilizzare un editor che verifica la presenza di errori durante la digitazione, come PhpEd . PhpEd include anche un debugger in grado di fornire informazioni più dettagliate. (Il debugger PhpEd è molto simile a xdebug e si integra direttamente nell'editor in modo da utilizzare 1 programma per fare tutto.)

Anche il link di Cartman è molto buono: http://www.ibm.com/developerworks/library/os-debug/

Quanto segue abilita tutti gli errori:

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

Vedi anche i seguenti link

• http://php.net/manual/en/errorfunc.configuration.php#ini.display-errors
• http://php.net/manual/en/errorfunc.configuration.php#ini.display-startup-errors
• http://php.net/manual/en/function.error-reporting.php

Il seguente codice dovrebbe visualizzare tutti gli errori:

<?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(!@is_string($name = @array_search($type, @array_flip($_ERRORS))))
    {
        $name = 'E_UNKNOWN';
    };

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

$old_error_handler = set_error_handler("ErrorHandler");

// other php code

?>

L'unico modo per generare una pagina vuota con questo codice è quando si verifica un errore nel gestore di arresto. Ho copiato e incollato questo dal mio cms senza testarlo, ma sono sicuro che funzioni.

Errori e avvisi di solito compaiono nelle impostazioni di php.ini ....\logs\php_error.logo in ....\logs\apache_error.logbase a esse.

Anche errori utili vengono spesso indirizzati al browser, ma poiché non sono html validi non vengono visualizzati.

Quindi "tail -f"i tuoi file di registro e quando ottieni uno schermo vuoto usa IES" view "-> opzioni di menu" source "per visualizzare l'output non elaborato.

È possibile includere le seguenti righe nel file che si desidera eseguire il debug:

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

Questo sovrascrive le impostazioni predefinite in php.ini, che fanno semplicemente in modo che PHP riporti gli errori nel registro.

Configurazione PHP

2 voci in php.ini determinano l'output degli errori:

1. display_errors
2. error_reporting

In produzione , di display_errorssolito è impostato su Off(Il che è una buona cosa, perché la visualizzazione degli errori nei siti di produzione non è generalmente auspicabile!).

Tuttavia, in fase di sviluppo , dovrebbe essere impostato su On, in modo che vengano visualizzati gli errori. Controlla !

error_reporting(a partire da PHP 5.3) è impostato di default su E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED(significato, tutto è mostrato tranne avvisi, standard rigorosi e avvisi di ammortamento). In caso di dubbio, impostarlo su E_ALLper visualizzare tutti gli errori. Controlla !

Whoa whoa! Nessun controllo! Non posso cambiare il mio php.ini!

È un peccato. Di solito gli host condivisi non consentono l'alterazione del loro file php.ini e quindi l'opzione non è purtroppo disponibile. Ma non temere! Abbiamo altre opzioni !

Configurazione di runtime

Nello script desiderato, possiamo modificare le voci php.ini in runtime! Significato, verrà eseguito quando viene eseguito lo script! Dolce!

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

Queste due righe avranno lo stesso effetto della modifica delle voci php.ini come sopra! Eccezionale!

Ottengo ancora una pagina vuota / errore 500!

Ciò significa che la sceneggiatura non era nemmeno stata eseguita! Questo di solito accade quando si verifica un errore di sintassi!

Con errori di sintassi, lo script non arriva nemmeno al runtime. Non riesce in fase di compilazione , il che significa che utilizzerà i valori in php.ini, che se non fossero stati modificati, potrebbe non consentire la visualizzazione degli errori.

Log degli errori

Inoltre, per impostazione predefinita PHP registra errori. Nell'hosting condiviso, può trovarsi in una cartella dedicata o nella stessa cartella dello script offensivo.

Se hai accesso a php.ini, puoi trovarlo sotto la error_logvoce.

C'è un'estensione davvero utile chiamata " xdebug " che renderà i tuoi rapporti molto più belli.

Uso sempre questa sintassi all'inizio dello script php.

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

Per una risoluzione dei problemi rapida e pratica di solito suggerisco qui su SO:

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

da mettere all'inizio della sceneggiatura in fase di risoluzione dei problemi. Questo non è perfetto, la variante perfetta è che si abiliti anche quello nel php.inie che registri gli errori in PHP per catturare la sintassi e gli errori di avvio.

Le impostazioni descritte qui mostrano tutti gli errori, gli avvisi e gli avvisi, compresi quelli severi, indipendentemente dalla versione di PHP.

Prossime cose da considerare:

• Installa Xdebug e abilita il debug remoto con il tuo IDE.

Vedi anche:

• Segnalazione errori (PHP nel modo giusto.)
• ^Documenti costanti predefiniti
• error_reporting()^Documenti
• display_errors^Documenti

È possibile registrare un hook per rendere visibile l'ultimo errore o avviso.

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

register_shutdown_function('shutdown');

l'aggiunta di questo codice all'inizio di index.php ti aiuterà a eseguire il debug dei problemi.

Questo è un problema di configurazione caricata vs. runtime

È importante riconoscere che durante la fase di compilazione o analisi si verifica un errore di sintassi o un errore di analisi , il che significa che PHP salverà prima ancora che abbia la possibilità di eseguire qualsiasi codice. Quindi se stai modificando la display_errorsconfigurazione di PHP durante il runtime (questo include qualsiasi cosa dall'uso ini_setnel tuo codice all'utilizzo di .htaccess, che è un file di configurazione del runtime), allora sono in gioco solo le impostazioni di configurazione caricate di default .

Come evitare sempre WSOD nello sviluppo

Per evitare un WSOD, devi assicurarti che il file di configurazione caricato sia attivo display_errorse error_reportingimpostato su -1( questo è l'E_ALL equivalente perché garantisce che tutti i bit siano attivati ​​indipendentemente dalla versione di PHP in esecuzione ). Non codificare il valore costante di E_ALL, poiché tale valore è soggetto a modifiche tra le diverse versioni di PHP.

La configurazione caricata è il tuo php.inifile caricato o il tuo apache.confo httpd.confo il file virtualhost. Questi file vengono letti solo una volta durante la fase di avvio (ad esempio quando si avvia apache httpd o php-fpm) e vengono sovrascritti solo dalle modifiche alla configurazione del runtime. Accertandosi che display_errors = 1e error_reporting = -1nel file di configurazione caricato si assicuri che non si vedrà mai un WSOD indipendentemente dalla sintassi o dall'errore di analisi che si verificano prima che si verifichi una modifica del runtime come ini_set('display_errors', 1);o error_reporting(E_ALL);possa avvenire.

Come trovare i file di configurazione caricati (php.ini)

Per individuare i file di configurazione caricati, basta creare un nuovo file PHP con solo il seguente codice ...

<?php
phpinfo();

Quindi punta il tuo browser lì e guarda il file di configurazione caricato e i file .ini aggiuntivi analizzati , che di solito sono nella parte superiore del tuo phpinfo()e includeranno il percorso assoluto di tutti i file di configurazione caricati.

Se vedi (none)invece del file, significa che non hai un php.ini nel percorso del file di configurazione (php.ini) . Quindi puoi scaricare lo stock php.ini in bundle con PHP da qui e copiarlo nel percorso del file di configurazione come php.ini, quindi assicurarti che l'utente php disponga delle autorizzazioni sufficienti per leggere da quel file. Dovrai riavviare httpd o php-fpm per caricarlo. Ricorda, questo è il file di sviluppo php.ini fornito in bundle con l'origine PHP. Quindi per favore non usarlo in produzione!

Non farlo nella produzione

Questo è davvero il modo migliore per evitare un WSOD in fase di sviluppo. Chiunque suggerisca di inserire ini_set('display_errors', 1);o error_reporting(E_ALL);nella parte superiore dello script PHP o di utilizzare .htaccess come hai fatto qui, non ti aiuterà a evitare un WSOD quando si verifica un errore di sintassi o analisi (come nel tuo caso qui) se il file di configurazione caricato è display_errorsspento.

Molte persone (e le installazioni stock di PHP) useranno un file di produzione ini che è display_errorsstato disattivato per impostazione predefinita, il che di solito provoca la stessa frustrazione che hai provato qui. Perché PHP lo ha già disattivato all'avvio, quindi rileva un errore di sintassi o analisi e non esegue l'output con nulla. Ti aspetti che il tuo ini_set('display_errors',1);in cima allo script PHP avrebbe dovuto evitarlo, ma non importa se PHP non può analizzare il tuo codice perché non avrà mai raggiunto il runtime.

Se sei super cool, potresti provare:

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

Ciò visualizzerà errori solo quando si esegue localmente. Ti dà anche la variabile test_server da usare in altri posti dove appropriato.

Eventuali errori che si verificano prima dell'esecuzione dello script non verranno rilevati, ma per il 99% degli errori che faccio, non è un problema.

Nella parte superiore della pagina scegli un parametro

error_reporting(E_ERROR | E_WARNING | E_PARSE);

Per persistere e renderlo confortale, puoi modificare il tuo file php.ini. Di solito è memorizzato in /etc/php.inio /etc/php/php.ini, ma molti locali php.inipossono sovrascriverlo, a seconda delle linee guida per la configurazione del provider di hosting. Controlla un phpinfo()file Loaded Configuration Filein alto, per essere sicuro di quale viene caricato per ultimo.

Cerca display_errors in quel file. Dovrebbero esserci solo 3 casi, di cui 2 sono commentati.

Cambia la linea non commentata in:

display_errors = stdout

Non so se sarà d'aiuto, ma ecco un pezzo del mio file di configurazione standard per i progetti php. Tendo a non dipendere troppo dalle configurazioni di Apache anche sul mio server.

Non ho mai avuto il problema dell'errore che scompare, quindi forse qualcosa qui ti darà un'idea.

Modificato per mostrare 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>");
}

error_reporting(E_ALL | E_STRICT);
ini_set('display_errors', 1);
ini_set('html_errors', 1);

Inoltre, puoi ottenere informazioni più dettagliate con xdebug .

Consiglio Nette Tracy per una migliore visualizzazione di errori ed eccezioni in PHP:

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

error_reporting(E_ALL | E_STRICT);

E attiva gli errori di visualizzazione in php.ini

Puoi registrare il tuo gestore di errori in PHP. Scaricare tutti gli errori su un file potrebbe aiutarti in questi casi oscuri, per esempio. Nota che la tua funzione verrà chiamata, indipendentemente da quale sia il tuo attuale report_errore . Esempio molto semplice:

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

Le due linee chiave necessarie per ottenere errori utili da PHP sono:

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

Come sottolineato da altri collaboratori, questi sono disattivati ​​per impostazione predefinita per motivi di sicurezza. Come suggerimento utile: quando configuri il tuo sito è utile fare un passaggio per i tuoi diversi ambienti in modo che questi errori siano ATTIVI per impostazione predefinita nei tuoi ambienti locali e di sviluppo. Ciò può essere ottenuto con il seguente codice (idealmente nel file index.php o nel file di configurazione, in modo che sia attivo dall'inizio):

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

Anche FirePHP può essere utile.

apri php.ini, assicurati che sia impostato su:

display_errors = On

riavvia il tuo server.

Potresti anche provare PHPStorm come editor di codice. Troverà molti errori PHP e altri errori di sintassi proprio mentre digiti nell'editor.

se sei un utente ubuntu, vai al tuo terminale ed esegui questo comando

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

dove mostrerà i recenti 50 errori. Esiste un file di errore error.logper apache2 che registra tutti gli errori.

Per attivare la segnalazione completa degli errori, aggiungi questo al tuo script:

error_reporting(E_ALL);

Ciò provoca la visualizzazione anche di avvisi minimi. E, nel caso in cui:

ini_set('display_errors', '1');

Forzerà la visualizzazione degli errori. Questo dovrebbe essere disattivato nei server di produzione, ma non durante lo sviluppo.

Gli "ERRORI" sono le cose più utili per gli sviluppatori per conoscere i loro errori e risolverli per rendere il sistema perfetto.

PHP offre alcuni dei modi migliori per conoscere gli sviluppatori perché e dove il loro codice sta ottenendo gli errori, quindi conoscendo tali errori gli sviluppatori possono migliorare il loro codice in molti modi.

I modi migliori per scrivere seguendo due righe nella parte superiore dello script per ottenere tutti i messaggi di errore:

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

Un altro modo per usare strumenti di debugger come xdebug nel tuo IDE.

È possibile abilitare la segnalazione completa degli errori (inclusi avvisi e messaggi rigorosi). Alcune persone lo trovano troppo prolisso, ma vale la pena provarlo. Impostato error_reportingsu E_ALL | E_STRICTnel tuo php.ini.

error_reporting = E_ALL | E_STRICT

E_STRICT ti informerà sulle funzioni deprecate e ti darà consigli sui metodi migliori per svolgere determinate attività.

Se non desideri avvisi, ma ritieni utili altri tipi di messaggi, prova ad escludere gli avvisi:

error_reporting = (E_ALL | E_STRICT) & ~E_NOTICE

Assicurati anche che display_errorssia abilitato in php.ini. Se la tua versione di PHP è precedente alla 5.2.4, impostala su On:

display_errors = "On"

Se la tua versione è 5.2.4 o successiva, usa:

display_errors = "stderr"

Oltre all'errore_reporting e all'impostazione ini display_errors, è possibile ottenere errori SYNTAX dai file di registro del server Web. Quando sto sviluppando PHP carico i log del mio server del mio sistema di sviluppo nel mio editor. Ogni volta che provo una pagina e ottengo una schermata vuota, il file di registro diventa obsoleto e il mio editor mi chiede se voglio ricaricarlo. Quando lo faccio, salto in fondo e c'è l'errore di sintassi. Per esempio:

[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

Per coloro che usano nginx e hanno uno schermo bianco anche per i file con <?php echo 123;. Nel mio caso non avevo questa opzione richiesta per PHP nel file di configurazione di nginx:

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

Questa opzione non era nel file fastcgi_params, quindi PHP non funzionava e non c'erano errori nei log.