Est-il possible d'écrire une chaîne ou de se connecter à la console?

Ce que je veux dire

Tout comme dans JSP, si nous imprimons quelque chose comme system.out.println("some")ça, il sera là sur la console, pas sur une page.

Firefox

Sur Firefox, vous pouvez utiliser une extension appelée FirePHP qui permet la journalisation et le vidage des informations de vos applications PHP vers la console. Il s'agit d'un addon à l'extension de développement Web génial Firebug .

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

Chrome

Cependant, si vous utilisez Chrome, il existe un outil de débogage PHP appelé Chrome Logger ou webug (webug a des problèmes avec l'ordre des journaux).

Plus récemment, Clockwork est en développement actif qui étend les outils de développement en ajoutant un nouveau panneau pour fournir des informations de débogage et de profilage utiles. Il fournit un support prêt à l' emploi pour Laravel 4 et Slim 2 et un support peut être ajouté via son API extensible.

Utiliser Xdebug

Une meilleure façon de déboguer votre PHP serait via Xdebug . La plupart des navigateurs fournissent des extensions d'assistance pour vous aider à transmettre la chaîne de cookie / requête requise pour initialiser le processus de débogage.

• Chrome - Xdebug Helper
• Firefox - Le Xdebug le plus simple
• Opera - Xdebug
• Safari - Xdebug Toggler

Ou vous utilisez l'astuce de PHP Debug pour consoler .

Vous avez d'abord besoin d'une petite fonction d'assistance PHP

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

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

Ensuite, vous pouvez l'utiliser comme ceci:

debug_to_console("Test");

Cela créera une sortie comme celle-ci:

Debug Objects: Test

Si vous cherchez une approche simple, faites écho en JSON:

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

Par défaut, toutes les sorties vont à stdout, qui est la réponse HTTP ou la console, selon que votre script est exécuté par Apache ou manuellement sur la ligne de commande. Mais vous pouvez utiliser error_logpour la journalisation et divers flux d'E / S peuvent être écrits avec fwrite.

Essayez ce qui suit. Ça fonctionne:

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

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

Crée un

<div>

avec le

display="none"

de sorte que le div ne s'affiche pas, mais le

console.log()

est créée en javascript. Vous obtenez donc le message dans la console.

En tant qu'auteur de la page Web liée dans la réponse populaire , je voudrais ajouter ma dernière version de cette fonction d'aide simple. C'est beaucoup plus solide.

J'utilise json_encode()pour vérifier si le type de variable n'est pas nécessaire et ajouter également un tampon pour résoudre les problèmes avec les frameworks. Il n'y a pas de retour solide ou d'utilisation excessive 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;
}

Usage

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

Capture d'écran du résultat

Aussi un exemple simple comme image pour le comprendre beaucoup plus facilement:

Je pense qu'il peut être utilisé -

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

Quelques bonnes réponses qui ajoutent plus de profondeur; mais j'avais besoin de quelque chose de plus simple et plus comme la console.log()commande JavaScript .

J'utilise PHP dans beaucoup de "collecte de données et transformation en XML" dans les applications Ajax. Le JavaScript console.logne fonctionne pas dans ce cas; il casse la sortie XML.

Xdebug, etc. avait des problèmes similaires.

Ma solution sous Windows:

• Configurer un .txtfichier accessible et accessible en écriture
• Définissez la error_logvariable PHP dans le .inifichier pour écrire dans ce fichier
• Ouvrez le fichier dans l' Explorateur de fichiers Windows et ouvrez un volet d'aperçu pour celui-ci
• Utilisez la error_log('myTest');commande PHP pour envoyer des messages

Cette solution est simple et répond à mes besoins la plupart du temps. PHP standard et le volet d'aperçu est automatiquement mis à jour à chaque fois que PHP y écrit.

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

Interaction PHP et JavaScript.

Je trouve cela 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;
    }
}

Et utilisez-le comme:

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

Quelles sorties dans la console:

Important
 Less Important
     Even Less Important
Again Important

