Jak szybko i wygodnie wyłączyć wszystkie konsole.rejestruj wypowiedzi w moim kodzie?

Poniżej jest bardziej szczegółowy:

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 zerowanie popularnych metod w konsoli, jeśli one istnieją, i mogą być wywoływane bez błędu i praktycznie bez obciążenia wydajności. W przypadku przeglądarki takiej jak IE6 bez konsoli, zostaną utworzone metody atrapy, aby zapobiec błędom. Oczywiście w Firebug jest o wiele więcej funkcji, takich jak trace, profile, time itp. Mogą zostać dodane do listy, jeśli użyjesz ich w swoim kodzie.

Możesz również sprawdzić, czy debugger ma te specjalne metody lub nie (ie, IE) i zerować 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(){};
    }
}

Z tego co wiem z dokumentacji , Firebug nie dostarcza żadnej zmiennej do przełączania stanu debugowania. Zamiast tego owiń konsolę.log() w pakiecie, który wywołuje go warunkowo, np.:

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 zamiast:

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

Wiem, że pytałeś jak wyłączyć konsolę.log, ale to może być to, czego naprawdę szukasz. W ten sposób nie musisz jawnie włączać ani wyłączać konsoli. 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() {};
}

Zdaję sobie sprawę, że to stary post, ale nadal wyskakuje na górze wyników Google, więc tutaj jest bardziej eleganckie rozwiązanie non-jQuery, które działa w najnowszych Chrome, FF i IE.

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

Nie powinieneś!

Nadpisywanie wbudowanych funkcji nie jest dobrą praktyką. Nie ma również gwarancji, że wyłączysz wszystkie dane wyjściowe, inne biblioteki, których używasz, mogą przywrócić zmiany i istnieją inne funkcje, które mogą zapisywać na konsoli; .dir(), .warning(), .error(), .debug(), .assert() itd.

Jak niektórzy sugerowali, można definiować zmienną DEBUG_MODE i logować warunkowo. W zależności od złożoności i charakteru kodu, dobrym pomysłem może być napisanie własnego loggera obiekt / funkcja, która otacza obiekt konsoli i ma wbudowaną tę funkcję. To byłoby właściwe miejsce do czynienia z oprzyrządowanie .

To powiedziawszy, w celach' testowych ' możesz pisać testy zamiast drukować na konsoli. Jeśli nie robisz żadnych testów, a te console.log() wiersze były tylko Pomocą do napisania kodu, po prostu je usuń .

Wystarczy zmienić flagę DEBUG, aby nadpisać konsolę.funkcja log. To powinno załatwić sprawę.

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

Jeśli używasz IE7, konsola nie zostanie zdefiniowana. Więc bardziej przyjazną dla IE wersją byłoby:

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

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

• No jquery
• Funkcja anonimowa nie zanieczyszczająca globalnej przestrzeni nazw
• Uchwyt case where window.console not defined
• po prostu zmodyfikuj .funkcja logowania konsoli

Poszedłbym na to:

