Ou vous utilisez l'astuce de ce site PHP Debug console

D'abord, vous avez besoin d'une petite fonction D'aide PHP

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

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

, Alors vous pouvez l'utiliser comme ceci

debug_to_console( "Test" );

, Cela va créer une sortie comme ceci:

Debug Objects: Test

Si vous cherchez une approche simple, echo as 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_log pour l'enregistrement et le divers flux e/S peut être écrit avec fwrite.

Essayez ceci il fonctionne:

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

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

J'utilise PHP dans beaucoup de "collecte de données et transformation en xml" dans L'application AJAX. le JS console.log ne fonctionne pas dans ce cas; il casse la sortie xml. (Peut-être que quelqu'un a une solution pour cela?)

Xdebug etc avait des problèmes similaires.

Ma solution dans Windows:

• configurez un fichier .txt accessible et accessible en écriture
• définir le PHP error_log variable dans le .ini fichier pour écrire ce fichier
• ouvrez le fichier dans l'Explorateur de fichiers Windows et ouvrez un volet de prévisualisation
• Utilisez la commande error_log('myTest'); PHP pour envoyer des messages

Cette solution est simple, répond à mes besoins la plupart du temps, PHP standard, et le volet de prévisualisation se met automatiquement à jour chaque fois que PHP y écrit.

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

J'utilise json_encode() pour vérifier le type var 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;
}

Utilisation

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

Capture D'écran du résultat

Aussi un exemple simple comme image à comprendre beaucoup facile.

Je trouve cela utile:

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

        echo $output;
    }
}

Et l'utiliser 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);
?>

Qui sort dans la console:

Important
 Less Important
     Even Less Important
Again Important

Et vous pouvez désactiver les journaux moins importants en les limitant en utilisant $debug value

    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 n'est pas affiché, mais le

    console.log()

Est créée en javascript. Si vous obtenez le message dans la console.

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

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

Je pense qu'il peut être utilisé --

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

    if (is_array($data) || is_object($data)) {
        $html = "<script>console.log('PHP: ".json_encode($data)."');</script>";
    } else {
        $html = "<script>console.log('PHP: ".$data."');</script>";
    }

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

jsLogs(array("test1", "test2")); # PHP: ["test1","test2"]
jsLogs(array("test1"=>array("subtest1", "subtest2"))); #PHP: {"test1":["subtest1","subtest2"]}
jsLogs("testing string"); #PHP: testing string

Si vous voulez écrire dans le fichier journal PHP, et non la console JavaScript, vous pouvez utiliser ceci:

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

Référence: http://php.net/manual/en/function.error-log.php

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

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

Pour activer la journalisation, il vous suffit d'enregistrer le 'ChromePhp.php fichier 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 à ce:

Il y a aussi une grande extension Google Chrome Console PHP avec bibliothèque php qui permet de:

• Voir erreurs et exception dans la console JavaScript Chrome et dans les popups de notification.
• vider toute variable de type.
• exécuter du code PHP à distance.
• Protégez l'accès par mot de passe.
• grouper les journaux de la console sur demande.
• aller au fichier d'erreur: ligne dans votre éditeur de texte.
• copier les données d'erreur / débogage dans le presse-papiers (pour les testeurs).

J'ai abandonné tout ce qui précède en faveur de http://phptoolcase.com/guides/ptc-debug-guide.html 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.

Notez les différentes "catégories". Vous pouvez cliquer sur n'importe quel tableau pour le développer/le coller.

Fromn la page web

"Caractéristiques Principales:

Show globals vars ($GLOBALS, $_POST, $_GET, $_COOKIE ...)
Show php version and loaded extensions
Replace php built in error handler
Log sql queries
Monitor code and sql queries execution time
Inspect variables for changes
Function calls tracing
Code coverage analysis to check which lines of script where executed
Dump of all types of variable
File inspector with code highlighter to view source code
Send messages to js console(Chrome only), for ajax scripts

"

Grand post merci, je cherchais un moyen de déboguer le code dans un plugin Wordpress que je développais et suis tombé sur ce post.

J'ai pris les bits de code qui me sont les plus applicables à partir des réponses ci-dessus 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 );

J'espère que quelqu'un d'autre trouvera cette fonction utile.

Si cette fonction est utilisée avec le développement fonction doit être placé dans les fonctions.fichier php du thème enfant et peut ensuite être appelé n'importe où dans le code.

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

Interaction PHP et Javascript.

À partir de 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 à firebug pour le débogage via la console.

Cet article explique clairement les étapes simples

Https://medium.com/@kudehinbuoluwaponle/migrate-from-firephp-to-chromephp-in-5-minutes-without-breaking-existing-code-e4afd1b28c5c

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 et QuantumPHP (une fourchette de ChromePHP) le font dans Firefox.

Si vous avez la patience, x-debug est une meilleure option - vous obtenez un aperçu plus profond de PHP, avec la possibilité de mettre en pause votre script, voir ce qui se passe, puis reprendre le script.

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

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

    if ( is_array( $data ) )
        error_log( end(split('/',$caller['file'])) . ':' . $caller['line'] . ' => ' . implode( ',', $data) );
    else
        error_log( end(split('/',$caller['file'])) . ':' . $caller['line'] . ' => ' . $data );

}

Voici une fonction pratique. Il est super simple à utiliser, vous permet de passer autant d'arguments que vous le souhaitez, de tout type, et affichera le contenu de l'objet dans la fenêtre de la console du navigateur comme si vous appeliez console.log à partir de JavaScript-mais à partir de 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'args d'entrée, et permettre à cette fonction d'avoir infiniment beaucoup de console.journaliser les demandes d'un appel de fonction