Wie kann ich schnell und bequem alle console.log-Anweisungen in meinem Code deaktivieren?

Gibt es eine Möglichkeit, alle console.logAnweisungen in meinem JavaScript-Code zu Testzwecken zu deaktivieren?

Definieren Sie die Funktion console.log in Ihrem Skript neu.

console.log = function() {}

Das war's, keine Nachrichten mehr an die Konsole.

BEARBEITEN:

Cides Idee erweitern. Ein benutzerdefinierter Logger, mit dem Sie die Anmeldung von Ihrem Code ein- und ausschalten können.

Von meiner Firefox-Konsole:

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

Wie benutzt man den obigen 'Logger'? Rufen Sie in Ihrem Bereitschaftsereignis logger.disableLogger auf, damit Konsolennachrichten nicht protokolliert werden. Fügen Sie logger.enableLogger und logger.disableLogger Aufrufe innerhalb der Methode hinzu, für die Sie Nachrichten an der Konsole protokollieren möchten.

Folgendes ist gründlicher:

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

Dadurch werden die gängigen Methoden in der Konsole auf Null gesetzt, sofern vorhanden. Sie können fehlerfrei und praktisch ohne Leistungsaufwand aufgerufen werden. Bei einem Browser wie IE6 ohne Konsole werden die Dummy-Methoden erstellt, um Fehler zu vermeiden. Natürlich gibt es in Firebug noch viele weitere Funktionen wie Ablaufverfolgung, Profil, Zeit usw. Sie können der Liste hinzugefügt werden, wenn Sie sie in Ihrem Code verwenden.

Sie können auch überprüfen, ob der Debugger über diese speziellen Methoden verfügt oder nicht (z. B. IE), und die nicht unterstützten Methoden auf Null setzen:

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

Soweit ich der Dokumentation entnehmen kann, liefert Firebug keine Variable zum Umschalten des Debug-Status. Wickeln Sie stattdessen console.log () in einen Wrapper ein, der ihn bedingt aufruft, dh:

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

Um nicht alle vorhandenen Anrufe ändern zu müssen, können Sie stattdessen Folgendes verwenden:

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

Du solltest nicht!

Es ist keine gute Praxis, integrierte Funktionen zu überschreiben. Es gibt auch keine Garantie dafür, dass Sie alle Ausgaben unterdrücken. Andere Bibliotheken, die Sie verwenden, können Ihre Änderungen rückgängig machen, und es gibt andere Funktionen, die möglicherweise in die Konsole schreiben. .dir(), .warning(), .error(), .debug(), .assert()Usw.

Wie einige vorgeschlagen haben, können Sie eine DEBUG_MODEVariable definieren und bedingt protokollieren. Abhängig von der Komplexität und Art Ihres Codes kann es eine gute Idee sein, ein eigenes Logger-Objekt / eine eigene Logger-Funktion zu schreiben, die das Konsolenobjekt umschließt und über diese integrierte Funktion verfügt. Das wäre der richtige Ort, um sich mit Instrumentierung zu befassen .

Zu Testzwecken können Sie jedoch Tests schreiben , anstatt auf die Konsole zu drucken. Wenn Sie keine Tests durchführen und diese console.log()Zeilen nur eine Hilfe zum Schreiben Ihres Codes waren, löschen Sie sie einfach .

Mir ist klar, dass dies ein alter Beitrag ist, der jedoch immer noch ganz oben in den Google-Ergebnissen angezeigt wird. Hier ist eine elegantere Nicht-jQuery-Lösung, die in den neuesten Versionen von Chrome, FF und IE funktioniert.

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

Ich weiß, dass Sie gefragt haben, wie Sie console.log deaktivieren sollen, aber das ist möglicherweise das, wonach Sie wirklich suchen. Auf diese Weise müssen Sie die Konsole nicht explizit aktivieren oder deaktivieren. Es verhindert einfach diese lästigen Konsolenfehler für Leute, die es nicht geöffnet oder installiert haben.

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

Ändern Sie einfach das Flag DEBUG, um die Funktion console.log zu überschreiben. Dies sollte den Trick tun.

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

Ich bin überrascht, dass von all diesen Antworten niemand kombiniert:

• Keine Frage
• Anonyme Funktion, um den globalen Namespace nicht zu verschmutzen
• Behandeln Sie den Fall, in dem window.console nicht definiert ist
• Ändern Sie einfach die .log-Funktion der Konsole

Ich würde das machen:

(function () {

    var debug = false

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

Nachdem ich auch nach diesem Problem gesucht und es in meiner Cordova-App ausprobiert habe, möchte ich nur jeden Entwickler warnen, dass Windows Phone nicht überschrieben wird

    console.log

weil die App beim Start abstürzt.

Es stürzt nicht ab, wenn Sie mit etwas Glück lokal entwickeln. Wenn Sie es jedoch im Geschäft einreichen, stürzt die App ab.

Einfach überschreiben

    window.console.log 

wenn du musst.

Das funktioniert in meiner App:

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

    }

Wenn Sie IE7 verwenden, wird die Konsole nicht definiert. Eine IE-freundlichere Version wäre also:

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

Dies ist eine Mischung aus Antworten von SolutionYogi und Chris S. Es werden die Zeilennummern und der Dateiname von console.log beibehalten. Beispiel 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');
});

Wenn Sie Grunt verwenden, können Sie eine Aufgabe hinzufügen, um die Anweisungen console.log zu entfernen / zu kommentieren. Daher wird die console.log nicht mehr aufgerufen.

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

Ich habe Folgendes verwendet, um das Problem zu lösen:

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

Setzen Sie debug auf 1, um das Debuggen zu aktivieren. Verwenden Sie dann die Logger-Funktion, wenn Sie Debug-Text ausgeben. Es ist auch so eingerichtet, dass zwei Parameter akzeptiert werden.

Also statt

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

verwenden

logger("my","log");

Ich habe Winston benutzt Logger früher verwendet.

Heutzutage verwende ich aus Erfahrung einfacheren Code:

1. Legen Sie die Umgebungsvariable über cmd / Befehlszeile fest (unter Windows):

   cmd
   setx LOG_LEVEL info

Oder Sie könnten eine Variable in Ihrem Code haben, wenn Sie möchten, aber oben ist besser.

2. Starten Sie cmd / command line oder IDE / editor wie Netbeans neu

3. Habe unten wie Code:

   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. Verwenden Sie jetzt alle Konsolen. * Wie folgt:

   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

Nun, basierend auf Ihren LOG_LEVEL-Einstellungen, die in Punkt 1 vorgenommen wurden (wie z. setx LOG_LEVEL log und Befehlszeile neu starten), werden einige der oben gedruckt, andere werden nicht gedruckt

Hoffe das hat geholfen.

Achtung: Schamloser Stecker!

Sie können auch so etwas wie mein JsTrace-Objekt verwenden, um eine modulare Ablaufverfolgung mit "Switching" -Funktion auf Modulebene zu haben, mit der Sie nur das aktivieren können, was Sie gerade sehen möchten.

http://jstrace.codeplex.com

(Hat auch ein NuGet-Paket für diejenigen, die sich interessieren)

Alle Ebenen sind standardmäßig auf "Fehler" eingestellt, obwohl Sie sie "ausschalten" können. Ich kann mir allerdings nicht vorstellen, warum Sie KEINE Fehler sehen möchten

Sie können sie folgendermaßen ändern:

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

Weitere Dokumente finden Sie in der Dokumentation

T.

Ich habe in dieser URL einen etwas fortgeschritteneren Code gefunden. JavaScript-Tipp: 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() {};
}

Ich habe eine Bibliothek für diesen Anwendungsfall entwickelt: https://github.com/sunnykgupta/jsLogger

Eigenschaften:

1. Es überschreibt sicher die console.log.
2. Passt auf, wenn die Konsole nicht verfügbar ist (oh ja, das müssen Sie auch berücksichtigen.)
3. Speichert alle Protokolle (auch wenn sie unterdrückt werden) zum späteren Abrufen.
4. Griffe große Konsolenfunktionen wie log, warn, error, info.

Ist offen für Änderungen und wird aktualisiert, sobald neue Vorschläge auftauchen.

