Quando uso a constante PHP "PHP_EOL"?

Quando é uma boa ideia usar PHP_EOL?

Às vezes, vejo isso em exemplos de código do PHP. Isso lida com problemas de linha de extremidade do DOS / Mac / Unix?

Sim, PHP_EOLé ostensivamente usado para encontrar o caractere de nova linha de maneira compatível com várias plataformas, para lidar com problemas de DOS / Unix.

Observe que PHP_EOL representa o caractere final do sistema atual . Por exemplo, ele não encontrará uma linha final do Windows quando executada em um sistema semelhante ao Unix.

Do main/php.hPHP versão 7.1.1 e versão 5.6.30:

#ifdef PHP_WIN32
#   include "tsrm_win32.h"
#   include "win95nt.h"
#   ifdef PHP_EXPORTS
#       define PHPAPI __declspec(dllexport)
#   else
#       define PHPAPI __declspec(dllimport)
#   endif
#   define PHP_DIR_SEPARATOR '\\'
#   define PHP_EOL "\r\n"
#else
#   if defined(__GNUC__) && __GNUC__ >= 4
#       define PHPAPI __attribute__ ((visibility("default")))
#   else
#       define PHPAPI
#   endif
#   define THREAD_LS
#   define PHP_DIR_SEPARATOR '/'
#   define PHP_EOL "\n"
#endif

Como você pode ver, PHP_EOLpode ser "\r\n"(nos servidores Windows) ou "\n"(em qualquer outra coisa). Nas versões PHP anteriores à 5.4.0RC8, havia um terceiro valor possível para PHP_EOL: "\r"(nos servidores MacOSX). Ele estava errado e foi corrigido em 01/03/2012 com o bug 61193 .

Como outros já disseram, você pode usar PHP_EOLem qualquer tipo de saída (onde qualquer um desses valores é válido - como: HTML, XML, logs ...) onde você deseja novas linhas unificadas . Lembre-se de que é o servidor que determina o valor, não o cliente. Os visitantes do Windows obterão o valor do servidor Unix, o que é inconveniente para eles algumas vezes.

Eu só queria mostrar os possíveis valores de PHP_EOLbackup pelas fontes PHP, uma vez que ainda não foi mostrado aqui ...

Você usa PHP_EOLquando deseja uma nova linha e deseja ser multiplataforma.

Pode ser quando você está gravando arquivos no sistema de arquivos (logs, exportações, outros).

Você pode usá-lo se quiser que o HTML gerado seja legível. Então você pode seguir o seu <br />com um PHP_EOL.

Você o usaria se estiver executando o php como um script do cron e precisar produzir algo e formatá-lo para uma tela.

Você pode usá-lo se estiver criando um email para enviar que necessite de alguma formatação.

PHP_EOL (string) O símbolo 'End Of Line' correto para esta plataforma. Disponível desde PHP 4.3.10 e PHP 5.0.2

Você pode usar essa constante ao ler ou gravar arquivos de texto no sistema de arquivos do servidor.

As terminações de linha não importam na maioria dos casos, pois a maioria dos softwares é capaz de lidar com arquivos de texto, independentemente de sua origem. Você deve ser consistente com o seu código.

Se as terminações de linha importarem, especifique explicitamente as terminações de linha em vez de usar a constante. Por exemplo:

• Cabeçalhos HTTP devem ser separados por\r\n
• Arquivos CSV devem usar \r\ncomo separador de linhas

Eu gostaria de dar uma resposta que aborda "Quando não usá-lo", pois ainda não foi abordada e posso imaginar que ela seja usada às cegas e que ninguém perceba a existência de um problema até mais tarde. Parte disso contradiz algumas das respostas existentes.

Se estiver imprimindo em uma página da Web em HTML, principalmente em texto <textarea>, <pre>ou <code>você provavelmente sempre desejará usar \ne não PHP_EOL.

A razão para isso é que, embora o código funcione bem em um servidor - que é uma plataforma semelhante ao Unix - se implantado em um host do Windows (como a plataforma Windows Azure), isso pode alterar a maneira como as páginas são exibidas em alguns navegadores. (especificamente Internet Explorer - algumas versões exibem \ n e \ r).

