În conformitate cu acest mesaj acesta a fost în beta, dar l's nu în presă?
console.jurnalul este disponibil doar după ce ați deschis Developer Tools (F12 pentru a comuta deschise și închise). Lucru amuzant este că după ce ai'am deschis-o, o puteți închide, apoi mai posta la aceasta prin intermediul consolei.jurnal de apeluri, iar acestea vor fi văzute atunci când redeschideți-l. Am'm gândindu-mă că este un bug de felul, și poate fi reparat, dar vom vedea.
Am'll, probabil, doar folosi ceva de genul asta:
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)
}
și chiar mai simplu:
function trace(s) {
try { console.log(s) } catch (e) { alert(s) }
}
Chiar mai bine pentru rezervă este aceasta:
var alertFallback = true; if (typeof consola === "nedefinit" || tip de consola.log === "nedefinit") { consola = {}; dacă (alertFallback) { console.log = function(msg) { alert(msg); }; } else { console.log = function() {}; } }
Asta e părerea mea despre diverse răspunsuri. Am vrut să văd mesajele înregistrate, chiar dacă nu au IE consola deschide atunci când au fost concediați, așa că le împinge într-o consolă.mesaje matrice care pot crea. Am adăugat, de asemenea, o funcție de consolare.dump()pentru a facilita vizualizarea întregului jurnal.
consola.clar()` va goli coada de mesaje.
Aceste solutii, de asemenea, "mânere" alte Consola metode (care cred că toate provin din Firebug Consola API)
În cele din urmă, această soluție este în formă de o VIAȚA, astfel încât să nu polueze aplicare la nivel mondial. Rezervă funcția de argument este definit în partea de jos a codului.
Am doar o picătură într-stăpânul meu JS fișiere, care este inclus pe fiecare pagină, și să uitați despre el.
(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)
Linia `var args = Array.prototip.felie.apel(argumente); creează o Serie de "argumente" Obiect. Acest lucru este necesar deoarece argumente nu este într-adevăr un Array.
capcana()este un handler implicit pentru oricare dintre funcțiile API. Trec argumente pentru a "mesaj", astfel încât să obțineți un jurnal de argumentele care au fost transmise la orice apel API (nu doar pentru console.log
).
Am adăugat un plus de matrice consola.prime
, care surprinde argumente exact ca a trecut la capcana()
. Mi-am dat seama că args.alăturați-vă(' ')
a fost conversie obiecte string `"[object Object]" care poate fi uneori de dorit. Multumesc bfontaine pentru sugestie.
Presupunând că don't grijă despre o rezervă de alertă, aici's un și mai concis mod de soluție Internet Explorer's neajunsuri:
var console=console||{"log":function(){}};
Îmi place abordarea postat de "orange80". L's elegantă, pentru că puteți seta o dată și să uitați de el.
Alte abordări avea nevoie să faci ceva diferit (apel altceva decât simple `consola.log () de fiecare dată), care este cu lumânarea... știu că m-am'd uita în cele din urmă.
Am'am luat un pas mai departe, de ambalaj cod într-o funcție de utilitate care puteți apela o dată la începutul javascript, oriunde, cât's înainte de logare. (M-am'm a instala acest lucru în compania mea's de date eveniment produs router. Aceasta va ajuta la simplificarea cross-browser-ul de design de noua sa interfata de administrare.)
/**
* 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() {}; }
}
}
Dacă aveți "nedefinit" pentru toate dvs. de consola.jurnal apeluri, asta înseamnă că încă mai ai un vechi firebuglite încărcate (firebug.js). Acesta va suprascrie toate valabile funcții de IE8's console.jurnal, chiar dacă ele nu există. Aceasta este ceea ce mi s-a întâmplat oricum.
Verificați pentru alt cod imperative consola obiect.
Cea mai bună soluție pentru orice browser care lipsa unei console este:
// 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;
}
}
}());
Există atât de multe Răspunsuri. Soluția mea pentru acest lucru a fost:
globalNamespace.globalArray = new Array();
if (typeof console === "undefined" || typeof console.log === "undefined") {
console = {};
console.log = function(message) {globalNamespace.globalArray.push(message)};
}
Pe scurt, dacă consola.log nu't există (sau, în acest caz, e't deschis) apoi depozitați într-un jurnal de nume global Matrice. În acest fel, tu're nu a insistat cu milioane de alerte și încă puteți vizualiza jurnalele dvs. cu consola pentru dezvoltatori deschis sau închis.
Am gasit asta pe 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 = {});
}
} ());
Am'm folosind Walter's de abordare de mai sus (a se vedea: https://stackoverflow.com/a/14246240/3076102)
Nu se amestecă într-o soluție am găsit aici https://stackoverflow.com/a/7967670 pentru a în mod corespunzător show Obiecte.
Acest lucru înseamnă capcana funcția devine:
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,' ');
}
}
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 />'));
}
}
}
Sper că acest lucru este de ajutor:-)
Face propriile consola în html .... ;-) Acest lucru poate fi imprved dar puteți începe cu :
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);
}
};
}
Îmi place această metodă (folosind jquery's doc gata)... acesta vă permite să utilizați consola chiar si in ie... singura captura este că aveți nevoie pentru a reîncărca pagina dacă deschideți ie's dev tools după pagină se încarcă...
ar putea fi impermeabil de contabilitate pentru toate funcțiile, dar eu folosesc doar log deci, aceasta este ceea ce fac.
//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
}})();
}
});
Aici este o versiune care se va conecta la consola, atunci când instrumentele de dezvoltare sunt deschise și nu atunci când acestea sunt închise.
(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)