'konsol' adalah kesalahan yang tidak terdefinisi untuk Internet Explorer

Saya menggunakan Firebug dan memiliki beberapa pernyataan seperti:

console.log("...");

di halaman saya. Di IE8 (mungkin versi sebelumnya juga) saya mendapatkan kesalahan skrip yang mengatakan 'konsol' tidak terdefinisi. Saya mencoba meletakkan ini di bagian atas halaman saya:

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

masih saya mendapatkan kesalahan. Adakah cara untuk menghilangkan kesalahan?

Mencoba

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

Variabel tidak terdefinisi tidak dapat dirujuk secara langsung. Namun, semua variabel global adalah atribut dengan nama yang sama dari konteks global ( windowdalam hal browser), dan mengakses atribut yang tidak ditentukan adalah baik-baik saja.

Atau gunakan if (typeof console === 'undefined') console = ...jika Anda ingin menghindari variabel ajaib window, lihat jawaban @Tim Down .

Rekatkan yang berikut di bagian atas JavaScript Anda (sebelum menggunakan konsol):

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

Wrapper penutupan fungsi adalah untuk lingkup variabel untuk tidak mendefinisikan variabel apa pun. Ini melindungi terhadap tidak terdefinisi consoledan tidak terdefinisi console.debug(dan metode lain yang hilang).

EDIT: Saya perhatikan bahwa HTML5 Boilerplate menggunakan kode serupa di file js / plugins.js, jika Anda mencari solusi yang (mungkin) akan terus diperbarui.

Alternatif lain adalah typeofoperator:

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

Alternatif lain adalah dengan menggunakan perpustakaan logging, seperti log4javascript saya sendiri .

Untuk solusi yang lebih kuat, gunakan kode ini (diambil dari kode sumber 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;
        }
    }
}());

Dalam skrip saya, saya juga menggunakan steno:

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

atau, jika tidak mungkin atau tidak layak untuk mengedit setiap baris console.log, saya membuat konsol palsu:

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

Anda dapat menggunakan IE8 console.log()jika telah Developer Toolsdibuka dan Anda juga dapat menggunakan Consolekotak teks pada tab skrip.

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

Berdasarkan dua jawaban sebelumnya oleh

• Vinícius Moraes
• Peter Tseng

dan dokumentasi untuk

• Internet Explorer (IE 10)
• Safari (2012. 07. 23.)
• Firefox (2013. 05. 20.)
• Chrome (2013. 01. 25.) dan Chrome (2012. 10. 04.)
• dan beberapa pengetahuan saya

Inilah implementasi upaya terbaik untuk masalah ini, artinya jika ada console.log yang benar-benar ada, ini mengisi celah untuk metode yang tidak ada melalui console.log.

Misalnya untuk IE6 / 7 Anda dapat mengganti logging dengan waspada (bodoh tapi berfungsi) dan kemudian memasukkan monster di bawah ini (saya menyebutnya console.js): [Jangan ragu untuk menghapus komentar sesuai keinginan, saya meninggalkannya untuk referensi, minimizer dapat mengatasinya]:

<!--[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>

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

Di IE9, jika konsol tidak dibuka, kode ini:

alert(typeof console);

akan menampilkan "objek", tetapi kode ini

alert(typeof console.log);

akan mengeluarkan pengecualian TypeError, tetapi tidak mengembalikan nilai yang tidak ditentukan;

Jadi, versi kode yang dijamin akan terlihat seperti ini:

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

Saya hanya menggunakan console.log dalam kode saya. Jadi saya menyertakan 2 liner yang sangat pendek

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

Melihat bahwa OP menggunakan Firebug dengan IE, maka anggaplah itu Firebug Lite . Ini adalah situasi yang funky karena konsol didefinisikan di IE saat jendela debugger dibuka, tetapi apa yang terjadi ketika Firebug sudah berjalan? Tidak yakin, tapi mungkin metode "firebugx.js" mungkin cara yang baik untuk menguji dalam situasi ini:

sumber:

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

(tautan yang diperbarui 12/2014)

Saya menggunakan fauxconsole ; Saya memodifikasi css sedikit sehingga terlihat lebih bagus tetapi bekerja dengan sangat baik.

Untuk debugging di IE, lihat log4javascript ini

Untuk IE8 atau dukungan konsol terbatas pada console.log (tanpa debug, lacak, ...) Anda dapat melakukan hal berikut:

• Jika konsol ATAU console.log tidak terdefinisi: Buat fungsi dummy untuk fungsi konsol (lacak, debug, log, ...)

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

• Lain jika console.log didefinisikan (IE8) DAN console.debug (lainnya) tidak didefinisikan: redirect semua fungsi logging ke console.log, ini memungkinkan untuk menyimpan log tersebut!

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

Tidak yakin tentang dukungan tegas dalam berbagai versi IE, tetapi ada saran dipersilahkan. Diposting juga jawaban ini di sini: Bagaimana saya bisa menggunakan logging konsol di Internet Explorer?

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

Rintisan konsol dalam 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: () => { },
    }
};

Anda dapat menggunakan yang di bawah ini untuk memberikan tingkat asuransi tambahan yang telah Anda dapatkan dari semua pangkalan. Penggunaan typeofpertama akan menghindari undefinedkesalahan. Menggunakan ===juga akan memastikan bahwa nama tipe sebenarnya adalah string "tidak terdefinisi". Terakhir, Anda ingin menambahkan parameter ke tanda tangan fungsi (saya pilih secara logMsgsewenang-wenang) untuk memastikan konsistensi, karena Anda meneruskan apa pun yang ingin Anda cetak ke konsol ke fungsi log. Ini juga membuat Anda sangat akurat dan menghindari segala peringatan / kesalahan dalam IDE JS aware Anda.

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

Terkadang konsol akan berfungsi di IE8 / 9 tetapi gagal di waktu lain. Perilaku tidak menentu ini tergantung pada apakah Anda memiliki alat pengembang terbuka dan dijelaskan dalam pertanyaan stackoverflow Apakah IE9 mendukung console.log, dan apakah ini merupakan fungsi nyata?

Mengalami masalah serupa menjalankan console.log di windows anak di IE9, dibuat oleh fungsi window.open.

Tampaknya dalam hal ini konsol hanya ditentukan di jendela induk dan tidak ditentukan di jendela anak hingga Anda menyegarkannya. Hal yang sama berlaku untuk anak-anak dari windows anak.

Saya menangani masalah ini dengan membungkus log di fungsi berikutnya (di bawah ini adalah bagian dari modul)

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

Setelah mengalami begitu banyak masalah dengan hal ini (sulit untuk men-debug kesalahan karena jika Anda membuka konsol pengembang kesalahan tidak lagi terjadi!) Saya memutuskan untuk membuat kode berlebihan untuk tidak perlu repot dengan ini lagi:

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

Secara pribadi saya hanya pernah menggunakan console.log dan console.error, tetapi kode ini menangani semua fungsi lain seperti yang ditunjukkan di Mozzila Developer Network: https://developer.mozilla.org/en-US/docs/Web/API/console . Cukup taruh kode itu di bagian atas halaman Anda dan Anda selesai selamanya dengan ini.

Anda dapat menggunakan console.log (...) langsung di Firefox tetapi tidak di IEs. Di IEs Anda harus menggunakan window.console.