Não tenho certeza se isso ainda é um problema desde o IE6 ou não, por isso pode ser bastante discutível, mas parece valer a pena mencionar se ajuda as pessoas a pensarem sobre o contexto. Pode haver outros casos (como XHTML estrito) em que a saída repentina de \ralgumas plataformas pode causar problemas com a saída, e tenho certeza de que existem outros casos extremos como esse.

Como já foi observado por alguém, você não gostaria de usá-lo ao retornar cabeçalhos HTTP - pois eles sempre devem seguir o RFC em qualquer plataforma.

Eu não o usaria para algo como delimitadores em arquivos CSV (como alguém sugeriu). A plataforma em que o servidor está executando não deve determinar as terminações da linha nos arquivos gerados ou consumidos.

Achei o PHP_EOL muito útil para manipulação de arquivos, especialmente se você estiver escrevendo várias linhas de conteúdo em um arquivo.

Por exemplo, você tem uma sequência longa que deseja quebrar nas várias linhas enquanto escreve em um arquivo simples. Usar \ r \ n pode não funcionar, basta colocar PHP_EOL no seu script e o resultado é incrível.

Confira este exemplo simples abaixo:

<?php

$output = 'This is line 1' . PHP_EOL .
          'This is line 2' . PHP_EOL .
          'This is line 3';

$file = "filename.txt";

if (is_writable($file)) {
    // In our example we're opening $file in append mode.
    // The file pointer is at the bottom of the file hence
    // that's where $output will go when we fwrite() it.
    if (!$handle = fopen($file, 'a')) {
         echo "Cannot open file ($file)";
         exit;
    }
    // Write $output to our opened file.
    if (fwrite($handle, $output) === FALSE) {
        echo "Cannot write to file ($file)";
        exit;
    }
    echo "Success, content ($output) wrote to file ($file)";
    fclose($handle);
} else {
    echo "The file $file is not writable";
}
?>

Não, o PHP_EOL não lida com problemas de linha final, porque o sistema em que você usa essa constante não é o mesmo sistema para o qual você envia a saída.

Eu não recomendaria o uso do PHP_EOL. Uso do Unix / Linux \ n, MacOS / OS X alterado de \ r para \ n também e no Windows muitos aplicativos (especialmente navegadores) também podem exibi-lo corretamente. No Windows, também é fácil alterar o código existente do lado do cliente para usar apenas \ n e ainda manter a compatibilidade com versões anteriores: basta alterar o delimitador para o corte de linha de \ r \ n para \ n e envolvê-lo em uma função do tipo trim () .

A definição do PHP_EOL é que ele fornece o caractere de nova linha do sistema operacional em que você está trabalhando.

Na prática, você quase nunca precisa disso. Considere alguns casos:

• Quando você está enviando para a web, não há realmente nenhuma convenção, exceto que você deve ser consistente. Como a maioria dos servidores é Unixy, você deseja usar um "\ n" de qualquer maneira.

• Se você estiver produzindo para um arquivo, o PHP_EOL pode parecer uma boa ideia. No entanto, você pode obter um efeito semelhante ao ter uma nova linha literal dentro do seu arquivo, e isso o ajudará se você estiver tentando executar alguns arquivos formatados em CRLF no Unix sem prejudicar as novas linhas existentes (como alguém com um sistema de inicialização dupla) , Posso dizer que prefiro o último comportamento)

O PHP_EOL é tão ridiculamente longo que não vale a pena usá-lo.

Há um lugar óbvio em que isso pode ser útil: quando você está escrevendo um código que usa predominantemente seqüências de aspas simples. É discutível se:

echo 'A $variable_literal that I have'.PHP_EOL.'looks better than'.PHP_EOL;  
echo 'this other $one'."\n";

A arte disso é ser consistente. O problema com mix e correspondência '' e "" é que, quando você obtém sequências longas, não precisa realmente procurar o tipo de citação que usou.

Como em todas as coisas da vida, depende do contexto.

A "nova linha" padrão do DOS / Windows é CRLF (= \ r \ n) e não LFCR (\ n \ r). Se colocarmos o último, é provável que produza alguns comportamentos inesperados (bem, de fato, meio que esperados!: D).

Atualmente, quase todos os programas (bem escritos) aceitam o LF padrão UNIX (\ n) para código de nova linha, até mesmo daemons de remetentes de correio (RFC define CRLF como nova linha para cabeçalhos e corpo da mensagem).

Prático com error_log () se você estiver produzindo várias linhas.

