Come disabilitare rapidamente e comodamente tutte le istruzioni console.log nel mio codice?

Esiste un modo per disattivare tutte le console.logdichiarazioni nel mio codice JavaScript, a scopo di test?

Ridefinisci la funzione console.log nello script.

console.log = function() {}

Ecco fatto, niente più messaggi da console.

MODIFICARE:

Espandere l'idea di Cide. Un logger personalizzato che è possibile utilizzare per attivare / disattivare la registrazione dal proprio codice.

Dalla mia console di 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!');
    }
 );

Come usare il 'logger' sopra? Nel tuo evento pronto, chiama logger.disableLogger in modo che i messaggi della console non vengano registrati. Aggiungi chiamate a logger.enableLogger e logger.disableLogger all'interno del metodo per il quale desideri registrare i messaggi sulla console.

Quanto segue è più approfondito:

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

Questo azzererà i metodi comuni nella console, se esiste, e possono essere chiamati senza errori e praticamente senza sovraccarico di prestazioni. Nel caso di un browser come IE6 senza console, verranno creati i metodi fittizi per prevenire errori. Ovviamente ci sono molte altre funzioni in Firebug, come traccia, profilo, tempo, ecc. Possono essere aggiunte all'elenco se le usi nel tuo codice.

Puoi anche verificare se il debugger ha quei metodi speciali o meno (cioè IE) e azzerare quelli che non supporta:

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

Per quanto ne so dalla documentazione , Firebug non fornisce alcuna variabile per attivare lo stato di debug. Invece, avvolgi console.log () in un wrapper che lo chiama in modo condizionale, ovvero:

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

Per non dover cambiare tutte le chiamate esistenti, puoi invece usare questo:

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

Non dovresti!

Non è una buona pratica sovrascrivere le funzioni integrate. Non vi è inoltre alcuna garanzia che si eliminerà tutto l'output, altre librerie utilizzate potrebbero annullare le modifiche e ci sono altre funzioni che possono scrivere sulla console; .dir(), .warning(), .error(), .debug(),.assert() Etc.

Come alcuni hanno suggerito, è possibile definire una DEBUG_MODEvariabile e accedere in modo condizionale. A seconda della complessità e della natura del codice, potrebbe essere una buona idea scrivere il proprio oggetto logger / funzione che avvolge l'oggetto console e che abbia questa funzionalità integrata. Sarebbe il posto giusto per occuparsi della strumentazione .

Detto questo, per scopi di "test" è possibile scrivere test invece di stampare sulla console. Se non stai eseguendo alcun test e quelle console.log()righe sono solo un aiuto per scrivere il tuo codice, semplicemente cancellali .

Mi rendo conto che questo è un vecchio post, ma appare ancora in cima ai risultati di Google, quindi ecco una soluzione non jQuery più elegante che funziona negli ultimi Chrome, FF e IE.

(function (original) {
    console.enableLogging = function () {
        console.log = original;
    };
    console.disableLogging = function () {
        console.log = function () {};
    };
})(console.log);

So che hai chiesto come disabilitare console.log, ma questo potrebbe essere quello che stai veramente cercando. In questo modo non è necessario abilitare o disabilitare esplicitamente la console. Previene semplicemente quegli fastidiosi errori della console per le persone che non lo hanno aperto o installato.

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

Basta cambiare il flag DEBUGper sovrascrivere la funzione console.log. Questo dovrebbe fare il trucco.

var DEBUG = false;
// ENABLE/DISABLE Console Logs
if(!DEBUG){
  console.log = function() {}
}

Sono sorpreso che di tutte quelle risposte nessuno combina:

• No jquery
• Funzione anonima per non inquinare lo spazio dei nomi globale
• Gestire il caso in cui window.console non è definito
• Basta modificare la funzione .log della console

Vorrei per questo:

(function () {

    var debug = false

    if (debug === false) {
        if ( typeof(window.console) === 'undefined') { window.console = {}; }
        window.console.log = function () {};
    }
})()

Dopo aver cercato anche questo problema e averlo provato nella mia app Cordova, voglio solo avvisare tutti gli sviluppatori di Windows Phone di non sovrascrivere

    console.log

perché l'app si arresterà in modo anomalo all'avvio.

Non andrà in crash se stai sviluppando localmente se sei fortunato, ma l'invio in negozio comporterà l'arresto anomalo dell'app.

Basta sovrascrivere

    window.console.log 

se hai bisogno di.

Funziona nella mia app:

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

    }

Se si utilizza IE7, la console non verrà definita. Quindi una versione più intuitiva di IE sarebbe:

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

Questo è un ibrido di risposte da SolutionYogi e Chris S. Mantiene i numeri di riga console.log e il nome del file. Esempio 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');
});

Se si utilizza Grunt è possibile aggiungere un'attività per rimuovere / commentare le istruzioni console.log. Pertanto console.log non viene più chiamato.

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

Ho usato il seguente per affrontare il problema: -

var debug = 1;
var logger = function(a,b){ if ( debug == 1 ) console.log(a, b || "");};

Impostare il debug su 1 per abilitare il debug. Quindi utilizzare la funzione logger durante l'output del testo di debug. È anche impostato per accettare due parametri.

Quindi, invece di

console.log("my","log");

uso

logger("my","log");

Ho usato Winston Logger in precedenza.

Oggi sto usando sotto il codice più semplice per esperienza:

1. Imposta la variabile di ambiente da cmd / riga di comando (su Windows):

   cmd
   setx LOG_LEVEL info

