Muitas vezes, tentarei executar um script PHP e obter uma tela em branco de volta. Nenhuma mensagem de erro; apenas uma tela vazia. A causa pode ter sido um erro de sintaxe simples (colchete errado, ponto e vírgula ausente) ou uma falha na chamada de função ou algo completamente diferente.

É muito difícil descobrir o que deu errado. Acabo comentando o código, inserindo instruções "eco" em todos os lugares, etc., tentando diminuir o problema. Mas certamente deve haver uma maneira melhor, certo?

Existe uma maneira de obter o PHP para produzir uma mensagem de erro útil, como Java faz?

Para erros de sintaxe, você precisa habilitar a exibição de erros no php.ini. Por padrão, eles estão desativados porque você não deseja que um "cliente" veja as mensagens de erro. Verifique esta página na documentação do PHP para obter informações sobre as 2 diretivas: error_reportinge display_errors. display_errorsé provavelmente o que você deseja alterar. Se você não pode modificar o php.ini, também pode adicionar as seguintes linhas a um arquivo .htaccess:

php_flag  display_errors        on
php_value error_reporting       2039

Você pode considerar o uso do valor E_ALL (conforme mencionado pelo Gumbo) para sua versão do PHP para error_reportingobter todos os erros. mais informações

3 outros itens: (1) Você pode verificar o arquivo de log de erros, pois ele terá todos os erros (a menos que o log tenha sido desativado). (2) A adição das duas linhas a seguir ajudará você a depurar erros que não são erros de sintaxe:

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

(3) Outra opção é usar um editor que verifique se há erros ao digitar, como PhpEd . O PhpEd também vem com um depurador que pode fornecer informações mais detalhadas. (O depurador PhpEd é muito semelhante ao xdebug e integra-se diretamente ao editor, para que você use 1 programa para fazer tudo.)

O link do Cartman também é muito bom: http://www.ibm.com/developerworks/library/os-debug/

A seguir, são ativados todos os erros:

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

Veja também os seguintes links

• 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

O código a seguir deve exibir todos os erros:

<?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

?>

A única maneira de gerar uma página em branco com esse código é quando você tem um erro no manipulador de desligamento. Copiei e colei isso nos meus próprios cms sem testá-lo, mas tenho certeza que funciona.

Erros e avisos geralmente aparecem dentro ....\logs\php_error.logou ....\logs\apache_error.logdependem das configurações do php.ini.

Erros úteis também costumam ser direcionados ao navegador, mas como não são html válidos, não são exibidos.

Portanto, "tail -f"seus arquivos de log e, quando aparecer uma tela em branco, use as opções de menu" view "->" source "do IEs para visualizar a saída bruta.

Você pode incluir as seguintes linhas no arquivo que deseja depurar:

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

Isso substitui as configurações padrão no php.ini, que apenas fazem o PHP relatar os erros no log.

Configuração PHP

2 entradas no php.ini determinam a saída de erros:

1. display_errors
2. error_reporting

Na produção , display_errorsgeralmente é definido como Off(o que é bom, porque a exibição de erros nos locais de produção geralmente não é desejável!).

No entanto, no desenvolvimento , ele deve ser definido como On, para que os erros sejam exibidos. Verifique !

error_reporting(a partir do PHP 5.3) é definido por padrão como E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED(o que significa que tudo é mostrado, exceto avisos, padrões rígidos e avisos de reprovação). Em caso de dúvida, configure-o E_ALLpara exibir todos os erros. Verifique !

Whoa whoa! Sem verificação! Não consigo mudar meu php.ini!

Isso é uma vergonha. Normalmente, os hosts compartilhados não permitem a alteração do arquivo php.ini e, portanto, essa opção está infelizmente indisponível. Mas não temas! Temos outras opções !

Configuração de tempo de execução

No script desejado, podemos alterar as entradas do php.ini em tempo de execução! Ou seja, ele será executado quando o script for executado! Doce!

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

Essas duas linhas terão o mesmo efeito de alterar as entradas do php.ini como acima! Impressionante!

Ainda recebo um erro de página em branco / 500!

Isso significa que o script nem sequer rodou! Isso geralmente acontece quando você tem um erro de sintaxe!

Com erros de sintaxe, o script nem chega ao tempo de execução. Ele falha no tempo de compilação , o que significa que utilizará os valores no php.ini, que se você não tivesse alterado, podem não permitir a exibição de erros.

Logs de erro

Além disso, o PHP, por padrão, registra erros. Na hospedagem compartilhada, pode estar em uma pasta dedicada ou na mesma pasta que o script incorreto.

Se você tiver acesso ao php.ini, poderá encontrá-lo na error_logentrada.

Existe uma extensão realmente útil chamada " xdebug " que também tornará seus relatórios muito melhores.

Eu estou sempre usando essa sintaxe no topo do script php.

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

Para uma solução rápida e prática, normalmente sugiro aqui no SO:

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

