Question

为了测试目的，有没有办法关闭我的JavaScript代码中的所有console.log语句？

Answer 1

在脚本中重新定义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!'); } );

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

Answer 2

以下是更彻底的：

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

Answer 3

据documentation我所知，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);
    }
}

Answer 4

你不应该！

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

正如一些人所建议的，你可以定义一个DEBUG_MODE变量并有条件地记录。根据代码的复杂性和性质，编写自己的记录器对象/函数可能是一个好主意，该对象/函数包含控制台对象并具有内置的此功能。这将是处理仪器的正确场所。

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

Answer 5

我知道你问过如何禁用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() {};
}

Answer 6

我意识到这是一个老帖子，但它仍然会出现在谷歌搜索结果的顶部，所以这里有一个更优雅的非jQuery解决方案，适用于最新的Chrome，FF和IE。

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

Answer 7

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

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

Answer 8

I am surprised that of all those answers no one combines:

No jquery
Anonymous function to not pollute global namespace
Handle case where window.console not defined
Just modify the .log function of the console

I'd go for this:

let spelplan = [{defaultSquare with pos = {x=1; y=1}} .. {defaultSquare with pos = {x=1; y=1}} .. {defaultSquare with pos = {x=9; y=9}}]

Answer 9

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

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

Answer 10

在我搜索了这个问题以及在我的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) {

    }

Answer 11

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

Answer 12

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

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

Answer 13

我在此网址JavaScript Tip: 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() {};
}

Answer 14

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

功能

它安全地覆盖了console.log。

如果控制台不可用，请注意（哦，是的，你也需要考虑因素。）

存储所有日志（即使它们被禁止）以供日后检索。

处理主要的控制台功能，例如log，warn，error，info。

可以修改，并会在出现新建议时更新。

Answer 15

警告：无耻插头！

您还可以使用类似我的JsTrace对象的模块化跟踪，并使用模块级“切换”功能，只打开您当时想要查看的内容。

http://jstrace.codeplex.com

（对于那些关心的人，还有一个NuGet包）

所有级别都默认为“错误”，但您可以将其关闭“关闭”。虽然，我想不出你为什么不想看到错误

您可以像这样更改它们：

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

更多文档，请查看the Documentation

Ť

Answer 16

我之前使用过winston记录器。

现在我正在使用以下更简单的经验代码：

从cmd /命令行设置环境变量（在Windows上）：
```
cmd
setx LOG_LEVEL info
```

或者，如果您愿意，可以在代码中添加变量，但上面的内容更好。

重启cmd /命令行，或IDE /编辑器，如Netbeans

以下代码：

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

现在使用所有控制台。*如下：

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和重启命令行），上面会打印一些，其他人不会打印

希望有所帮助。

Answer 17

如果您使用的是gulp，则可以使用this插件：

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

npm install gulp-remove-logging

下一步，将此行添加到您的gulpfile中：

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

最后，将配置设置（见下文）添加到您的gulp文件中。

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

Answer 18

如果使用Webpack，则可以使用Terser plugin来完全排除console.log函数调用。

这样，您可以拥有一个干净的生产应用程序包，该程序包不会公开不必要的信息，但在调试版本中仍具有所有这些信息。

https://github.com/terser/terser#compress-options

drop_console（默认值：false）-传递true以放弃对console。*函数的调用。如果希望删除特定的函数调用（例如console.info）和/或在删除函数调用后保留函数参数的副作用，请改用pure_funcs。

minimizer: [
    new TerserPlugin({
        terserOptions: {
            compress: {
                pure_funcs: [ 'console.log' ]
            }
        }
    }),
]

或者，您可以使用drop_console: true排除所有控制台调用。

Answer 19

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

Answer 20

我的全面解决方案是禁用/覆盖所有console.*功能here。

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

在此引用它：

＆＃13;

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

＆＃13;

Answer 21

这应该覆盖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);

Answer 22

我写了这个：

//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，默认情况下会禁用日志功能，你仍然可以启用它致电console.log.setEnabled(true)

Answer 23

您可以使用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')完全禁用每条日志消息。

Answer 24

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

    (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本身包含一些警告。

谢谢！

Answer 25

我写了一个 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);
  }
}

说明：

除了logger.enable和logger.disable外，您还可以使用console。['log'，'warn'，'error']方法以及使用logger类。
通过使用logger类显示，启用或禁用消息，可以使代码更清晰，更可维护。
以下代码向您展示了如何使用logger类：
- logger.disable()-禁用所有控制台消息
- logger.enable()-启用所有控制台消息
- logger.log('message1', 'message2')-类似于console.log。
- logger.warn('message1', 'message2')-类似于console.warn。
- logger.error('message1', 'message2')-类似于console.error。祝您编程愉快。

Answer 26

我认为2020年最简单，最容易理解的方法就是创建像log()这样的全局函数，您可以选择以下方法之一：

const debugging = true;

function log(toLog) {
  if (debugging) {
    console.log(toLog);
  }
}

