É possível escrever uma string ou fazer login no console?

O que eu quero dizer

Assim como no JSP, se imprimirmos algo como system.out.println("some"), estará lá no console, não em uma página.

Raposa de fogo

No Firefox, você pode usar uma extensão chamada FirePHP, que permite o registro e o despejo de informações de seus aplicativos PHP no console. Este é um complemento para a incrível extensão de desenvolvimento web Firebug .

• http://www.studytrails.com/blog/using-firephp-in-firefox-to-debug-php/

cromada

No entanto, se você estiver usando o Chrome, existe uma ferramenta de depuração do PHP chamada Chrome Logger ou webug (o webug tem problemas com a ordem dos logs).

Mais recentemente, o Clockwork está em desenvolvimento ativo, estendendo as Ferramentas do desenvolvedor, adicionando um novo painel para fornecer informações úteis sobre depuração e criação de perfil. Ele fornece suporte imediato ao Laravel 4 e Slim 2 e o suporte pode ser adicionado por meio de sua API extensível.

Usando o Xdebug

Uma maneira melhor de depurar seu PHP seria via Xdebug . A maioria dos navegadores fornece extensões auxiliares para ajudá-lo a passar a string de cookie / consulta necessária para inicializar o processo de depuração.

• Chrome - Xdebug Helper
• Firefox - O Xdebug mais fácil
• Opera - Xdebug
• Safari - Xdebug Toggler

Ou você usa o truque do PHP Debug para console .

Primeiro você precisa de uma pequena função auxiliar PHP

function debug_to_console($data) {
    $output = $data;
    if (is_array($output))
        $output = implode(',', $output);

    echo "<script>console.log('Debug Objects: " . $output . "' );</script>";
}

Então você pode usá-lo assim:

debug_to_console("Test");

Isso criará uma saída como esta:

Debug Objects: Test

Se você está procurando uma abordagem simples, eco como JSON:

<script>
    console.log(<?= json_encode($foo); ?>);
</script>

Por padrão, toda saída é acessada stdout, que é a resposta HTTP ou o console, dependendo de seu script ser executado pelo Apache ou manualmente na linha de comando. Mas você pode usar error_logpara o log e vários fluxos de E / S podem ser gravados com fwrite.

Tente o seguinte. Está funcionando:

echo("<script>console.log('PHP: " . $data . "');</script>");

echo 
"<div display='none'>
    <script type='text/javascript'>
        console.log('console log message');
    </script>
</div>";

Cria um

<div>

com o

display="none"

para que a div não seja exibida, mas o

console.log()

A função é criada em javascript. Então você recebe a mensagem no console.

Como autor da página vinculada na resposta popular , gostaria de adicionar minha última versão desta função auxiliar simples. É muito mais sólido.

Eu uso json_encode()para verificar se o tipo de variável não é necessário e também adicionar um buffer para resolver problemas com estruturas. Não há um retorno sólido ou uso excessivo de header().

/**
 * Simple helper to debug to the console
 *
 * @param $data object, array, string $data
 * @param $context string  Optional a description.
 *
 * @return string
 */
function debug_to_console($data, $context = 'Debug in Console') {

    // Buffering to solve problems frameworks, like header() in this and not a solid return.
    ob_start();

    $output  = 'console.info(\'' . $context . ':\');';
    $output .= 'console.log(' . json_encode($data) . ');';
    $output  = sprintf('<script>%s</script>', $output);

    echo $output;
}

Uso