Dies sollte alle Methoden von window.console überschreiben. Sie können es ganz oben in Ihren Skriptbereich einfügen. Wenn Sie sich in einem PHP-Framework befinden, können Sie diesen Code nur drucken, wenn Ihre App-Umgebung produziert wird oder wenn eine Art Debug-Flag deaktiviert ist. Dann würden alle Ihre Protokolle in Ihrem Code in Entwicklungsumgebungen oder im Debug-Modus funktionieren.

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

Ich habe das geschrieben:

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

    }
}

Leider funktioniert es nicht im strikten Modus.

Also mit console.fn.setEnabled = setEnabledund console.fn.setEnabled(false)wo fnkönnte dann fast jede Konsolenfunktion sein. Für Ihren Fall wäre:

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

Ich habe das auch geschrieben:

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

Dann müssen Sie nur noch FLAGSden Standardwert eingeben (bevor Sie den obigen Code ausführen), FLAGS.LOG = falseund die Protokollfunktion ist standardmäßig deaktiviert, und Sie können den Aufruf trotzdem aktivierenconsole.log.setEnabled(true)

Meine umfassende Lösung zum Deaktivieren / Überschreiben aller console.*Funktionen ist hier .

Stellen Sie natürlich sicher, dass Sie es einschließen, nachdem Sie den erforderlichen Kontext überprüft haben. Zum Beispiel bombardiert es nur andere wichtige Komponenten usw., wenn es nur in der Produktionsversion enthalten ist.

Hier zitieren:

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

Wenn Sie gulp verwenden, können Sie dieses Plugin verwenden:

Installieren Sie dieses Plugin mit dem folgenden Befehl:

npm install gulp-remove-logging

Fügen Sie als Nächstes diese Zeile zu Ihrer Gulpfile hinzu:

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

Zuletzt fügen Sie die Konfigurationseinstellungen (siehe unten) zu Ihrer Gulpfile hinzu.

Aufgabenkonfiguration

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

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

Sie können Javascript AOP verwenden (z. B. jquery-aop ) verwenden, um alle Aufrufe von console.debug / log (around) abzufangen und nicht mit dem eigentlichen Aufruf fortzufahren, wenn eine globale Variable auf false gesetzt ist.

Sie können sogar (ab und zu) einen Ajax-Aufruf ausführen, um das Verhalten des aktivierten / deaktivierten Protokolls auf dem Server zu ändern. Dies kann sehr interessant sein, um das Debuggen zu aktivieren, wenn ein Problem in einer Staging-Umgebung oder dergleichen auftritt.

Sie können logeek verwenden. Hiermit können Sie die Sichtbarkeit Ihrer Protokollnachrichten steuern. So machen Sie das:

<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

Sie können auch logeek.show('nothing')jede Protokollnachricht vollständig deaktivieren.

Nachdem ich einige Nachforschungen und Entwicklungen für dieses Problem angestellt hatte, stieß ich auf diese Lösung, die Warnungen / Fehler / Protokolle nach Ihrer Wahl verbirgt.

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

Fügen Sie diesen Code vor dem JQuery-Plugin hinzu (z. B. /../jquery.min.js), auch wenn dies JavaScript-Code ist, für den kein JQuery erforderlich ist. Weil einige Warnungen in JQuery selbst sind.

Vielen Dank!!

Ich habe eine ES2015- Lösung geschrieben (nur mit Webpack verwenden ).

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

Beschreibung:

1. Zusammen mit logger.enable und logger.disable können Sie auch die Methoden console. ['Log', 'warn', 'error'] mit der logger-Klasse verwenden.
2. Durch die Verwendung der Logger-Klasse zum Anzeigen, Aktivieren oder Deaktivieren von Nachrichten wird der Code viel sauberer und wartbarer.
3. Der folgende Code zeigt Ihnen, wie Sie die Logger-Klasse verwenden:
   • logger.disable() - Deaktivieren Sie alle Konsolenmeldungen
   • logger.enable() - Aktivieren Sie alle Konsolenmeldungen
   • logger.log('message1', 'message2') - funktioniert genau wie console.log.
   • logger.warn('message1', 'message2') - funktioniert genau wie console.warn.
   • logger.error('message1', 'message2')- funktioniert genau wie console.error. Viel Spaß beim Codieren.