Eu descobri que muitas instruções de depuração parecem estranhas na minha instalação do Windows, já que os desenvolvedores assumiram finais unix ao dividir as strings.

Eu uso a constante PHP_EOL em alguns scripts de linha de comando que tive que escrever. Eu desenvolvo na minha máquina Windows local e testo em uma caixa de servidor Linux. Usar a constante significava que não precisava me preocupar em usar a linha correta para cada uma das plataformas.

Eu tenho um site onde um script de log grava uma nova linha de texto em um arquivo de texto após uma ação do usuário, que pode estar usando qualquer sistema operacional.

O uso do PHP_EOL não parece ideal neste caso. Se o usuário estiver no Mac OS e gravar no arquivo de texto, ele colocará \ n. Ao abrir o arquivo de texto em um computador Windows, ele não mostra uma quebra de linha. Por esse motivo, utilizo "\ r \ n", que funciona ao abrir o arquivo em qualquer sistema operacional.

Você está escrevendo um código que usa predominantemente seqüências de aspas simples.

echo 'A $variable_literal that I have'.PHP_EOL.'looks better than'.PHP_EOL;  
echo 'this other $one'."\n";

Estou usando o WebCalendar e constatei que o Mac iCal vomita na importação de um arquivo ics gerado porque o final de linha é codificado no xcal.php como "\ r \ n". Entrei e substituí todas as ocorrências por PHP_EOL e agora o iCal está feliz! Também testei no Vista e o Outlook também conseguiu importar o arquivo, mesmo que o caractere de fim de linha seja "\ n".

Quando o jumi (plugin do joomla para PHP) compila seu código por algum motivo, ele remove todas as barras invertidas do seu código. Tais que algo como $csv_output .= "\n";se torna$csv_output .= "n";

Bug muito chato!

Use PHP_EOL para obter o resultado desejado.

Em alguns sistemas, pode ser útil usar essa constante, porque se, por exemplo, você estiver enviando um email, poderá usar o PHP_EOL para que um script entre sistemas funcione em mais sistemas ... mas mesmo que seja útil em algum momento, você pode encontrar isso constante e indefinida, a hospedagem moderna com o mecanismo php mais recente não tem esse problema, mas acho que uma coisa boa é escrever um código de bit que salve essa situação:

<?php
  if (!defined('PHP_EOL')) {
    if (strtoupper(substr(PHP_OS,0,3) == 'WIN')) {
      define('PHP_EOL',"\r\n");
    } elseif (strtoupper(substr(PHP_OS,0,3) == 'MAC')) {
      define('PHP_EOL',"\r");
    } elseif (strtoupper(substr(PHP_OS,0,3) == 'DAR')) {
      define('PHP_EOL',"\n");
    } else {
      define('PHP_EOL',"\n");
    }
  }
?>

Então você pode usar o PHP_EOL sem problemas ... óbvio que o PHP_EOL deve ser usado em scripts que devem funcionar em mais sistemas ao mesmo tempo, caso contrário, você pode usar \ n ou \ r ou \ r \ n ...

Nota: PHP_EOL pode ser

1) on Unix    LN    == \n
2) on Mac     CR    == \r
3) on Windows CR+LN == \r\n

Espero que esta resposta ajude.

Acabei de experimentar esse problema ao enviar para um cliente Windows. Claro, o PHP_EOL é do lado do servidor, mas a maior parte do conteúdo do php é para clientes do Windows. Então eu tenho que colocar minhas descobertas aqui para a próxima pessoa.

A) ecoa 'Meu texto'. PHP_EOL; // Ruim, porque isso gera apenas \ n e a maioria das versões do bloco de notas do Windows exibe isso em uma única linha, e a maioria dos softwares de contabilidade do Windows não pode importar esse tipo de caractere de fim de linha.

B) eco 'Meu texto \ r \ n'; // Ruim, porque strings de aspas simples entre aspas não interpretam \ r \ n

C) echo "Meu texto \ r \ n"; // Sim, funciona! Parece correto no bloco de notas e funciona ao importar o arquivo para outros softwares do Windows, como o Windows Accounting e o Windows Manufacturing Software.

Eu prefiro usar \ n \ r. Também estou em um sistema Windows e \ n funciona muito bem na minha experiência.

Como o PHP_EOL não funciona com expressões regulares, e essa é a maneira mais útil de lidar com texto, então eu realmente nunca o usei ou precisei.