Et vous pouvez désactiver les journaux moins importants en les limitant à l'aide de la valeur $ debug.

Court et facile, pour les tableaux, les chaînes ou aussi les objets.

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 vous souhaitez écrire dans le fichier journal PHP et non dans la console JavaScript, vous pouvez utiliser ceci:

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

Référence: error_log

Pour Chrome, il existe une extension appelée Chrome Logger permettant de consigner les messages PHP.

Les Firefox DevTools ont même un support intégré pour le protocole Chrome Logger .

Pour activer la journalisation, il vous suffit d'enregistrer le fichier «ChromePhp.php» dans votre projet. Ensuite, il peut être utilisé comme ceci:

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

Exemple tiré de la page GitHub .

La sortie peut alors ressembler à ceci:

Il existe également une excellente extension Google Chrome, PHP Console , avec une bibliothèque PHP qui vous permet de:

• Consultez les erreurs et exceptions dans la console JavaScript Chrome et dans les fenêtres de notification.
• Vider tout type de variable.
• Exécutez le code PHP à distance.
• Protégez l'accès par mot de passe.
• Grouper les journaux de console sur demande.
• Sauter à error file:line dans votre éditeur de texte.
• Copiez les données d'erreur / de débogage dans le presse-papiers (pour les testeurs).

Je cherchais un moyen de déboguer du code dans un plugin WordPress que je développais et suis tombé sur ce post.

J'ai pris les morceaux de code qui me sont les plus applicables dans d'autres réponses et les ai combinés en une fonction que je peux utiliser pour déboguer WordPress. La fonction est:

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'utilisation est la suivante:

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

Si cette fonction est utilisée avec le développement WordPress, la fonction doit être placée dans le functions.phpfichier du thème enfant et peut ensuite être appelée n'importe où dans le code.

J'ai abandonné tout ce qui précède au profit de Debugger & Logger . Je ne peux pas le louer assez!

Cliquez simplement sur l'un des onglets en haut à droite ou sur le "cliquez ici" pour développer / masquer.

Remarquez les différentes "catégories". Vous pouvez cliquer sur n'importe quel tableau pour l'agrandir / le réduire.

Depuis la page Web

Caractéristiques principales:

• Afficher les variables globales ($ GLOBALS, $ _POST, $ _GET, $ _COOKIE, etc.)
• Afficher la version PHP et les extensions chargées
• Remplacer le gestionnaire d'erreurs PHP intégré
• Consigner les requêtes SQL
• Surveiller le temps d'exécution du code et des requêtes SQL
• Inspecter les variables pour les changements
• Traçage des appels de fonction
• Analyse de la couverture du code pour vérifier quelles lignes de script ont été exécutées
• Dump de tous les types de variable
• Inspecteur de fichiers avec surligneur de code pour afficher le code source
• Envoyer des messages à la console JavaScript (Chrome uniquement), pour les scripts Ajax

Depuis 2017, Firebug et donc FirePHP a été désactivé .

J'ai écrit quelques petites modifications à l'outil ChromePHP pour permettre une migration transparente de FirePHP vers Firebug pour le débogage via la console.

Cet article explique en étapes simples et claires

Migrez de FirePHP vers ChromePHP en 5 minutes (sans casser le code existant)

Pour les appels Ajax ou les réponses XML / JSON, où vous ne voulez pas jouer avec le corps, vous devez envoyer des journaux via des en-têtes HTTP, puis les ajouter à la console avec une extension Web. C'est ainsi que FirePHP (plus disponible) et QuantumPHP (un fork de ChromePHP) le font dans Firefox.

Si vous avez la patience, x-debug est une meilleure option - vous obtenez une compréhension plus approfondie de PHP, avec la possibilité de suspendre votre script, de voir ce qui se passe, puis de reprendre le script.

Je suis peut-être en retard pour une fête, mais je cherchais une implémentation de la fonction de journalisation qui:

• prend un nombre variable d'arguments séparés par des virgules, tout comme javascript console.log() ,
• donne une sortie formatée (pas seulement une chaîne sérialisée),
• se distingue d'un javascript commun console.log().

