Ist es möglich, einen String zu schreiben oder sich in die Konsole einzuloggen?

Was ich meine

Genau wie in JSP wird etwas, das wir drucken system.out.println("some"), an der Konsole und nicht auf einer Seite angezeigt.

Feuerfuchs

In Firefox können Sie eine Erweiterung namens FirePHP verwenden , die das Protokollieren und Speichern von Informationen aus Ihren PHP-Anwendungen auf der Konsole ermöglicht. Dies ist ein Addon zur fantastischen Webentwicklungserweiterung Firebug .

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

Chrom

Wenn Sie jedoch Chrome verwenden, gibt es ein PHP-Debugging-Tool namens Chrome Logger oder webug (webug hat Probleme mit der Reihenfolge der Protokolle).

In jüngerer Zeit befindet sich Clockwork in der aktiven Entwicklung, die die Entwicklertools um ein neues Bedienfeld erweitert, das nützliche Informationen zum Debuggen und Profilieren bietet. Es bietet sofort Unterstützung für Laravel 4 und Slim 2 und kann über die erweiterbare API hinzugefügt werden.

Verwenden von Xdebug

Ein besserer Weg, um Ihr PHP zu debuggen, wäre über Xdebug . Die meisten Browser bieten Hilfserweiterungen, mit denen Sie die erforderliche Cookie- / Abfragezeichenfolge übergeben können, um den Debugging-Prozess zu initialisieren.

• Chrome - Xdebug Helper
• Firefox - Der einfachste Xdebug
• Opera - Xdebug
• Safari - Xdebug Toggler

Oder Sie verwenden den Trick von PHP Debug zur Konsole .

Zuerst benötigen Sie eine kleine PHP-Hilfsfunktion

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

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

Dann können Sie es so verwenden:

debug_to_console("Test");

Dadurch wird eine Ausgabe wie folgt erstellt:

Debug Objects: Test

Wenn Sie nach einem einfachen Ansatz suchen, geben Sie als JSON wieder:

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

Standardmäßig wird die gesamte Ausgabe an stdoutdie HTTP-Antwort oder die Konsole gesendet, je nachdem, ob Ihr Skript von Apache oder manuell in der Befehlszeile ausgeführt wird. Sie können es jedoch error_logfür die Protokollierung verwenden und verschiedene E / A-Streams können mit geschrieben werden fwrite.

Versuche Folgendes. Es funktioniert:

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

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

Erstellt eine

<div>

mit dem

display="none"

damit das div nicht angezeigt wird, sondern das

console.log()

Funktion wird in Javascript erstellt. So erhalten Sie die Nachricht in der Konsole.

Als Autor der verlinkten Webseite in der beliebten Antwort möchte ich meine letzte Version dieser einfachen Hilfsfunktion hinzufügen. Es ist viel fester.

Ich json_encode()überprüfe, ob der Variablentyp nicht erforderlich ist, und füge einen Puffer hinzu, um Probleme mit Frameworks zu lösen. Es gibt keine solide Rendite oder übermäßige Nutzung von 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;
}

Verwendungszweck

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

Screenshot des Ergebnisses

Auch ein einfaches Beispiel als Bild, um es viel einfacher zu verstehen:

Ich denke, es kann verwendet werden -

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

Einige großartige Antworten, die mehr Tiefe hinzufügen; aber ich brauchte etwas einfacheres und ähnlicheres wie den JavaScript- console.log()Befehl.

Ich benutze PHP in vielen "Daten sammeln und in XML verwandeln" in Ajax-Anwendungen. Das JavaScript console.logfunktioniert in diesem Fall nicht. es bricht die XML-Ausgabe.

Xdebug usw. hatte ähnliche Probleme.

Meine Lösung in Windows:

• Richten Sie eine .txtDatei ein, die leicht zugänglich und beschreibbar ist
• Stellen Sie die PHP- error_logVariable in der .iniDatei so ein, dass in diese Datei geschrieben wird
• Öffnen Sie die Datei im Windows- Datei-Explorer und öffnen Sie einen Vorschaufenster dafür
• Verwenden Sie den error_log('myTest');PHP-Befehl, um Nachrichten zu senden

Diese Lösung ist einfach und erfüllt die meiste Zeit meine Anforderungen. Standard-PHP und das Vorschaufenster werden bei jedem Schreiben von PHP automatisch aktualisiert.

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

PHP- und JavaScript-Interaktion.

Ich finde das hilfreich:

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

Und benutze es wie:

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

Welche Ausgänge in der Konsole:

Important
 Less Important
     Even Less Important
Again Important

Und Sie können weniger wichtige Protokolle ausschalten, indem Sie sie mit dem Wert $ debug einschränken.

