Czy można napisać ciąg lub zalogować się do konsoli?

Co miałem na myśli

Podobnie jak w JSP, jeśli wydrukujemy coś takiego system.out.println("some"), będzie tam na konsoli, a nie na stronie.

Firefox

W przeglądarce Firefox można użyć rozszerzenia o nazwie FirePHP, które umożliwia rejestrowanie i zrzut informacji z aplikacji PHP na konsolę. Jest to dodatek do niesamowitego rozszerzenia do projektowania stron internetowych Firebug .

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

Chrom

Jeśli jednak używasz Chrome, istnieje narzędzie do debugowania PHP o nazwie Chrome Logger lub webug (webug ma problemy z kolejnością dzienników).

Ostatnio Clockwork jest w fazie rozwoju, która rozszerza Narzędzia programistyczne, dodając nowy panel, który zapewnia przydatne informacje dotyczące debugowania i profilowania. Zapewnia natychmiastowe wsparcie dla Laravel 4 i Slim 2, a wsparcie można dodać za pomocą rozszerzalnego interfejsu API.

Korzystanie z Xdebug

Lepszym sposobem na debugowanie PHP jest Xdebug . Większość przeglądarek zapewnia rozszerzenia pomocnicze, które pomagają przekazać wymagany ciąg cookie / ciąg zapytania w celu zainicjowania procesu debugowania.

• Chrome - Xdebug Helper
• Firefox - najłatwiejszy Xdebug
• Opera - Xdebug
• Safari - Xdebug Toggler

Lub wykorzystujesz sztuczkę z PHP Debuguj do konsoli .

Najpierw potrzebujesz małej funkcji pomocnika PHP

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

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

Następnie możesz użyć tego w następujący sposób:

debug_to_console("Test");

Spowoduje to utworzenie takiego wyniku:

Debug Objects: Test

Jeśli szukasz prostego podejścia, wykonaj echo jako JSON:

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

Domyślnie wszystkie dane wyjściowe są przekazywane do stdout, czyli odpowiedzi HTTP lub konsoli, w zależności od tego, czy skrypt jest uruchamiany przez Apache, czy ręcznie w wierszu polecenia. Ale można używać error_logdo rejestrowania i różnych strumieni I / O może być zapisanych do z fwrite.

Spróbuj wykonać następujące czynności. To działa:

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

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

Tworzy a

<div>

z

display="none"

aby div nie był wyświetlany, ale

console.log()

funkcja jest tworzona w javascript. Otrzymujesz wiadomość w konsoli.

Jako autor połączonej strony w popularnej odpowiedzi , chciałbym dodać moją ostatnią wersję tej prostej funkcji pomocnika. Jest o wiele bardziej solidny.

Używam, json_encode()aby sprawdzić, czy typ zmiennej nie jest konieczny, a także dodać bufor, aby rozwiązać problemy z frameworkami. Nie ma stałego zwrotu ani nadmiernego wykorzystania 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;
}

Stosowanie

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

Zrzut ekranu wyniku

Również prosty przykład jako obraz, aby zrozumieć to znacznie łatwiej:

Myślę, że można go użyć -

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

Kilka świetnych odpowiedzi, które dodają więcej głębi; ale potrzebowałem czegoś prostszego i bardziej podobnego do JavaScriptconsole.log() polecenia .

Używam PHP do „zbierania danych i przekształcania w XML” w aplikacjach Ajax. W takim przypadku JavaScript console.lognie działa; psuje wyjście XML.

Xdebug itp. Miał podobne problemy.

Moje rozwiązanie w systemie Windows:

• Skonfiguruj .txtplik, który jest dość łatwy do zdobycia i do zapisu
• Ustaw error_logzmienną PHP w .inipliku, aby zapisać do tego pliku
• Otwórz plik w Eksploratorze plików systemu Windows i otwórz okienko podglądu
• Użyj error_log('myTest');polecenia PHP, aby wysyłać wiadomości

To rozwiązanie jest proste i przez większość czasu spełnia moje potrzeby. Standardowe PHP, a okienko podglądu aktualizuje się automatycznie za każdym razem, gdy PHP do niego pisze.

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

Interakcja PHP i JavaScript.

Uważam to za pomocne:

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

I używaj go w następujący sposób:

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

Które wyjścia w konsoli:

Important
 Less Important
     Even Less Important
Again Important

