O que aconteceu com o console.log no IE8?

De acordo com este post foi na versão beta, mas não está no lançamento?

Ainda melhor para o fallback é este:

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

O console.log só está disponível depois que você abriu as Ferramentas de Desenvolvedor (F12 para abri-lo e abrir). O engraçado é que depois de abri-lo, você pode fechá-lo, depois ainda postá-lo via chamadas console.log, e essas serão vistas quando você reabri-lo. Eu estou pensando que é um tipo de bug, e pode ser corrigido, mas vamos ver.

Eu provavelmente vou usar algo assim:

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

e ainda mais simples:

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

Esta é a minha opinião sobre as várias respostas. Eu queria realmente ver as mensagens registradas, mesmo se eu não tivesse o console do IE aberto quando elas fossem triggersdas, então eu as console.messages em um array console.messages que eu crio. Eu também adicionei uma function console.dump() para facilitar a visualização de todo o log. console.clear() irá esvaziar a fila de mensagens.

Essas soluções também “manipulam” os outros methods do Console (que, acredito, todos se originam da API do Console do Firebug )

Finalmente, esta solução está na forma de um IIFE , por isso não polui o escopo global. O argumento da function de fallback é definido na parte inferior do código.

Acabei de soltá-lo no meu arquivo mestre JS que está incluído em todas as páginas, e esquecê-lo.

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

Alguma informação extra

A linha var args = Array.prototype.slice.call(arguments); cria um Array a partir dos arguments Object. Isso é necessário porque os argumentos não são realmente uma Matriz .

trap() é um manipulador padrão para qualquer uma das funções da API. Eu passo os argumentos para a message para que você obtenha um log dos argumentos que foram passados ​​para qualquer chamada de API (não apenas console.log ).

Editar

Eu adicionei um console.raw extra console.raw que captura os argumentos exatamente como passados ​​para trap() . Percebi que args.join(' ') estava convertendo objects para a string "[object Object]" que às vezes pode ser indesejável. Obrigado bfontaine pela sugestão .

Vale a pena notar que o console.log no IE8 não é uma function JavaScript verdadeira. Não suporta os methods apply ou call .

Supondo que você não se importe com um retorno para alertar, aqui está uma maneira ainda mais concisa de solucionar as falhas do Internet Explorer:

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

Eu realmente gosto da abordagem postada por “orange80”. É elegante porque você pode configurá-lo uma vez e esquecê-lo.

As outras abordagens exigem que você faça algo diferente (chame algo diferente de simples console.log() todas as vezes), o que é apenas uma questão de problemas … Sei que acabaria esquecendo.

Eu dei um passo adiante, envolvendo o código em uma function de utilitário que você pode chamar uma vez no início do seu javascript, em qualquer lugar, desde que seja antes de qualquer registro. (Estou instalando isso no produto de roteador de dados de evento da minha empresa. Isso ajudará a simplificar o design entre navegadores de sua nova interface administrativa.)

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

Se você ficar “indefinido” para todas as suas chamadas console.log, isso provavelmente significa que você ainda tem um antigo firebuglite carregado (firebug.js). Ele irá sobrescrever todas as funções válidas do console.log do IE8, mesmo que elas existam. Isso é o que aconteceu comigo de qualquer maneira.

Verifique se há outro código substituindo o object do console.

A melhor solução para qualquer navegador que não tenha um console é:

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

Existem tantas respostas. Minha solução para isso foi:

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

Em suma, se o console.log não existir (ou, neste caso, não estiver aberto), armazene o log em um Array de namespace global. Dessa forma, você não será importunado com milhões de alertas e ainda poderá ver seus registros com o console do desenvolvedor abertos ou fechados.

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

Aqui está o meu “IE, por favor, não bata”

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

Eu encontrei isso no github :

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

Estou usando a abordagem de Walter acima (consulte: https://stackoverflow.com/a/14246240/3076102 )

Eu misturo uma solução que encontrei aqui https://stackoverflow.com/a/7967670 para mostrar corretamente os objects.

Isso significa que a function trap se torna:

 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,'
').replace(/\t/g,'   '); } } 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($('
').attr('id', '_console_log')); $('#_console_log').append(message).append($('
')); } } }

Espero que isto seja útil:-)

Ele funciona no IE8. Abra as Ferramentas de Desenvolvedor do IE8, pressionando F12.

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

Eu gosto deste método (usando jquery doc pronto) … ele permite que você use o console, mesmo em ie … só pegar é que você precisa recarregar a página se você abrir ferramentas de ferramentas do IE após a página carrega …

Poderia ser mais claro, contando todas as funções, mas eu só uso o log, então é isso que eu faço.

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

Aqui está uma versão que será registrada no console quando as ferramentas do desenvolvedor estiverem abertas e não quando estiverem fechadas.

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

Faça seu próprio console em html …. 😉 Isso pode ser feito, mas você pode começar com:

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