Hoe kan ik in PHP naar de console schrijven?

Is het mogelijk om een string te schrijven of in te loggen op de console?

Wat ik bedoel

Net als in JSP, als we iets als system.out.println("some")afdrukken, staat het daar op de console, niet op een pagina.


Antwoord 1, autoriteit 100%

Firefox

In Firefox kunt u een extensie gebruiken genaamd FirePHPdie het loggen en dumpen van informatie uit uw PHP-applicaties mogelijk maakt naar de console. Dit is een toevoeging aan de geweldige webontwikkelingsextensie Firebug.

Chrome

Als u echter Chrome gebruikt, is er een PHP-foutopsporingstool genaamd Chrome Loggerof webug(webug heeft problemen met de volgorde van logboeken).

Meer recentelijk is Clockworkin actieve ontwikkeling die de Developer Tools uitbreidt door een nieuw paneel toe te voegen aan nuttige debugging- en profileringsinformatie te verstrekken. Het biedt kant-en-klare ondersteuning voor Laravel 4en Slim 2en ondersteuning kan worden toegevoegd via de uitbreidbare API.

Xdebug gebruiken

Een betere manier om je PHP te debuggen is via Xdebug. De meeste browsers bieden hulpextensies om u te helpen de vereiste cookie-/queryreeks door te geven om het foutopsporingsproces te initialiseren.


Antwoord 2, autoriteit 94%

Of je gebruikt de truc van PHP Debug naar console.

Eerst heb je een kleine PHP-helperfunctie nodig

function debug_to_console($data) {
    $output = $data;
    if (is_array($output))
        $output = implode(',', $output);
    echo "<script>console.log('Debug Objects: " . $output . "' );</script>";
}

Dan kun je het als volgt gebruiken:

debug_to_console("Test");

Hierdoor ontstaat een uitvoer zoals deze:

Debug Objects: Test

Antwoord 3, autoriteit 51%

Als u op zoek bent naar een eenvoudige aanpak, echo als JSON:

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

Antwoord 4, autoriteit 31%

Standaard gaat alle uitvoer naar stdout, het HTTP-antwoord of de console, afhankelijk van of uw script door Apache of handmatig op de opdrachtregel wordt uitgevoerd. Maar u kunt error_loggebruiken voor het loggen en verschillende I/O-streamskunnen worden geschreven met fwrite.


Antwoord 5, autoriteit 26%

Probeer het volgende. Het werkt:

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

Antwoord 6, autoriteit 14%

Als auteur van de gelinkte webpagina in het populaire antwoord, wil ik mijn laatste versie van deze eenvoudige hulpfunctie. Het is veel steviger.

Ik gebruik json_encode()om te controleren of het variabeletype niet nodig is en voeg een buffer toe om problemen met frameworks op te lossen. Er is geen solide rendement of overmatig gebruik van 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;
}

Gebruik

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

Screenshot van het resultaat

ook een eenvoudig voorbeeld als een afbeelding om het veel eenvoudiger te begrijpen:


Antwoord 7, Autoriteit 13%

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

Creëert een

<div>

Met de

display="none"

zodat de div niet wordt weergegeven, maar de

console.log()

functie is gemaakt in JavaScript. Dus u krijgt het bericht in de console.


Antwoord 8, Autoriteit 11%

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

PHP en JavaScript-interactie.


Antwoord 9, Autoriteit 11%

Ik denk dat het kan worden gebruikt –

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

Antwoord 10, Autoriteit 9%

enkele grote antwoorden die meer diepte toevoegen; Maar ik had iets eenvoudiger en meer als het Javascript console.log()-opdracht.

Ik gebruik PHP in veel “verzamelgegevens en verander in XML” in Ajax-toepassingen. Het JavaScript console.logwerkt niet in dat geval; het breekt de XML-uitgang.

xDebug, enz. Had vergelijkbare problemen.

Mijn oplossing in Windows:

  • Instellen A .txt-bestand dat enigszins gemakkelijk is om naar en beschrijfbaar te zijn
  • Zet de PHP error_logVariabele in de .iniBestand om naar dat bestand te schrijven
  • Open het bestand in Windows bestandsverkenner en open een preview-paneel voor het
  • Gebruik de error_log('myTest');PHP-opdracht om berichten te verzenden

Deze oplossing is eenvoudig en voldoet de meeste tijd aan mijn behoeften. Standaard PHP en het voorbeeldvenster wordt automatisch bijgewerkt elke keer dat PHP erop schrijft.


Antwoord 11, Autoriteit 7%

Ik vind dit nuttig:

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

en gebruik het zoals:

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

Welke uitgangen in console:

Important
 Less Important
     Even Less Important
Again Important

En u kunt minder belangrijke logbestanden uitschakelen door ze te beperken met de waarde $debug.


