Como desabilitar de forma rápida e conveniente todas as instruções console.log no meu código?

Existe alguma maneira de desativar todas as console.loginstruções no meu código JavaScript, para fins de teste?

Redefina a função console.log no seu script.

console.log = function() {}

É isso aí, não há mais mensagens para o console.

EDITAR:

Expandindo a ideia de Cide. Um criador de logs personalizado que você pode usar para ativar / desativar o logon do seu código.

No meu 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!');
    }
 );

Como usar o 'logger' acima? No seu evento pronto, chame logger.disableLogger para que as mensagens do console não sejam registradas. Adicione chamadas a logger.enableLogger e logger.disableLogger dentro do método para o qual você deseja registrar mensagens no console.

O seguinte é mais completo:

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

Isso zerará os métodos comuns no console, se houver, e eles podem ser chamados sem erros e praticamente sem sobrecarga de desempenho. No caso de um navegador como o IE6 sem console, os métodos fictícios serão criados para evitar erros. Obviamente, existem muitas outras funções no Firebug, como rastreamento, perfil, hora, etc. Elas podem ser adicionadas à lista se você as usar no seu código.

Você também pode verificar se o depurador tem esses métodos especiais ou não (ou seja, IE) e zerar os que não são compatíveis:

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

Até onde eu sei pela documentação , o Firebug não fornece nenhuma variável para alternar o estado de depuração. Em vez disso, envolva console.log () em um invólucro que o chama condicionalmente, ou seja:

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

Para não precisar alterar todas as chamadas existentes, você pode usar isso:

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

Você não deveria!

Não é uma boa prática substituir funções internas. Também não há garantia de que você suprimirá toda a saída; outras bibliotecas usadas podem reverter suas alterações e existem outras funções que podem ser gravadas no console; .dir(), .warning(), .error(), .debug(), .assert()Etc.

Como alguns sugeriram, você pode definir uma DEBUG_MODEvariável e registrar condicionalmente. Dependendo da complexidade e natureza do seu código, pode ser uma boa ideia escrever seu próprio objeto / função de logger que envolva o objeto do console e tenha esse recurso embutido. Esse seria o lugar certo para lidar com a instrumentação .

Dito isto, para fins de 'teste', você pode escrever testes em vez de imprimir no console. Se você não estiver fazendo nenhum teste, e essas console.log()linhas foram apenas uma ajuda para escrever seu código, basta excluí-las .

Sei que este é um post antigo, mas ainda aparece no topo dos resultados do Google, então aqui está uma solução não-jQuery mais elegante que funciona nos mais recentes Chrome, FF e IE.

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

Sei que você perguntou como desativar o console.log, mas pode ser isso que você realmente procura. Dessa forma, você não precisa habilitar ou desabilitar explicitamente o console. Ele simplesmente evita esses erros irritantes do console para pessoas que não o abrem ou instalam.

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 alterar o sinalizador DEBUGpara substituir a função console.log. Isso deve fazer o truque.

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

Estou surpreso que, de todas essas respostas, ninguém combina:

• Sem jquery
• Função anônima para não poluir o espaço para nome global
• Manipular caso em que window.console não definido
• Basta modificar a função .log do console

Eu iria para isso:

