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

257

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

Zack Burt
fonte
11
usar um editor de texto que suporta "substituir todos" e substituir "console.log" com "//console.log"
helloandre
5
@helloandre - que fica um pouco cansativo mas se você usar o registro, informação, avisar de depuração e erro
UpTheCreek
Esperamos chegar a um ponto em que as implementações do navegador ignorem automaticamente as instruções do console, a menos que a ferramenta de depuração do navegador esteja ativada.
Faintsignal 5/11
2
As respostas abaixo são ótimas, mas você não precisa reinventar a roda nessa questão. Dê uma olhada no picolog . Ele possui uma API compatível com o console (do NodeJS), para que você possa usá-lo como um substituto. Ele suporta os níveis de log fora da caixa, funciona no navegador, no NodeJS e no Nashorn, pode ser facilmente configurado a partir da string de consulta (navegador) ou variável de ambiente PICOLOG_LEVEL(nó) e é super pequeno. Menos de 900 bytes compactados e compactados. Disclaimer: Eu sou o autor.
Stijn de Witt
Existe uma maneira simples de substituir todas as consolefunções. Basta olhar para stapp.space/disable-javascript-console-on-production
Piotr Stapp

Respostas:

427

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.

SolutionYogi
fonte
Forneça detalhes sobre o que não funciona? A linha acima gera um erro? Se sim, qual é a mensagem de erro?
SolutionYogi
1
Funciona para mim no IE8. ;-)
Eugene Lazutkin 01/08/09
O código substitui e restaura a função console.log. Se o IE7 suportar o método console.log, ele deverá funcionar.
SolutionYogi
3
console.log = function () {} parece não funcionar no Firefox. Você ainda recebe um erro 'o console não está definido'.
DA.
2
Que solução horrível. Modificando console.log... Por que não apenas ter uma função booleana e condicional para o log?
Dementic
76

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(){};
    }
}
mwilcox
fonte
Isso funcionou perfeitamente para mim, embora eu tenha ajustado um pouco, verifiquei o ambiente (só quero desativado na produção)
Muganwas
27

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);
    }
}
Cide
fonte
1
Obrigado, embora isso signifique que eu preciso reescrever todas as minhas instruções console.log como debug.log.
Zack Burt
Esta é a maneira certa de fazer isso - é claro, se você está começando do zero.
OpenSource
3
Também é a maneira correta de fazer isso se você tiver uma boa função de localização / substituição em seu editor.
BaroqueBobcat 01/08/09
2
Não há necessidade de escrever seu próprio invólucro, pelo menos se você estiver usando o jQuery. O jQuery Debugging Plugin funciona muito bem. Como um bônus, ele fornece a emulação de console.log em navegadores sem ele. trainofthoughts.org/blog/2007/03/16/jquery-plugin-debug
Nelson
O único problema [menor], é claro, é que você precisa instalar um plugin. :) É bom saber, porém - obrigado!
Cide
17

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 .