Antwoord 12, autoriteit 5%

Kort en gemakkelijk, voor arrays, strings of ook objecten.

function console_log( $data ) {
  $output  = "<script>console.log( 'PHP debugger: ";
  $output .= json_encode(print_r($data, true));
  $output .= "' );</script>";
  echo $output;
}

Antwoord 13, autoriteit 5%

Voor Chrome is er een extensie genaamd Chrome Loggerwaarmee PHP-berichten kunnen worden geregistreerd.

De Firefox DevTools hebben zelfs geïntegreerde ondersteuning voor het Chrome Logger-protocol .

Om de logboekregistratie in te schakelen, hoeft u alleen de ‘ChromePhp.php’ op te slaan bestandin uw project. Dan kan het als volgt worden gebruikt:

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

Voorbeeld overgenomen van de GitHub-pagina.

De uitvoer kan er dan als volgt uitzien:


Antwoord 14, Autoriteit 5%

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

Antwoord 15, Autoriteit 5%

Als u wilt schrijven naar het PHP-logbestand, en niet de JavaScript-console die u dit kunt gebruiken:

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

Referentie: error_log


Antwoord 16, Autoriteit 3%

Er is ook een geweldige Google Chrome-extensie, PHP-console , met een PHP-bibliotheek waarmee u:

  • Zie fouten en uitzonderingen in de Chrome JavaScript-console en in de pop-up van de melding.
  • Dump elk type variabele.
  • voer op afstand PHP-code uit.
  • Toegang met wachtwoord beveiligen.
  • Groepsconsole-logs op verzoek.
  • Ga naar error file:linein uw teksteditor.
  • Fout / foutopsporingsgegevens naar het klembord (voor testers).

Antwoord 17, Autoriteit 2%

Ik was op zoek naar een manier om code te debuggen in een WordPress-plug-in die ik ontwikkelde en deze post tegenkwam.

Ik nam de stukjes code die het meest van toepassing is op mij van andere reacties en gecombineerd deze in een functie die ik kan gebruiken voor het debuggen van WordPress. De functie is:

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

Gebruik is als volgt:

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

Als deze functie wordt gebruikt met WordPress Development, moet de functie in de functions.php-bestand van het kindthema worden geplaatst en kan dan overal in de Code worden gebeld.


Antwoord 18, Autoriteit 2%

Hier is mijn oplossing, het goede ding hiervan is dat je zoveel params kunt passeren als je wilt.

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

Oproep het op deze manier

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

Nu moet u de uitvoer in uw console, Happy Coding:)

bekijken


Antwoord 19

Ik heb al het bovenstaande opgegeven ten gunste van Debugger & Logger. Ik kan het niet genoeg prijzen!

Klik gewoon op een van de tabbladen rechtsboven of op “klik hier” om uit te vouwen/verbergen.

Let op de verschillende “categorieën”. U kunt op elke array klikken om deze uit of samen te vouwen.

Van de webpagina

Belangrijkste kenmerken:

  • Toon globale variabelen ($GLOBALS, $_POST, $_GET, $_COOKIE, etc.)
  • Plaats PHP-versie en geladen extensies
  • Ingebouwde PHP-fouthandler vervangen
  • SQL-query’s loggen
  • Monitor code en uitvoeringstijd van SQL-query’s
  • Inspecteer variabelen op wijzigingen
  • Functie-oproepen traceren
  • Codedekkingsanalyse om te controleren welke scriptregels zijn uitgevoerd
  • Dump van alle soorten variabelen
  • Bestandsinspecteur met codemarkering om de broncode te bekijken
  • Stuur berichten naar JavaScript-console (alleen Chrome), voor Ajax-scripts


Antwoord 20

Vanaf 2017 is Firebug en dus FirePHP uitgeschakeld.

Ik heb wat kleine wijzigingen aangebracht aan de ChromePHP-tool om een naadloze migratie van FirePHP naar Firebug mogelijk te maken voor foutopsporing via de console.

In dit artikel wordt uitgelegd in duidelijke eenvoudige stappen

Migreer van FirePHP naar ChromePHP in 5 minuten (zonder bestaande code te breken)


Antwoord 21

Voor Ajax-oproepen of XML / JSON Reacties, waar u niet met het lichaam wilt knoeien, moet u logs via HTTP-headers verzenden en vervolgens aan de console toevoegen met een webextensie. Dit is hoe Firephp (niet langer beschikbaar) en Quantumphp (een vork van ChroomPhP) doe het in Firefox.

Als u het geduld hebt, is X-Debug een betere optie – u wordt dieper inzicht in PHP, met de mogelijkheid om uw script te pauzeren, zie wat er aan de hand is en vervolgens het script hervat.


Antwoord 22

