Jak szybko i wygodnie wyłączyć wszystkie instrukcje console.log w moim kodzie?

Czy jest jakiś sposób na wyłączenie wszystkich console.loginstrukcji w moim kodzie JavaScript do celów testowych?

Ponownie zdefiniuj funkcję console.log w skrypcie.

console.log = function() {}

To wszystko, nie ma już komunikatów do konsoli.

EDYTOWAĆ:

Rozwijanie pomysłu Cide'a. Niestandardowy program rejestrujący, za pomocą którego można włączać / wyłączać logowanie z kodu.

Z mojej konsoli 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!');
    }
 );

Jak korzystać z powyższego „loggera”? W gotowym zdarzeniu wywołaj logger.disableLogger, aby komunikaty konsoli nie były rejestrowane. Dodaj wywołania do logger.enableLogger i logger.disableLogger w ramach metody, dla której chcesz rejestrować wiadomości w konsoli.

Następujące informacje są dokładniejsze:

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

Spowoduje to wyzerowanie typowych metod w konsoli, jeśli taka istnieje, i można je wywoływać bez błędów i praktycznie bez narzutu wydajności. W przypadku przeglądarki takiej jak IE6 bez konsoli zostaną utworzone fałszywe metody, aby zapobiec błędom. Oczywiście w Firebug jest wiele innych funkcji, takich jak śledzenie, profil, czas itp. Można je dodać do listy, jeśli użyjesz ich w kodzie.

Możesz również sprawdzić, czy debugger ma te specjalne metody, czy nie (tj. IE) i wyzerować te, których nie obsługuje:

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

O ile mogę stwierdzić z dokumentacji , Firebug nie dostarcza żadnej zmiennej do przełączania stanu debugowania. Zamiast tego zawiń console.log () w opakowaniu, które warunkowo to wywołuje, tj .:

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

Aby nie musieć zmieniać wszystkich istniejących połączeń, możesz użyć tego:

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

Nie powinieneś!

Zastępowanie wbudowanych funkcji nie jest dobrą praktyką. Nie ma również gwarancji, że usuniesz wszystkie dane wyjściowe, inne używane biblioteki mogą cofnąć zmiany i istnieją inne funkcje, które mogą zapisywać na konsoli; .dir(), .warning(), .error(), .debug(), .assert()Itd.

Jak niektórzy sugerują, możesz zdefiniować DEBUG_MODEzmienną i logować się warunkowo. W zależności od złożoności i charakteru kodu dobrym pomysłem może być napisanie własnego obiektu / funkcji rejestratora, który otacza obiekt konsoli i ma tę wbudowaną funkcję. To byłoby właściwe miejsce do radzenia sobie z oprzyrządowaniem .

To powiedziawszy, do celów „testowania” możesz pisać testy zamiast drukować na konsoli. Jeśli nie przeprowadzasz żadnych testów, a te console.log()wiersze były tylko pomocą do napisania kodu, po prostu je usuń .

Zdaję sobie sprawę, że jest to stary post, ale wciąż pojawia się na szczycie wyników Google, więc oto bardziej eleganckie rozwiązanie inne niż jQuery, które działa w najnowszych przeglądarkach Chrome, FF i IE.

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

Wiem, że zapytałeś, jak wyłączyć console.log, ale to może być to, czego naprawdę szukasz. W ten sposób nie musisz jawnie włączać ani wyłączać konsoli. To po prostu zapobiega tym nieznośnym błędom konsoli dla osób, które nie mają go otwartego lub zainstalowanego.

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

Wystarczy zmienić flagę, DEBUGaby zastąpić funkcję console.log. To powinno załatwić sprawę.

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

Dziwi mnie, że z tych wszystkich odpowiedzi nikt nie łączy:

• Bez jquery
• Anonimowa funkcja nie zanieczyszczająca globalnej przestrzeni nazw
• Uchwyć skrzynkę, w której nie zdefiniowano okna. Konsola
• Wystarczy zmodyfikować funkcję .log konsoli

