Как быстро и удобно отключить все операторы console.log в моем коде?

Есть ли способ отключить все console.log заявления в моем коде JavaScript, для целей тестирования?

Источник

38 ответов

Решение

Переопределите функцию 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);
Источник

Просто поменяй флаг 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 () {};
    }
})()
Источник

Я знаю, что вы спрашивали, как отключить 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() {};
}
Источник

После того как я выполнил поиск этой проблемы, а также попробовал ее в своем приложении 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() {} }; 
}
Источник

Вот решение, над которым я только что работал, довольно исчерпывающее. Я рассмотрел все полностью поддерживаемые методы консоли из 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. Использование

Используется так же, как "console". но с "регистратором".

      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. Это мое обновленное решение:

      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. по-прежнему.

Источник

Это гибрид ответов 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');
});
Источник

Если вы используете Webpack, вы можете использовать плагин Terser, чтобы полностью исключить 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 чтобы исключить все консольные вызовы.

Источник

Отключить console.log Только:

      console.log = function() {};

Чтобы отключить все функции, которые пишут в консоль:

      for (let func in console) {
   console[func] = function() {};
}
Источник

Я использовал Winston Logger ранее.

В настоящее время я использую ниже простой код из опыта:

  1. Установите переменную среды (например, в Windows):

    setx LOG_LEVEL info

Конечно, это может быть переменная в вашем коде, если хотите.

  1. Перезапустите командную строку, или, IDE/ редактор, как Netbeans

  2. Иметь ниже, как код:

    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. Теперь используйте всю консоль.* Как показано ниже:

    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, некоторые из вышеперечисленных будут напечатаны, другие не будут напечатаны

Источник

Если вы используете Grunt, вы можете добавить задачу, чтобы удалить / прокомментировать операторы console.log. Поэтому console.log больше не вызывается.

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

Источник

Эй~ Давайте по-современному, как в 2022 году~

и представлены в ES6. Это инструменты, которые мы ищем, чтобы сделатьconsole.logбыть «отключенным» с условием.

Традиционным способом вам нужно создать еще одну функцию, подобную этой:

          let console_disabled = true;

    function console_log() {
      if (!console_disabled) {
        console.log.apply(console, arguments); //Dev Tools will mark the coding line here
      }
    }

Однако это создаст другую функцию, и вы не сможете зарегистрировать сообщение со строкой кода, показанной в Dev Tools.

Вот путь 2022 года.

Для получения подробной информации оProxyиReflect, посетите https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

Источник

был представлен в JS 2020. В браузерахglobalThisтакой же какwindow, на nodejs - то же, что иglobalи т. д. В любой среде он будет указывать непосредственно на глобальный объект, поэтому этот код будет работать в любой среде, поддерживающей JS2020. Подробнее: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis

В любом современном браузере и nodejs v12 или новее вы должны использовать это:

      globalThis.console.log = () => null;
globalThis.console.warn = () => null;
globalThis.console.info = () => null;
globalThis.console.error = () => null;
Источник

Я использовал следующее для решения этой проблемы:

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");
Источник

Мое комплексное решение, чтобы отключить / переопределить все 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");
})();

Источник

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

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

http://jstrace.codeplex.com/

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

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

Вы можете изменить их следующим образом:

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

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

T

Источник

Упрощение /questions/35488980/kak-byistro-i-udobno-otklyuchit-vse-operatoryi-consolelog-v-moem-kode/35489004#35489004

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() {};
}
Источник

Я нашел немного более продвинутый фрагмент кода в этом 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() {};
}
Источник

Это должно переопределить все методы 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);
Источник

Я разработал библиотеку для этого варианта использования: https://github.com/sunnykgupta/jsLogger

Особенности:

  1. Это безопасно переопределяет console.log.
  2. Заботится, если консоль недоступна (о, да, вам нужно учесть это тоже.)
  3. Сохраняет все журналы (даже если они подавлены) для последующего извлечения.
  4. Обрабатывает основные функции консоли, такие как log, warn, error, info,

Открыт для изменений и будет обновляться при появлении новых предложений.

Источник

Чтобы добавить немного к другим ответам, я лично хотел отключить только определенные части моего кода (модули 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 вместо обработчика строк и переключить режим отладки в файле, с которым вы сейчас работаете.

Источник

Если вы используете 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/"
      )
    ); });
Источник 
      console.log('pre');
/* pre content */ 
// define a new console
let preconsole = Object.assign({}, window.console);
let aftconsole = Object.assign({}, window.console, {
    log: function(text){
        preconsole.log(text);
        preconsole.log('log');
    }
});
console = aftconsole;
/* content */

console.log('content');

/* end of content */
console = preconsole;
console.log('aft');
Источник

Один лайнер просто установил devMode true/false;

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

Источник

Я написал это:

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

Источник
Другие вопросы по тегам