"console" n'est pas défini d'erreur d'Internet Explorer

Je suis à l'aide de Firebug et ont certains des énoncés comme:

console.log("...");

dans ma page. Dans IE8 (probablement des versions antérieures de trop), j'ai des erreurs de script en disant "console" n'est pas défini. J'ai essayé de mettre le présent en haut de ma page:

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

encore j'obtiens les erreurs. De toute façon pour se débarrasser des erreurs?

Utilisation typeof dans votre cas, cela vous évitera non défini erreur: if(typeof console === "undefined") { var console = { log: function (logMsg) { } }; }
console.log() ne fonctionne que lorsque IE dev outil est ouvert (oui, c'est à dire est merdique). voir stackoverflow.com/questions/7742781/...
La meilleure réponse à cette question est stackoverflow.com/a/16916941/2274855
voir github.com/h5bp/html5-boilerplate/blob/master/js/plugins.js
lien est rompu, l'utiliser à la place: github.com/h5bp/html5-boilerplate/blob/master/src/js/plugins.js
À l'aide de journalisation de la console dans la production est une mauvaise idée de toute façon, au moins une odeur de code. Vous pourriez, par accident, d'exposer des données utilisateur sensibles. J'utilise un Sonar pour détecter tout console.log états, et de me forcer à l'enlever avant de passer à la production.
if(!window.console) alert("Please use a real browser")

InformationsquelleAutor user246114 | 2010-07-24

375

Essayer
```
if (!window.console) console = ...
```
D'une variable non définie ne peut pas être appelé directement. Cependant, toutes les variables globales sont des attributs de même nom que le contexte global (window en cas de navigateurs), et l'accès à un attribut non défini est fine.

Ou de l'utilisation if (typeof console === 'undefined') console = ... si vous voulez éviter la magie variable window, voir @Tim de Down réponse.
- Merci cela fonctionne.
- Juste pour être clair à quiconque, à l'aide de ce, lieu <script type="text/javascript"> if (!window.console) console = {log: function() {}}; </script> en haut de votre page! Merci Kenny.
- Qu'en est var console = console || { log: function() {} };
- Pour utiliser cette abréviation que vous avez besoin d'inclure window: var console = window.console || { log: function() {} };
- Putain... vous construisez un site agréable, en la développant pour votre navigateur préféré. À la fin vous passer 4 ou 5 HEURES, ce qui le rend compatible avec tous les autres navigateurs MODERNES, et puis vous passer 4-5 JOURS, ce qui le rend compatible avec IE.
- Le problème avec cette réponse, si vous utilisez un autre nom comme de débogage, d'avertir, de compter avec navigateur qui manque console va lancer une exception, voir la meilleure façon de le faire stackoverflow.com/a/16916941/2274855
- Juste pour info, le code ci-dessus posté par killianmcc empêche tout simplement une erreur, mais le console.log() fonction ne fait absolument rien.
- qui n'affecte que la portée locale de la console. Vous avez besoin de modifier window.log d'affecter les autres fichiers de script, qui tombent en dehors de la portée locale.
InformationsquelleAutor kennytm
317

Collez le code suivant en haut de votre code JavaScript (avant d'utiliser la console):
```
/**
 * 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;
  }
})();
```
La fonction de fermeture de l'emballage à la portée des variables afin de ne pas définir toutes les variables. Cela protège à la fois indéfini console et indéfini console.debug (et d'autres manquant méthodes).

EDIT: j'ai remarqué que Boilerplate HTML5 utilise un code similaire dans son js/plugins.js fichier, si vous êtes à la recherche d'une solution qui sera (probablement) être tenus à jour.
- Pourquoi cette réponse si peu de upvotes? C'est la plus complète de celles publiées ici.
- En raison de la date. Absolument d'accord avec le fonctionnement correct des solutions. Je pense que ce sujet doivent être modérés. Désolé pour le mauvais anglais.
- Assez complet, sauf qu'il ne va pas essayer de rediriger la journalisation de la fonction log (si présent), de sorte que tous les journaux sont perdus
- Pour préciser, par exemple, si la console.le débogage est pas défini, la réorienter vers la console.journal au lieu de noop?
- Quand cela se produit exactement? Ce code ne devrait définir des éléments qui ne sont pas encore définies.
- infini de voter....
- ce n'est pas correct. Ce code n'est pas de remplacer toutes les méthodes existantes. Au lieu de cela, il les talons de tout inexistante méthode sur la console actuelle de mise en œuvre de ne rien faire quand on l'appelle. Par exemple, si Firefox a une méthode console.highfive(), et le Chrome n'a pas, ce code serait de définir console.highfive = function() {}; afin de l'appelant console.highfive(user); en Chrome serait de ne rien faire, mais serait encore exécuter comme prévu dans Firefox. Dans IE, chaque méthode doit être écrasé.
- Voir aussi solution similaire appelé "firebugx.js" trouve ici: code.google.com/p/fbug/source/browse/branches/firebug1.2/lite/...
- Dernière ligne devrait être: }());
- Je pense que de toute façon - (function(){...}()) ou (function(){...})() - fonctionne réellement
InformationsquelleAutor Peter Tseng
73