Kurz und einfach, für Arrays, Strings oder auch Objekte.

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
}

Wenn Sie in die PHP-Protokolldatei und nicht in die JavaScript-Konsole schreiben möchten, können Sie Folgendes verwenden:

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

Referenz: error_log

Für Chrome gibt es eine Erweiterung namens Chrome Logger , mit der PHP-Nachrichten protokolliert werden können.

Die Firefox DevTools unterstützen sogar das Chrome Logger-Protokoll .

Um die Protokollierung zu aktivieren, müssen Sie nur die Datei 'ChromePhp.php' in Ihrem Projekt speichern . Dann kann es so verwendet werden:

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

Beispiel von der GitHub-Seite .

Die Ausgabe kann dann folgendermaßen aussehen:

Es gibt auch eine großartige Google Chrome-Erweiterung, PHP Console , mit einer PHP-Bibliothek , mit der Sie:

• Siehe Fehler und Ausnahmen in der Chrome JavaScript-Konsole und in den Benachrichtigungs-Popups.
• Dump jede Art von Variable.
• Führen Sie PHP-Code remote aus.
• Schützen Sie den Zugriff mit einem Passwort.
• Gruppieren Sie Konsolenprotokolle auf Anfrage.
• Wechseln Sie error file:linein Ihrem Texteditor zu.
• Kopieren Sie Fehler- / Debug-Daten in die Zwischenablage (für Tester).

Ich suchte nach einer Möglichkeit, Code in einem von mir entwickelten WordPress-Plugin zu debuggen, und stieß auf diesen Beitrag.

Ich habe die Code-Teile, die für mich am besten geeignet sind, aus anderen Antworten genommen und diese zu einer Funktion kombiniert, die ich zum Debuggen von WordPress verwenden kann. Die Funktion ist:

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

Die Verwendung ist wie folgt:

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

Wenn diese Funktion bei der WordPress-Entwicklung verwendet wird, sollte die Funktion in der functions.phpDatei des untergeordneten Themas platziert werden und kann dann an einer beliebigen Stelle im Code aufgerufen werden.

Ich habe all das zugunsten von Debugger & Logger aufgegeben . Ich kann es nicht genug loben!

Klicken Sie einfach auf eine der Registerkarten oben rechts oder auf "Hier klicken", um sie zu erweitern / auszublenden.

Beachten Sie die verschiedenen "Kategorien". Sie können auf ein beliebiges Array klicken, um es zu erweitern / zu reduzieren.

Von der Webseite

Haupteigenschaften:

• Globale Variablen anzeigen ($ GLOBALS, $ _POST, $ _GET, $ _COOKIE usw.)
• PHP-Version und geladene Erweiterungen anzeigen
• Ersetzen Sie den in PHP integrierten Fehlerbehandler
• Protokollieren Sie SQL-Abfragen
• Überwachen Sie die Ausführungszeit von Code- und SQL-Abfragen
• Überprüfen Sie die Variablen auf Änderungen
• Ablaufverfolgung von Funktionsaufrufen
• Analyse der Codeabdeckung, um zu überprüfen, welche Skriptzeilen ausgeführt wurden
• Speicherauszug aller Arten von Variablen
• Dateiinspektor mit Code-Textmarker zum Anzeigen des Quellcodes
• Senden Sie Nachrichten für Ajax-Skripte an die JavaScript-Konsole (nur Chrome)

Ab 2017 wurde Firebug und damit FirePHP deaktiviert .

Ich habe einige kleine Änderungen am ChromePHP-Tool vorgenommen, um eine nahtlose Migration von FirePHP zu Firebug zum Debuggen über die Konsole zu ermöglichen.

Dieser Artikel erklärt in einfachen Schritten

Migrieren Sie in 5 Minuten von FirePHP zu ChromePHP (ohne vorhandenen Code zu beschädigen).

Bei Ajax-Aufrufen oder XML / JSON-Antworten, bei denen Sie sich nicht mit dem Text herumschlagen möchten, müssen Sie Protokolle über HTTP-Header senden und diese dann mit einer Web-Erweiterung zur Konsole hinzufügen. So machen es FirePHP (nicht mehr verfügbar) und QuantumPHP (eine Gabelung von ChromePHP) in Firefox.

Wenn Sie die Geduld haben, ist x-debug eine bessere Option - Sie erhalten einen tieferen Einblick in PHP, können Ihr Skript anhalten, sehen, was gerade passiert, und dann das Skript fortsetzen.

Ich könnte zu spät zu einer Party kommen, aber ich suchte nach einer Implementierung der Protokollierungsfunktion, die:

• verwendet eine variable Anzahl von durch Kommas getrennten Argumenten, genau wie Javascript console.log() ,
• gibt eine formatierte Ausgabe (nicht nur eine serialisierte Zeichenfolge),
• ist von einem gängigen Javascript unterscheidbar console.log().

