Comment désactiver rapidement et facilement toutes les instructions console.log dans mon code?

Existe-t-il un moyen de désactiver toutes les console.loginstructions dans mon code JavaScript, à des fins de test?

Redéfinissez la fonction console.log dans votre script.

console.log = function() {}

Voilà, plus de messages à consoler.

ÉDITER:

Développer l'idée de Cide. Un enregistreur personnalisé que vous pouvez utiliser pour activer / désactiver la connexion à partir 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 l'enregistreur ci-dessus? Dans votre événement prêt, appelez logger.disableLogger pour que les messages de la console ne soient pas enregistré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 approfondi:

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

Cela supprimera les méthodes courantes de la console si elles existent, et elles peuvent être appelées sans erreur et pratiquement sans surcharge de performances. Dans le cas d'un navigateur comme IE6 sans console, les méthodes factices seront créées pour éviter les erreurs. Bien sûr, il y a beaucoup plus de fonctions dans Firebug, comme trace, profil, 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 possède ou non ces méthodes spéciales (c'est-à-dire IE) et mettre à zéro celles qu'il ne prend pas en charge:

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

Pour autant que je sache dans la documentation , Firebug ne fournit aucune variable pour basculer l'état de débogage. Au lieu de cela, enveloppez console.log () dans un wrapper qui l'appelle conditionnellement, c'est-à-dire:

DEBUG = true; // set to false to disable debugging
function debug_log() {
    if ( DEBUG ) {
        console.log.apply(this, arguments);
    }
}

Pour ne pas avoir à modifier 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 des fonctions intégrées. Il n'y a également aucune garantie que vous supprimerez toutes les sorties, les autres bibliothèques que vous utilisez peuvent annuler vos modifications et il existe d'autres fonctions qui peuvent écrire sur la console; .dir(), .warning(), .error(), .debug(), .assert()Etc.

Comme certains l'ont suggéré, vous pouvez définir une DEBUG_MODEvariable 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 d'enregistreur qui entoure l'objet console et intègre cette capacité. Ce serait le bon endroit pour traiter de l' instrumentation .

Cela dit, à des fins de «test», vous pouvez écrire des tests au lieu d'imprimer sur la console. Si vous ne faites aucun test et que ces console.log()lignes n'étaient qu'une aide pour écrire votre code, supprimez-les simplement .

Je me rends compte que c'est un ancien article, mais il apparaît toujours en haut des résultats de Google, alors voici une solution non jQuery plus élégante qui fonctionne dans les derniers 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 à activer ou 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() {};
}

DEBUGModifiez simplement l'indicateur 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 de toutes ces réponses, personne ne combine:

• Pas de requête
• Fonction anonyme pour ne pas polluer l'espace de noms global
• Gérer le cas où window.console n'est pas défini
• Modifiez simplement 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 () {};
    }
})()

Après avoir également recherché ce problème et l'avoir essayé dans mon application cordova, je veux simplement avertir chaque développeur que Windows Phone ne doit pas écraser

    console.log

car l'application se bloque au démarrage.

Il ne plantera pas si vous développez local si vous êtes chanceux, mais le soumettre en magasin entraînera le crash de l'application.

Écraser

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

    }

Si vous utilisez IE7, la console ne sera pas définie. Une version plus conviviale d'IE serait donc:

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

C'est un hybride de réponses de SolutionYogi et Chris S. Il maintient les numéros de ligne et le 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é.

https://www.npmjs.org/package/grunt-remove-logging-calls

J'ai utilisé ce qui suit pour régler le 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. Utilisez ensuite 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 utilisé l' enregistreur Winston plus tôt.

Aujourd'hui, j'utilise ci-dessous un code plus simple d'expérience:

1. Définissez la variable d'environnement à partir de cmd / ligne de commande (sous Windows):

   cmd
   setx LOG_LEVEL info

Ou, vous pouvez avoir une variable dans votre code si vous le souhaitez, mais au-dessus c'est mieux.

2. Redémarrez cmd / ligne de commande, ou, IDE / éditeur comme Netbeans

3. Avoir ci-dessous comme le 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;
   }

4. Utilisez maintenant toutes les consoles. * Comme 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 de vos paramètres LOG_LEVEL définis au point 1 (comme, setx LOG_LEVEL log et redémarrer la ligne de commande), certains des éléments ci-dessus s'impriment, d'autres ne s'impriment pas

J'espère que cela a aidé.

Attention: fiche sans vergogne!

Vous pouvez également utiliser quelque chose comme mon objet JsTrace pour avoir un suivi modulaire avec une capacité de "commutation" au niveau du module pour activer uniquement ce que vous voulez voir à ce moment-là.

http://jstrace.codeplex.com

