Comment désactiver rapidement et facilement toutes les instructions console.log dans mon code?
Est-il possible de désactiver toutes les instructions console.log dans mon code JavaScript, à des fins de test?
Redéfinissez la fonction console.log dans votre script.
console.log = function() {}
Ça y est, plus de messages à console.
EDIT:
Développer l'idée de Cide. Un enregistreur personnalisé que vous pouvez utiliser pour activer/désactiver l’enregistrement de votre code.
Depuis ma console Firefox:
var logger = function()
{
var oldConsoleLog = null;
var pub = {};
pub.enableLogger = function enableLogger()
{
if(oldConsoleLog == null)
return;
window['console']['log'] = oldConsoleLog;
};
pub.disableLogger = function disableLogger()
{
oldConsoleLog = console.log;
window['console']['log'] = function() {};
};
return pub;
}();
$(document).ready(
function()
{
console.log('hello');
logger.disableLogger();
console.log('hi', 'hiya');
console.log('this wont show up in console');
logger.enableLogger();
console.log('This will show up!');
}
);
Comment utiliser le 'logger' ci-dessus? Dans votre événement ready, appelez logger.disableLogger pour que les messages de la console ne soient pas consignés. Ajoutez des appels à logger.enableLogger et logger.disableLogger dans la méthode pour laquelle vous souhaitez consigner des messages sur la console.
Ce qui suit est plus complet:
var DEBUG = false;
if(!DEBUG){
if(!window.console) window.console = {};
var methods = ["log", "debug", "warn", "info"];
for(var i=0;i<methods.length;i++){
console[methods[i]] = function(){};
}
}
Les méthodes courantes de la console, si elles existent, sont mises à zéro. Elles peuvent être appelées sans erreur et sans aucune surcharge de performances. Dans le cas d'un navigateur comme IE6 sans console, les méthodes fictives seront créées pour éviter les erreurs. Bien entendu, il existe de nombreuses autres fonctions dans Firebug, telles que la trace, le profil, l'heure, etc. Elles peuvent être ajoutées à la liste si vous les utilisez dans votre code.
Vous pouvez également vérifier si le débogueur a ces méthodes spéciales ou non (ie IE) et mettre à zéro celles qu'il ne supporte pas:
if(window.console && !console.dir){
var methods = ["dir", "dirxml", "trace", "profile"]; //etc etc
for(var i=0;i<methods.length;i++){
console[methods[i]] = function(){};
}
}
D'après ce que je peux dire à partir de documentation , Firebug ne fournit aucune variable permettant de basculer l'état de débogage. Envisagez plutôt console.log () dans un wrapper qui l’appelle de manière conditionnelle, c.-à-d.:
DEBUG = true; // set to false to disable debugging
function debug_log() {
if ( DEBUG ) {
console.log.apply(this, arguments);
}
}
Pour ne pas avoir à changer tous les appels existants, vous pouvez utiliser ceci à la place:
DEBUG = true; // set to false to disable debugging
old_console_log = console.log;
console.log = function() {
if ( DEBUG ) {
old_console_log.apply(this, arguments);
}
}
Tu ne devrais pas!
Ce n'est pas une bonne pratique d'écraser les fonctions intégrées. De plus, rien ne garantit que vous supprimerez toutes les sorties, les autres bibliothèques que vous utilisez peuvent annuler vos modifications et d'autres fonctions peuvent écrire dans la console. .dir(), .warning(), .error(), .debug(), .assert() etc.
Comme suggéré par certains, vous pouvez définir une variable DEBUG_MODE et vous connecter de manière conditionnelle. En fonction de la complexité et de la nature de votre code, il peut être judicieux d'écrire votre propre objet/fonction de journalisation qui enveloppe l'objet de la console et intègre cette fonctionnalité. Ce serait le bon endroit pour traiter instrumentation.
Cela dit, à des fins de "test", vous pouvez écrire tests au lieu d'imprimer sur la console. Si vous ne faites aucun test et que ces console.log() lignes étaient simplement une aide pour écrire votre code, supprimez-les simplement.
Je me rends compte qu’il s’agit d’un vieux message mais qu’il apparaît toujours en haut des résultats de Google. Voici donc une solution plus élégante, non jQuery, qui fonctionne dans les dernières versions de Chrome, FF et IE.
(function (original) {
console.enableLogging = function () {
console.log = original;
};
console.disableLogging = function () {
console.log = function () {};
};
})(console.log);
Je sais que vous avez demandé comment désactiver console.log, mais c'est peut-être ce que vous recherchez vraiment. De cette façon, vous n'avez pas besoin d'activer ou de désactiver explicitement la console. Il empêche simplement ces erreurs de console embêtantes pour les personnes qui ne l'ont pas ouvert ou installé.
if(typeof(console) === 'undefined') {
var console = {};
console.log = console.error = console.info = console.debug = console.warn = console.trace = console.dir = console.dirxml = console.group = console.groupEnd = console.time = console.timeEnd = console.assert = console.profile = function() {};
}
Il suffit de changer l'indicateur DEBUG pour remplacer la fonction console.log. Cela devrait faire l'affaire.
var DEBUG = false;
// ENABLE/DISABLE Console Logs
if(!DEBUG){
console.log = function() {}
}
Je suis surpris que personne ne combine toutes ces réponses:
- Pas de requête
- Fonction anonyme pour ne pas polluer l'espace de noms global
- Traiter le cas où window.console n'est pas défini
- Il suffit de modifier la fonction .log de la console
J'irais pour ça:
(function () {
var debug = false
if (debug === false) {
if ( typeof(window.console) === 'undefined') { window.console = {}; }
window.console.log = function () {};
}
})()
Si vous utilisez IE7, la console ne sera pas définie. Donc, une version plus IE conviviale serait:
if (typeof console == "undefined" || typeof console.log == "undefined")
{
var console = { log: function() {} };
}
Après avoir également recherché ce problème et l'avoir essayé dans mon application Cordova, je souhaite simplement avertir tous les développeurs Windows Phone de ne pas écraser
console.log
parce que l'application va planter au démarrage.
Si vous avez de la chance, cela ne plantera pas si vous développez en local, mais si vous le soumettez en magasin, l'application se plantera.
Écraser juste
window.console.log
si tu as besoin de.
Cela fonctionne dans mon application:
try {
if (typeof(window.console) != "undefined") {
window.console = {};
window.console.log = function () {
};
window.console.info = function () {
};
window.console.warn = function () {
};
window.console.error = function () {
};
}
if (typeof(alert) !== "undefined") {
alert = function ()
{
}
}
} catch (ex) {
}
Ceci est un hybride de réponses de SolutionYogi et de Chris S. Il maintient le numéros de ligne et nom de fichier console.log. Exemple jsFiddle .
// Avoid global functions via a self calling anonymous one (uses jQuery)
(function(MYAPP, $, undefined) {
// Prevent errors in browsers without console.log
if (!window.console) window.console = {};
if (!window.console.log) window.console.log = function(){};
//Private var
var console_log = console.log;
//Public methods
MYAPP.enableLog = function enableLogger() { console.log = console_log; };
MYAPP.disableLog = function disableLogger() { console.log = function() {}; };
}(window.MYAPP = window.MYAPP || {}, jQuery));
// Example Usage:
$(function() {
MYAPP.disableLog();
console.log('this should not show');
MYAPP.enableLog();
console.log('This will show');
});
Si vous utilisez Grunt, vous pouvez ajouter une tâche afin de supprimer/commenter les instructions console.log. Par conséquent, le fichier console.log n'est plus appelé.
J'ai utilisé ce qui suit pour résoudre ce problème: -
var debug = 1;
var logger = function(a,b){ if ( debug == 1 ) console.log(a, b || "");};
Définissez le débogage sur 1 pour activer le débogage. Ensuite, utilisez la fonction de journalisation lors de la sortie du texte de débogage. Il est également configuré pour accepter deux paramètres.
Donc, au lieu de
console.log("my","log");
utilisation
logger("my","log");
J'ai développé une bibliothèque pour cette utilisation: https://github.com/sunnykgupta/jsLogger
Caractéristiques:
- Il remplace en toute sécurité le fichier console.log.
- Prend soin de vous si la console n'est pas disponible (oh oui, vous devez aussi en tenir compte.)
- Stocke tous les journaux (même s'ils sont supprimés) pour une récupération ultérieure.
- Gère les fonctions principales de la console comme
log,warn,error,info.
Est ouvert aux modifications et sera mis à jour à chaque nouvelle suggestion.
Attention: fiche éhontée!
Vous pouvez également utiliser quelque chose comme mon objet JsTrace pour obtenir un traçage modulaire avec une fonctionnalité de "commutation" au niveau du module pour n'activer que ce que vous voulez voir à ce moment-là.
(A également un paquet NuGet, pour ceux qui se soucient)
Tous les niveaux sont définis par défaut sur "erreur", bien que vous puissiez les "désactiver". Cependant, je ne vois pas pourquoi vous ne voudriez PAS voir d'erreurs
Vous pouvez les changer comme ça:
Trace.traceLevel('ModuleName1', Trace.Levels.log);
Trace.traceLevel('ModuleName2', Trace.Levels.info);
Pour plus de documentation, consultez la documentation
T
Cela devrait remplacer toutes les méthodes de window.console. Vous pouvez le placer tout en haut de la section scripts, et si vous utilisez un framework PHP, vous ne pouvez imprimer ce code que lorsque l'environnement de votre application est en production ou qu'un indicateur de débogage est désactivé. Tous vos journaux de votre code fonctionneraient alors dans des environnements de développement ou en mode débogage.
window.console = (function(originalConsole){
var api = {};
var props = Object.keys(originalConsole);
for (var i=0; i<props.length; i++) {
api[props[i]] = function(){};
}
return api;
})(window.console);
J'ai utilisé winston plus tôt.
De nos jours, j'utilise ci-dessous un code d'expérience simple:
Définissez la variable d'environnement à partir de cmd/ligne de commande (sous Windows):
cmd setx LOG_LEVEL info
Ou bien, vous pourriez avoir une variable dans votre code si vous voulez, mais ci-dessus, c'est mieux.
Redémarrez cmd/ligne de commande ou IDE/éditeur comme Netbeans
Avez ci-dessous comme code:
console.debug = console.log; // define debug function console.silly = console.log; // define silly function switch (process.env.LOG_LEVEL) { case 'debug': case 'silly': // print everything break; case 'dir': case 'log': console.debug = function () {}; console.silly = function () {}; break; case 'info': console.debug = function () {}; console.silly = function () {}; console.dir = function () {}; console.log = function () {}; break; case 'trace': // similar to error, both may print stack trace/ frames case 'warn': // since warn() function is an alias for error() case 'error': console.debug = function () {}; console.silly = function () {}; console.dir = function () {}; console.log = function () {}; console.info = function () {}; break; }Maintenant, utilisez toute la console. * Ci-dessous:
console.error(' this is a error message '); // will print console.warn(' this is a warn message '); // will print console.trace(' this is a trace message '); // will print console.info(' this is a info message '); // will print, LOG_LEVEL is set to this console.log(' this is a log message '); // will NOT print console.dir(' this is a dir message '); // will NOT print console.silly(' this is a silly message '); // will NOT print console.debug(' this is a debug message '); // will NOT print
Maintenant, en fonction des paramètres LOG_LEVEL définis dans le point 1 (comme setx LOG_LEVEL log et redémarrez la ligne de commande), certains des éléments ci-dessus seront imprimés, d'autres pas.
J'espère que ça a aidé.
J'ai trouvé un morceau de code un peu plus avancé dans cette URL Astuce JavaScript: Bust and Disable console.log :
var DEBUG_MODE = true; // Set this value to false for production
if(typeof(console) === 'undefined') {
console = {}
}
if(!DEBUG_MODE || typeof(console.log) === 'undefined') {
// FYI: Firebug might get cranky...
console.log = console.error = console.info = console.debug = console.warn = console.trace = console.dir = console.dirxml = console.group = console.groupEnd = console.time = console.timeEnd = console.assert = console.profile = function() {};
}
J'ai écrit ceci:
//Make a copy of the old console.
var oldConsole = Object.assign({}, console);
//This function redefine the caller with the original one. (well, at least i expect this to work in chrome, not tested in others)
function setEnabled(bool) {
if (bool) {
//Rewrites the disable function with the original one.
console[this.name] = oldConsole[this.name];
//Make sure the setEnable will be callable from original one.
console[this.name].setEnabled = setEnabled;
} else {
//Rewrites the original.
var fn = function () {/*function disabled, to enable call console.fn.setEnabled(true)*/};
//Defines the name, to remember.
Object.defineProperty(fn, "name", {value: this.name});
//replace the original with the empty one.
console[this.name] = fn;
//set the enable function
console[this.name].setEnabled = setEnabled
}
}
Malheureusement, cela ne fonctionne pas en mode strict.
Donc, en utilisant console.fn.setEnabled = setEnabled puis console.fn.setEnabled(false) où fn pourrait être presque n'importe quelle fonction de console. Pour votre cas serait:
console.log.setEnabled = setEnabled;
console.log.setEnabled(false);
J'ai aussi écrit ceci:
var FLAGS = {};
FLAGS.DEBUG = true;
FLAGS.INFO = false;
FLAGS.LOG = false;
//Adding dir, table, or other would put the setEnabled on the respective console functions.
function makeThemSwitchable(opt) {
var keysArr = Object.keys(opt);
//its better use this type of for.
for (var x = 0; x < keysArr.length; x++) {
var key = keysArr[x];
var lowerKey = key.toLowerCase();
//Only if the key exists
if (console[lowerKey]) {
//define the function
console[lowerKey].setEnabled = setEnabled;
//Make it enabled/disabled by key.
console[lowerKey].setEnabled(opt[key]);
}
}
}
//Put the set enabled function on the original console using the defined flags and set them.
makeThemSwitchable(FLAGS);
alors il vous suffit de mettre dans FLAGS la valeur par défaut (avant d'exécuter le code ci-dessus), comme FLAGS.LOG = false, et la fonction de journalisation serait désactivée par défaut, mais vous pouvez toujours l'activer en appelant console.log.setEnabled(true).
Ma solution complète pour désactiver/remplacer toutes les fonctions console.* est ici .
Bien sûr, assurez-vous de l'inclure après avoir vérifié le contexte nécessaire. Par exemple, inclure uniquement dans la version de production, ne pas bombarder d'autres composants cruciaux, etc.
En le citant ici:
"use strict";
(() => {
var console = (window.console = window.console || {});
[
"assert", "clear", "count", "debug", "dir", "dirxml",
"error", "exception", "group", "groupCollapsed", "groupEnd",
"info", "log", "markTimeline", "profile", "profileEnd", "table",
"time", "timeEnd", "timeStamp", "trace", "warn"
].forEach(method => {
console[method] = () => {};
});
console.log("This message shouldn't be visible in console log");
})();Si vous utilisez gulp, vous pouvez utiliser le plugin this :
Installez ce plugin avec la commande:
npm install gulp-remove-loggingEnsuite, ajoutez cette ligne à votre fichier gulp:
var gulp_remove_logging = require("gulp-remove-logging");Enfin, ajoutez les paramètres de configuration (voir ci-dessous) à votre fichier gulp.
Configuration de la tâche
gulp.task("remove_logging", function() { return gulp.src("src/javascripts/**/*.js") .pipe( gulp_remove_logging() ) .pipe( gulp.dest( "build/javascripts/" ) ); });
Vous pouvez utiliser javascript AOP (par exemple, jquery-aop ) pour intercepter tous les appels à console.debug/log (autour de) et ne pas procéder à l'appel réel si une variable globale est définie sur false.
Vous pouvez même effectuer un appel ajax (de temps en temps) pour modifier le comportement activé/désactivé du journal sur le serveur, ce qui peut s'avérer très intéressant pour permettre le débogage lorsque vous rencontrez un problème dans un environnement de stockage intermédiaire ou autre.
Une simplification de https://stackoverflow.com/a/46189791/871166
switch (process.env.LOG_LEVEL) {
case 'ERROR':
console.warn = function() {};
case 'WARN':
console.info = function() {};
case 'INFO':
console.log = function() {};
case 'LOG':
console.debug = function() {};
console.dir = function() {};
}
Vous pouvez utiliser logeek , Il vous permet de contrôler la visibilité de vos messages de journal. Voici comment vous faites cela:
<script src="bower_components/dist/logeek.js"></script>
logeek.show('security');
logeek('some message').at('copy'); //this won't be logged
logeek('other message').at('secturity'); //this would be logged
Vous pouvez également logeek.show('nothing') pour désactiver totalement chaque message du journal.