Was ist mit console.log in IE8 passiert?

Laut diesem Beitrag war es in der Beta, aber es ist nicht in der Veröffentlichung?

Noch besser für den Fallback ist dies:

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

console.log ist erst verfügbar, nachdem Sie die Entwicklertools geöffnet haben (F12, um sie zu öffnen und zu schließen). Das Lustige ist, dass Sie es nach dem Öffnen schließen und dann über console.log-Aufrufe veröffentlichen können. Diese werden angezeigt, wenn Sie es erneut öffnen. Ich denke, das ist eine Art Fehler und kann behoben werden, aber wir werden sehen.

Ich werde wahrscheinlich nur so etwas verwenden:

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

und noch einfacher:

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

Dies ist meine Sicht auf die verschiedenen Antworten. Ich wollte die protokollierten Nachrichten tatsächlich sehen, auch wenn die IE-Konsole beim Auslösen nicht geöffnet war, und schiebe sie in ein von console.messagesmir erstelltes Array. Ich habe auch eine Funktion hinzugefügt console.dump(), um das Anzeigen des gesamten Protokolls zu erleichtern.console.clear()wird die Nachrichtenwarteschlange leeren.

Diese Lösung "behandelt" auch die anderen Konsolenmethoden (von denen ich glaube, dass sie alle von der Firebug-Konsolen-API stammen ).

Schließlich liegt diese Lösung in Form eines IIFE vor , sodass der globale Geltungsbereich nicht verschmutzt wird. Das Fallback-Funktionsargument wird am Ende des Codes definiert.

Ich lege es einfach in meine Master-JS-Datei, die auf jeder Seite enthalten ist, und vergesse es.

(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
        console.raw.push(args);
        var message = args.join(' ');
        console.messages.push(message);
        fallback(message);
    };

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

Einige zusätzliche Informationen

Die Linie var args = Array.prototype.slice.call(arguments);erstellt ein Array aus dem argumentsObjekt. Dies ist erforderlich, da Argumente nicht wirklich ein Array sind .

trap()ist ein Standardhandler für eine der API-Funktionen. Ich übergebe die Argumente an, messagedamit Sie ein Protokoll der Argumente erhalten, die an einen API-Aufruf übergeben wurden (nicht nur console.log).

Bearbeiten

Ich habe ein zusätzliches Array hinzugefügt console.raw, das die Argumente genau so erfasst, wie sie übergeben wurden trap(). Mir wurde klar, dass args.join(' ')Objekte in die Zeichenfolge konvertiert wurden, "[object Object]"was manchmal unerwünscht sein kann. Danke bfontaine für den Vorschlag .

Es ist erwähnenswert, dass console.login IE8 keine echte Javascript-Funktion ist. Die Methoden applyoder callwerden nicht unterstützt .

Angenommen, Sie interessieren sich nicht für einen Fallback zur Warnung, dann finden Sie hier eine noch präzisere Möglichkeit, die Mängel des Internet Explorers zu umgehen:

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

Ich mag den Ansatz von "orange80" sehr. Es ist elegant, weil Sie es einmal einstellen und vergessen können.

Bei den anderen Ansätzen müssen Sie etwas anderes tun (etwas anderes als einfach nennen console.log() jedes Mal ), was nur nach Ärger fragt… Ich weiß, dass ich es irgendwann vergessen würde.

Ich bin noch einen Schritt weiter gegangen, indem ich den Code in eine Dienstprogrammfunktion eingebunden habe, die Sie am Anfang Ihres Javascript einmal aufrufen können, solange es vor der Protokollierung liegt. (Ich installiere dies in dem Event Data Router-Produkt meines Unternehmens. Es wird dazu beitragen, das browserübergreifende Design der neuen Administrationsoberfläche zu vereinfachen.)

