È possibile scrivere una stringa o accedere alla console?

Quello che intendo

Proprio come in JSP, se stampiamo qualcosa del genere system.out.println("some"), sarà lì sulla console, non su una pagina.

Firefox

Su Firefox è possibile utilizzare un'estensione chiamata FirePHP che consente la registrazione e il dumping delle informazioni dalle applicazioni PHP alla console. Questo è un componente aggiuntivo della fantastica estensione di sviluppo web Firebug .

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

Cromo

Tuttavia, se si utilizza Chrome, esiste uno strumento di debug PHP chiamato Chrome Logger o webug (webug ha problemi con l'ordine dei registri).

Più recentemente Clockwork è in fase di sviluppo attivo che estende gli strumenti per sviluppatori aggiungendo un nuovo pannello per fornire utili informazioni di debug e profilazione. Fornisce supporto immediato per Laravel 4 e Slim 2 e il supporto può essere aggiunto tramite la sua API estensibile.

Usando Xdebug

Un modo migliore per eseguire il debug di PHP sarebbe tramite Xdebug . La maggior parte dei browser fornisce estensioni di supporto per aiutarti a passare la stringa di cookie / query richiesta per inizializzare il processo di debug.

• Chrome - Xdebug Helper
• Firefox - Xdebug più semplice
• Opera - Xdebug
• Safari - Xdebug Toggler

Oppure usi il trucco di PHP Debug per console .

Per prima cosa hai bisogno di una piccola funzione di aiuto PHP

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

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

Quindi puoi usarlo in questo modo:

debug_to_console("Test");

Questo creerà un output come questo:

Debug Objects: Test

Se stai cercando un approccio semplice, fai eco come JSON:

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

Per impostazione predefinita, tutto l'output va a stdout, che è la risposta HTTP o la console, a seconda che lo script sia eseguito da Apache o manualmente sulla riga di comando. Ma è possibile utilizzare error_logper la registrazione e vari flussi di I / O possono essere scritti con fwrite.

Prova quanto segue. Funziona:

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

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

Crea un

<div>

con il

display="none"

in modo che il div non sia visualizzato, ma il

console.log()

la funzione è creata in javascript. Quindi ricevi il messaggio nella console.

Come autore della pagina Web collegata nella risposta popolare , vorrei aggiungere la mia ultima versione di questa semplice funzione di supporto. È molto più solido.

Uso json_encode()per verificare se il tipo di variabile non è necessario e aggiungo anche un buffer per risolvere i problemi con i framework. Non c'è un ritorno solido o un uso eccessivo di 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);`

Schermata del risultato

Anche un semplice esempio come immagine per capirlo molto più facilmente:

Penso che possa essere usato -

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"]}

Alcune grandi risposte che aggiungono più profondità; ma avevo bisogno di qualcosa di più semplice e più simile al console.log()comando JavaScript .

Uso PHP in molte "raccolta di dati e trasformazione in XML" nelle applicazioni Ajax. JavaScript console.lognon funziona in quel caso; interrompe l'output XML.

Xdebug, ecc. Aveva problemi simili.

La mia soluzione in Windows:

• Imposta un .txtfile che sia in qualche modo facilmente raggiungibile e scrivibile
• Imposta la error_logvariabile PHP nel .inifile per scrivere su quel file
• Apri il file in Esplora file di Windows e apri un riquadro di anteprima per esso
• Usa il error_log('myTest');comando PHP per inviare messaggi

Questa soluzione è semplice e soddisfa le mie esigenze per la maggior parte del tempo. PHP standard e il riquadro di anteprima si aggiorna automaticamente ogni volta che PHP vi scrive.

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

Interazione PHP e JavaScript.

Lo trovo utile:

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 usalo come:

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

Quali uscite nella console:

Important
 Less Important
     Even Less Important
Again Important

E puoi disattivare i log meno importanti limitandoli usando il valore $ debug.

Breve e facile, per matrici, stringhe o anche oggetti.

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 si desidera scrivere nel file di registro PHP e non nella console JavaScript, è possibile utilizzare questo:

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

Riferimento: error_log

Per Chrome esiste un'estensione chiamata Chrome Logger che consente di registrare i messaggi PHP.

Firefox DevTools ha persino il supporto integrato per il protocollo Chrome Logger .

Per abilitare la registrazione, devi solo salvare il file 'ChromePhp.php' nel tuo progetto. Quindi può essere utilizzato in questo modo:

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

Esempio tratto dalla pagina GitHub .

L'output potrebbe quindi apparire così:

Esiste anche una fantastica estensione di Google Chrome, PHP Console , con una libreria PHP che ti consente di:

• Visualizza errori ed eccezioni nella console JavaScript di Chrome e nei popup di notifica.
• Scarica qualsiasi tipo di variabile.
• Esegui il codice PHP in remoto.
• Proteggi l'accesso tramite password.
• Raggruppa i log della console su richiesta.
• Vai a error file:linenel tuo editor di testo.
• Copia i dati di errore / debug negli Appunti (per tester).

Stavo cercando un modo per eseguire il debug del codice in un plugin WordPress che stavo sviluppando e mi sono imbattuto in questo post.

Ho preso le parti di codice che mi sono più applicabili da altre risposte e le ho combinate in una funzione che posso usare per il debug di WordPress. La funzione è:

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

L'utilizzo è il seguente:

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

Se questa funzione viene utilizzata con lo sviluppo di WordPress, la funzione deve essere inserita nel functions.phpfile del tema figlio e può quindi essere chiamata in qualsiasi punto del codice.

Ho abbandonato tutto quanto sopra a favore di Debugger & Logger . Non posso elogiarlo abbastanza!

Basta fare clic su una delle schede in alto a destra o su "fai clic qui" per espandere / nascondere.

Notare le diverse "categorie". È possibile fare clic su qualsiasi array per espanderlo / comprimerlo.

Dalla pagina Web

Caratteristiche principali:

• Mostra variabili globali ($ GLOBALS, $ _POST, $ _GET, $ _COOKIE, ecc.)
• Mostra la versione di PHP e le estensioni caricate
• Sostituisci il gestore errori incorporato PHP
• Registra query SQL
• Monitorare il tempo di esecuzione delle query SQL e di codice
• Ispezionare le variabili per le modifiche
• La funzione chiama traccia
• Analisi della copertura del codice per verificare quali righe di script sono state eseguite
• Dump di tutti i tipi di variabili
• Ispettore di file con evidenziatore di codice per visualizzare il codice sorgente
• Invia messaggi alla console JavaScript (solo Chrome), per gli script Ajax

A partire dal 2017, Firebug e quindi FirePHP sono stati disabilitati .

Ho scritto alcune piccole modifiche allo strumento ChromePHP per consentire una migrazione senza soluzione di continuità da FirePHP a Firebug per il debug tramite la console.

Questo articolo spiega in modo chiaro e semplice

Migrare da FirePHP a ChromePHP in 5 minuti (senza interrompere il codice esistente)

Per le chiamate Ajax o le risposte XML / JSON, dove non si desidera fare confusione con il corpo, è necessario inviare i registri tramite le intestazioni HTTP, quindi aggiungerli alla console con un'estensione Web. Ecco come FirePHP (non più disponibile) e QuantumPHP (un fork di ChromePHP) lo fanno in Firefox.

Se hai la pazienza, x-debug è un'opzione migliore: ottieni una visione più approfondita di PHP, con la possibilità di mettere in pausa lo script, vedere cosa sta succedendo, quindi riprendere lo script.

Potrei essere in ritardo per una festa, ma stavo cercando un'implementazione della funzione di registrazione che:

• accetta un numero variabile di argomenti separati da virgola, proprio come JavaScript console.log(),
• fornisce un output formattato (non solo una stringa serializzata),
• è distinguibile da un javascript comune console.log().

Quindi l'output è simile al seguente:

(Lo snippet di seguito è testato su php 7.2.11. Non sono sicuro della sua compatibilità con le versioni precedenti di php. Può essere un problema anche per javascript (in un termine di vecchi browser), perché crea una virgola finale dopo gli console.log()argomenti - che non è legale fino al 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);

?>

Ognuno di questi due funziona:

<?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>");
?>

Ecco la mia soluzione, il bello di questo è che puoi passare tutti i parametri che vuoi.

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

Chiamalo in questo modo

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

Ora dovresti essere in grado di vedere l'output nella tua console, buona codifica :)

Uso:

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

Ecco una comoda funzione. È super semplice da usare, ti consente di passare tutti gli argomenti che desideri, di qualsiasi tipo, e visualizzerà il contenuto dell'oggetto nella finestra della console del browser come se avessi chiamato console.log da JavaScript, ma da PHP

Nota, puoi utilizzare anche i tag passando "TAG-YourTag" e verrà applicato fino alla lettura di un altro tag, ad esempio "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 () sono funzioni PHP per la lettura di un numero dinamico di argomenti di input e consentono a questa funzione di avere infinite richieste console.log da una chiamata di funzione.

Sebbene questa sia una vecchia domanda, la stavo cercando. Ecco la mia raccolta di alcune soluzioni a cui ho risposto qui e altre idee trovate altrove per ottenere una soluzione unica per tutti.

CODICE :

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

TEST E UTILIZZO:

L'utilizzo è semplice. Includi la prima funzione per la pubblicazione manuale sulla console. Utilizzare la seconda funzione per deviare la gestione delle eccezioni php. Il seguente test dovrebbe dare un'idea.

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

SPIEGAZIONE :

• La funzione console($data, $is_error, $file, $fn)accetta stringa o matrice come primo argomento e la pubblica sulla console usando js inserts.

• Il secondo argomento è un flag per differenziare i log normali dagli errori. Per errori, stiamo aggiungendo listener di eventi per informarci tramite avvisi se sono stati generati errori, evidenziando anche nella console. Per impostazione predefinita, questo flag è false.

• Il terzo e il quarto argomento sono dichiarazioni esplicite di file e numeri di riga, che è facoltativo. Se assenti, per impostazione predefinita utilizzano la funzione php predefinita debug_backtrace()per recuperarli.

• La funzione successiva exceptions_to_console($svr, $str, $file, $ln)ha quattro argomenti nell'ordine chiamato dal gestore di eccezioni predefinito di php. Qui, il primo argomento è la severità, che viene ulteriormente controllata con costanti predefinite utilizzando la funzione severity_tag($code)per fornire ulteriori informazioni sull'errore.

AVVISO :

• Il codice precedente utilizza funzioni e metodi JS che non sono disponibili nei browser più vecchi. Per compatibilità con le versioni precedenti, ha bisogno di sostituzioni.

• Il codice sopra è per gli ambienti di test, dove solo tu hai accesso al sito. Non utilizzarlo in siti Web (di produzione) live.

SUGGERIMENTI:

• La prima funzione ha console()lanciato alcuni avvisi, quindi li ho racchiusi in un'altra funzione e l'ho chiamata usando l'operatore di controllo degli errori '@'. Questo può essere evitato se non ti dispiace gli avvisi.

• Ultimo ma non meno importante, gli avvisi che spuntano possono essere fastidiosi durante la codifica. Per questo sto usando questo segnale acustico (trovato nella soluzione: https://stackoverflow.com/a/23395136/6060602 ) anziché avvisi popup. È piuttosto interessante e le possibilità sono infinite, puoi suonare i tuoi brani preferiti e rendere la programmazione meno stressante.