wake-up-neo.com

'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 mit der Meldung, dass die 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. Irgendeine Weise, die Störungen loszuwerden?

372
user246114

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 (window bei Browsern), und der Zugriff auf ein undefiniertes Attribut ist in Ordnung.

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

376
kennytm

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 Funktionsabschluss-Wrapper dient dazu, die Variablen so einzuschränken, dass keine Variablen definiert werden. Dies schützt sowohl vor undefiniertem console als auch vor undefiniertem console.debug (und andere fehlende Methoden).

EDIT: Mir ist aufgefallen, dass HTML5 Boilerplate verwendet ähnlichen Code in der Datei js/plugins.js, wenn Sie nach einer Lösung suchen, die (wahrscheinlich) auf dem neuesten Stand gehalten wird.

317
Peter Tseng

Eine andere Alternative ist der Operator typeof:

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

Eine weitere Alternative ist die Verwendung einer Protokollierungsbibliothek, z. B. meine eigene log4javascript .

73
Tim Down

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

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

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 () {});
13
iblamefish

Sie können console.log() verwenden, wenn Sie Developer Tools in IE8 geöffnet und Sie können auch das Textfeld Console auf der Registerkarte script verwenden.

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

Basierend auf zwei vorherigen Antworten von

und die Dokumentationen für

Hier ist eine Best-Effort-Implementierung für das Problem: Wenn es ein tatsächlich vorhandenes console.log gibt, füllt es die Lücken für nicht vorhandene Methoden über console.log aus.

Beispielsweise können Sie für IE6/7 die Protokollierung durch eine Warnung ersetzen (dumm, aber funktioniert) und dann das folgende Monster einschließen (ich nannte es console.js): 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];
            }
        }
    })();
7
TWiStErRob

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

alert(typeof console);

wird "Objekt" zeigen, aber dieser 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() {};
}
6
bonbonez

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(){};
6
Ruben Decrop

Es wurde bemerkt, dass OP Firebug mit IE verwendet. Nehmen wir also an, es ist Firebug Lite . Dies ist eine unkonventionelle Situation, da die Konsole in IE beim Öffnen des Debugger-Fensters definiert wird, aber was passiert, wenn Firebug bereits ausgeführt wird? Nicht sicher, aber möglicherweise 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)

2
Roberto
console = console || { 
    debug: function(){}, 
    log: function(){}
    ...
}
1
David Glass

Überprüfen Sie für das Debuggen in IE das log4javascript

1
Praveen

Für die auf console.log beschränkte IE8- oder Konsolenunterstützung (kein Debug, Trace, ...) können Sie folgende Aktionen ausführen:

  • If console OR console.log undefined: Dummy-Funktionen für Konsolenfunktionen erstellen (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 nach console.log um, um diese Protokolle beizubehalten!

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

Nicht sicher über die Assert-Unterstützung in verschiedenen IE Versionen, aber alle Vorschläge sind willkommen. Veröffentlichte auch diese Antwort hier: Wie kann ich die Konsolenprotokollierung in Internet Explorer verwenden?

1

Ich benutze fauxconsole ; Ich habe das CSS ein wenig modifiziert, damit es schöner aussieht, aber sehr gut funktioniert.

1
Stijn Geukens

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.

In diesem Fall wird die Konsole anscheinend nur im übergeordneten Fenster definiert und ist in untergeordneten Fenstern nicht definiert, bis Sie sie aktualisieren. Gleiches gilt für Kinder von Kinderfenstern.

Ich beschäftige mich mit diesem 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);
    }
0
Max Venediktov

Stub der Konsole 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: () => { },
    }
};
0
devi

Manchmal funktioniert die Konsole in IE8/9, in anderen Fällen jedoch nicht. Dieses fehlerhafte Verhalten hängt davon ab, ob Entwickler-Tools geöffnet sind und wird in der Frage zum Stapelüberlauf beschrieben. Unterstützt der IE9 die Datei console.log und ist dies eine echte Funktion?

0
Anon

Sie können das Folgende verwenden, um einen zusätzlichen Versicherungsabschluss zu erhalten, bei dem alle Grundlagen abgedeckt sind. Wenn Sie zuerst typeof verwenden, werden alle undefined Fehler vermieden. Mit === wird auch sicherstellen, dass der Name des Typs tatsächlich die Zeichenfolge "undefiniert" ist. Schließlich möchten Sie der Funktionssignatur einen Parameter hinzufügen (ich habe logMsg willkürlich gewählt), um die Konsistenz zu gewährleisten, da Sie alles, was Sie an die Konsole drucken möchten, an die Protokollfunktion übergeben. Auf diese Weise behalten Sie auch den Überblick und vermeiden Warnungen/Fehler in Ihrer JS-fähigen IDE.

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