function log(toLog) {
  if (true) { // You could manually change it (Annoying, though)
    console.log(toLog);
  }
}

您可以说这些功能的缺点是：

您仍在运行时调用函数
您必须记住在第二个选项中更改debugging变量或if语句
您需要确保已在所有其他文件之前加载该功能

我对这些陈述的反驳是，这是不会完全删除console或console.log函数的唯一方法，我认为这是不好的编程方法，因为其他正在网站上工作的开发人员必须意识到您无知地删除了它们。另外，您无法在JavaScript中编辑JavaScript源代码，因此，如果您真的想删除某些代码中的所有代码，则可以使用一个缩小器，该缩小器会缩小代码并删除所有console.log。现在，选择权是您的，您将做什么？

Answer 27

您可以使用javascript AOP（例如jquery-aop）来拦截对console.debug / log（around）的所有调用，如果某个全局变量设置为false，则不会继续执行实际调用。

您甚至可以进行ajax调用（现在和之后），这样您就可以更改服务器上的日志启用/禁用行为，这对于在临时环境中遇到问题时启用调试非常有趣。

Answer 28

一个内衬仅将devMode设置为true / false;

console.log = devMode ? console.log : () => { };

Answer 29

仅禁用console.log：

console.log = function() {};

要禁用所有写入控制台的功能，

for (let func in console) {
   console[func] = function() {};
}

Answer 30

这是我刚刚研究的一个相当详尽的解决方案。我介绍了 https://developer.mozilla.org/en-US/docs/Web/API/console

中所有完全支持的控制台方法

1.创建js文件“logger.js”并在其中放入以下代码

logger = {
    assert: function() {
        if(logger.active && logger.doAssert) {
            console.assert.apply(null,arguments);
        }
    },
    clear: function() {
        if(logger.active && logger.doClear) {
            console.clear();
        }
    },
    count: function() {
        if(logger.active && logger.doCount) {
            console.count.apply(null,arguments);
        }
    },
    countReset: function() {
        if(logger.active && logger.doCountReset) {
            console.countReset.apply(null,arguments);
        }
    },
    debug: function() {
        if(logger.active && logger.doDebug) {
            console.debug.apply(null,arguments);
        }
    },
    dir: function() {
        if(logger.active && logger.doDir) {
            console.dir.apply(null,arguments);
        }
    },
    dirxml: function() {
        if(logger.active && logger.doDirxml) {
            console.dirxml.apply(null,arguments);
        }
    },
    error: function() {
        if(logger.active && logger.doError) {
            console.error.apply(null,arguments);
        }
    },
    group: function() {
        if(logger.active && logger.doGroup) {
            console.group.apply(null,arguments);
        }
    },
    groupCollapsed: function() {
        if(logger.active && logger.doGroup) {
            console.groupCollapsed.apply(null,arguments);
        }
    },
    groupEnd: function() {
        if(logger.active && logger.doGroup) {
            console.groupEnd.apply(null,arguments);
        }
    },
    info: function() {
        if(logger.active && logger.doInfo) {
            console.info.apply(null,arguments);
        }
    },
    log: function() {
        if(logger.active && logger.doLog) {
            console.log.apply(null,arguments);
        }
    },
    table: function() {
        if(logger.active && logger.doTable) {
            console.table.apply(null,arguments);
        }
    },
    time: function() {
        if(logger.active && logger.doTime) {
            console.time.apply(null,arguments);
        }
    },
    timeEnd: function() {
        if(logger.active && logger.doTime) {
            console.timeEnd.apply(null,arguments);
        }
    },
    timeLog: function() {
        if(logger.active && logger.doTime) {
            console.timeLog.apply(null,arguments);
        }
    },
    trace: function() {
        if(logger.active && logger.doTrace) {
            console.trace.apply(null,arguments);
        }
    },
    warn: function() {
        if(logger.active && logger.doWarn) {
            console.warn.apply(null,arguments);
        }
    },
    active: true,
    doAssert: true,
    doClear: true,
    doCount: true,
    doCountReset: true,
    doDebug: true,
    doDir: true,
    doDirxml: true,
    doError: true,
    doGroup: true,
    doInfo: true,
    doLog: true,
    doTable: true,
    doTime: true,
    doTrace: true,
    doWarn: true
};

2.在所有页面中包含日志的所有脚本之前包含

3.替换所有“控制台”。与“记录器”。在您的脚本中

4.用法

就像“控制台”一样使用。但带有“记录器”。

logger.clear();
logger.log("abc");

最后禁用部分或全部日志

//disable/enable all logs
logger.active = false; //disable
logger.active = true; //enable

//disable some logs
logger.doLog = false; //disable
logger.doInfo = false; //disable

logger.doLog = true; //enable
logger.doInfo = true; //enable

logger.doClear; //log clearing code will no longer clear the console.

编辑

在我最近的项目中使用我的解决方案一段时间后，我意识到很难记住我应该使用 logger. 而不是 console.。所以出于这个原因，我决定覆盖 console。这是我更新的解决方案：