Oppure, potresti avere una variabile nel tuo codice se vuoi, ma sopra è meglio.

2. Riavvia cmd / riga di comando o IDE / editor come Netbeans

3. Hanno sotto il codice simile:

   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. Ora usa tutta la console. * Come di seguito:

   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

Ora, in base alle impostazioni LOG_LEVEL effettuate al punto 1 (like setx LOG_LEVEL loge riavvia riga di comando), alcune delle opzioni precedenti verranno stampate, altre non verranno stampate

Spero che abbia aiutato.

Attenzione: spina senza vergogna!

Potresti anche usare qualcosa come il mio oggetto JsTrace per avere una traccia modulare con capacità di "commutazione" a livello di modulo per accendere solo ciò che vuoi vedere in quel momento.

http://jstrace.codeplex.com

(Ha anche un pacchetto NuGet, per chi se ne frega)

Tutti i livelli predefiniti sono "errore", sebbene sia possibile chiuderli "off". Tuttavia, non riesco a pensare al motivo per cui NON vorresti vedere errori

Puoi cambiarli in questo modo:

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

Per ulteriori documenti, consulta la documentazione

T

Ho trovato un po 'di codice più avanzato in questo URL Suggerimento 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() {};
}

Ho sviluppato una libreria per questo caso d'uso: https://github.com/sunnykgupta/jsLogger

Caratteristiche:

1. Sostituisce in modo sicuro console.log.
2. Si preoccupa se la console non è disponibile (oh sì, è necessario tener conto anche di questo.)
3. Memorizza tutti i registri (anche se vengono eliminati) per un successivo recupero.
4. Maniglie principali funzioni della console piace log, warn, error, info.

È aperto per modifiche e verrà aggiornato ogni volta che emergono nuovi suggerimenti.

Questo dovrebbe sovrascrivere tutti i metodi di window.console. Puoi metterlo nella parte superiore della sezione degli script e, se ti trovi in ​​un framework PHP, puoi stampare questo codice solo quando l'ambiente dell'app è di produzione o se un tipo di flag di debug è disabilitato. Quindi avresti tutti i tuoi log nel tuo codice che lavorano su ambienti di sviluppo o in modalità debug.

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

Ho scritto questo:

//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

    }
}

Sfortunatamente non funziona con la modalità rigorosa.

Quindi usando console.fn.setEnabled = setEnablede quindi console.fn.setEnabled(false)dove fnpotrebbe essere quasi qualsiasi funzione di console. Per il tuo caso sarebbe:

console.log.setEnabled = setEnabled;
console.log.setEnabled(false);

Ho scritto anche questo:

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

quindi devi solo inserire il FLAGSvalore predefinito (prima di eseguire il codice sopra), come FLAGS.LOG = falsee la funzione di registro sarebbe disabilitata per impostazione predefinita, e comunque potresti abilitarla chiamandoconsole.log.setEnabled(true)

La mia soluzione completa per disabilitare / sovrascrivere tutte le console.*funzioni è qui .

Naturalmente, assicurati di includerlo dopo aver verificato il contesto necessario. Ad esempio, incluso solo nella versione di produzione, non sta bombardando altri componenti cruciali ecc.

Citandolo qui:

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

Se stai usando gulp, puoi usare questo plugin:

Installa questo plugin con il comando:

npm install gulp-remove-logging

Quindi, aggiungi questa riga al tuo gulpfile:

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

Infine, aggiungi le impostazioni di configurazione (vedi sotto) al tuo gulpfile.

Configurazione dell'attività

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

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

È possibile utilizzare javascript AOP (ad esempio jquery-aop ) per intercettare tutte le chiamate a console.debug / log (in giro) e non procedere con l'effettiva chiamata se alcune variabili globali sono impostate su false.

È anche possibile effettuare una chiamata Ajax (di tanto in tanto) in modo da poter modificare il comportamento abilitato / disabilitato del registro sul server, che può essere molto interessante per abilitare il debug di fronte a un problema in un ambiente di gestione temporanea o simile.

Puoi usare logeek , ti permette di controllare la visibilità dei tuoi messaggi di log. Ecco come lo fai:

<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

Puoi anche logeek.show('nothing')disabilitare totalmente ogni messaggio di registro.

Dopo aver fatto qualche ricerca e sviluppo per questo problema, mi sono imbattuto in questa soluzione che nasconderà avvisi / errori / registri secondo la vostra scelta.

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

Aggiungi questo codice prima del plug-in JQuery (ad es. /../Jquery.min.js) anche se si tratta di un codice JavaScript che non richiede JQuery. Perché alcuni avvisi sono in JQuery stesso.

Grazie!!

Ho scritto una soluzione ES2015 (utilizzare solo con 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);
  }
}

Descrizione:

1. Insieme a logger.enable e logger.disable puoi usare i metodi console. ['Log', 'warn', 'error'] e usando la classe logger.
2. Usando la classe logger per visualizzare, abilitare o disabilitare i messaggi rende il codice molto più pulito e gestibile.
3. Il codice seguente mostra come utilizzare la classe logger:
   • logger.disable() - disabilita tutti i messaggi della console
   • logger.enable() - abilita tutti i messaggi della console
   • logger.log('message1', 'message2') - funziona esattamente come console.log.
   • logger.warn('message1', 'message2') - funziona esattamente come console.warn.
   • logger.error('message1', 'message2')- funziona esattamente come console.error. Buona codifica ...