Une autre alternative est le typeof opérateur:
```
if (typeof console == "undefined") {
    this.console = {log: function() {}};
}
```
Encore une autre alternative est d'utiliser une bibliothèque de journalisation, comme mon propre log4javascript.
- Ce serait une bonne idée de changer non déclarées affectation dans une déclaration juste, cependant.
- Entendez-vous à l'aide de var? Que ferait qu'embrouiller les choses ici. Ou voulez-vous dire de l'affectation à window.console plutôt que console?
- À l'aide de var. Pourquoi serait-il confondre les choses ici?
- Mettre un var à l'intérieur d'un if bloc est source de confusion et ressemble à une erreur. Il modifie également la nature de console indépendamment de si le if bloc est exécuté en raison d'une variable est toujours déclarée. Je suis d'accord qui, implicitement, de l'affectation à une variable globale que je suis ici ressemble également à une erreur, mais c'est seulement à des changements de comportement lorsque console est pas défini. Aucune n'est idéale.
- Le problème avec l'omission var lors de l'affectation à console — comme dans cet exemple — n'est même pas tellement que ça ressemble à une erreur. Tout d'abord, c'est à dire DOM a une fâcheuse particularité non déclarées lors de la cession déclenche une erreur si l'identifiant est le même que l'id de l'un des éléments dans le document. Deuxième — et surtout — dans l'ES5 mode strict, undecl. la cession est en fait une volonté délibérée de ReferenceError. Étant donné que le mode strict est plus ou moins une direction d'une langue, pour des raisons de compatibilité, undecl. les devoirs sont à éviter. Mais si vous devez, this.console=.. est un alt. option.
- Re IE DOM portée globale de la pollution de la folie, je suis conscient de cela, mais nous savons déjà de la console n'est pas défini, au moins au point que le code est exécuté. L'ES5 point est bonne: je n'ai pas commencé à penser en termes de ES5 tout le temps encore. Pour moi, je ne considère pas l'utilisation de ce code, de toute façon, et au lieu de créer un wrapper autour de la console.
- Bonjour downvoter? Veuillez vous expliquer.
- Hey Tim. Je vois que tu changé console = ... à this.console = .... Excellent, j'ai changé mon vote.
- Ah, bien, merci. Se demande si il pourrait avoir été vous. J'ai été en attente jusqu'à ce que nous ayons fini de discuter avant de le changer; l'ES5 point a remporté, mais je n'étais pas sûr de savoir si vous étiez toujours en pourparlers var console sur this.console.
- Eh bien personnellement, j'utilise var console = ... et this.console = ... de façon interchangeable. Permettez-moi également de souligner que la déclaration de la variable ne change pas la nature de la variable (ou la propriété de la variable objet, pour être précis). Si console est déjà une propriété globale, var console exécuté dans le code mondial est essentiellement un no-op. C'est pourquoi if (typeof console == 'undefined') { var console = ... } ne change pas console du tout si c'est déjà déclaré. Version Alternative serait var console; if (typeof console == 'undefined') { console = .. }, mais cela pourrait sembler confus ainsi 🙂
- OK. Vous avez raison. De toute évidence en utilisant var console allait changer la nature d'un console de la propriété qui a été ajoutée à l'objet global plus tard, mais ce n'était pas le point nous étions déjà en train de discuter. Merci.
- Ce qu'est une discussion à confusion. +1 pour orginal réponse. Si je pouvais donner des +2 je voudrais pour fournir un lien pour vous propre log4javascript. Grâce OP!
- Inattendue "typeof'. L'utilisation de '===' pour comparer directement avec indéfini.
- Pas de. typeof est garantie pour renvoyer une chaîne de caractères et "undefined" est une chaîne de caractères. Lorsque les deux opérandes sont de même type, == et === sont spécifiés pour effectuer exactement les mêmes étapes. À l'aide de typeof x == "undefined" est un solide moyen de tester si x est pas défini dans toute l'étendue et toute ECMAScript 3 conforme de l'environnement.
- Aussi, pour être rigoureux cela devrait utiliser ===. C'est le seul 100% stricte réponse fournie viens de dire !de la fenêtre.console de générer des erreurs dans certains navigateurs. if (typeof(var) === "undefined") et utiliser des accolades est la bonne syntaxe stricte de cette opération.
- et === sont précisément équivalent dans ce cas, parce que les deux opérandes sont garantis d'être des chaînes de caractères, donc il n'y a aucun avantage objectif à l'aide de ===. Aussi typeof est un opérateur plutôt qu'une fonction si les parenthèses sont inutiles.
- Désolé je n'étais pas clair, le code n'est pas stricte, === rendra stricte et passer peluchage, espérons que précise ce que je voulais dire
- Assez juste, si "strict" signifie "conforme à Douglas Crockford de l'idée subjective de bonnes pratiques". La standardisation sur === n'est pas une mauvaise idée, mais ce n'est en utilisant == le cas échéant. Comme vous l'aurez deviné, je trouve JSLint trop d'opinions.
- Je pense que Crockford est bon, cette fois-ci, mais je voudrais tout de même vérifier ce vs navigateur interprètes sur une véritable monde de différences, mais c'est un thread différent.
- Eh bien, dans le ECMAScript spec, les étapes pour == et === sont exactement les mêmes que lorsque les opérandes sont de même type, et pas de point de référence, je l'ai vu a montré de différences significatives de performance entre eux pour de tels cas.
InformationsquelleAutor Tim Down