const consoleSubstitute = console;
console = {
    assert: function() {
        if(console.active && console.doAssert) {
            consoleSubstitute.assert.apply(null,arguments);
        }
    },
    clear: function() {
        if(console.active && console.doClear) {
            consoleSubstitute.clear();
        }
    },
    count: function() {
        if(console.active && console.doCount) {
            consoleSubstitute.count.apply(null,arguments);
        }
    },
    countReset: function() {
        if(console.active && console.doCountReset) {
            consoleSubstitute.countReset.apply(null,arguments);
        }
    },
    debug: function() {
        if(console.active && console.doDebug) {
            consoleSubstitute.debug.apply(null,arguments);
        }
    },
    dir: function() {
        if(console.active && console.doDir) {
            consoleSubstitute.dir.apply(null,arguments);
        }
    },
    dirxml: function() {
        if(console.active && console.doDirxml) {
            consoleSubstitute.dirxml.apply(null,arguments);
        }
    },
    error: function() {
        if(console.active && console.doError) {
            consoleSubstitute.error.apply(null,arguments);
        }
    },
    group: function() {
        if(console.active && console.doGroup) {
            consoleSubstitute.group.apply(null,arguments);
        }
    },
    groupCollapsed: function() {
        if(console.active && console.doGroup) {
            consoleSubstitute.groupCollapsed.apply(null,arguments);
        }
    },
    groupEnd: function() {
        if(console.active && console.doGroup) {
            consoleSubstitute.groupEnd.apply(null,arguments);
        }
    },
    info: function() {
        if(console.active && console.doInfo) {
            consoleSubstitute.info.apply(null,arguments);
        }
    },
    log: function() {
        if(console.active && console.doLog) {
            if(console.doLogTrace) {
                console.groupCollapsed(arguments);
                consoleSubstitute.trace.apply(null,arguments);
                console.groupEnd();
            } else {
                consoleSubstitute.log.apply(null,arguments);
            }
        }
    },
    table: function() {
        if(console.active && console.doTable) {
            consoleSubstitute.table.apply(null,arguments);
        }
    },
    time: function() {
        if(console.active && console.doTime) {
            consoleSubstitute.time.apply(null,arguments);
        }
    },
    timeEnd: function() {
        if(console.active && console.doTime) {
            consoleSubstitute.timeEnd.apply(null,arguments);
        }
    },
    timeLog: function() {
        if(console.active && console.doTime) {
            consoleSubstitute.timeLog.apply(null,arguments);
        }
    },
    trace: function() {
        if(console.active && console.doTrace) {
            consoleSubstitute.trace.apply(null,arguments);
        }
    },
    warn: function() {
        if(console.active && console.doWarn) {
            consoleSubstitute.warn.apply(null,arguments);
        }
    },
    active: true,
    doAssert: true,
    doClear: true,
    doCount: true,
    doCountReset: true,
    doDebug: true,
    doDir: true,
    doDirxml: true,
    doError: true,
    doGroup: true,
    doInfo: true,
    doLog: true,
    doLogTrace: false,
    doTable: true,
    doTime: true,
    doTrace: true,
    doWarn: true
};

现在您可以照常使用 console.。

Answer 31

为了在其他答案之上添加一点，我个人只想关闭我的代码的特定部分（ES6 模块，但简单的单独脚本也应该可以工作）。


// old console to restore functionality
const consoleHolder = window.console;

// arbitrary strings, for which the console stays on (files which you aim to debug)
const debuggedHandlers = ["someScript", "anotherScript"];

// get console methods and create a dummy with all of them empty
const consoleMethodKeys = Object.getOwnPropertyNames(window.console).filter(item => typeof window.console[item] === 'function');
const consoleDummy = {};
consoleMethodKeys.forEach(method => consoleDummy[method] = () => {});

export function enableConsoleRedirect(handler) {
  if (!debuggedHandlers.includes(handler)) {
    window.console = consoleDummy;
  }
}

export function disableConsoleRedirect() {
  window.console = consoleHolder;
}

然后，只需将此模块导入到您希望能够切换调试模式的任何文件中，调用文件顶部的启用函数和底部的禁用函数。

如果您想在简单的脚本中使用它，您可能需要将顶部包装在匿名函数中和/或稍微重新组织一下以最大程度地减少命名空间污染。

此外，您可能只想使用 true/false 而不是字符串处理程序，并在您当前使用的文件中切换调试模式。

Answer 32

我在自己弄清楚之后找到了这个线程。这是我的解决方案：

const testArray = {
  a: 1,
  b: 2
};
const verbose = true; //change this to false to turn off all comments
const consoleLog = (...message) => {
  return verbose ? console.log(...message) : null;
};

console.log("from console.log", testArray);
consoleLog("from consoleLog", testArray);
// use consoleLog() for the comments you want to be able to toggle.

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

32 个答案:

你不应该！