What happened to console.log in IE8?

What happened to console.log in IE8?

According to this post it was in the beta, but it’s not in the release?


Solution 1:

Even better for fallback is this:

   var alertFallback = true;
   if (typeof console === "undefined" || typeof console.log === "undefined") {
     console = {};
     if (alertFallback) {
         console.log = function(msg) {
     } else {
         console.log = function() {};

Solution 2:

console.log is only available after you have opened the Developer Tools (F12 to toggle it open and closed).
Funny thing is that after you’ve opened it, you can close it, then still post to it via console.log calls, and those will be seen when you reopen it.
I’m thinking that is a bug of sorts, and may be fixed, but we shall see.

I’ll probably just use something like this:

function trace(s) {
  if ('console' in self && 'log' in console) console.log(s)
  // the line below you might want to comment out, so it dies silent
  // but nice for seeing when the console is available or not.
  else alert(s)

and even simpler:

function trace(s) {
  try { console.log(s) } catch (e) { alert(s) }

Solution 3:

This is my take on the various answers. I wanted to actually see the logged messages, even if I did not have the IE console open when they were fired, so I push them into a console.messages array that I create. I also added a function console.dump() to facilitate viewing the whole log. console.clear() will empty the message queue.

Related:  How to change cursor from pointer to finger using jQuery?

This solutions also “handles” the other Console methods (which I believe all originate from the Firebug Console API)

Finally, this solution is in the form of an IIFE, so it does not pollute the global scope. The fallback function argument is defined at the bottom of the code.

I just drop it in my master JS file which is included on every page, and forget about it.

(function (fallback) {    

    fallback = fallback || function () { };

    // function to trap most of the console functions from the FireBug Console API. 
    var trap = function () {
        // create an Array from the arguments Object           
        var args = Array.prototype.slice.call(arguments);
        // console.raw captures the raw args, without converting toString
        var message = args.join(' ');

    // redefine console
    if (typeof console === 'undefined') {
        console = {
            messages: [],
            raw: [],
            dump: function() { return console.messages.join('\n'); },
            log: trap,
            debug: trap,
            info: trap,
            warn: trap,
            error: trap,
            assert: trap,
            clear: function() { 
                  console.messages.length = 0; 
                  console.raw.length = 0 ;
            dir: trap,
            dirxml: trap,
            trace: trap,
            group: trap,
            groupCollapsed: trap,
            groupEnd: trap,
            time: trap,
            timeEnd: trap,
            timeStamp: trap,
            profile: trap,
            profileEnd: trap,
            count: trap,
            exception: trap,
            table: trap

})(null); // to define a fallback function, replace null with the name of the function (ex: alert)

Some extra info

The line var args = Array.prototype.slice.call(arguments); creates an Array from the arguments Object. This is required because arguments is not really an Array.

Related:  How to make the main content div fill height of screen with css [duplicate]

trap() is a default handler for any of the API functions. I pass the arguments to message so that you get a log of the arguments that were passed to any API call (not just console.log).


I added an extra array console.raw that captures the arguments exactly as passed to trap(). I realized that args.join(' ') was converting objects to the string "[object Object]" which may sometimes be undesirable. Thanks bfontaine for the suggestion.

Solution 4:

It’s worth noting that console.log in IE8 isn’t a true Javascript function. It doesn’t support the apply or call methods.

Solution 5:

Assuming you don’t care about a fallback to alert, here’s an even more concise way to workaround Internet Explorer’s shortcomings:

var console=console||{"log":function(){}};

Solution 6:

I really like the approach posted by “orange80”. It’s elegant because you can set it once and forget it.

The other approaches require you to do something different (call something other than plain console.log() every time), which is just asking for trouble… I know that I’d eventually forget.

Related:  DOM element to corresponding vue.js component

I’ve taken it a step further, by wrapping the code in a utility function that you can call once at the beginning of your javascript, anywhere as long as it’s before any logging. (I’m installing this in my company’s event data router product. It will help simplify the cross-browser design of its new admin interface.)

 * Call once at beginning to ensure your app can safely call console.log() and
 * console.dir(), even on browsers that don't support it.  You may not get useful
 * logging on those browers, but at least you won't generate errors.
 * @param  alertFallback - if 'true', all logs become alerts, if necessary. 
 *   (not usually suitable for production)
function fixConsole(alertFallback)
    if (typeof console === "undefined")
        console = {}; // define it if it doesn't exist already
    if (typeof console.log === "undefined") 
        if (alertFallback) { console.log = function(msg) { alert(msg); }; } 
        else { console.log = function() {}; }
    if (typeof console.dir === "undefined") 
        if (alertFallback) 
            // THIS COULD BE IMPROVED… maybe list all the object properties?
            console.dir = function(obj) { alert("DIR: "+obj); }; 
        else { console.dir = function() {}; }