¿Cómo deshabilitar rápida y convenientemente todas las declaraciones de console.log en mi código?

¿Hay alguna manera de apagar todo console.log declaraciones en mi código JavaScript, con fines de prueba?

Redefina la función console.log en su script.

console.log = function() {}

Eso es todo, no más mensajes para consolar.

EDITAR:

Ampliando la idea de Cide. Un registrador personalizado que puede usar para activar / desactivar el inicio de sesión desde su código.

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

¿Cómo utilizar el 'registrador' anterior? En su evento listo, llame a logger.disableLogger para que los mensajes de la consola no se registren. Agregue llamadas a logger.enableLogger y logger.disableLogger dentro del método para el que desea registrar mensajes en la consola.

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 pondrá a cero 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 rastreo, perfil, hora, etc. Se pueden agregar a la lista si las usa en su código.

También puede verificar si el depurador tiene esos métodos especiales o no (es decir, IE) y poner a cero los que no admite:

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 deducir de la documentación , Firebug no proporciona ninguna variable para alternar el estado de depuración. En su lugar, envuelva console.log () en un contenedor que lo llame 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);
    }
}

¡Usted no debe!

No es una buena práctica sobrescribir las funciones integradas. Tampoco hay garantía de que suprima todos los resultados, otras bibliotecas que use 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 DEBUG_MODEvariable y registrar condicionalmente. Dependiendo de la complejidad y la naturaleza de su código, puede ser una buena idea escribir su propio objeto / función de registrador que envuelva el objeto de la consola y tenga esta capacidad incorporada. Ese sería el lugar adecuado para hacer frente a la instrumentación .

Dicho esto, para fines de 'prueba' puede escribir pruebas en lugar de imprimir en la consola. Si no está haciendo ninguna prueba, y esas console.log()líneas fueron solo una ayuda para escribir su código, simplemente elimínelas .

Me doy cuenta de que esta es una publicación antigua, pero aún aparece en la parte superior de los resultados de Google, por lo que aquí hay una solución más elegante que no es jQuery que funciona en los últimos Chrome, FF e IE.

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

Sé que preguntaste cómo deshabilitar console.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 la tienen abierta o instalada.

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

Simplemente cambie la bandera DEBUGpara anular la función console.log. Esto debería funcionar.

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

Me sorprende que de todas esas respuestas nadie combine:

• No jquery
• Función anónima para no contaminar el espacio de nombres global
• Manejar el caso donde window.console no está definido
• Simplemente modifique la función .log 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 buscar este problema también y probarlo dentro de mi aplicación cordova, solo quiero advertir a todos los desarrolladores que Windows Phone no sobrescriba

    console.log

porque la aplicación se bloqueará al inicio.

No se bloqueará si está desarrollando local si tiene suerte, pero al enviarlo a la tienda se bloqueará la aplicación.

Solo sobrescribe

    window.console.log 

si lo necesitas.

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

    }

Si usa IE7, la consola no se definirá. Entonces, una versión más amigable con IE sería:

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

Este es un híbrido de respuestas de SolutionYogi y Chris S. Mantiene los números de línea de console.log y el nombre del 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 usa Grunt, puede agregar una tarea para eliminar / comentar las declaraciones de console.log. Por lo tanto, ya no se llama a console.log.

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

He estado usando lo siguiente para tratar el problema:

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

Establezca depuración en 1 para habilitar la depuración. Luego use la función de registrador al generar texto de depuración. También está configurado para aceptar dos parámetros.

Entonces, en lugar de

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

utilizar

logger("my","log");

He usado winston logger anteriormente.

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

1. Establezca la variable de entorno desde cmd / línea de comando (en Windows):

   cmd
   setx LOG_LEVEL info

O bien, podría tener una variable en su código si lo desea, pero más arriba es mejor.

2. Reinicie cmd / línea de comando, o IDE / editor como Netbeans

3. Tener abajo como código:

   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. Ahora use todas las consolas. * Como se muestra a continuación:

   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, en función de la configuración de LOG_LEVEL realizada en el punto 1 (como, setx LOG_LEVEL logy reiniciar la línea de comando), algunos de los anteriores se imprimirán, otros no se imprimirán

Espero que haya ayudado.

Advertencia: ¡enchufe descarado!

También podría usar algo como mi objeto JsTrace para tener un rastreo 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 están predeterminados en "error", aunque puede apagarlos "off". Sin embargo, no puedo pensar por qué NO querrías ver errores

Puedes cambiarlos así:

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

Para más documentos, consulte la documentación

T

Encontré un fragmento de código un poco más avanzado en esta url. Consejo de JavaScript: busto y deshabilitar 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

caracteristicas:

1. Invalida de forma segura el archivo console.log.
2. Tenga cuidado si la consola no está disponible (oh sí, también debe tenerlo en cuenta).
3. Almacena todos los registros (incluso si están suprimidos) para su posterior recuperación.
4. Manijas principales funciones de la consola como log, warn, error, info.

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

Esto debería anular todos los métodos de window.console. Puede ponerlo en la parte superior de la sección de sus scripts, y si está en un marco PHP solo puede imprimir este código cuando el entorno de su aplicación es de producción, o si algún tipo de indicador de depuración está desactivado. 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);

Yo 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 modo estricto.

Entonces, usando console.fn.setEnabled = setEnabledy luego console.fn.setEnabled(false)dónde fnpodría haber 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 el FLAGSvalor predeterminado (antes de ejecutar el código anterior), como FLAGS.LOG = falsey la función de registro se deshabilitaría de manera predeterminada, y aún así podría habilitarla llamandoconsole.log.setEnabled(true)

Mi solución integral para deshabilitar / anular todas las console.*funciones está aquí .

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

Citando 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á usando gulp, puede usar este complemento:

Instale este complemento con el comando:

npm install gulp-remove-logging

A continuación, agregue esta línea a su archivo de trago:

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

Por último, agregue los ajustes de configuración (ver más abajo) a su archivo de trago.

Configuración de tareas

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

Una simplificación de 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() {};
}

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

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

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')deshabilitar totalmente cada mensaje de registro.

Después de investigar un poco y desarrollar este problema, encontré esta solución que ocultará advertencias / Errores / Registros según su elección.

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

Agregue este código antes del complemento JQuery (por ejemplo, /../jquery.min.js) incluso si se trata de un código JavaScript que no requiere JQuery. Porque algunas advertencias están en JQuery.

¡¡Gracias!!

Escribí una solución ES2015 (usar solo con 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);
  }
}

Descripción:

1. Junto con logger.enable y logger.disable, puede usar los métodos de consola. ['Log', 'warn', 'error'] y la clase logger.
2. Al usar la clase logger para mostrar, habilitar o deshabilitar mensajes hace que el código sea mucho más limpio y fácil de mantener.
3. El siguiente código le muestra cómo usar la clase logger:
   • logger.disable() - deshabilitar todos los mensajes de la consola
   • logger.enable() - habilitar todos los mensajes de la consola
   • logger.log('message1', 'message2') - Funciona exactamente como console.log.
   • logger.warn('message1', 'message2') - Funciona exactamente como console.warn.
   • logger.error('message1', 'message2')- Funciona exactamente como console.error. Feliz codificación ..