Pour une solution plus robuste, utilisez ce morceau de code (pris sur le twitter du code source):

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

InformationsquelleAutor Vinícius Moraes

13

Dans mes scripts, je dois soit utiliser le raccourci:
```
window.console && console.log(...) //only log if the function exists
```
ou, s'il n'est pas possible de modifier chaque console.ligne de journal, j'ai créer un faux console:
```
//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 () {});
```
- Erreur de syntaxe. Pourquoi ne pas simplement if(!console) {console = {} ; console.log = function(){};}
- Ou pas seulement !window.console && (window.console = { log: function () { } });
InformationsquelleAutor iblamefish
10

Vous pouvez utiliser console.log() si vous avez Developer Tools dans IE8 ouvert et vous pouvez également utiliser le Console zone de texte sur l'onglet script.
- Ce n'est pas bon si vous oubliez de sweap le code de la console. L'erreur dans IE8 empêchera votre code JS de travail
InformationsquelleAutor

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

caveat emptor: ce doit être définie au niveau mondial où this se réfère à window.

InformationsquelleAutor insign

6

Dans IE9, si la console n'est pas ouvert, ce code:
```
alert(typeof console);
```
va montrer "objet", mais ce code
```
alert(typeof console.log);
```
va jeter exception TypeError, mais pas de retour à la valeur indéfinie;

