'console' ist ein undefinierter Fehler für Internet Explorer

Ich benutze Firebug und habe einige Aussagen wie:

console.log("...");

auf meiner Seite. In IE8 (wahrscheinlich auch in früheren Versionen) erhalte ich Skriptfehler, die besagen, dass "Konsole" undefiniert ist. Ich habe versucht, dies oben auf meiner Seite zu platzieren:

<script type="text/javascript">
    if (!console) console = {log: function() {}};
</script>

trotzdem bekomme ich die fehler. Gibt es eine Möglichkeit, die Fehler zu beseitigen?

Versuchen

if (!window.console) console = ...

Eine undefinierte Variable kann nicht direkt referenziert werden. Alle globalen Variablen sind jedoch Attribute mit demselben Namen wie der globale Kontext ( windowim Fall von Browsern), und der Zugriff auf ein undefiniertes Attribut ist in Ordnung.

Oder verwenden if (typeof console === 'undefined') console = ...Sie, wenn Sie die magische Variable vermeiden möchten window, lesen Sie die Antwort von @Tim Down .

Fügen Sie Folgendes oben in Ihr JavaScript ein (bevor Sie die Konsole verwenden):

/**
 * Protect window.console method calls, e.g. console is not defined on IE
 * unless dev tools are open, and IE doesn't define console.debug
 * 
 * Chrome 41.0.2272.118: debug,error,info,log,warn,dir,dirxml,table,trace,assert,count,markTimeline,profile,profileEnd,time,timeEnd,timeStamp,timeline,timelineEnd,group,groupCollapsed,groupEnd,clear
 * Firefox 37.0.1: log,info,warn,error,exception,debug,table,trace,dir,group,groupCollapsed,groupEnd,time,timeEnd,profile,profileEnd,assert,count
 * Internet Explorer 11: select,log,info,warn,error,debug,assert,time,timeEnd,timeStamp,group,groupCollapsed,groupEnd,trace,clear,dir,dirxml,count,countReset,cd
 * Safari 6.2.4: debug,error,log,info,warn,clear,dir,dirxml,table,trace,assert,count,profile,profileEnd,time,timeEnd,timeStamp,group,groupCollapsed,groupEnd
 * Opera 28.0.1750.48: debug,error,info,log,warn,dir,dirxml,table,trace,assert,count,markTimeline,profile,profileEnd,time,timeEnd,timeStamp,timeline,timelineEnd,group,groupCollapsed,groupEnd,clear
 */
(function() {
  // Union of Chrome, Firefox, IE, Opera, and Safari console methods
  var methods = ["assert", "cd", "clear", "count", "countReset",
    "debug", "dir", "dirxml", "error", "exception", "group", "groupCollapsed",
    "groupEnd", "info", "log", "markTimeline", "profile", "profileEnd",
    "select", "table", "time", "timeEnd", "timeStamp", "timeline",
    "timelineEnd", "trace", "warn"];
  var length = methods.length;
  var console = (window.console = window.console || {});
  var method;
  var noop = function() {};
  while (length--) {
    method = methods[length];
    // define undefined methods as noops to prevent errors
    if (!console[method])
      console[method] = noop;
  }
})();

Der Wrapper zum Schließen von Funktionen dient dazu, die Variablen so zu definieren, dass keine Variablen definiert werden. Dies schützt sowohl vor undefinierten consoleals auch vor undefinierten console.debug(und anderen fehlenden Methoden).

BEARBEITEN: Ich habe festgestellt, dass HTML5 Boilerplate in seiner Datei js / plugins.js ähnlichen Code verwendet, wenn Sie nach einer Lösung suchen, die (wahrscheinlich) auf dem neuesten Stand gehalten wird.

Eine andere Alternative ist der typeofBetreiber:

if (typeof console == "undefined") {
    this.console = {log: function() {}};
}

Eine weitere Alternative ist die Verwendung einer Protokollierungsbibliothek, z. B. meines eigenen log4javascript .

Verwenden Sie für eine robustere Lösung diesen Code (aus dem Quellcode von Twitter):

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

In meinen Skripten verwende ich entweder die Kurzform:

window.console && console.log(...) // only log if the function exists

oder wenn es nicht möglich oder machbar ist, jede console.log-Zeile zu bearbeiten, erstelle ich eine gefälschte Konsole:

// check to see if console exists. If not, create an empty object for it,
// then create and empty logging function which does nothing. 
//
// REMEMBER: put this before any other console.log calls
!window.console && (window.console = {} && window.console.log = function () {});