Ik ben misschien te laat voor een feest, maar ik was op zoek naar een implementatie van de loggingfunctie die:

  • neemt een variabel aantal door komma’s gescheiden argumenten, net als Javascript console.log(),
  • geeft een geformatteerde uitvoer (niet alleen een serialized string),
  • onderscheidbaar is van een gemeenschappelijk Javascript console.log().

Dus de uitvoer ziet er zo uit:

(Het onderstaande fragment is getest op PHP 7.2.11. Ik weet het niet zeker van de PHP achterwaartse compatibiliteit. Het kan ook een probleem zijn voor JavaScript (op een termijn van oude browsers) Omdat het een trailing comma maakt na console.log()argumenten – die niet legaal is tot 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);
?>

Antwoord 23

Een van deze twee werkt:

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

Antwoord 24

Hier is een handige functie. Het is supereenvoudig te gebruiken, stelt je in staat zoveel argumenten door te geven als je wilt, van elk type, en zal de objectinhoud in het browserconsolevenster weergeven alsof je console.log vanuit JavaScript hebt aangeroepen – maar dan vanuit PHP

Opmerking, u kunt ook tags gebruiken door ‘TAG-YourTag’ door te geven, en deze wordt toegepast totdat een andere tag wordt gelezen, bijvoorbeeld ‘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>";
            }
        }
    }
}

OPMERKING: Func_Num_Args () en FUNC_NUM_ARGS () zijn PHP-functies voor het lezen van een dynamisch aantal invoerargumenten en sta deze functie toe om oneindig veel console te hebben. Log-aanvragen van de ene functie-oproep.


Antwoord 25

Hoewel dit een oude vraag is, ben ik hier naar op zoek geweest. Hier is mijn compilatie van sommige oplossingen die hier zijn beantwoord en sommige andere ideeën elders gevonden om een ​​oplossing voor één formaat te krijgen.

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 & GEBRUIK:

Gebruik is eenvoudig. Voeg de eerste functie toe om handmatig naar de console te posten. Gebruik de tweede functie om de afhandeling van php-uitzonderingen om te leiden. De volgende test zou een idee moeten geven.

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

UITLEG :

  • De functie console($data, $is_error, $file, $fn)neemt string of array als eerste argument en plaatst deze op console met js-inserts.

  • Tweede argument is een vlag om normale logs te onderscheiden van fouten. Voor fouten voegen we gebeurtenislisteners toe om ons via waarschuwingen te informeren als er fouten zijn opgetreden, ook in de console. Deze vlag is standaard ingesteld op false.

  • Derde en vierde argument zijn expliciete verklaringen van bestands- en regelnummers, wat optioneel is. Als ze afwezig zijn, gebruiken ze standaard de vooraf gedefinieerde php-functie debug_backtrace()om ze voor ons op te halen.

  • Volgende functie exceptions_to_console($svr, $str, $file, $ln)heeft vier argumenten in de volgorde die wordt aangeroepen door de standaard uitzonderingshandler van php. Hier is het eerste argument de ernst, die we verder controleren met vooraf gedefinieerde constanten met behulp van de functie severity_tag($code)om meer informatie over fouten te geven.

OPMERKING:

  • Bovenstaande code gebruikt JS-functies en -methoden die niet beschikbaar zijn in oudere browsers. Voor compatibiliteit met oudere versies heeft het vervangingen nodig.

  • Bovenstaande code is voor testomgevingen, waar alleen u toegang heeft tot de site. Gebruik dit niet in live (productie)websites.

SUGGESTIES:

  • Eerste functie console()gooide enkele mededelingen, dus ik heb ze in een andere functie gewikkeld en deze aangeroepen met de foutcontrole-operator ‘@’. Dit kan worden vermeden als u de mededelingen niet erg vindt.

  • Last but not least kunnen waarschuwingen die verschijnen, vervelend zijn tijdens het coderen. Hiervoor gebruik ik deze pieptoon (te vinden in oplossing: https://stackoverflow.com/a/23395136/6060602) in plaats van pop-upwaarschuwingen. Het is best cool en de mogelijkheden zijn eindeloos, je kunt je favoriete deuntjes spelen en coderen minder stressvol maken.


Antwoord 26

Schoon, snel en eenvoudig zonder nutteloze code:

function consolelog($data) {
    echo "<script>console.log('".$data."');</script>";
}

Antwoord 27

Gebruik:

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

Antwoord 28

Kort en eenvoudig met printfen json_encode:

function console_log($data) {
    printf('<script>console.log(%s);</script>', json_encode($data));
}

Antwoord 29

Ik denk dat de beste oplossing is om te gebruiken
error_log(content)
Dit is uitvoer


Antwoord 30

in startcode…

error_reporting(-1);
ini_set('display_errors', 'On'); 

het werkt

Other episodes