如何快速方便地禁用代码中的所有console.log语句？

有什么方法可以关闭console.log我的JavaScript代码中的所有语句以进行测试？

在脚本中重新定义console.log函数。

console.log = function() {}

就是这样，没有更多消息要控制台。

编辑：

扩展Cide的想法。一个自定义记录器，可用于在代码中切换登录/注销。

在我的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!');
    }
 );

如何使用上述“记录器”？在您的就绪事件中，请调用logger.disableLogger，以便不会记录控制台消息。在要将消息记录到控制台的方法内，将调用添加到logger.enableLogger和logger.disableLogger。

以下内容更为详尽：

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

如果存在的话，这将使控制台中的常用方法归零，并且可以毫无错误地调用它们，并且几乎没有性能开销。对于没有控制台的IE6之类的浏览器，将创建虚拟方法以防止错误。当然，Firebug中还有更多功能，例如跟踪，配置文件，时间等。如果在代码中使用它们，则可以将它们添加到列表中。

您还可以检查调试器是否具有那些特殊方法（即IE），并将不支持的方法归零：

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

据我从文档中得知，Firebug不提供任何变量来切换调试状态。而是将console.log（）包装在有条件地调用它的包装器中，即：

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

不必更改所有现有呼叫，可以改用以下方法：

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

你不应该！

覆盖内置函数不是一个好习惯。也不能保证您将抑制所有输出，您使用的其他库可能会还原您的更改，并且其他功能可能会写入控制台。.dir()，.warning()，.error()，.debug()，.assert()等。

如一些建议，您可以定义一个DEBUG_MODE变量并有条件地记录日志。根据代码的复杂性和性质，最好编写自己的记录程序对象/函数，该对象环绕控制台对象并内置此功能。那将是处理仪器的正确地方。

就是说，出于“测试”的目的，您可以编写测试而不是打印到控制台。如果您不进行任何测试，而这些console.log()行仅是编写代码的辅助手段，只需删除它们即可。

我意识到这是一篇过时的文章，但仍然出现在Google搜索结果的顶部，因此这里有一个更优雅的非jQuery解决方案，可在最新的Chrome，FF和IE中使用。

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

我知道您问过如何禁用console.log，但这可能正是您真正想要的。这样，您不必显式启用或禁用控制台。它只是为那些没有打开或未安装控制台的人避免了那些讨厌的控制台错误。

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

只需更改该标志DEBUG即可覆盖console.log函数。这应该可以解决问题。

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

令我惊讶的是，在所有这些答案中，没有人将其结合在一起：

• 没有jQuery
• 匿名函数不污染全局名称空间
• 未定义window.console的情况
• 只需修改控制台的.log功能

我会为此：

(function () {

    var debug = false

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

在我也搜索了此问题并在我的cordova应用程序中尝试了此问题之后，我只想警告Windows Phone的每个开发人员不要覆盖

    console.log

因为该应用将在启动时崩溃。

如果您很幸运在本地开发的话，它不会崩溃，但是在商店中提交它将导致应用程序崩溃。

只是覆盖

    window.console.log 

如果你需要。

这适用于我的应用程序：

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

    }

如果您使用的是IE7，则不会定义控制台。因此，对IE更友好的版本是：

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

这是SolutionYogi和Chris S的答案的混合体。它维护console.log的行号和文件名。示例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');
});

如果您使用Grunt，则可以添加任务以删除/注释console.log语句。因此，不再调用console.log。

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

香港专业教育学院一直在使用以下方法来解决他的问题：

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

将debug设置为1以启用调试。然后在输出调试文本时使用记录器功能。它还设置为接受两个参数。

所以，代替

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

用

logger("my","log");

我以前使用过winston logger。

如今，我正在使用以下来自经验的简单代码：

1. 通过cmd /命令行设置环境变量（在Windows上）：

   cmd
   setx LOG_LEVEL info

或者，您可以根据需要在代码中包含一个变量，但是上面的方法更好。

2. 重新启动cmd /命令行，或者重新启动IDE /编辑器（如Netbeans）