Sie können verwenden, console.log()wenn Sie Developer Toolsin IE8 geöffnet haben, und Sie können auch das ConsoleTextfeld auf der Registerkarte Skript verwenden.

if (typeof console == "undefined") {
  this.console = {
    log: function() {},
    info: function() {},
    error: function() {},
    warn: function() {}
  };
}

Basierend auf zwei vorherigen Antworten von

• Vinícius Moraes
• Peter Tseng

und die Dokumentationen für

• Internet Explorer (IE 10)
• Safari (2012. 07. 23.)
• Firefox (2013. 05. 20.)
• Chrome (2013. 01. 25.) und Chrome (2012. 10. 04.)
• und einige meiner Kenntnisse

Hier ist eine Best-Effort-Implementierung für das Problem. Wenn also ein console.log vorhanden ist, füllt es die Lücken für nicht vorhandene Methoden über console.log.

Zum Beispiel können Sie für IE6 / 7 die Protokollierung durch Warnung ersetzen (dumm, funktioniert aber) und dann das folgende Monster einfügen (ich habe es console.js genannt): [Sie können Kommentare nach Belieben entfernen, ich habe sie als Referenz hinterlassen. ein Minimierer kann sie angehen]:

<!--[if lte IE 7]>
<SCRIPT LANGUAGE="javascript">
    (window.console = window.console || {}).log = function() { return window.alert.apply(window, arguments); };
</SCRIPT>
<![endif]-->
<script type="text/javascript" src="console.js"></script>

und console.js:

    /**
     * Protect window.console method calls, e.g. console is not defined on IE
     * unless dev tools are open, and IE doesn't define console.debug
     */
    (function() {
        var console = (window.console = window.console || {});
        var noop = function () {};
        var log = console.log || noop;
        var start = function(name) { return function(param) { log("Start " + name + ": " + param); } };
        var end = function(name) { return function(param) { log("End " + name + ": " + param); } };

        var methods = {
            // Internet Explorer (IE 10): http://msdn.microsoft.com/en-us/library/ie/hh772169(v=vs.85).aspx#methods
            // assert(test, message, optionalParams), clear(), count(countTitle), debug(message, optionalParams), dir(value, optionalParams), dirxml(value), error(message, optionalParams), group(groupTitle), groupCollapsed(groupTitle), groupEnd([groupTitle]), info(message, optionalParams), log(message, optionalParams), msIsIndependentlyComposed(oElementNode), profile(reportName), profileEnd(), time(timerName), timeEnd(timerName), trace(), warn(message, optionalParams)
            // "assert", "clear", "count", "debug", "dir", "dirxml", "error", "group", "groupCollapsed", "groupEnd", "info", "log", "msIsIndependentlyComposed", "profile", "profileEnd", "time", "timeEnd", "trace", "warn"

            // Safari (2012. 07. 23.): https://developer.apple.com/library/safari/#documentation/AppleApplications/Conceptual/Safari_Developer_Guide/DebuggingYourWebsite/DebuggingYourWebsite.html#//apple_ref/doc/uid/TP40007874-CH8-SW20
            // assert(expression, message-object), count([title]), debug([message-object]), dir(object), dirxml(node), error(message-object), group(message-object), groupEnd(), info(message-object), log(message-object), profile([title]), profileEnd([title]), time(name), markTimeline("string"), trace(), warn(message-object)
            // "assert", "count", "debug", "dir", "dirxml", "error", "group", "groupEnd", "info", "log", "profile", "profileEnd", "time", "markTimeline", "trace", "warn"

            // Firefox (2013. 05. 20.): https://developer.mozilla.org/en-US/docs/Web/API/console
            // debug(obj1 [, obj2, ..., objN]), debug(msg [, subst1, ..., substN]), dir(object), error(obj1 [, obj2, ..., objN]), error(msg [, subst1, ..., substN]), group(), groupCollapsed(), groupEnd(), info(obj1 [, obj2, ..., objN]), info(msg [, subst1, ..., substN]), log(obj1 [, obj2, ..., objN]), log(msg [, subst1, ..., substN]), time(timerName), timeEnd(timerName), trace(), warn(obj1 [, obj2, ..., objN]), warn(msg [, subst1, ..., substN])
            // "debug", "dir", "error", "group", "groupCollapsed", "groupEnd", "info", "log", "time", "timeEnd", "trace", "warn"

            // Chrome (2013. 01. 25.): https://developers.google.com/chrome-developer-tools/docs/console-api
            // assert(expression, object), clear(), count(label), debug(object [, object, ...]), dir(object), dirxml(object), error(object [, object, ...]), group(object[, object, ...]), groupCollapsed(object[, object, ...]), groupEnd(), info(object [, object, ...]), log(object [, object, ...]), profile([label]), profileEnd(), time(label), timeEnd(label), timeStamp([label]), trace(), warn(object [, object, ...])
            // "assert", "clear", "count", "debug", "dir", "dirxml", "error", "group", "groupCollapsed", "groupEnd", "info", "log", "profile", "profileEnd", "time", "timeEnd", "timeStamp", "trace", "warn"
            // Chrome (2012. 10. 04.): https://developers.google.com/web-toolkit/speedtracer/logging-api
            // markTimeline(String)
            // "markTimeline"

            assert: noop, clear: noop, trace: noop, count: noop, timeStamp: noop, msIsIndependentlyComposed: noop,
            debug: log, info: log, log: log, warn: log, error: log,
            dir: log, dirxml: log, markTimeline: log,
            group: start('group'), groupCollapsed: start('groupCollapsed'), groupEnd: end('group'),
            profile: start('profile'), profileEnd: end('profile'),
            time: start('time'), timeEnd: end('time')
        };

        for (var method in methods) {
            if ( methods.hasOwnProperty(method) && !(method in console) ) { // define undefined methods as best-effort methods
                console[method] = methods[method];
            }
        }
    })();

