Cómo desactivar rápida y convenientemente todas las consolas.¿registrar declaraciones en mi código?

Lo siguiente es más completo:

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

Esto eliminará los métodos comunes en la consola si existe, y se pueden llamar sin error y prácticamente sin sobrecarga de rendimiento. En el caso de un navegador como IE6 sin consola, se crearán los métodos ficticios para evitar errores. Por supuesto, hay muchas más funciones en Firebug, como trace, profile, time, etc. Se pueden agregar a la lista si los usa en su código.

También puede comprobar si el depurador tiene los métodos especiales o no (ie, IE) y cero a los que no soporta:

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

Por lo que puedo decir de la documentación , Firebug no proporciona ninguna variable para alternar el estado de depuración. En su lugar, envuelva la consola.log() en un wrapper que lo llama condicionalmente, es decir:

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

Para no tener que cambiar todas las llamadas existentes, puede usar esto en su lugar:

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

Sé que preguntaste cómo deshabilitar la consola.log, pero esto podría ser lo que realmente buscas. De esta manera no tiene que habilitar o deshabilitar explícitamente la consola. Simplemente evita esos molestos errores de consola para las personas que no lo tienen abierto o instalado.

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

Me doy cuenta de que este es un post antiguo, pero todavía aparece en la parte superior de los resultados de Google, así que aquí hay una solución más elegante que no es jQuery que funciona en la última Chrome, FF, e IE.

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

¡No deberías!

No es una buena práctica sobrescribir funciones integradas. Tampoco hay garantía de que suprimirá toda la salida, otras bibliotecas que utilice pueden revertir sus cambios y hay otras funciones que pueden escribir en la consola; .dir(), .warning(), .error(), .debug(), .assert() etc.

Como algunos sugirieron, podría definir una variable DEBUG_MODE y un registro condicional. Dependiendo de la complejidad y la naturaleza de su código, puede ser una buena idea escribir su propio registrador objeto / función que envuelve el objeto de la consola y tiene esta capacidad incorporada. Ese sería el lugar correcto para hacer frente a instrumentación .

Dicho esto, para propósitos de 'testing' puedes escribir tests en lugar de imprimir en la consola. Si no está haciendo ninguna prueba, y esas console.log() líneas eran solo una ayuda para escribir su código, simplemente elimínelas.

Simplemente cambie la bandera DEBUG para anular la consola.función de registro. Esto debería hacer el truco.

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

Si está utilizando IE7, la consola no se definirá. Así que una versión amigable más IE sería:

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

Me sorprende que de todas esas respuestas nadie las combine:

• No hay jquery
• Función anónima para no contaminar el espacio de nombres global
• Manejar el caso donde la ventana.consola no definida
• Basta con modificar el .función de registro de la consola

Yo iría por esto:

(function () {

    var debug = false

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

Después de que busqué este problema también y lo probé dentro de mi aplicación Cordova, solo quiero advertir a todos los desarrolladores de Windows phone que no sobrescriban

    console.log

Porque la aplicación se bloqueará al iniciar.

No se bloqueará si está desarrollando local si tiene suerte, pero enviar en la tienda resultará en el bloqueo de la aplicación.

Simplemente sobrescribir

    window.console.log 

Si es necesario.

Esto funciona en mi aplicación:

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

    }

Esta un híbrido de respuestas de SolutionYogi y Chris S. mantiene la consola.registrar números de línea y nombre de archivo. Ejemplo 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');
});

Si utiliza Grunt, puede agregar una tarea para eliminar/comentar la consola.declaraciones de registro. Por lo tanto la consola.los registros ya no se llaman.

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

Advertencia: Shameless plug!

También podría usar algo como mi objeto JsTrace para tener un seguimiento modular con capacidad de "conmutación" a nivel de módulo para activar solo lo que desea ver en ese momento.

Http://jstrace.codeplex.com