Die Ausgabe sieht also so aus:

(Das folgende Snippet wurde auf PHP getestet 7.2.11. Ich bin mir nicht sicher, ob es auf PHP abwärtskompatibel ist. Es kann auch ein Problem für Javascript sein (in einem Begriff alter Browser), da es nach console.log()Argumenten ein nachfolgendes Komma erzeugt - was nicht der Fall ist legal bis 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);

?>

Alle diese beiden funktionieren:

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

Verwenden:

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

Hier ist eine praktische Funktion. Es ist sehr einfach zu bedienen, ermöglicht es Ihnen, beliebig viele Argumente eines beliebigen Typs zu übergeben und zeigt den Objektinhalt im Browser-Konsolenfenster so an, als hätten Sie console.log über JavaScript aufgerufen - aber über PHP

Beachten Sie, dass Sie Tags auch verwenden können, indem Sie 'TAG-YourTag' übergeben. Diese werden angewendet, bis ein anderes Tag gelesen wird, z. B. '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>";
            }
        }
    }
}

HINWEIS : func_num_args () und func_num_args () sind PHP-Funktionen zum Lesen einer dynamischen Anzahl von Eingabeargumenten und ermöglichen es dieser Funktion, unendlich viele console.log-Anforderungen von einem Funktionsaufruf zu erhalten.

Hier ist meine Lösung. Das Gute an dieser ist, dass Sie so viele Parameter übergeben können, wie Sie möchten.

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

Nennen Sie es so

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

Jetzt sollten Sie in der Lage sein, die Ausgabe in Ihrer Konsole zu sehen, fröhliche Codierung :)

Obwohl dies eine alte Frage ist, habe ich danach gesucht. Hier ist meine Zusammenstellung einiger hier beantworteter Lösungen und einiger anderer Ideen, die an anderer Stelle gefunden wurden, um eine Einheitslösung zu erhalten.

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

TESTS & NUTZUNG:

Die Verwendung ist einfach. Fügen Sie die erste Funktion zum manuellen Posten auf der Konsole hinzu. Verwenden Sie die zweite Funktion, um die Behandlung von PHP-Ausnahmen umzuleiten. Der folgende Test sollte eine Idee geben.

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

ERKLÄRUNG:

• Die Funktion verwendet einen console($data, $is_error, $file, $fn)String oder ein Array als erstes Argument und stellt es mithilfe von js-Einfügungen auf der Konsole bereit.

• Das zweite Argument ist ein Flag, um normale Protokolle von Fehlern zu unterscheiden. Bei Fehlern fügen wir Ereignis-Listener hinzu, um uns durch Warnungen zu informieren, wenn Fehler ausgelöst wurden, und um sie auch in der Konsole hervorzuheben. Dieses Flag ist standardmäßig auf false gesetzt.

• Das dritte und vierte Argument sind explizite Deklarationen von Datei- und Zeilennummern, was optional ist. Wenn sie nicht vorhanden sind, verwenden sie standardmäßig die vordefinierte PHP-Funktion debug_backtrace(), um sie für uns abzurufen.

• Die nächste Funktion exceptions_to_console($svr, $str, $file, $ln)hat vier Argumente in der Reihenfolge, die vom PHP-Standardausnahmehandler aufgerufen wird. Hier ist das erste Argument der Schweregrad, den wir mit vordefinierten Konstanten unter Verwendung der Funktion weiter überprüfen severity_tag($code), um weitere Informationen zu Fehlern bereitzustellen.

BEACHTEN :

• Der obige Code verwendet JS-Funktionen und -Methoden, die in älteren Browsern nicht verfügbar sind. Aus Gründen der Kompatibilität mit älteren Versionen muss es ersetzt werden.

• Der obige Code dient zum Testen von Umgebungen, in denen Sie allein Zugriff auf die Site haben. Verwenden Sie dies nicht in Live-Websites (Produktionswebsites).

VORSCHLÄGE :

• Die erste Funktion hat console()einige Hinweise ausgegeben, daher habe ich sie in eine andere Funktion eingeschlossen und sie mit dem Fehlerkontrolloperator '@' aufgerufen. Dies kann vermieden werden, wenn Ihnen die Hinweise nichts ausmachen.

• Zu guter Letzt kann das Auftauchen von Warnungen beim Codieren ärgerlich sein. Dafür verwende ich diesen Piepton (in Lösung gefunden: https://stackoverflow.com/a/23395136/6060602 ) anstelle von Popup-Warnungen. Es ist ziemlich cool und die Möglichkeiten sind endlos. Sie können Ihre Lieblingsmusik spielen und das Codieren weniger stressig machen.