Wybrałbym to:

(function () {

    var debug = false

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

Po tym, jak szukałem tego problemu i wypróbowałem go w mojej aplikacji Cordova, chcę tylko ostrzec każdego programistę, aby Windows Phone nie nadpisał

    console.log

ponieważ aplikacja ulega awarii podczas uruchamiania.

Nie zawiesza się, jeśli rozwijasz się lokalnie, jeśli masz szczęście, ale przesłanie go do sklepu spowoduje awarię aplikacji.

Po prostu nadpisz

    window.console.log 

Jeśli potrzebujesz.

Działa to w mojej aplikacji:

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

    }

Jeśli używasz IE7, konsola nie zostanie zdefiniowana. Bardziej przyjazna dla IE wersja to:

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

To hybryda odpowiedzi od SolutionYogi i Chrisa S. Utrzymuje numery linii i nazwa pliku console.log. Przykład 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');
});

Jeśli używasz Grunta, możesz dodać zadanie w celu usunięcia / skomentowania instrukcji console.log. Dlatego plik console.log nie jest już wywoływany.

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

Użyłem następujących, aby poradzić sobie z problemem: -

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

Ustaw debugowanie na 1, aby włączyć debugowanie. Następnie użyj funkcji rejestratora podczas wysyłania tekstu debugowania. Jest również skonfigurowany do akceptowania dwóch parametrów.

Więc zamiast

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

posługiwać się

logger("my","log");

Użyłem wcześniej rejestratora Winston .

Obecnie używam poniżej prostszego kodu z doświadczenia:

1. Ustaw zmienną środowiskową z wiersza poleceń cmd / (w systemie Windows):

   cmd
   setx LOG_LEVEL info

Lub możesz mieć zmienną w swoim kodzie, jeśli chcesz, ale powyżej jest lepiej.

2. Uruchom ponownie polecenie cmd / wiersz poleceń lub edytor IDE /, taki jak Netbeans

3. Posiadaj poniższy kod:

   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. Teraz użyj całej konsoli. * Jak poniżej:

   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

Teraz, w oparciu o ustawienia LOG_LEVEL wprowadzone w punkcie 1 (jak setx LOG_LEVEL logi zrestartuj wiersz poleceń), niektóre z powyższych wydrukują, inne nie wydrukują

Mam nadzieję, że to pomogło.

Ostrzeżenie: bezwstydna wtyczka!

Możesz także użyć czegoś takiego jak mój obiekt JsTrace, aby mieć modułowe śledzenie z funkcją „przełączania” na poziomie modułu, aby włączyć tylko to, co chcesz w danym momencie zobaczyć.

http://jstrace.codeplex.com

(Ma również pakiet NuGet dla tych, którym zależy)

Wszystkie poziomy domyślnie mają wartość „błąd”, ale można je wyłączyć. Chociaż nie mogę wymyślić, dlaczego NIE chcesz widzieć błędów

Możesz je zmienić w następujący sposób:

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

Aby uzyskać więcej dokumentów, sprawdź dokumentację

T.

W tym adresie URL znalazłem trochę bardziej zaawansowany fragment kodu Wskazówka: 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() {};
}

Opracowałem bibliotekę dla tego przypadku użycia: https://github.com/sunnykgupta/jsLogger

Cechy:

1. Bezpiecznie zastępuje plik console.log.
2. Dba o to, czy konsola nie jest dostępna (o tak, też trzeba to uwzględnić).
3. Przechowuje wszystkie dzienniki (nawet jeśli są pomijane) do późniejszego pobrania.
4. Uchwyty główne funkcje konsoli podoba log, warn, error, info.

Jest otwarty na modyfikacje i będzie aktualizowany za każdym razem, gdy pojawią się nowe sugestie.