Możesz wyłączyć mniej ważne dzienniki, ograniczając je przy użyciu wartości $ debugowania.

Krótkie i łatwe, do tablic, ciągów znaków, a także obiektów.

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
}

Jeśli chcesz pisać do pliku dziennika PHP, a nie do konsoli JavaScript, możesz użyć tego:

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

Odniesienie: dziennik błędów

W przeglądarce Chrome jest rozszerzenie o nazwie Chrome Logger, umożliwiające rejestrowanie wiadomości PHP.

Firefox DevTools ma nawet zintegrowaną obsługę protokołu Chrome Logger .

Aby włączyć rejestrowanie, wystarczy zapisać plik „ChromePhp.php” w swoim projekcie. Następnie można go użyć w następujący sposób:

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

Przykład pochodzi ze strony GitHub .

Dane wyjściowe mogą wyglądać następująco:

Istnieje również świetne rozszerzenie Google Chrome, konsola PHP , z biblioteką PHP, która pozwala:

• Zobacz błędy i wyjątki w konsoli Chrome JavaScript i wyskakujących oknach powiadomień.
• Zrzuć dowolny typ zmiennej.
• Wykonuj kod PHP zdalnie.
• Chroń dostęp hasłem.
• Grupuj dzienniki konsoli na żądanie.
• Przejdź do error file:lineedytora tekstu.
• Skopiuj dane błędu / debugowania do schowka (dla testerów).

Szukałem sposobu debugowania kodu we wtyczce WordPress, którą opracowywałem i natknąłem się na ten post.

Wziąłem fragmenty kodu, które są dla mnie najbardziej odpowiednie, z innych odpowiedzi i połączyłem je w funkcję, której mogę użyć do debugowania WordPress. Funkcja to:

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

Użycie jest następujące:

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

Jeśli ta funkcja jest używana z programowaniem WordPress, należy ją umieścić w functions.phppliku motywu potomnego, a następnie można wywołać w dowolnym miejscu kodu.

Porzuciłem wszystkie powyższe na rzecz Debuggera i Loggera . Nie mogę tego wystarczająco pochwalić!

Wystarczy kliknąć jedną z kart w prawym górnym rogu lub „kliknij tutaj”, aby rozwinąć / ukryć.

Zwróć uwagę na różne „kategorie”. Możesz kliknąć dowolną tablicę, aby ją rozwinąć / zwinąć.

Ze strony internetowej

Główne cechy:

• Pokaż zmienne globalne ($ GLOBALS, $ _POST, $ _GET, $ _COOKIE itp.)
• Pokaż wersję PHP i załadowane rozszerzenia
• Zastąp wbudowaną obsługę błędów PHP
• Zaloguj zapytania SQL
• Monitoruj czas wykonywania kodu i zapytań SQL
• Sprawdź zmienne pod kątem zmian
• Śledzenie wywołań funkcji
• Analiza zasięgu kodu w celu sprawdzenia, które wiersze skryptu zostały wykonane
• Zrzut wszystkich typów zmiennych
• Inspektor plików z wyróżnieniem kodu, aby wyświetlić kod źródłowy
• Wysyłaj wiadomości do konsoli JavaScript (tylko Chrome) w przypadku skryptów Ajax

Od 2017 roku Firebug, a więc i FirePHP, został wyłączony .

Napisałem kilka drobnych modyfikacji w narzędziu ChromePHP, aby umożliwić płynną migrację z FirePHP do Firebug w celu debugowania za pośrednictwem konsoli.

W tym artykule wyjaśniono w łatwych krokach

Migracja z FirePHP do ChromePHP w 5 minut (bez zerwania istniejącego kodu)

W przypadku wywołań Ajax lub odpowiedzi XML / JSON, w których nie chcesz zadzierać z treścią, musisz wysłać dzienniki przez nagłówki HTTP, a następnie dodać je do konsoli za pomocą rozszerzenia internetowego. W ten sposób FirePHP (nie jest już dostępny) i QuantumPHP (rozwidlenie ChromePHP) robią to w Firefox.

Jeśli masz cierpliwość, x-debugowanie jest lepszą opcją - masz głębszy wgląd w PHP, z możliwością wstrzymania skryptu, sprawdzenia, co się dzieje, a następnie wznowienia skryptu.

Mogę się spóźnić na imprezę, ale szukałem implementacji funkcji logowania, która:

• pobiera zmienną liczbę argumentów oddzielonych przecinkami, tak jak javascript console.log(),
• daje sformatowane wyjście (nie tylko szeregowy ciąg),
• jest odróżnialny od wspólnego javascript console.log().

Dane wyjściowe wyglądają tak:

(Poniższy fragment kodu jest testowany na php 7.2.11. Nie jestem pewien jego zgodności wstecznej z php. Może to stanowić problem również dla javascript (w terminach starych przeglądarek), ponieważ tworzy on przecinek po console.log()argumentach - co nie jest legalne do 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);

?>

Każdy z tych dwóch działa:

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

Oto moje rozwiązanie, dobrą rzeczą jest to, że możesz przekazać tyle parametrów, ile chcesz.

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

Nazwij to w ten sposób

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

Teraz powinieneś być w stanie zobaczyć wyjście w konsoli, szczęśliwego kodowania :)

Posługiwać się:

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

Oto przydatna funkcja. Jest bardzo prosty w użyciu, pozwala przekazywać dowolną liczbę argumentów dowolnego rodzaju i wyświetla zawartość obiektu w oknie konsoli przeglądarki tak, jakbyś wywołał console.log z JavaScript - ale z PHP

Uwaga: możesz także używać tagów, przekazując „TAG-YourTag”, i będzie on stosowany, dopóki nie zostanie odczytany inny tag, na przykład „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>";
            }
        }
    }
}

UWAGA: func_num_args () i func_num_args () to funkcje PHP do odczytu dynamicznej liczby argumentów wejściowych i pozwalają tej funkcji na nieskończenie wiele żądań console.log z jednego wywołania funkcji.

Chociaż to stare pytanie, szukałem tego. Oto moja kompilacja niektórych rozwiązań, na które odpowiedziano tutaj, i kilka innych pomysłów znalezionych gdzie indziej, aby uzyskać rozwiązanie uniwersalne.

KOD :

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

TESTY I UŻYTKOWANIE:

Użycie jest proste. Uwzględnij pierwszą funkcję ręcznego wysyłania do konsoli. Użyj drugiej funkcji do przekierowywania obsługi wyjątków php. Poniższy test powinien dać pomysł.

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

OBJAŚNIENIE:

• Funkcja console($data, $is_error, $file, $fn)przyjmuje ciąg lub tablicę jako pierwszy argument i umieszcza go na konsoli za pomocą wstawek js.

• Drugi argument to flaga odróżniająca zwykłe dzienniki od błędów. W przypadku błędów dodajemy detektory zdarzeń, aby informować nas za pośrednictwem alertów o wystąpieniu błędów, a także wyróżniać w konsoli. Ta flaga ma domyślną wartość false.

• Trzeci i czwarty argument to jawne deklaracje numerów plików i linii, które są opcjonalne. Jeśli ich nie ma, domyślnie używają predefiniowanej funkcji php, debug_backtrace()aby je dla nas pobrać.

• Następna funkcja exceptions_to_console($svr, $str, $file, $ln)ma cztery argumenty w kolejności wywoływanej przez domyślną procedurę obsługi wyjątków php. Tutaj pierwszym argumentem jest dotkliwość, którą dodatkowo sprawdzamy za pomocą predefiniowanych stałych za pomocą funkcji, severity_tag($code)aby dostarczyć więcej informacji o błędzie.

OGŁOSZENIE :

• Powyższy kod używa funkcji i metod JS, które nie są dostępne w starszych przeglądarkach. Aby zachować zgodność ze starszymi wersjami, wymaga wymiany.

• Powyższy kod służy do testowania środowisk, w których tylko Ty masz dostęp do witryny. Nie używaj tego w witrynach na żywo (produkcyjnych).

PROPOZYCJE :

• Pierwsza funkcja console()rzuciła pewne uwagi, więc zawinąłem je w inną funkcję i nazwałem ją za pomocą operatora kontroli błędów „@”. Można tego uniknąć, jeśli nie przeszkadza ci zawiadomienie.

• Co więcej, pojawiające się alerty mogą być denerwujące podczas kodowania. W tym celu używam tego sygnału dźwiękowego (znalezionego w rozwiązaniu: https://stackoverflow.com/a/23395136/6060602 ) zamiast alertów wyskakujących. Jest całkiem fajny, a możliwości są nieograniczone, możesz grać w swoje ulubione utwory i sprawić, że kodowanie będzie mniej stresujące.