La sortie ressemble donc à ça:

(L'extrait ci-dessous est testé sur php 7.2.11. Je ne suis pas sûr de sa compatibilité ascendante avec php. Cela peut également être un problème pour javascript (dans un terme d'anciens navigateurs), car il crée une virgule de fin après les console.log()arguments - ce qui n'est pas légal jusqu'au 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);

?>

Chacun de ces deux fonctionne:

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

Voici ma solution, la bonne chose à propos de celui-ci est que vous pouvez passer autant de paramètres que vous le souhaitez.

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

Appelez ça de cette façon

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

Vous devriez maintenant pouvoir voir la sortie dans votre console, codage heureux :)

Utilisation:

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

Voici une fonction pratique. Il est super simple à utiliser, vous permet de passer autant d'arguments que vous le souhaitez, de n'importe quel type, et affichera le contenu de l'objet dans la fenêtre de la console du navigateur comme si vous appeliez console.log depuis JavaScript - mais depuis PHP

Remarque, vous pouvez également utiliser des balises en passant «TAG-YourTag», et il sera appliqué jusqu'à ce qu'une autre balise soit lue, par exemple, «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>";
            }
        }
    }
}

REMARQUE: func_num_args () et func_num_args () sont des fonctions PHP pour lire un nombre dynamique d'arguments d'entrée et permettent à cette fonction d'avoir infiniment de requêtes console.log à partir d'un seul appel de fonction.

Bien que ce soit une vieille question, je la cherchais. Voici ma compilation de quelques solutions répondues ici et quelques autres idées trouvées ailleurs pour obtenir une solution unique.

CODE:

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

ESSAIS ET UTILISATION:

L'utilisation est simple. Inclure la première fonction pour publier manuellement sur la console. Utilisez la deuxième fonction pour détourner la gestion des exceptions php. Le test suivant devrait donner une idée.

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

EXPLICATION:

• La fonction console($data, $is_error, $file, $fn)prend une chaîne ou un tableau comme premier argument et la publie sur la console à l'aide d'inserts js.

• Le deuxième argument est un indicateur pour différencier les journaux normaux des erreurs. Pour les erreurs, nous ajoutons des écouteurs d'événements pour nous informer par le biais d'alertes si des erreurs ont été lancées, en les mettant également en évidence dans la console. Ce drapeau est défini par défaut sur false.

• Les troisième et quatrième arguments sont des déclarations explicites de numéros de fichier et de ligne, ce qui est facultatif. S'ils sont absents, ils utilisent par défaut la fonction php prédéfinie debug_backtrace()pour les récupérer pour nous.

• La fonction suivante exceptions_to_console($svr, $str, $file, $ln)a quatre arguments dans l'ordre appelé par le gestionnaire d'exceptions par défaut de php. Ici, le premier argument est la gravité, que nous vérifions en outre avec des constantes prédéfinies en utilisant la fonction severity_tag($code)pour fournir plus d'informations sur l'erreur.

REMARQUER :

• Le code ci-dessus utilise des fonctions et des méthodes JS qui ne sont pas disponibles dans les anciens navigateurs. Pour la compatibilité avec les anciennes versions, il a besoin de remplacements.

• Le code ci-dessus est destiné aux environnements de test, où vous seul avez accès au site. Ne l'utilisez pas sur des sites Web (de production) en direct.

SUGGESTIONS :

• La première fonction a console()lancé quelques notifications, je les ai donc enveloppées dans une autre fonction et je l'ai appelée en utilisant l'opérateur de contrôle d'erreur '@'. Cela peut être évité si cela ne vous dérange pas.

• Enfin, les alertes qui apparaissent peuvent être gênantes lors du codage. Pour cela, j'utilise ce bip (trouvé dans la solution: https://stackoverflow.com/a/23395136/6060602 ) au lieu des alertes contextuelles. C'est assez cool et les possibilités sont infinies, vous pouvez jouer vos morceaux préférés et rendre le codage moins stressant.