Wenn in IE9 die Konsole nicht geöffnet ist, lautet dieser Code:

alert(typeof console);

zeigt "Objekt", aber diesen Code

alert(typeof console.log);

löst eine TypeError-Ausnahme aus, gibt jedoch keinen undefinierten Wert zurück;

Die garantierte Version des Codes sieht also ungefähr so ​​aus:

try {
    if (window.console && window.console.log) {
        my_console_log = window.console.log;
    }
} catch (e) {
    my_console_log = function() {};
}

Ich verwende nur console.log in meinem Code. Also habe ich einen sehr kurzen 2 Liner dabei

var console = console || {};
console.log = console.log || function(){};

Es wurde festgestellt, dass OP Firebug mit IE verwendet. Nehmen Sie also an, es handelt sich um Firebug Lite . Dies ist eine unkonventionelle Situation, da die Konsole im IE definiert wird, wenn das Debugger-Fenster geöffnet wird. Was passiert jedoch, wenn Firebug bereits ausgeführt wird? Ich bin mir nicht sicher, aber vielleicht ist die Methode "firebugx.js" ein guter Weg, um in dieser Situation zu testen:

Quelle:

https://code.google.com/p/fbug/source/browse/branches/firebug1.2/lite/firebugx.js?r=187

    if (!window.console || !console.firebug) {
        var names = [
            "log", "debug", "info", "warn", "error", "assert",
            "dir","dirxml","group","groupEnd","time","timeEnd",
            "count","trace","profile","profileEnd"
        ];
        window.console = {};
        for (var i = 0; i < names.length; ++i)
            window.console[names[i]] = function() {}
    }

(aktualisierte Links 12/2014)

Ich benutze Fauxconsole ; Ich habe das CSS ein wenig modifiziert, damit es besser aussieht, aber sehr gut funktioniert.

Überprüfen Sie zum Debuggen im IE dieses log4javascript

Für IE8- oder Konsolenunterstützung, die auf console.log beschränkt ist (kein Debug, Trace, ...), können Sie Folgendes tun:

• Wenn console ODER console.log undefiniert ist: Erstellen Sie Dummy-Funktionen für Konsolenfunktionen (Trace, Debug, Log, ...)

  window.console = { debug : function() {}, ...};

• Andernfalls, wenn console.log definiert ist (IE8) UND console.debug (irgendein anderes) nicht definiert ist: Leiten Sie alle Protokollierungsfunktionen zu console.log um, damit diese Protokolle beibehalten werden können!

  window.console = { debug : window.console.log, ...};

Ich bin mir nicht sicher, ob Assert in verschiedenen IE-Versionen unterstützt wird, aber Vorschläge sind willkommen. Diese Antwort wurde auch hier veröffentlicht: Wie kann ich die Konsolenprotokollierung in Internet Explorer verwenden?

console = console || { 
    debug: function(){}, 
    log: function(){}
    ...
}

Konsolenstummel in TypeScript:

if (!window.console) {
console = {
    assert: () => { },
    clear: () => { },
    count: () => { },
    debug: () => { },
    dir: () => { },
    dirxml: () => { },
    error: () => { },
    group: () => { },
    groupCollapsed: () => { },
    groupEnd: () => { },
    info: () => { },
    log: () => { },
    msIsIndependentlyComposed: (e: Element) => false,
    profile: () => { },
    profileEnd: () => { },
    select: () => { },
    time: () => { },
    timeEnd: () => { },
    trace: () => { },
    warn: () => { },
    }
};

Sie können das Folgende verwenden, um einen zusätzlichen Versicherungsgrad zu erhalten, bei dem alle Grundlagen abgedeckt sind. Die Verwendung von typeoffirst vermeidet undefinedFehler. Durch ===die Verwendung wird auch sichergestellt, dass der Name des Typs tatsächlich die Zeichenfolge "undefiniert" ist. Schließlich möchten Sie der Funktionssignatur einen Parameter hinzufügen (ich habe ihn logMsgwillkürlich ausgewählt), um die Konsistenz zu gewährleisten, da Sie alles, was Sie drucken möchten, an die Konsole an die Protokollfunktion übergeben. Auf diese Weise bleiben Sie auch intelligent und vermeiden Warnungen / Fehler in Ihrer JS-fähigen IDE.

if(!window.console || typeof console === "undefined") {
  var console = { log: function (logMsg) { } };
}

Manchmal funktioniert die Konsole in IE8 / 9, aber zu anderen Zeiten schlägt sie fehl. Dieses fehlerhafte Verhalten hängt davon ab, ob Sie Entwicklertools geöffnet haben, und wird in der Frage zum Stapelüberlauf beschrieben. Unterstützt IE9 console.log und ist es eine echte Funktion?

Es ist ein ähnliches Problem beim Ausführen von console.log in untergeordneten Fenstern in IE9 aufgetreten, das von der Funktion window.open erstellt wurde.

Es scheint, dass in diesem Fall die Konsole nur im übergeordneten Fenster definiert und in untergeordneten Fenstern undefiniert ist, bis Sie sie aktualisieren. Gleiches gilt für Kinder von Kinderfenstern.

Ich behebe dieses Problem, indem ich das Protokoll in die nächste Funktion einbinde (unten ist ein Fragment des Moduls).

getConsole: function()
    {
        if (typeof console !== 'undefined') return console;

        var searchDepthMax = 5,
            searchDepth = 0,
            context = window.opener;

        while (!!context && searchDepth < searchDepthMax)
        {
            if (typeof context.console !== 'undefined') return context.console;

            context = context.opener;
            searchDepth++;
        }

        return null;
    },
    log: function(message){
        var _console = this.getConsole();
        if (!!_console) _console.log(message);
    }

Nachdem ich so viele Probleme mit dieser Sache hatte (es ist schwierig, den Fehler zu debuggen, da der Fehler beim Öffnen der Entwicklerkonsole nicht mehr auftritt!), Entschied ich mich, einen Overkill-Code zu erstellen, um mich nie wieder damit beschäftigen zu müssen:

if (typeof window.console === "undefined")
    window.console = {};

if (typeof window.console.debug === "undefined")
    window.console.debug= function() {};

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

if (typeof window.console.error === "undefined")
    window.console.error= function() {alert("error");};

if (typeof window.console.time === "undefined")
    window.console.time= function() {};

if (typeof window.console.trace === "undefined")
    window.console.trace= function() {};

if (typeof window.console.info === "undefined")
    window.console.info= function() {};

if (typeof window.console.timeEnd === "undefined")
    window.console.timeEnd= function() {};

if (typeof window.console.group === "undefined")
    window.console.group= function() {};

if (typeof window.console.groupEnd === "undefined")
    window.console.groupEnd= function() {};

if (typeof window.console.groupCollapsed === "undefined")
    window.console.groupCollapsed= function() {};

if (typeof window.console.dir === "undefined")
    window.console.dir= function() {};

if (typeof window.console.warn === "undefined")
    window.console.warn= function() {};

Persönlich verwende ich immer nur console.log und console.error, aber dieser Code behandelt alle anderen Funktionen, wie im Mozzila Developer Network gezeigt: https://developer.mozilla.org/en-US/docs/Web/API/console . Setzen Sie diesen Code einfach oben auf Ihre Seite und Sie sind für immer damit fertig.

Sie können console.log (...) direkt in Firefox verwenden, jedoch nicht in IEs. In IEs müssen Sie window.console verwenden.