Powinno to zastąpić wszystkie metody window.console. Możesz umieścić go na samej górze sekcji skryptów, a jeśli korzystasz z frameworka PHP, możesz wydrukować ten kod tylko wtedy, gdy środowisko aplikacji jest produkcyjne lub jeśli jakiś rodzaj flagi debugowania jest wyłączony. Wtedy wszystkie logi w kodzie będą działać w środowiskach programistycznych lub w trybie debugowania.

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

Ja to napisałem:

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

    }
}

Niestety nie działa w trybie ścisłym.

Więc używając, console.fn.setEnabled = setEnableda następnie console.fn.setEnabled(false)gdzie fnmoże być prawie każda funkcja konsoli. W twoim przypadku byłoby:

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

Też napisałem:

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

więc po prostu musisz wprowadzić FLAGSwartość domyślną (przed wykonaniem powyższego kodu), na przykład FLAGS.LOG = falsefunkcja dziennika byłaby domyślnie wyłączona, a mimo to można ją było włączyćconsole.log.setEnabled(true)

Moje kompleksowe rozwiązanie do wyłączania / zastępowania wszystkich console.*funkcji jest tutaj .

Oczywiście upewnij się, że dołączasz to po sprawdzeniu niezbędnego kontekstu. Na przykład, tylko w wersji produkcyjnej, nie bombarduje żadnych innych kluczowych komponentów itp.

Cytując to tutaj:

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

Jeśli używasz gulp, możesz użyć tej wtyczki:

Zainstaluj tę wtyczkę za pomocą polecenia:

npm install gulp-remove-logging

Następnie dodaj tę linię do swojego pliku gulp:

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

Na koniec dodaj ustawienia konfiguracji (patrz poniżej) do swojego pliku gulp.

Konfiguracja zadania

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

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

Możesz użyć javascript AOP (np. Jquery-aop ), aby przechwycić wszystkie wywołania konsoli console.debug / log (około) i nie kontynuować faktycznego wywołania, jeśli jakaś zmienna globalna ma wartość false.

Możesz nawet wykonać wywołanie ajax (od czasu do czasu), aby zmienić zachowanie włączania / wyłączania dziennika na serwerze, co może być bardzo interesujące, aby umożliwić debugowanie w obliczu problemu w środowisku pomostowym lub podobnym.

Możesz użyć logeek , pozwala kontrolować widoczność wiadomości w dzienniku. Oto jak to zrobić:

<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

Możesz także logeek.show('nothing')całkowicie wyłączyć każdy komunikat dziennika.

Po przeprowadzeniu badań i rozwoju tego problemu, natknąłem się na to rozwiązanie, które ukryje ostrzeżenia / błędy / logi zgodnie z twoim wyborem.

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

Dodaj ten kod przed wtyczką JQuery (np. /../Jquery.min.js), nawet jeśli jest to kod JavaScript, który nie wymaga JQuery. Ponieważ niektóre ostrzeżenia znajdują się w samym JQuery.

Dzięki!!

Napisałem rozwiązanie ES2015 (używaj tylko z pakietem 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);
  }
}

Opis:

1. Wraz z logger.enable i logger.disable możesz korzystać z metod konsoli. [„Log”, „warn”, „error”] również za pomocą klasy logger.
2. Dzięki użyciu klasy logger do wyświetlania, włączania lub wyłączania komunikatów kod jest znacznie bardziej przejrzysty i łatwy w utrzymaniu.
3. Poniższy kod pokazuje, jak korzystać z klasy logger:
   • logger.disable() - wyłącz wszystkie komunikaty konsoli
   • logger.enable() - włącz wszystkie komunikaty konsoli
   • logger.log('message1', 'message2') - działa dokładnie tak jak console.log.
   • logger.warn('message1', 'message2') - działa dokładnie tak samo jak console.warn.
   • logger.error('message1', 'message2')- działa dokładnie tak jak console.error. Szczęśliwego kodowania ..