Как быстро и удобно отключить все операторы 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);
    }
}

Я понимаю, что это старый пост, но он по-прежнему всплывает в верхней части результатов Google, поэтому вот более элегантное решение, не относящееся к jQuery, которое работает в последних версиях Chrome, FF и IE.

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

Ты не должен!

Не рекомендуется перезаписывать встроенные функции. Также нет гарантии, что вы подавите все выходные данные, другие библиотеки, которые вы используете, могут отменить ваши изменения, и есть другие функции, которые могут записывать в консоль; .dir(), .warning(), .error(), .debug(),.assert() И т.д.

Как некоторые предположили, вы можете определить DEBUG_MODEпеременную и войти условно. В зависимости от сложности и характера вашего кода, может быть хорошей идеей написать свой собственный объект / функцию регистратора, который оборачивается вокруг объекта консоли и имеет встроенную возможность. Это было бы правильное место, чтобы иметь дело с приборами .

Тем не менее, для целей «тестирования» вы можете писать тесты вместо печати на консоль. Если вы не проводите никакого тестирования, и эти 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, чтобы включить отладку. Затем используйте функцию logger при выводе текста отладки. Он также настроен на прием двух параметров.

Итак, вместо

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

использование

logger("my","log");

Я использовал Уинстон 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

Теперь, основываясь на ваших настройках LOG_LEVEL, сделанных в точке 1 (например, setx LOG_LEVEL log и перезапустите командную строку), некоторые из перечисленных выше будут напечатаны, другие не будут напечатаны

Надеюсь, что это помогло.

Предупреждение: бесстыдная вилка!

Вы также можете использовать что-то вроде моего объекта JsTrace, чтобы иметь модульную трассировку с возможностью «переключения» на уровне модуля, чтобы включать только то, что вы хотите видеть в данный момент.

http://jstrace.codeplex.com

(Также есть пакет NuGet, для тех, кто заботится)

Все уровни по умолчанию «ошибка», хотя вы можете отключить их. Хотя я не могу понять, почему вы НЕ хотели бы видеть ошибки

Вы можете изменить их так:

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

Для получения дополнительной документации ознакомьтесь с документацией

T

В этом URL-адресе 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() {};
}

Я разработал библиотеку для этого варианта использования: 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 и функция журнала будет отключена по умолчанию, и все же вы можете включить его, вызывая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), даже если это код JavaScript, который не требует JQuery. Потому что некоторые предупреждения есть в самом 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. Использование класса logger для отображения, включения или выключения сообщений делает код намного чище и удобнее в обслуживании.
3. Код ниже показывает, как использовать класс логгера:
   • logger.disable() - отключить все консольные сообщения
   • logger.enable() - включить все сообщения консоли
   • logger.log('message1', 'message2') - работает так же, как console.log.
   • logger.warn('message1', 'message2') - работает так же, как console.warn.
   • logger.error('message1', 'message2')- работает так же, как console.error. Удачного кодирования ..