¿Es posible escribir una cadena o iniciar sesión en la consola?

Lo que quiero decir

Al igual que en JSP, si imprimimos algo así system.out.println("some"), estará allí en la consola, no en una página.

Firefox

En Firefox puede usar una extensión llamada FirePHP que permite el registro y descarga de información de sus aplicaciones PHP a la consola. Este es un complemento de la increíble extensión de desarrollo web Firebug .

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

Cromo

Sin embargo, si está utilizando Chrome, existe una herramienta de depuración de PHP llamada Chrome Logger o webug (webug tiene problemas con el orden de los registros).

Más recientemente Clockwork está en desarrollo activo, que amplía las Herramientas para desarrolladores al agregar un nuevo panel para proporcionar información útil de depuración y creación de perfiles. Proporciona soporte inmediato para Laravel 4 y Slim 2 y se puede agregar soporte a través de su API extensible.

Usando Xdebug

Una mejor manera de depurar tu PHP sería a través de Xdebug . La mayoría de los navegadores proporcionan extensiones auxiliares para ayudarlo a pasar la cadena de cookie / consulta requerida para inicializar el proceso de depuración.

• Chrome - Xdebug Helper
• Firefox - el Xdebug más fácil
• Opera - Xdebug
• Safari - Toggler Xdebug

O usas el truco de PHP Debug para consolar .

Primero necesitas una pequeña función auxiliar de PHP

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

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

Entonces puedes usarlo así:

debug_to_console("Test");

Esto creará una salida como esta:

Debug Objects: Test

Si está buscando un enfoque simple, repita como JSON:

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

Por defecto, todos los resultados van a stdout, que es la respuesta HTTP o la consola, dependiendo de si su script es ejecutado por Apache o manualmente en la línea de comando. Pero puede usarlo error_logpara iniciar sesión y se pueden escribir varias secuencias de E / S confwrite .

Intenta lo siguiente. Está funcionando:

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 el

display="none"

para que no se muestre el div, sino el

console.log()

La función se crea en JavaScript. Entonces recibes el mensaje en la consola.

Como autor de la página web vinculada en la respuesta popular , me gustaría agregar mi última versión de esta función auxiliar simple. Es mucho mas solido.

Utilizo json_encode()para verificar si el tipo de variable no es necesario y también agrego un búfer para resolver problemas con marcos. No tiene un rendimiento sólido o un uso excesivo 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 pantalla del resultado.

También un ejemplo simple como imagen para entenderlo mucho más fácilmente:

Creo que se puede usar

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

Algunas excelentes respuestas que agregan más profundidad; pero necesitaba algo más simple y más parecido al JavaScriptconsole.log() comando .

Utilizo PHP en una gran cantidad de "recopilación de datos y convertir en XML" en aplicaciones Ajax. El JavaScript console.logno funciona en ese caso; rompe la salida XML.

Xdebug, etc. tuvo problemas similares.

Mi solución en Windows:

• Configure un .txtarchivo que sea fácil de acceder y que se pueda escribir
• Establezca la error_logvariable PHP en el .iniarchivo para escribir en ese archivo
• Abra el archivo en el Explorador de archivos de Windows y abra un panel de vista previa.
• Usa el error_log('myTest');comando PHP para enviar mensajes

Esta solución es simple y satisface mis necesidades la mayor parte del tiempo. PHP estándar, y el panel de vista previa se actualiza automáticamente cada vez que PHP escribe en él.

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

Interacción PHP y JavaScript.

Esto me parece ú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;
    }
}

Y úsalo 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);
?>

Qué salidas en la consola:

Important
 Less Important
     Even Less Important
Again Important

Y puede desactivar los registros menos importantes limitándolos con el valor $ debug.

Corto y fácil, para matrices, cadenas o también 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
}

Si desea escribir en el archivo de registro de PHP, y no en la consola de JavaScript, puede usar esto:

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

Referencia: error_log

Para Chrome hay una extensión llamada Chrome Logger permite registrar mensajes PHP.

Las DevTools de Firefox incluso tienen soporte integrado para el protocolo Chrome Logger .

Para habilitar el registro, solo necesita guardar el archivo 'ChromePhp.php' en su proyecto. Entonces se puede usar así:

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

Ejemplo tomado de la página de GitHub .

La salida puede verse así:

También hay una gran extensión de Google Chrome, Consola PHP , con una biblioteca PHP que le permite:

• Ver errores y excepciones en la consola de JavaScript de Chrome y en las ventanas emergentes de notificación.
• Volcar cualquier tipo de variable.
• Ejecuta código PHP de forma remota.
• Proteger el acceso por contraseña.
• Agrupe los registros de la consola por solicitud.
• Salta a error file:line en tu editor de texto.
• Copie los datos de error / depuración en el portapapeles (para probadores).

Estaba buscando una forma de depurar código en un complemento de WordPress que estaba desarrollando y encontré esta publicación.

Tomé los bits de código que me son más aplicables de otras respuestas y los combiné en una función que puedo usar para depurar WordPress. La función es:

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

El uso es el siguiente:

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

Si esta función se usa con el desarrollo de WordPress, la función se debe colocar en el functions.phparchivo del tema secundario y luego se puede invocar en cualquier parte del código.

He abandonado todo lo anterior en favor de Debugger & Logger . No puedo alabarlo lo suficiente!

Simplemente haga clic en una de las pestañas en la parte superior derecha, o en el "clic aquí" para expandir / ocultar.