(function () {

    var debug = false

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

Po Szukałem tego problemu jak również i próbował go w mojej aplikacji cordova, po prostu chcę ostrzec każdego dewelopera Dla Windows phone, aby nie nadpisać

    console.log

Ponieważ aplikacja zawiesi się przy starcie.

Nie zawiesi się, jeśli tworzysz lokalne, jeśli masz szczęście, ale złożenie w sklepie spowoduje awarię aplikacji.

Just overwrite

    window.console.log 

To działa 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) {

    }

To hybryda odpowiedzi z Rozwiązania i Chrisa S. utrzymuje konsolę.Zaloguj numery linii i nazwę pliku. 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 Grunt możesz dodać zadanie w celu usunięcia / skomentowania konsoli.log statements. Dlatego konsola.log nie są już wywoływane.

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

Uwaga: bezwstydna wtyczka!

Możesz również użyć czegoś takiego jak mój obiekt JsTrace, aby mieć modułowe śledzenie z możliwością "przełączania" na poziomie modułów, aby włączyć tylko to, co chcesz zobaczyć w tym czasie.

Http://jstrace.codeplex.com

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

Wszystkie poziomy domyślnie "błąd", choć można je wyłączyć "off". Chociaż nie mogę myśleć, dlaczego nie chcesz widzieć błędów

Możesz je zmienić jak to:

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

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

T

Znalazłem trochę bardziej zaawansowany fragment kodu w tym url Porada JavaScript: Bust i 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 zastosowania: https://github.com/sunnykgupta/jsLogger

Cechy:

1. bezpiecznie nadpisuje konsolę.log.
2. dba o to, czy konsola nie jest dostępna (o tak, to też musisz wziąć pod uwagę.)
3. przechowuje wszystkie dzienniki (nawet jeśli są tłumione) do późniejszego pobrania.
4. Obsługuje główne funkcje konsoli, takie jak log, warn, error, info.

Jest otwarty na modyfikacje i będzie aktualizowany ilekroć pojawią się nowe sugestie.

Ive been used the following to deal with he problem:-

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 logger podczas wysyłania tekstu debugowania. Jest również skonfigurowany tak, aby akceptował dwa parametry.

Więc zamiast

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

Użyj

logger("my","log");

Napisałem tak:

//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 use strict.

Więc użycie console.fn.setEnabled = setEnabled i console.fn.setEnabled(false) Gdzie fn może być niemal dowolną funkcją konsoli. W Twoim przypadku byłoby:

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

Ja też to 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 wystarczy wpisać FLAGS wartość domyślną (przed wykonaniem powyższego kodu), jak FLAGS.LOG = false i funkcja log będzie domyślnie wyłączona, a mimo to można ją włączyć wywołując console.log.setEnabled(true)

Użyłem wcześniejWinstona loggera.

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

1. Ustaw zmienną środowiskową (przykład, w systemie Windows):

   setx LOG_LEVEL info
   

Oczywiście, może to być zmienna w Twoim kodzie, jeśli chcesz.

1. Uruchom ponownie wiersz poleceń lub IDE / editor jak Netbeans

2. Mają poniżej podobny 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;
   }
   

3. Teraz używaj całej konsoli.* as 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 wykonane w punkcie 1, Niektóre z powyższych będą drukować, inne nie będą drukować

Możesz użyć javascript AOP (np. jquery-AOP), aby przechwycić wszystkie połączenia do konsoli.debug / log (around) I nie kontynuuj rzeczywistego wywołania, jeśli jakaś globalna zmienna jest ustawiona na false.

Możesz nawet wykonać wywołanie ajax (teraz i wtedy) , dzięki czemu możesz zmienić zachowanie włączone/wyłączone dziennika na serwerze, które może być bardzo interesujące, aby włączyć debugowanie, gdy napotkasz problem w środowisku przejściowym lub tym podobne.

Możesz użyć logeek , pozwala kontrolować widoczność wiadomości dziennika. 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 również logeek.show('nothing') całkowicie wyłączyć każdą wiadomość dziennika.

To powinno nadpisać wszystkie metody okna.konsola. Możesz umieścić go na samej górze sekcji Skrypty, a jeśli korzystasz z frameworka PHP, możesz wydrukować ten kod tylko wtedy, gdy środowisko aplikacji jest produkcyjne lub gdy wyłączona jest jakaś flaga debugowania. Wtedy będziesz mieć wszystkie swoje logi w kodzie pracującym 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);

Moim kompleksowym rozwiązaniem do wyłączania/nadpisywania wszystkich funkcji console.* jest TUTAJ.

Oczywiście upewnij się, że uwzględniasz go po sprawdzeniu niezbędnego kontekstu. Na przykład, tylko w wersji produkcyjnej, to nie bombardowanie ż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ć tego pluginu:

Zainstaluj ten plugin poleceniem:

npm install gulp-remove-logging

Następnie dodaj ten wiersz do pliku gulpfile:

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

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

Konfiguracja Zadania

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