// $data is the example variable, object; here an array.
$data = [ 'foo' => 'bar' ];
debug_to_console($data);`

Captura de tela do resultado

Também um exemplo simples como imagem para entender muito mais fácil:

Eu acho que pode ser usado -

function jsLogs($data) {
    $html = "";
    $coll;

    if (is_array($data) || is_object($data)) {
        $coll = json_encode($data);
    } else {
        $coll = $data;
    }

    $html = "<script>console.log('PHP: ${coll}');</script>";

    echo($html);
    # exit();
}

# For String
jsLogs("testing string"); #PHP: testing string

# For Array
jsLogs(array("test1", "test2")); # PHP: ["test1","test2"]

# For Object
jsLogs(array("test1"=>array("subtest1", "subtest2"))); #PHP: {"test1":["subtest1","subtest2"]}

Algumas ótimas respostas que adicionam mais profundidade; mas eu precisava de algo mais simples e mais parecido com o console.log()comando JavaScript .

Eu uso PHP em muitas "coleta de dados e viro XML" em aplicativos Ajax. O JavaScript console.lognão funciona nesse caso; quebra a saída XML.

Xdebug, etc. teve problemas semelhantes.

Minha solução no Windows:

• Configure um .txtarquivo de fácil acesso e gravável
• Defina a error_logvariável PHP no .iniarquivo para gravar nesse arquivo
• Abra o arquivo no Windows File Explorer e abra um painel de visualização para ele
• Use o error_log('myTest');comando PHP para enviar mensagens

Esta solução é simples e atende às minhas necessidades na maioria das vezes. PHP padrão, e o painel de visualização é atualizado automaticamente toda vez que o PHP grava nele.

$variable = "Variable";
echo "<script>console.log('$variable');</script>";

Interação PHP e JavaScript.

Acho isso útil:

function console($data, $priority, $debug)
{
    if ($priority <= $debug)
    {
        $output = '<script>console.log("' . str_repeat(" ", $priority-1) . (is_array($data) ? implode(",", $data) : $data) . '");</script>';

        echo $output;
    }
}

E use-o como:

<?php
    $debug = 5; // All lower and equal priority logs will be displayed
    console('Important', 1 , $debug);
    console('Less Important', 2 , $debug);
    console('Even Less Important', 5 , $debug);
    console('Again Important', 1 , $debug);
?>

Quais saídas no console:

Important
 Less Important
     Even Less Important
Again Important

E você pode desativar os logs menos importantes limitando-os usando o valor $ debug.

Curto e fácil, para matrizes, strings ou também objetos.

function console_log( $data ) {
  $output  = "<script>console.log( 'PHP debugger: ";
  $output .= json_encode(print_r($data, true));
  $output .= "' );</script>";
  echo $output;
}

function phpconsole($label='var', $x) {
    ?>
    <script type="text/javascript">
        console.log('<?php echo ($label)?>');
        console.log('<?php echo json_encode($x)?>');
    </script>
    <?php
}

Se você deseja gravar no arquivo de log PHP, e não no console JavaScript, você pode usar isto:

error_log("This is logged only to the PHP log")

Referência: error_log

Para o Chrome, existe uma extensão chamada Chrome Logger, que permite registrar mensagens PHP.

O Firefox DevTools ainda possui suporte integrado ao protocolo Chrome Logger .

Para habilitar o log, basta salvar o arquivo 'ChromePhp.php' no seu projeto. Então pode ser usado assim:

include 'ChromePhp.php';
ChromePhp::log('Hello console!');
ChromePhp::log($_SERVER);
ChromePhp::warn('something went wrong!');

Exemplo retirado da página do GitHub .

A saída pode ficar assim:

Há também uma grande extensão do Google Chrome, o PHP Console , com uma biblioteca PHP que permite:

• Veja erros e exceções no console JavaScript do Chrome e nos pop-ups de notificação.
• Despejar qualquer tipo de variável.
• Execute o código PHP remotamente.
• Proteja o acesso por senha.
• Agrupe os logs do console por solicitação.
• Vá para o error file:lineseu editor de texto.
• Copie os dados de erro / depuração para a área de transferência (para testadores).

Eu estava procurando uma maneira de depurar o código em um plugin do WordPress que estava desenvolvendo e me deparei com este post.

Peguei os bits de código mais aplicáveis ​​a mim de outras respostas e os combinei em uma função que eu posso usar para depurar o WordPress. A função é:

function debug_log($object=null, $label=null, $priority=1) {
    $priority = $priority<1? 1: $priority;
    $message = json_encode($object, JSON_PRETTY_PRINT);
    $label = "Debug" . ($label ? " ($label): " : ': ');
    echo "<script>console.log('" . str_repeat("-", $priority-1) . $label . "', " . $message . ");</script>";
}

O uso é o seguinte:

$txt = 'This is a test string';
$sample_array = array('cat', 'dog', 'pig', 'ant', 'fly');
debug_log($txt, '', 7);
debug_log($sample_array);

Se essa função for usada no desenvolvimento do WordPress, ela deverá ser colocada no functions.phparquivo do tema filho e poderá ser chamada em qualquer lugar do código.

Eu abandonei tudo isso em favor do Debugger & Logger . Não posso elogiá-lo o suficiente!

Basta clicar em uma das guias no canto superior direito ou no "clique aqui" para expandir / ocultar.

Observe as diferentes "categorias". Você pode clicar em qualquer matriz para expandi-la / recolhê-la.

Na página da web

Principais características:

• Mostrar variáveis ​​globais ($ GLOBALS, $ _POST, $ _GET, $ _COOKIE etc.)
• Mostrar versão PHP e extensões carregadas
• Substitua o PHP incorporado no manipulador de erros
• Consultas SQL de log
• Monitorar o tempo de execução de consultas de código e SQL
• Inspecionar variáveis ​​para mudanças
• Rastreamento de chamadas de função
• Análise de cobertura de código para verificar quais linhas de script foram executadas
• Despejo de todos os tipos de variáveis
• Inspetor de arquivos com marcador de código para visualizar o código-fonte
• Enviar mensagens para o console JavaScript (somente Chrome), para scripts Ajax

A partir de 2017, o Firebug e, portanto, o FirePHP foram desativados .

Escrevi algumas pequenas modificações na ferramenta ChromePHP para permitir a migração direta do FirePHP para o Firebug para depuração via console.

Este artigo explica em etapas fáceis claras

Migre do FirePHP para o ChromePHP em 5 minutos (sem quebrar o código existente)

Para chamadas Ajax ou respostas XML / JSON, nas quais você não deseja mexer com o corpo, é necessário enviar logs por meio de cabeçalhos HTTP e adicioná-los ao console com uma extensão da web. É assim que o FirePHP (não está mais disponível) e o QuantumPHP (um fork do ChromePHP) fazem isso no Firefox.

Se você tiver paciência, o x-debug é uma opção melhor - você obtém uma visão mais profunda do PHP, com a capacidade de pausar seu script, ver o que está acontecendo e, em seguida, retomar o script.

Talvez eu esteja atrasado para uma festa, mas estava procurando uma implementação da função de log que:

• usa um número variável de argumentos separados por vírgula, assim como javascript console.log(),
• fornece uma saída formatada (não apenas uma sequência serializada),
• é distinguível de um javascript comum console.log().

Portanto, a saída é assim:

(O snippet abaixo é testado em php 7.2.11. Não tenho certeza sobre sua compatibilidade com versões anteriores do php. Também pode ser um problema para javascript (em termos de navegadores antigos), porque cria uma vírgula à direita após os console.log()argumentos - o que não é legal até ES 2017.)

<?php

function console_log(...$args)
{
    $args_as_json = array_map(function ($item) {
        return json_encode($item);
    }, $args);

    $js_code = "<script>console.log('%c 💬 log from PHP: ','background: #474A8A; color: #B0B3D6; line-height: 2',";
    foreach ($args_as_json as $arg) {
        $js_code .= "{$arg},";
    }
    $js_code .= ")</script>";

    echo $js_code;
}

$list = ['foo', 'bar'];
$obj = new stdClass();
$obj->first_name = 'John';
$obj->last_name = 'Johnson';

echo console_log($list, 'Hello World', 123, $obj);

?>

Qualquer um destes dois está funcionando:

<?php
    $five = 5;
    $six = 6;
?>
<script>
    console.log(<?php echo $five + $six ?>);
</script>


<?php
    $five = 5;
    $six = 6;
    echo("<script>console.log($five + $six);</script>");
?>

Aqui está a minha solução, a coisa boa sobre este é que você pode passar quantos parâmetros quiser.

function console_log()
{
    $js_code = 'console.log(' . json_encode(func_get_args(), JSON_HEX_TAG) .
        ');';
    $js_code = '<script>' . $js_code . '</script>';
    echo $js_code;
}

Chame assim

console_log('DEBUG>>', 'Param 1', 'Param 2');
console_log('Console DEBUG:', $someRealVar1, $someVar, $someArray, $someObj);

Agora você deve conseguir ver a saída em seu console, feliz codificação :)

Usar:

function console_log($data) {
    $bt = debug_backtrace();
    $caller = array_shift($bt);

    if (is_array($data))
        $dataPart = implode(',', $data);
    else
        $dataPart = $data;

    $toSplit = $caller['file'])) . ':' .
               $caller['line'] . ' => ' . $dataPart

    error_log(end(split('/', $toSplit));
}

Aqui está uma função útil. É super simples de usar, permite passar quantos argumentos você quiser, de qualquer tipo, e exibirá o conteúdo do objeto na janela do console do navegador como se você tivesse chamado console.log do JavaScript - mas do PHP

Observe que você também pode usar tags passando 'TAG-YourTag', e ele será aplicado até que outra tag seja lida, por exemplo, 'TAG-YourNextTag'

/*
 *  Brief:         Print to console.log() from PHP
 *
 *  Description:   Print as many strings,arrays, objects, and
 *                 other data types to console.log from PHP.
 *
 *                 To use, just call consoleLog($data1, $data2, ... $dataN)
 *                 and each dataI will be sent to console.log - note
 *                 that you can pass as many data as you want an
 *                 this will still work.
 *
 *                 This is very powerful as it shows the entire
 *                 contents of objects and arrays that can be
 *                 read inside of the browser console log.
 *
 *                 A tag can be set by passing a string that has the
 *                 prefix TAG- as one of the arguments. Everytime a
 *                 string with the TAG- prefix is detected, the tag
 *                 is updated. This allows you to pass a tag that is
 *                 applied to all data until it reaches another tag,
 *                 which can then be applied to all data after it.
 *
 *                 Example:
 *
 *                 consoleLog('TAG-FirstTag', $data, $data2, 'TAG-SecTag, $data3);
 *
 *                 Result:
 *                     FirstTag '...data...'
 *                     FirstTag '...data2...'
 *                     SecTag   '...data3...'
 */
function consoleLog(){
    if(func_num_args() == 0){
        return;
    }

    $tag = '';
    for ($i = 0; $i < func_num_args(); $i++) {
        $arg = func_get_arg($i);
        if(!empty($arg)){
            if(is_string($arg) && strtolower(substr($arg, 0, 4)) === 'tag-'){
                $tag = substr($arg, 4);
            }else{
                $arg = json_encode($arg, JSON_HEX_TAG | JSON_HEX_AMP );
                echo "<script>console.log('" . $tag . " " . $arg . "');</script>";
            }
        }
    }
}

NOTA: func_num_args () e func_num_args () são funções PHP para ler um número dinâmico de argumentos de entrada e permitem que essa função tenha infinitas solicitações console.log de uma chamada de função.

Embora essa seja uma pergunta antiga, eu tenho procurado por isso. Aqui está minha compilação de algumas soluções respondidas aqui e algumas outras idéias encontradas em outros lugares para obter uma solução única para todos.

CÓDIGO:

    // Post to browser console
    function console($data, $is_error = false, $file = false, $ln = false) {
        if(!function_exists('console_wer')) {
            function console_wer($data, $is_error = false, $bctr, $file, $ln) {
                echo '<div display="none">'.'<script type="text/javascript">'.(($is_error!==false) ? 'if(typeof phperr_to_cns === \'undefined\') { var phperr_to_cns = 1; document.addEventListener("DOMContentLoaded", function() { setTimeout(function(){ alert("Alert. see console."); }, 4000); });  }' : '').' console.group("PHP '.(($is_error) ? 'error' : 'log').' from "+window.atob("'.base64_encode((($file===false) ? $bctr['file'] : $file)).'")'.((($ln!==false && $file!==false) || $bctr!==false) ? '+" on line '.(($ln===false) ? $bctr['line'] : $ln).' :"' : '+" :"').'); console.'.(($is_error) ? 'error' : 'log').'('.((is_array($data)) ? 'JSON.parse(window.atob("'.base64_encode(json_encode($data)).'"))' : '"'.$data.'"').'); console.groupEnd();</script></div>'; return true;
            }
        }
        return @console_wer($data, $is_error, (($file===false && $ln===false) ? array_shift(debug_backtrace()) : false), $file, $ln);
    }

    //PHP Exceptions handler
    function exceptions_to_console($svr, $str, $file, $ln) {
        if(!function_exists('severity_tag')) {
            function severity_tag($svr) {
                $names = [];
                $consts = array_flip(array_slice(get_defined_constants(true)['Core'], 0, 15, true));
                foreach ($consts as $code => $name) {
                    if ($svr & $code) $names []= $name;
                }
                return join(' | ', $names);
            }
        }
        if (error_reporting() == 0) {
            return false;
        }
        if(error_reporting() & $svr) {
            console(severity_tag($svr).' : '.$str, true, $file, $ln);
        }
    }

    // Divert php error traffic
    error_reporting(E_ALL);  
    ini_set("display_errors", 1);
    set_error_handler('exceptions_to_console');

TESTES E USO:

O uso é simples. Inclua a primeira função para postar no console manualmente. Use a segunda função para desviar o tratamento de exceções php. O teste a seguir deve dar uma idéia.

    // Test 1 - Auto - Handle php error and report error with severity info
    $a[1] = 'jfksjfks';
    try {
          $b = $a[0];
    } catch (Exception $e) {
          echo "jsdlkjflsjfkjl";
    }

    // Test 2 - Manual - Without explicitly providing file name and line no.
          console(array(1 => "Hi", array("hellow")), false);

    // Test 3 - Manual - Explicitly providing file name and line no.
          console(array(1 => "Error", array($some_result)), true, 'my file', 2);

    // Test 4 - Manual - Explicitly providing file name only.
          console(array(1 => "Error", array($some_result)), true, 'my file');

EXPLICAÇÃO:

• A função console($data, $is_error, $file, $fn)pega string ou array como primeiro argumento e a publica no console usando js insert.

• O segundo argumento é um sinalizador para diferenciar logs normais contra erros. Para erros, estamos adicionando ouvintes de eventos para nos informar por meio de alertas se algum erro foi lançado, também destacando no console. Esse sinalizador é padronizado como false.

• O terceiro e o quarto argumentos são declarações explícitas de números de arquivos e linhas, o que é opcional. Se ausentes, o padrão é usar a função php predefinida debug_backtrace()para buscá-las para nós.

• A próxima função exceptions_to_console($svr, $str, $file, $ln)tem quatro argumentos na ordem chamada pelo manipulador de exceção padrão do php. Aqui, o primeiro argumento é severity, que fazemos uma verificação cruzada de constantes predefinidas usando a função severity_tag($code)para fornecer mais informações sobre erros.

AVISO PRÉVIO :

• O código acima usa funções e métodos JS que não estão disponíveis em navegadores mais antigos. Para compatibilidade com versões mais antigas, ele precisa de substituições.

• O código acima é para ambientes de teste, onde você sozinho tem acesso ao site. Não use isso em sites ao vivo (de produção).

SUGESTÕES:

• A primeira função console()gerou alguns avisos, então os agrupei em outra função e chamei-a usando o operador de controle de erro '@'. Isso pode ser evitado se você não se importar com os avisos.

• Por último, mas não menos importante, os alertas exibidos podem ser irritantes durante a codificação. Para isso, estou usando este sinal sonoro (encontrado na solução: https://stackoverflow.com/a/23395136/6060602 ) em vez de alertas pop-up. É bem legal e as possibilidades são infinitas, você pode tocar suas músicas favoritas e tornar a codificação menos estressante.