(A également un package NuGet, pour ceux qui s'en soucient)

Tous les niveaux sont définis par défaut sur "erreur", mais vous pouvez les désactiver "off". Cependant, je ne vois pas pourquoi vous ne voudriez PAS voir d'erreurs

Vous pouvez les changer comme ceci:

Trace.traceLevel('ModuleName1', Trace.Levels.log);
Trace.traceLevel('ModuleName2', Trace.Levels.info);

Pour plus de documents, consultez la documentation

T

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 développé une bibliothèque pour ce cas d'utilisation: https://github.com/sunnykgupta/jsLogger

Fonctionnalités:

1. Il remplace en toute sécurité le console.log.
2. Prend soin si la console n'est pas disponible (oh oui, vous devez également en tenir compte.)
3. Stocke tous les journaux (même s'ils sont supprimés) pour une récupération ultérieure.
4. Poignées principales fonctions de la console comme log, warn, error, info.

Est ouvert aux modifications et sera mis à jour chaque fois que de nouvelles suggestions émergeront.

Cela devrait remplacer toutes les méthodes de window.console. Vous pouvez le mettre tout en haut de votre section de scripts, et si vous êtes sur un framework PHP, vous ne pouvez imprimer ce code que lorsque votre environnement d'application est en production, ou si une sorte d'indicateur de débogage est désactivée. Ensuite, vous auriez tous vos journaux dans votre code travaillant sur 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 é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 = setEnabledet console.fn.setEnabled(false)où fnpourrait être presque n'importe quelle fonction de console. Car 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);

donc il vous suffit de mettre la FLAGSvaleur par défaut (avant d'exécuter le code ci-dessus), comme FLAGS.LOG = falseet la fonction de journal serait désactivée par défaut, et vous pourriez toujours l'activer en appelantconsole.log.setEnabled(true)

Ma solution complète pour désactiver / remplacer toutes les console.*fonctions est ici .

Bien sûr, assurez-vous de l'inclure après avoir vérifié le contexte nécessaire. Par exemple, uniquement dans la version de production, il ne bombarde aucun autre composant crucial, etc.

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 ce plugin:

Installez ce plugin avec la commande:

npm install gulp-remove-logging

Ensuite, ajoutez cette ligne à votre gulpfile:

var gulp_remove_logging = require("gulp-remove-logging");

Enfin, ajoutez les paramètres de configuration (voir ci-dessous) à votre gulpfile.

Configuration des tâches

gulp.task("remove_logging", function() {
     return gulp.src("src/javascripts/**/*.js")
    .pipe(
      gulp_remove_logging()
    )
    .pipe(
      gulp.dest(
        "build/javascripts/"
      )
    ); });

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 javascript AOP (par exemple jquery-aop ) pour intercepter tous les appels à console.debug / log (autour) et ne pas procéder à l'appel réel si une variable globale est définie sur false.

Vous pouvez même faire un appel ajax (de temps en temps) afin de pouvoir modifier le comportement de journal activé / désactivé sur le serveur, ce qui peut être très intéressant pour activer le débogage face à un problème dans un environnement de transfert ou autre.

Vous pouvez utiliser logeek , il vous permet de contrôler la visibilité de vos messages de journal. Voici comment procéder:

<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')désactiver totalement chaque message de journal.

Après avoir fait quelques recherches et développements pour ce problème, je suis tombé sur cette solution qui masquera les avertissements / erreurs / journaux selon votre choix.

    (function () {
    var origOpen = XMLHttpRequest.prototype.open;
    XMLHttpRequest.prototype.open = function () {        
        console.warn = function () { };
        window['console']['warn'] = function () { };
        this.addEventListener('load', function () {                        
            console.warn('Something bad happened.');
            window['console']['warn'] = function () { };
        });        
    };
})();

Ajoutez ce code avant le plugin JQuery (par exemple /../jquery.min.js) même s'il s'agit d'un code JavaScript qui ne nécessite pas JQuery. Parce que certains avertissements sont dans JQuery lui-même.

Merci!!

J'ai écrit une ES2015 solution (utiliser uniquement avec Webpack ).

class logger {
  static isEnabled = true;

  static enable () {
    if(this.constructor.isEnabled === true){ return; }

    this.constructor.isEnabled = true;
  }

  static disable () {
    if(this.constructor.isEnabled === false){ return; }

    this.constructor.isEnabled = false;
  }

  static log () {
    if(this.constructor.isEnabled === false ) { return; }

    const copy = [].slice.call(arguments);

    window['console']['log'].apply(this, copy);
  }

  static warn () {
    if(this.constructor.isEnabled === false ) { return; }

    const copy = [].slice.call(arguments);

    window['console']['warn'].apply(this, copy);
  }

  static error () {
    if(this.constructor.isEnabled === false ) { return; }

    const copy = [].slice.call(arguments);

    window['console']['error'].apply(this, copy);
  }
}

La description:

1. En plus de logger.enable et logger.disable, vous pouvez utiliser les méthodes console. ['Log', 'warn', 'error'] ainsi que la classe logger.
2. En utilisant la classe logger pour afficher, activer ou désactiver les messages, le code est beaucoup plus propre et maintenable.
3. Le code ci-dessous vous montre comment utiliser la classe logger:
   • logger.disable() - désactiver tous les messages de la console
   • logger.enable() - activer tous les messages de la console
   • logger.log('message1', 'message2') - fonctionne exactement comme console.log.
   • logger.warn('message1', 'message2') - fonctionne exactement comme console.warn.
   • logger.error('message1', 'message2')- fonctionne exactement comme console.error. Bon codage ..