para ser colocado no início do script que está sob resolução de problemas. Isso não é perfeito, a variante perfeita é que você também habilita isso php.inie registra os erros no PHP para capturar erros de sintaxe e de inicialização.

As configurações descritas aqui exibem todos os erros, avisos e avisos, incluindo os estritos, independentemente da versão do PHP.

Próximas coisas a considerar:

• Instale o Xdebug e ative a depuração remota com seu IDE.

Veja também:

• Relatório de Erros (PHP da maneira certa.)
• ^{Documentos de} constantes predefinidas
• error_reporting()^Documentos
• display_errors^Documentos

É possível registrar um gancho para tornar visível o último erro ou aviso.

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

register_shutdown_function('shutdown');

adicionar esse código ao início de index.php ajudará você a depurar os problemas.

Este é um problema de configuração carregada versus tempo de execução

É importante reconhecer que um erro de sintaxe ou erro de análise ocorre durante a etapa de compilação ou análise , o que significa que o PHP será liberado antes mesmo que você tenha a chance de executar qualquer código. Portanto, se você estiver modificando a display_errorsconfiguração do PHP durante o tempo de execução (isso inclui tudo, desde usar ini_setno seu código até usar .htaccess, que é um arquivo de configuração de tempo de execução), apenas as configurações padrão carregadas estão em jogo.

Como sempre evitar o WSOD no desenvolvimento

Para evitar um WSOD você quiser ter certeza de que o seu arquivo de configuração carregado tem display_errorsligado e error_reportingpronto para -1( esta é a E_ALL equivalente porque garante que todos os bits são ligados independentemente de qual versão do PHP você está executando ). Não codifique o valor constante de E_ALL, porque esse valor está sujeito a alterações entre diferentes versões do PHP.

Configuração carregada ou é o seu carregado php.iniarquivo ou seu apache.confou httpd.confou arquivo virtualhost. Esses arquivos são lidos apenas uma vez durante o estágio de inicialização (quando você inicia o apache httpd ou php-fpm, por exemplo) e são substituídos apenas pelas alterações na configuração do tempo de execução. Certifique-se de que, display_errors = 1e error_reporting = -1no seu arquivo de configuração carregado, você nunca verá um WSOD, independentemente da sintaxe ou do erro de análise que ocorrem antes que um tempo de execução seja alterado ini_set('display_errors', 1);ou error_reporting(E_ALL);possa ocorrer.

Como encontrar seus arquivos de configuração carregados (php.ini)

Para localizar o (s) arquivo (s) de configuração carregado (s), basta criar um novo arquivo PHP com apenas o seguinte código ...

<?php
phpinfo();

Em seguida, aponte o navegador para lá e observe os Arquivos de configuração carregados e os arquivos .ini adicionais analisados , que geralmente estão na parte superior do seu phpinfo()e incluirão o caminho absoluto para todos os arquivos de configuração carregados.

Se você (none)vir o arquivo, isso significa que você não tem um php.ini no caminho do arquivo de configuração (php.ini) . Portanto, você pode fazer o download do arquivo php.ini fornecido com o PHP a partir daqui e copiá-lo para o caminho do arquivo de configuração como php.ini, para garantir que o usuário do php tenha permissões suficientes para ler esse arquivo. Você precisará reiniciar o httpd ou php-fpm para carregá-lo. Lembre-se, este é o arquivo php.ini em desenvolvimento que vem junto com a fonte PHP. Então, por favor, não use em produção!

Só não faça isso na produção

Esta é realmente a melhor maneira de evitar um WSOD em desenvolvimento. Alguém sugerindo que você coloque ini_set('display_errors', 1);ou error_reporting(E_ALL);no topo do seu script PHP ou use .htaccess como você fez aqui, não ajudará a evitar um WSOD quando ocorrer um erro de sintaxe ou análise (como no seu caso aqui) se o seu arquivo de configuração carregado foi display_errorsdesligado.

Muitas pessoas (e instalações de estoque do PHP) usarão um arquivo de produção-ini que foi display_errorsdesativado por padrão, o que normalmente resulta na mesma frustração que você experimentou aqui. Como o PHP já o desativa quando é iniciado, ele encontra um erro de sintaxe ou de análise e falha com nada para produzir. Você espera que sua ini_set('display_errors',1);parte superior do script PHP evite isso, mas não importa se o PHP não pode analisar seu código, porque nunca alcançou o tempo de execução.

Se você é super legal, você pode tentar:

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

Isso exibirá apenas erros quando você estiver executando localmente. Também fornece a variável test_server para usar em outros lugares, onde apropriado.

Quaisquer erros que ocorram antes da execução do script não serão detectados, mas, para 99% dos erros cometidos, isso não é problema.

No topo da página, escolha um parâmetro

error_reporting(E_ERROR | E_WARNING | E_PARSE);