/**
 * 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() {}; }
    }
}

Wenn Sie für alle Ihre console.log-Aufrufe "undefiniert" erhalten, bedeutet dies wahrscheinlich, dass noch ein alter Firebuglite geladen ist (firebug.js). Es werden alle gültigen Funktionen von IE8s console.log überschrieben, obwohl sie vorhanden sind. Das ist mir sowieso passiert.

Suchen Sie nach anderem Code, der das Konsolenobjekt überschreibt.

Die beste Lösung für jeden Browser ohne Konsole ist:

// Avoid `console` errors in browsers that lack a console.
(function() {
    var method;
    var noop = function () {};
    var methods = [
        'assert', 'clear', 'count', 'debug', 'dir', 'dirxml', 'error',
        'exception', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log',
        'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd',
        'timeStamp', 'trace', 'warn'
    ];
    var length = methods.length;
    var console = (window.console = window.console || {});

    while (length--) {
        method = methods[length];

        // Only stub undefined methods.
        if (!console[method]) {
            console[method] = noop;
        }
    }
}());

Es gibt so viele Antworten. Meine Lösung dafür war:

globalNamespace.globalArray = new Array();
if (typeof console === "undefined" || typeof console.log === "undefined") {
    console = {};
    console.log = function(message) {globalNamespace.globalArray.push(message)};   
}

Kurz gesagt, wenn console.log nicht vorhanden ist (oder in diesem Fall nicht geöffnet ist), speichern Sie das Protokoll in einem globalen Namespace-Array. Auf diese Weise werden Sie nicht mit Millionen von Warnungen belästigt und können Ihre Protokolle weiterhin bei geöffneter oder geschlossener Entwicklerkonsole anzeigen.

if (window.console && 'function' === typeof window.console.log) {
    window.console.log (o);
}}

Hier ist mein "IE bitte nicht abstürzen"

typeof console=="undefined"&&(console={});typeof console.log=="undefined"&&(console.log=function(){});

Ich habe das auf Github gefunden :

// usage: log('inside coolFunc', this, arguments);
// paulirish.com/2009/log-a-lightweight-wrapper-for-consolelog/
window.log = function f() {
    log.history = log.history || [];
    log.history.push(arguments);
    if (this.console) {
        var args = arguments,
            newarr;
        args.callee = args.callee.caller;
        newarr = [].slice.call(args);
        if (typeof console.log === 'object') log.apply.call(console.log, console, newarr);
        else console.log.apply(console, newarr);
    }
};

// make it safe to use console.log always
(function(a) {
    function b() {}
    for (var c = "assert,count,debug,dir,dirxml,error,exception,group,groupCollapsed,groupEnd,info,log,markTimeline,profile,profileEnd,time,timeEnd,trace,warn".split(","), d; !! (d = c.pop());) {
        a[d] = a[d] || b;
    }
})(function() {
    try {
        console.log();
        return window.console;
    } catch(a) {
        return (window.console = {});
    }
} ());

Ich verwende Walters Ansatz von oben (siehe: https://stackoverflow.com/a/14246240/3076102 ).

Ich mische eine Lösung ein, die ich hier gefunden habe: https://stackoverflow.com/a/7967670 , um Objekte richtig anzuzeigen.

Dies bedeutet, dass die Trap-Funktion:

function trap(){
    if(debugging){
        // create an Array from the arguments Object           
        var args = Array.prototype.slice.call(arguments);
        // console.raw captures the raw args, without converting toString
        console.raw.push(args);
        var index;
        for (index = 0; index < args.length; ++index) {
            //fix for objects
            if(typeof args[index] === 'object'){ 
                args[index] = JSON.stringify(args[index],null,'\t').replace(/\n/g,'<br>').replace(/\t/g,'&nbsp;&nbsp;&nbsp;');
            }
        }
        var message = args.join(' ');
        console.messages.push(message);
        // instead of a fallback function we use the next few lines to output logs
        // at the bottom of the page with jQuery
        if($){
            if($('#_console_log').length == 0) $('body').append($('<div />').attr('id', '_console_log'));
            $('#_console_log').append(message).append($('<br />'));
        }
    }
} 

Ich hoffe das ist hilfreich :-)

Es funktioniert in IE8. Öffnen Sie die Entwicklertools von IE8, indem Sie F12 drücken.

>>console.log('test')
LOG: test

Ich mag diese Methode (mit jquery's doc ready) ... Sie können die Konsole auch in verwenden, dh ... nur der Haken ist, dass Sie die Seite neu laden müssen, wenn Sie die Entwickler-Tools von ie öffnen, nachdem die Seite geladen wurde ...

Es könnte schlanker sein, wenn alle Funktionen berücksichtigt werden, aber ich verwende nur das Protokoll, also mache ich das so.

//one last double check against stray console.logs
$(document).ready(function (){
    try {
        console.log('testing for console in itcutils');
    } catch (e) {
        window.console = new (function (){ this.log = function (val) {
            //do nothing
        }})();
    }
});

Hier ist eine Version, die sich bei der Konsole anmeldet, wenn die Entwicklertools geöffnet sind und nicht, wenn sie geschlossen sind.

(function(window) {

   var console = {};
   console.log = function() {
      if (window.console && (typeof window.console.log === 'function' || typeof window.console.log === 'object')) {
         window.console.log.apply(window, arguments);
      }
   }

   // Rest of your application here

})(window)

Machen Sie Ihre eigene Konsole in HTML .... ;-) Dies kann verbessert werden, aber Sie können beginnen mit:

if (typeof console == "undefined" || typeof console.log === "undefined") {
    var oDiv=document.createElement("div");
    var attr = document.createAttribute('id'); attr.value = 'html-console';
    oDiv.setAttributeNode(attr);


    var style= document.createAttribute('style');
    style.value = "overflow: auto; color: red; position: fixed; bottom:0; background-color: black; height: 200px; width: 100%; filter: alpha(opacity=80);";
    oDiv.setAttributeNode(style);

    var t = document.createElement("h3");
    var tcontent = document.createTextNode('console');
    t.appendChild(tcontent);
    oDiv.appendChild(t);

    document.body.appendChild(oDiv);
    var htmlConsole = document.getElementById('html-console');
    window.console = {
        log: function(message) {
            var p = document.createElement("p");
            var content = document.createTextNode(message.toString());
            p.appendChild(content);
            htmlConsole.appendChild(p);
        }
    };
}