other - depurar javascript chrome

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

Question

¿Hay alguna forma de desactivar todas las declaraciones de console.log en mi código JavaScript, para fines de prueba?

Answer 1

¡Usted no debe!

No es una buena práctica sobrescribir las funciones incorporadas. Tampoco hay garantía de que suprimirá todos los resultados, 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 registrar de forma condicional. 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 se ajusta al objeto de la consola y tiene esta capacidad incorporada. Ese sería el lugar adecuado para hacer frente a la instrumentación .

Dicho esto, para propósitos de "prueba" puede escribir pruebas en lugar de imprimir en la consola. Si no está realizando ninguna prueba, y esas líneas console.log() fueron solo una ayuda para escribir su código, simplemente bórrelas .

Answer 2

Advertencia: enchufe descarado!

También puede 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 los que cuidan)

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, echa un vistazo a la documentación

T

Answer 3

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

caracteristicas:

1. Anula de forma segura la consola.log.
2. Presta atención si la consola no está disponible (oh sí, también debes 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á cada vez que surjan nuevas sugerencias.

Answer 4

Después de que busqué este problema y lo probé dentro de mi aplicación de cordova, solo quiero advertir a todos los desarrolladores para que Windows Phone no sobrescriba

    console.log

porque la aplicación se bloqueará en el inicio.

No se bloqueará si está desarrollando local si tiene suerte, pero si lo envía en la tienda, la aplicación se bloqueará.

Solo sobrescribir

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

    }

Answer 5

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

Answer 6

Este es un híbrido de respuestas de SolutionYogi y Chris S. Mantiene los números de línea y el nombre del archivo de console.log. 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'');
});

Answer 7

Esto debería anular todos los métodos de window.console. Puede colocarlo en la parte superior de la sección de 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 marca de depuración está deshabilitada. Luego 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);

Answer 8

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

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

Answer 9

He utilizado winston Logger anteriormente.

Hoy en día estoy usando más abajo el 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.

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

3. Tenga 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 usa toda la consola. * Como se muestra 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, según la configuración de LOG_LEVEL realizada en el punto 1, se imprimirán algunos de los anteriores y otros no.

Answer 10

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 métodos ficticios para evitar errores. Por supuesto, hay muchas más funciones en Firebug, como rastreo, perfil, tiempo, 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 eliminar 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(){};
    }
}

Answer 11

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 y funciona en las últimas versiones de Chrome, FF e IE.

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

Answer 12

Me sorprende que de todas esas respuestas nadie combine:

• No jquery
• Función anónima para no contaminar el espacio de nombres global.
• Manejar caso donde window.console no definido
• Solo modifica 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 () {};
    }
})()

Answer 13

Mi solución integral para deshabilitar / anular todas las funciones de la console.* Está here .

Por supuesto, asegúrese de incluirlo después de verificar el contexto necesario. Por ejemplo, solo incluido en el lanzamiento 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");
})();

Answer 14

Podría usar el AOP de javascript (por ejemplo, jquery-aop ) para interceptar todas las llamadas a console.debug / log (alrededor) y no continuar con la invocación real si alguna variable global está configurada como falsa.

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

Answer 15

Por lo que puedo ver en la documentation , Firebug no suministra ninguna variable para alternar el estado de depuración. En su lugar, ajuste 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);
    }
}

Answer 16

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

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

Answer 17

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

console.log = function() {}

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

EDITAR:

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

Desde mi consola de 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 usar el ''logger'' anterior? En su evento listo, llame al 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 cual desea registrar mensajes en la consola.

Answer 18

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

Answer 19

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

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

Answer 20

Si estás usando gulp, entonces puedes usar this complemento:

Instala 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 los ajustes 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/"
      )
    ); });

Answer 21

Si usa Grunt, puede agregar una tarea para eliminar / comentar las sentencias de console.log. Por lo tanto, la consola.log ya no se llama.

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

Answer 22

Simplemente cambie el indicador DEBUG para anular la función console.log. Esto debería funcionar.

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

Answer 23

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 de uso.

Por lo tanto, utilizando console.fn.setEnabled = setEnabled y luego console.fn.setEnabled(false) donde fn podría ser casi cualquier función de consola. Para tu caso sería:

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

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

por lo tanto, solo necesita poner en FLAGS el valor predeterminado (antes de ejecutar el código anterior), como FLAGS.LOG = false y la función de registro se desactivará de forma predeterminada, y aún así podría habilitarlo llamando a console.log.setEnabled(true)