Para persistir e torná-lo confortável, você pode editar seu arquivo php.ini. Geralmente é armazenado em /etc/php.iniou /etc/php/php.ini, mas mais locais php.inipodem substituí-lo, dependendo das diretrizes de configuração do seu provedor de hospedagem. Verifique um phpinfo()arquivo Loaded Configuration Filena parte superior, para ter certeza de qual deles será carregado por último.

Procure por display_errors nesse arquivo. Deve haver apenas 3 instâncias, das quais 2 são comentadas.

Altere a linha não comentada para:

display_errors = stdout

Não sei se vai ajudar, mas aqui está um pedaço do meu arquivo de configuração padrão para projetos php. Eu tendem a não depender muito das configurações do apache, mesmo no meu próprio servidor.

Eu nunca tenho o problema de erro que desaparece, então talvez algo aqui lhe dê uma idéia.

Editado para mostrar 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);

Além disso, você pode obter informações mais detalhadas com o xdebug .

Eu recomendo Nette Tracy para melhor visualização de erros e exceções no PHP:

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

error_reporting(E_ALL | E_STRICT);

E ative os erros de exibição no php.ini

Você pode registrar seu próprio manipulador de erros no PHP. Despejar todos os erros em um arquivo pode ajudá-lo nesses casos obscuros, por exemplo. Observe que sua função será chamada, independentemente do seu relatório de erro atual . Exemplo muito básico:

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

As duas linhas principais que você precisa para obter erros úteis do PHP são:

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

Conforme indicado por outros colaboradores, eles são desativados por padrão por razões de segurança. Como uma dica útil - quando você estiver configurando seu site, é útil fazer uma alternância para seus diferentes ambientes, para que esses erros estejam ativados por padrão nos ambientes local e de desenvolvimento. Isso pode ser conseguido com o seguinte código (idealmente no seu arquivo index.php ou config, para que esteja ativo desde o início):

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

O FirePHP também pode ser útil.

abra o seu php.ini, verifique se está configurado para:

display_errors = On

reinicie seu servidor.

Você também pode tentar o PHPStorm como seu editor de código. Ele encontrará muitos erros de sintaxe e PHP exatamente quando você estiver digitando no editor.

Se você é um usuário do Ubuntu, vá para o seu terminal e execute este comando

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

onde ele exibirá 50 erros recentes. Há um arquivo de erro error.logpara o apache2 que registra todos os erros.

Para ativar o relatório de erros completo, adicione isso ao seu script:

error_reporting(E_ALL);

Isso faz com que até avisos mínimos apareçam. E, apenas no caso:

ini_set('display_errors', '1');

Forçará a exibição de erros. Isso deve ser desativado nos servidores de produção, mas não quando você estiver desenvolvendo.

Os “ERROS” são as coisas mais úteis para os desenvolvedores conhecerem seus erros e os resolveram para tornar o sistema perfeito.

O PHP fornece algumas das melhores maneiras de conhecer os desenvolvedores, por que e onde seus trechos de código estão obtendo os erros; portanto, ao saber desses erros, os desenvolvedores podem melhorar seu código de várias maneiras.

Melhores maneiras de escrever as seguintes duas linhas na parte superior do script para obter todas as mensagens de erro:

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

Outra maneira de usar ferramentas de depuração como o xdebug no seu IDE.

Você pode ativar o relatório de erros completo (incluindo avisos e mensagens estritas). Algumas pessoas acham isso muito detalhado, mas vale a pena tentar. Defina error_reportingcomo E_ALL | E_STRICTno seu php.ini.

error_reporting = E_ALL | E_STRICT

E_STRICT notificará você sobre funções obsoletas e fornecerá recomendações sobre os melhores métodos para executar determinadas tarefas.

Se você não deseja avisos, mas encontra outros tipos de mensagens úteis, tente excluir avisos:

error_reporting = (E_ALL | E_STRICT) & ~E_NOTICE

Verifique também se display_errorsestá habilitado no php.ini. Se sua versão do PHP for anterior à 5.2.4, configure-a para On:

display_errors = "On"

Se sua versão for 5.2.4 ou mais recente, use:

display_errors = "stderr"

Além da configuração error_reporting e display_errors ini, você pode obter erros SYNTAX nos arquivos de log do servidor da web. Quando estou desenvolvendo PHP, carrego os logs do servidor da web do meu sistema de desenvolvimento no meu editor. Sempre que eu testo uma página e obtenho uma tela em branco, o arquivo de log fica obsoleto e meu editor pergunta se eu quero recarregá-la. Quando o faço, pulo para o fundo e há o erro de sintaxe. Por exemplo:

[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

Para quem usa o nginx e possui uma tela branca mesmo para arquivos <?php echo 123;. No meu caso, eu não tinha essa opção necessária para PHP no arquivo de configuração nginx:

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

Esta opção não estava no arquivo fastcgi_params, portanto, o PHP não funcionou e não houve erros nos logs.