(También tiene un paquete NuGet, para aquellos que se preocupan)

Todos los niveles por defecto a "error", aunque se puede apagar "off". Sin embargo, no puedo pensar en por qué no querría ver errores

Puedes cambiarlos como esto:

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

Para más documentos, echa un vistazo a la documentación

T

Encontré una pieza de código un poco más avanzada en esta url Consejo 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() {};
}

Desarrollé una biblioteca para este caso de uso: https://github.com/sunnykgupta/jsLogger

Características:

1. Sobrescribe de forma segura la consola.registro.
2. Tiene cuidado si la consola no está disponible (oh, sí, también necesita tener en cuenta eso.)
3. Almacena todos los registros (incluso si están suprimidos) para su posterior recuperación.
4. Maneja las principales funciones de la consola como log, warn, error, info.

Está abierto a modificaciones y se actualizará siempre que surjan nuevas sugerencias.

He estado usando lo siguiente para lidiar con el problema: -

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

Establezca debug en 1 para habilitar la depuración. A continuación, utilice la función logger al enviar texto de depuración. También está configurado para aceptar dos parámetros.

Entonces, en lugar de

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

Use

logger("my","log");

Escribí esto:

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

    }
}

Desafortunadamente no funciona en el modo use strict.

Así que usando console.fn.setEnabled = setEnabled y luego console.fn.setEnabled(false) donde fn podría ser casi cualquier función de consola. Para su caso sería:

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

También escribí esto:

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

Entonces solo necesita poner en el FLAGS el valor predeterminado (antes de ejecutar el código anterior), como FLAGS.LOG = false y la función de registro estaría deshabilitada por defecto, y aún así podría habilitarla llamando a console.log.setEnabled(true)

He usado winston logger anteriormente.

Hoy en día estoy usando el siguiente código más simple de la experiencia:

1. Establecer la variable de entorno (ejemplo, en Windows):

   setx LOG_LEVEL info
   

Por supuesto, esto podría ser una variable en su código si lo desea.

1. Reinicie la línea de comandos, o, IDE / editor como Netbeans

2. Tienen a continuación un código similar:

   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. Ahora usa toda la consola.* como abajo:

   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
   

Ahora, basado en la configuración LOG_LEVEL realizada en el punto 1, algunos de los anteriores se imprimirán, otros no se imprimirán

Puede usar javascript AOP (por ejemplo, jquery-aop) para interceptar todas las llamadas a la consola.debug / log (around) y no proceda con la invocación real si alguna variable global está establecida en false.

Incluso podría hacer una llamada ajax (de vez en cuando) para que pueda cambiar el comportamiento log enabled/disabled en el servidor, lo que puede ser muy interesante para habilitar la depuración cuando se enfrenta a un problema en un entorno de ensayo o tal.

Puede usar logeek, le permite controlar la visibilidad de sus mensajes de registro. Así es como lo haces:

<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

También puede logeek.show('nothing') desactivar totalmente cada mensaje de registro.

Esto debería anular todos los métodos de window.consola. Puede ponerlo en la parte superior de su sección de scripts, y si está en un marco PHP solo puede imprimir este código cuando su entorno de aplicación es de producción, o si algún tipo de indicador de depuración está deshabilitado. Entonces tendría todos sus registros en su código trabajando en entornos de desarrollo o en modo de depuración.

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

Mi solución completa para desactivar/anular todas las funciones console.* es aquí.

Por supuesto, asegúrese de incluirlo después de verificar el contexto necesario. Por ejemplo, solo incluyendo en la versión de producción, no está bombardeando ningún otro componente crucial, etc.

Citándolo aquí:

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

Si estás usando gulp, entonces puedes usar este plugin:

Instale este plugin con el comando:

npm install gulp-remove-logging

A continuación, agregue esta línea a su gulpfile:

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

Por último, agregue las opciones de configuración (ver más abajo) a su gulpfile.

Configuración de tareas

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