Donc, la garantie de la version de code ressemblera à ceci:
```
try {
    if (window.console && window.console.log) {
        my_console_log = window.console.log;
    }
} catch (e) {
    my_console_log = function() {};
}
```
- Perspicace réponse.
InformationsquelleAutor bonbonez
6

Je ne suis qu'à l'aide de la console.journal dans mon code. Donc, je trouve un très court 2 lignes
```
var console = console || {};
console.log = console.log || function(){};
```
- Comment son travail.. .Je ne vois pas de n'importe quelle console.ligne de journal imprimé sur le navigateur IE, j'ai testé avec 2 systèmes différents, où en 1 - console.journal de travail et 2, le système de ses pas. j'ai essayé dans les deux, mais pas en mesure de voir l'ouverture de la session dans les deux systèmes .
InformationsquelleAutor Ruben Decrop

Basé sur deux réponses précédentes par

et les documentations pour

Internet Explorer (IE 10)
Safari (de 2012. 07. 23.)
Firefox (en 2013. 05. 20.)
Chrome (2013. 01. 25.) et Chrome (de 2012. 10. 04.)
et certaines de mes connaissances

Voici un meilleur effort de mise en œuvre de la question, à savoir qu'il y a une console.journal de ce qui existe réellement, elle comble les lacunes de la non-existence de méthodes via la console.journal.

Par exemple pour IE6/7, vous pouvez remplacer l'enregistrement à l'aide d'alerte (stupide mais qui fonctionne), puis inclure le monstre ci-dessous (je l'ai appelé console.js):
[Hésitez pas à supprimer des commentaires comme bon vous semble, je les ai laissés pour référence, un minimiseur de les aborder]:

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

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

Je ne sais pas si nous avons besoin de methods.hasOwnProperty(method) && dans la boucle for.
Je suis sûr que vous n'en avez pas besoin.
Fait un test rapide dans google Chrome, la console: > x = { a: 1, b: 2} --> Object {a: 1, b: 2} et for(var f in x) {console.log(f + " " + x[f]);} 'end' --> a 1 b 2 "end". Si un objet anonyme n'a pas d'autres biens, et methods est juste créé avant la for boucle. Est-il possible de pirater le ci-dessus?
Oui. var x = { a: 1, b: 2}; Object.prototype.surprise = 'I\'m in yer objectz'; for (var f in x) {console.log(f, x[f]);} Vous ne savez jamais ce qu'est une bibliothèque a fait l'objets de l'héritage de la chaîne de l'objet sur lequel vous travaillez. Ainsi, la recommandation par le code javascript de la qualité des outils comme jshint et jslint à utiliser hasOwnProperty.

InformationsquelleAutor TWiStErRob

2

Remarqué que l'OP est à l'aide de Firebug avec IE, donc pour acquis que c'est Firebug Lite. C'est un funky situation que la console est défini à-dire lorsque la fenêtre du débogueur est ouvert, mais ce qui arrive quand Firebug est déjà en cours d'exécution? Pas sûr, mais peut-être le "firebugx.js" la méthode pourrait être une bonne façon de tester dans cette situation:

source:

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() {}
}
```
(liens mis à jour 12/2014)

InformationsquelleAutor Roberto
1

Je suis en utilisant fauxconsole; j'ai modifié le css un peu de sorte qu'il semble plus agréable mais fonctionne très bien.

InformationsquelleAutor Stijn Geukens
1

Pour le débogage dans IE, découvrez cette log4javascript
- C'est grand, d'autant que mon IE8 console n'est pas sortie de rien.
- Merci pour vos commentaires.
- J'ai été à la recherche pour le commentaire sur une autre question, qui dit: "sans vergogne l'auto-promotion" ou je ne sais pas - semblable à quelqu'un qui a dit qu'il a créé ce scipt, c'était toi? J'ai déjà fermé l'onglet. De toute façon, c'est vraiment un outil génial et très utile pour mon projet.
- Je n'ai pas créé ce script, je suis une personne comme vous bénéficié de l'aide de l'outil.
InformationsquelleAutor Praveen
1

Pour IE8 ou console en charge limitée de la console.journal (pas de débogage, de la trace, ...), vous pouvez effectuer les opérations suivantes:
- Si la console OU de la console.journal indéfini: Créer dummy fonctions pour
  fonctions de la console (trace de débogage, journal, ...)
  
  window.console = { debug : function() {}, ...};
- D'autre si la console.le journal est défini (IE8) ET la console.debug (autre) n'est pas définie: rediriger toutes les fonctions de journalisation de la console.journal, cela permet de garder les logs !
  
  window.console = { debug : window.console.log, ...};
Pas sûr de savoir le faire valoir de soutien dans les différentes versions IE, mais toutes les suggestions sont les bienvenues. Également posté cette réponse ici: Comment puis-je utiliser la console d'enregistrement de données dans Internet Explorer?

InformationsquelleAutor Christophe Roussy

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

InformationsquelleAutor David Glass

0

Vous pouvez utiliser le ci-dessous pour donner plus d'assurance que vous avez obtenu toutes les bases couverts. À l'aide de typeof première permettra d'éviter toute undefined erreurs. À l'aide de === veillera également à ce que le nom du type est en fait la chaîne "undefined". Enfin, vous pourrez vous souhaitez ajouter un paramètre à la fonction de signature (j'ai choisi logMsg arbitrairement) pour assurer la cohérence, puisque vous ne passer que vous voulez afficher dans la console de la fonction log. Cela aussi vous garder intellisense précis et évite tous les avertissements/erreurs dans votre JS conscient de l'IDE.
```
if(!window.console || typeof console === "undefined") {
var console = { log: function (logMsg) { } };
}
```
InformationsquelleAutor Flak DiNenno
0

Parfois de la console fonctionnera dans IE8/9, mais ne parviennent pas à d'autres moments. Ce comportement erratique dépend si vous avez les outils pour les développeurs, et qui est décrit dans stackoverflow question Ne IE9 support de la console.journal, et c'est une fonction réelle?

InformationsquelleAutor Anon
0

Rencontré de problème similaire de course de la console.journal des enfants de windows dans IE9, créé par la fenêtre.fonction d'ouverture.

Il semble que dans ce cas, la console est définie uniquement dans la fenêtre parent et n'est pas défini dans l'enfant de windows jusqu'à ce que vous les actualiser. Même chose s'applique pour les enfants de enfants de windows.

Je faire face à ce problème en enveloppant le journal en fonction suivante (ci-dessous, fragment de module)
```
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);
}
```
InformationsquelleAutor Max Venediktov

Tampon de la console en caractères d'imprimerie:

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

InformationsquelleAutor devi

-2

Après avoir oh tellement de problèmes avec cette chose (il est difficile de chercher l'erreur, car si vous ouvrez la console développeur de l'erreur ne se produit plus!) J'ai décidé de faire un excès de code pour ne jamais avoir à se soucier de cela plus jamais:

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

Personnellement je ne jamais utiliser la console.journal et de la console.l'erreur, mais ce code gère toutes les autres fonctions comme indiqué dans le Mozzila Developer Network: https://developer.mozilla.org/en-US/docs/Web/API/console.
Juste mis le code sur le haut de votre page et que vous vous êtes fait pour toujours avec cette.

InformationsquelleAutor Hoffmann

-10

Vous pouvez utiliser la console.journal(...) directement dans Firefox, mais pas dans les IEs. Dans IEs vous devez utiliser la fenêtre.console.
- console.journal et de la fenêtre.console.journal reportez-vous à la même fonction dans n'importe quel navigateur qui est même à distance conforme à ECMAscript. Il est de bonne pratique d'utiliser ce dernier afin d'éviter une variable locale accidentellement de l'ombre à la console globale de l'objet, mais qui n'a absolument rien à voir avec le choix du navigateur. console.journal fonctionne très bien avec IE8, et autant que je sache, il n'y a pas de fonctionnalité de journalisation dans IE6/7.
InformationsquelleAutor Mohit Kumar

Vous devez vous connecter pour publier un commentaire.