(function () {

    var debug = false

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

Depois que procurei esse problema e tentei dentro do meu aplicativo cordova, só quero avisar todos os desenvolvedores para que o windows phone não substitua

    console.log

porque o aplicativo falhará na inicialização.

Não irá falhar se você estiver desenvolvendo local, se tiver sorte, mas enviá-lo na loja resultará em falha no aplicativo.

Apenas substituir

    window.console.log 

se você precisar.

Isso funciona no meu aplicativo:

   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 você estiver usando o IE7, o console não será definido. Portanto, uma versão mais amigável do IE seria:

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

É um híbrido de respostas de SolutionYogi e Chris S. Ele mantém os números da linha console.log e o nome do arquivo. Exemplo 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 você usa o Grunt, pode adicionar uma tarefa para remover / comentar as instruções console.log. Portanto, o console.log não é mais chamado.

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

Eu tenho usado o seguinte para lidar com ele problema: -

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

Defina debug como 1 para habilitar a depuração. Em seguida, use a função de logger ao gerar texto de depuração. Também está configurado para aceitar dois parâmetros.

Então, ao invés de

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

usar

logger("my","log");

Eu usei o winston logger anteriormente.

Atualmente estou usando o código mais simples abaixo da experiência:

1. Defina a variável de ambiente de cmd / linha de comando (no Windows):

   cmd
   setx LOG_LEVEL info

Ou, você pode ter uma variável em seu código, se quiser, mas acima é melhor.

2. Reinicie o cmd / linha de comando ou IDE / editor como o Netbeans

3. Tenha abaixo como código:

   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. Agora use todo o console. * Como abaixo:

   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

Agora, com base nas configurações LOG_LEVEL feitas no ponto 1 (como setx LOG_LEVEL loge reiniciar a linha de comando), algumas das opções acima serão impressas, outras não.

Espero que tenha ajudado.

Atenção: Plug Shameless!

Você também pode usar algo como o meu objeto JsTrace para ter um rastreamento modular com o recurso de "comutação" no nível do módulo para ativar apenas o que você deseja ver no momento.

http://jstrace.codeplex.com

(Também possui um pacote NuGet, para quem se importa)

Todos os níveis são padronizados como "erro", mas você pode desativá-los. No entanto, não consigo pensar por que você NÃO gostaria de ver erros

Você pode alterá-los assim:

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

Para obter mais documentos, consulte a documentação

T

Encontrei um pedaço de código um pouco mais avançado neste URL Dica do JavaScript: Busque e desative o 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() {};
}

Desenvolvi uma biblioteca para este caso de uso: https://github.com/sunnykgupta/jsLogger

Recursos:

1. Ele substitui com segurança o console.log.
2. Tome cuidado se o console não estiver disponível (sim, você também deve levar isso em consideração).
3. Armazena todos os logs (mesmo que sejam suprimidos) para recuperação posterior.
4. Alças principais funções console como log, warn, error, info.

Está aberto a modificações e será atualizado sempre que novas sugestões surgirem.

Isso deve substituir todos os métodos do window.console. Você pode colocá-lo na parte superior da seção de scripts e, se estiver em uma estrutura PHP, poderá imprimir esse código apenas quando o ambiente do aplicativo estiver em produção ou se algum tipo de sinalizador de depuração estiver desativado. Então você teria todos os seus logs em seu código trabalhando em ambientes de desenvolvimento ou no modo de depuração.

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

Eu escrevi isto:

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

    }
}

Infelizmente, ele não funciona no modo estrito.

Então, usando console.fn.setEnabled = setEnablede, console.fn.setEnabled(false)em seguida, onde fnpoderia haver quase qualquer função do console. Para o seu caso seria:

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

Eu escrevi isso também:

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

então você só precisa colocar o FLAGSvalor padrão (antes de executar o código acima), like FLAGS.LOG = falsee a função de log seria desativada por padrão, e ainda assim você poderia habilitá-lo chamandoconsole.log.setEnabled(true)

Minha solução abrangente para desativar / substituir todas as console.*funções está aqui .

Obviamente, certifique-se de incluí-lo após verificar o contexto necessário. Por exemplo, incluindo apenas no lançamento da produção, não está bombardeando outros componentes cruciais etc.

Citando aqui:

"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 você estiver usando gulp, poderá usar este plugin:

Instale este plugin com o comando:

npm install gulp-remove-logging

Em seguida, adicione esta linha ao seu gulpfile:

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

Por fim, adicione as definições de configuração (veja abaixo) ao seu gulpfile.

Configuração da tarefa

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

Uma simplificação 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() {};
}

Você poderia usar o AOP javascript (por exemplo, jquery-aop ) para interceptar todas as chamadas para console.debug / log (around) e não prosseguir com a chamada real se alguma variável global estiver definida como false.

Você pode até fazer uma chamada ajax (de vez em quando) para poder alterar o comportamento ativado / desativado do log no servidor, o que pode ser muito interessante para habilitar a depuração ao enfrentar um problema em um ambiente intermediário ou semelhante.

Você pode usar o logeek , pois permite controlar a visibilidade das mensagens de log. Aqui está como você faz isso:

<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

Você também pode logeek.show('nothing')desativar totalmente todas as mensagens de log.

Depois de fazer alguma pesquisa e desenvolvimento para esse problema, me deparei com esta solução que oculta avisos / erros / logs de acordo com sua escolha.

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

Adicione esse código antes do plug-in JQuery (por exemplo, /../jquery.min.js), mesmo que este seja um código JavaScript que não exija JQuery. Porque alguns avisos estão no próprio JQuery.

Obrigado!!

Eu escrevi uma solução ES2015 (use apenas com o 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);
  }
}

Descrição:

1. Junto com logger.enable e logger.disable, você pode usar os métodos console. ['Log', 'warn', 'error'], bem como a classe logger.
2. O uso da classe logger para exibir, ativar ou desativar mensagens torna o código muito mais limpo e sustentável.
3. O código abaixo mostra como usar a classe logger:
   • logger.disable() - desativar todas as mensagens do console
   • logger.enable() - ativar todas as mensagens do console
   • logger.log('message1', 'message2') - funciona exatamente como console.log.
   • logger.warn('message1', 'message2') - funciona exatamente como console.warn.
   • logger.error('message1', 'message2')- funciona exatamente como console.error. Feliz codificação ..