3. 下面有类似的代码：

   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. 现在使用所有控制台。*，如下所示：

   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

现在，根据您在第1点所做的LOG_LEVEL设置（例如，setx LOG_LEVEL log并重新启动命令行），上面的某些内容将打印，其他内容将不会打印

希望能有所帮助。

警告：无耻的插头！

您还可以使用JsTrace对象之类的东西来进行模块化跟踪，并具有模块级别的“切换”功能，以仅打开您当时想要看到的内容。

http://jstrace.codeplex.com

（也有一个NuGet包，供那些关心的人使用）

所有级别默认为“错误”，尽管您可以将它们“关闭”。不过，我无法想到您为什么不想看到错误

您可以这样更改它们：

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

有关更多文档，请查看文档

Ť

我在该URL JavaScript技巧中找到了一些更高级的代码：胸围和禁用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() {};
}

我为此用例开发了一个库：https : //github.com/sunnykgupta/jsLogger

特征：

1. 它安全地覆盖console.log。
2. 注意控制台是否不可用（哦，是的，您也需要考虑这一点。）
3. 存储所有日志（即使已被抑制），以备以后检索。
4. 手柄主要控制台的功能，如log，warn，error，info。

开放供修改，只要有新建议就会更新。

这应该覆盖window.console的所有方法。您可以将其放在脚本部分的最顶部，如果您使用的是PHP框架，则只能在生产应用程序环境或禁用某种调试标志时打印此代码。这样，您就可以将所有日志记录在开发环境或调试模式下的代码中。

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

我这样写：

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

    }
}

不幸的是，它在严格模式下不起作用。

因此，使用console.fn.setEnabled = setEnabled，然后console.fn.setEnabled(false)在那里fn几乎可以是任何控制台功能。对于您的情况将是：

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

我也是这样写的：

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

因此，您只需要FLAGS输入默认值（在执行上面的代码之前），例如FLAGS.LOG = false，默认情况下将禁用log函数，并且仍然可以启用它调用console.log.setEnabled(true)

我在这里禁用/覆盖所有console.*功能的综合解决方案。

当然，请在检查必要的上下文后确保将其包括在内。例如，仅包括在生产版本中，它不会轰炸任何其他关键组件等。

在这里引用：

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

如果您正在使用gulp，则可以使用以下插件：

使用以下命令安装此插件：

npm install gulp-remove-logging

接下来，将此行添加到您的gulpfile中：

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

最后，将配置设置（请参见下文）添加到您的gulpfile中。

任务配置

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

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

您可以使用javascript AOP（例如jquery-aop）来拦截对console.debug / log（左右）的所有调用，并且如果某些全局变量设置为false，则不进行实际调用。

您甚至可以（不时地）进行ajax调用，以便可以更改服务器上启用/禁用日志的行为，这对于在暂存环境等中遇到问题时启用调试非常有意思。

您可以使用logeek，它可以控制日志消息的可见性。这是您的操作方式：

<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

您也logeek.show('nothing')可以完全禁用每条日志消息。

在对该问题进行了一些研究和开发之后，我遇到了该解决方案，该解决方案将根据您的选择隐藏警告/错误/日志。

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

将此代码添加到JQuery插件（例如/../jquery.min.js）之前，即使这是不需要JQuery的JavaScript代码。因为JQuery本身包含一些警告。

谢谢！！

我写了一个ES2015解决方案（仅与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);
  }
}

描述：

1. 除了logger.enable和logger.disable外，您还可以使用console。['log'，'warn'，'error']方法以及使用logger类。
2. 通过使用记录器类来显示，启用或禁用消息，可使代码更清晰和可维护。
3. 下面的代码向您展示如何使用logger类：
   • logger.disable() -禁用所有控制台消息
   • logger.enable() -启用所有控制台消息
   • logger.log('message1', 'message2') -完全类似于console.log。
   • logger.warn('message1', 'message2') -完全类似于console.warn。
   • logger.error('message1', 'message2')-就像console.error一样工作。快乐的编码