istepaniuk
fonte
7
"other libraries you use may revert your changes": se eu desativar console.logno início, eles não poderão reverter para a função antiga. Bem, eles podem reescrever o console.logcódigo fonte, mas por quê? "it may be a good idea to write your own logger object/function that wraps around the console object": Eu fiz isso no passado e é uma má ideia. O rastreio da saída do console refere-se ao wrapper e não à linha que o chama, dificultando a depuração.
Marco Sulla
3
O @LucasMalor "no início" implica que o código está acoplado a essa infraestrutura, limitando sua reutilização. É difícil generalizar; Um jogo, algumas animações DOM não são iguais à lógica de domínio dentro de um SPA complexo; as últimas não devem ter conhecimento do navegador, muito menos saber sobre algo chamado "console". Nesse caso, você deve ter uma estratégia de teste adequada em vez de invadir algumas console.log('Look ma, it reaches this point');no seu código, quando tudo mais falhar, você poderá realmente usar as debugger;instruções.
Istepaniuk
"the code is coupled to that infrastructure": o código provavelmente, mas o padrão não. Se você criar um modelo básico comum para suas páginas nas quais as funções de log estão desativadas, é uma lógica que você pode aplicar em qualquer lugar. "the later shouldn't be browser-aware": bem, então você não deve usar JS: P
Marco Sulla
3
@MarcoSulla Acho que ele está escrevendo códigos mais limpos. Dizer ".... você não deve usar JS" é um pouco pesado. Idealmente, como programador, não importa qual seja o seu ambiente, você deve modularizar o máximo possível; se ele não se importa com navegadores, você pode implantá-lo em mais lugares: essa é uma dependência a menos para se preocupar em quebrar suas coisas. Então, IMHO sim, ele está realmente certo. Lembre-se de que você começou dizendo "Se você criar um modelo básico comum ...", que por si só introduz uma dependência. Esse tipo de pensamento é o que complica o software. Alimento para o pensamento.
Dudewad 31/08/2015
1
O Adobe SiteCatalyics lança um monte de lixo no meu console e, em alguns casos, facilita a depuração. Assim sendo capaz de desativar temporariamente console.log quando eu executar uma chamada de terceiros seria muito útil para mim
spinn
16

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);
Joey Schooley
fonte
12

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() {};
}
Scott Greenfield
fonte
2
Para desabilitar o log específico do IE, consulte Chris S. answer.
GuruM
11

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() {}
}
Swanidhi
fonte
2
Eu daria um passo adiante e envolveria isso em uma função / classe de logger. Algo como isto:function myLog(msg) { if (debug) { console.log(msg); } }
sleblanc
Se estiver usando Angular, você poderá usá-lo como uma configuração global no arquivo application.js e como uma propriedade global para ativar / desativar os logs. Lembre-se, o console não será indefinido se a barra de ferramentas dos desenvolvedores estiver aberta no IE.
Swanidhi
10

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

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

    }
toranja
fonte
Obrigado pelo "aviso". No entanto, meu aplicativo baseado em cordova foi lançado na loja GooglePlay, testei-o com dispositivos telefônicos e tudo estava bem. Suponho que seu aviso foi limitado à loja de aplicativos "baseada em Windows"? ... NO ENTANTO, é bom aconselhar colocar as operações dentro do suporte try-catch para o caso de explodir. Daí o polegar para cima.
Panini Luncher 27/10/19
8

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() {} }; 
}
Chris S
fonte
5

É 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');
});
Justin
fonte
3

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");
Michae Pavlos Michael
fonte
3

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.

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

  2. 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;
    }
  3. 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.

Manohar Reddy Poreddy
fonte
2

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

Tom McKearney
fonte
2

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

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.

Sunny R Gupta
fonte
2

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);
agm-dev
fonte
1

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)

Gabriel De Oliveira Rohden
fonte
você acha que isso poderia ser usado para ativar o console.log no ambiente de produção em tempo real? como consola Chrome aberto, executar console.log.setEnabled(true)e começar a ver os logs
Rodrigo Assis
1
@RodrigoAssis sim, vai funcionar. Eu criei isso apenas para não perder a linha de chamada e ativar em qualquer lugar, mas essa não é a melhor maneira de fazer isso. A melhor maneira para logs é usar o caminho de curto-circuito como: var debug = false; debug && console.log(1/3)como você não precisa avaliar o conteúdo do log se não estiver ativado (nesse caso 1/3, não será avaliado), não perca a linha de chamada e pode ativar também é fácil (se não houver vars como consts).
Gabriel De Oliveira Rohden
1

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

kmonsoor
fonte
1

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/"
      )
    ); });
Andrew Nessin
fonte
1

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

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.

Stijn Geukens
fonte
Eu não implementei essa solução, não a vi. É teórico até agora.
Stijn Geukens
0

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.

Iman Mohamadi
fonte
0

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

Sunny_Sid
fonte
0

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 ..
Jaskaran Singh
fonte