Observe las diferentes "categorías". Puede hacer clic en cualquier matriz para expandirla / contraerla.

Desde la página web

Principales características:

• Mostrar variables globales ($ GLOBALS, $ _POST, $ _GET, $ _COOKIE, etc.)
• Mostrar la versión de PHP y las extensiones cargadas
• Reemplazar PHP integrado en el controlador de errores
• Registrar consultas SQL
• Monitorear el código y el tiempo de ejecución de consultas SQL
• Inspeccionar variables por cambios
• Función de seguimiento de llamadas
• Análisis de cobertura de código para verificar qué líneas de script se ejecutaron
• Volcado de todos los tipos de variables
• Inspector de archivos con resaltador de código para ver el código fuente
• Enviar mensajes a la consola de JavaScript (solo Chrome), para scripts de Ajax

A partir de 2017, Firebug y, por lo tanto, FirePHP se ha deshabilitado .

Escribí algunas pequeñas modificaciones en la herramienta ChromePHP para permitir una migración perfecta de FirePHP a Firebug para la depuración a través de la consola.

Este artículo explica en pasos claros y fáciles

Migre de FirePHP a ChromePHP en 5 minutos (sin romper el código existente)

Para las llamadas Ajax o las respuestas XML / JSON, donde no desea meterse con el cuerpo, debe enviar registros a través de encabezados HTTP, luego agregarlos a la consola con una extensión web. Así es como FirePHP (ya no está disponible) y QuantumPHP (una bifurcación de ChromePHP) lo hacen en Firefox.

Si tiene paciencia, x-debug es una mejor opción: obtiene una visión más profunda de PHP, con la capacidad de pausar su script, ver lo que está sucediendo y luego reanudar el script.

Puede que llegue tarde a una fiesta, pero estaba buscando una implementación de la función de registro que:

• toma un número variable de argumentos separados por comas, al igual que JavaScript console.log() ,
• da una salida formateada (no solo una cadena serializada),
• es distinguible de un javascript común console.log().

Entonces la salida se ve así:

(El fragmento a continuación se prueba en php 7.2.11. No estoy seguro de su compatibilidad con versiones anteriores de php. También puede ser un problema para JavaScript (en términos de navegadores antiguos), porque crea una coma final después de los console.log()argumentos, lo cual no es legal hasta 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);

?>

Cualquiera de estos dos 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>");
?>

Aquí está mi solución, lo bueno de esta es que puedes pasar tantos parámetros como quieras.

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

Llámalo de esta manera

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

Ahora debería poder ver la salida en su consola, feliz codificación :)

Utilizar:

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

Aquí hay una función útil. Es súper simple de usar, le permite pasar tantos argumentos como desee, de cualquier tipo, y mostrará el contenido del objeto en la ventana de la consola del navegador como si llamara console.log desde JavaScript, pero desde PHP

Tenga en cuenta que también puede usar etiquetas pasando 'TAG-YourTag', y se aplicará hasta que se lea otra etiqueta, por ejemplo, '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 () y func_num_args () son funciones de PHP para leer un número dinámico de argumentos de entrada, y permiten que esta función tenga infinitas solicitudes de console.log de una llamada de función.

Aunque esta es una vieja pregunta, he estado buscando esto. Aquí está mi compilación de algunas soluciones respondidas aquí y algunas otras ideas encontradas en otros lugares para obtener una solución ú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');

PRUEBAS Y USO:

El uso es simple. Incluya la primera función para publicar en la consola manualmente. Use la segunda función para desviar el manejo de excepciones de php. La siguiente prueba debería dar una 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');

EXPLICACIÓN

• La función console($data, $is_error, $file, $fn)toma una cadena o matriz como primer argumento y la publica en la consola usando inserciones js.

• El segundo argumento es una bandera para diferenciar los registros normales de los errores. Para errores, estamos agregando oyentes de eventos para informarnos a través de alertas si se arrojaron errores, también resaltando en la consola. Esta bandera está predeterminada en falso.

• Los argumentos tercero y cuarto son declaraciones explícitas de archivos y números de línea, que es opcional. Si está ausente, están predeterminados para usar la función predefinida de php debug_backtrace()para buscarlos para nosotros.

• La siguiente función exceptions_to_console($svr, $str, $file, $ln)tiene cuatro argumentos en el orden invocado por el controlador de excepciones predeterminado de php. Aquí, el primer argumento es la gravedad, que verificamos con constantes predefinidas utilizando la función severity_tag($code)para proporcionar más información sobre el error.

AVISO :

• El código anterior utiliza funciones y métodos JS que no están disponibles en navegadores antiguos. Para compatibilidad con versiones anteriores, necesita reemplazos.

• El código anterior es para probar entornos, donde solo usted tiene acceso al sitio. No use esto en sitios web en vivo (producción).

SUGERENCIAS

• La primera función console()arrojó algunos avisos, así que los incluí dentro de otra función y la llamé usando el operador de control de errores '@'. Esto se puede evitar si no le importaron los avisos.

• Por último, pero no menos importante, las alertas emergentes pueden ser molestas durante la codificación. Para esto estoy usando este pitido (que se encuentra en la solución: https://stackoverflow.com/a/23395136/6060602 ) en lugar de alertas emergentes. Es genial y las posibilidades son infinitas, puedes tocar tus canciones favoritas y hacer que la codificación sea menos estresante.