Comment désactiver rapidement et commodément toutes les consoles.enregistrer les déclarations dans mon code?

ce qui suit est plus complet:

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

cela va zéro sur les méthodes communes dans la console si elle existe, et ils peuvent être appelés sans erreur et pratiquement aucune performance overhead. Dans le cas d'un navigateur comme IE6 sans console, les méthodes factices seront créées pour prévenir les erreurs. Bien sûr, il y a beaucoup plus de fonctions dans Firebug, comme trace, profil, temps, etc. Ils peuvent être ajoutés à la liste, si vous les utilisez dans votre code.

vous pouvez également vérifier si le débogueur a ou non ces méthodes spéciales (ie, IE) et mettre à zéro celles qu'il ne supporte pas:

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

pour autant que je puisse dire à partir de la documentation , Firebug ne fournit aucune variable pour basculer l'état de débogage. Au lieu de cela, envelopper console.log() dans une enveloppe que conditionnellement l'appelle, c'est à dire:

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

pour ne pas avoir à changer tous les appels existants, vous pouvez utiliser ceci à la place:

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

je sais que vous avez demandé comment désactiver la console.journal, mais c'est peut-être ce que vous êtes vraiment après. De cette façon, vous n'avez pas à activer ou désactiver explicitement la console. Il prévient simplement ces fâcheuses erreurs de console pour les personnes qui ne l'ont pas ouvert ou installé.

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

je me rends compte que c'est un vieux post, mais il apparaît toujours au sommet des résultats de Google, donc voici une solution non-jQuery plus élégant qui fonctionne dans les derniers Chrome, FF, et IE.

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

vous ne devriez pas!

ce n'est pas une bonne pratique de remplacer les fonctions intégrées. Il n'y a pas non plus de garantie que vous supprimerez toutes les sorties, les autres bibliothèques que vous utilisez peuvent annuler vos modifications et il y a d'autres fonctions qui peuvent écrire sur la console.; .dir() , .warning() , .error() , .debug() , .assert() etc.

comme certains l'ont suggéré, vous pouvez définir une variable DEBUG_MODE et log conditionnellement. En fonction de la complexité et nature de votre code, ce peut être une bonne idée d'écrire votre propre objet/fonction logger qui entoure l'objet console et a cette capacité intégrée. Ce serait le bon endroit pour traiter avec instrumentation .

cela dit, pour les" tests "vous pouvez écrire tests au lieu d'imprimer sur la console. Si vous ne faites aucun test, et ces lignes console.log() étaient juste une aide pour écrire votre code, simplement les supprimer .

changez simplement le drapeau DEBUG pour outrepasser la console.la fonction log. Ceci devrait faire l'affaire.

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

si vous utilisez IE7, la console ne sera pas définie. Une version plus conviviale serait donc:

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

je suis surpris que de toutes ces réponses personne ne combine:

• Pas de jquery
• fonction Anonyme pour ne pas polluer l'espace de noms global
• poignée cas où fenêtre.console non définie
• il suffit de modifier le .fonction log de la console

j'irais pour cela:

(function () {

    var debug = false

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

après que j'ai cherché ce problème aswell et l'ai essayé dans mon application cordova, je veux juste avertir chaque développeur pour windows phone de ne pas écraser

    console.log

parce que l'application va se planter au démarrage.

il ne se plantera pas si vous développez local si vous êtes chanceux, mais soumettre en magasin il aura pour résultat de planter l'application.

juste overwrite

    window.console.log 

si vous en avez besoin.

cela fonctionne dans mon application:

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

    }

c'est un hybride de réponses de SolutionYogi et Chris S. il maintient la console.journal des numéros de ligne et le nom de fichier. exemple 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 vous utilisez Grunt vous pouvez ajouter une tâche afin de supprimer/commenter la console.journal des états. Donc la console.le journal ne sont plus appelés.

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

avertissement: bouchon sans vergogne!

vous pouvez aussi utiliser quelque chose comme mon objet JsTrace pour avoir un traçage modulaire avec une capacité de" commutation " au niveau du module pour seulement allumer ce que vous voulez voir à l'époque.

http://jstrace.codeplex.com

(a également un paquet NuGet, pour ceux qui s'occupent)

Tous les niveaux par défaut "erreur", si vous pouvez les faire taire "off". Cependant, je ne peux pas pensez à pourquoi vous ne voudriez pas voir des erreurs

vous pouvez les changer comme ceci:

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

pour plus de docs, check out la Documentation

T

j'ai trouvé un morceau de code un peu plus avancé dans cette url JavaScript Conseil: buste et console désactivée.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() {};
}

j'ai développé une bibliothèque pour cette usecase: https://github.com/sunnykgupta/jsLogger

Dispose:

1. il surpasse en toute sécurité la console.journal.
2. prend soin si la console n'est pas disponible (oh oui, vous devez prendre en compte cela aussi.)
3. stocke tous les journaux (même s'ils sont supprimés) pour une récupération ultérieure.
4. Gère les principales fonctions de la console comme log , warn , error , info .

peut faire l'objet de modifications et sera mis à jour à chaque nouvelle suggestion.

Ive été en utilisant les éléments suivants pour traiter avec lui de problème:-

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

définit le débogage à 1 pour activer le débogage. Puis utilisez la fonction logger lors de la sortie du texte de débogage. Il est également configuré pour accepter deux paramètres.

donc, au lieu de

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

utiliser

logger("my","log");

j'ai écrit ceci:

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

    }
}

malheureusement, il ne fonctionne pas sur Utiliser le mode strict.

donc en utilisant console.fn.setEnabled = setEnabled puis console.fn.setEnabled(false) où fn pourrait être presque n'importe quelle fonction de console. Pour votre cas serait:

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

j'ai écrit ceci:

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

alors vous avez besoin juste de mettre dans le FLAGS la valeur par défaut (avant d'exécuter la ci-dessus code), comme FLAGS.LOG = false et la fonction log serait désactivée par défaut, et vous pouvez encore l'activer appelant console.log.setEnabled(true)

j'ai utilisé winston logger plus tôt.

de nos jours, j'utilise ci-dessous le code plus simple de l'expérience:

1. définit la variable d'environnement (exemple, sur Windows):

   setx LOG_LEVEL info
   

bien sûr, cela pourrait être une variable dans votre code si vous le souhaitez.

2. redémarrez la ligne de commande, ou, IDE / editor like Netbeans

3. ci-dessous Ont comme 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. maintenant utiliser toute la console.* comme ci-dessous:

   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
   

maintenant, basé sur vos paramètres LOG_LEVEL faites dans le point 1, certains des ci-dessus vont imprimer, d'autres ne vont pas imprimer

vous pouvez utiliser javascript AOP (e.g. jquery-aop ) pour intercepter tous les appels à la console.debug / log (around) et ne pas procéder avec l'invocation réelle si une variable globale est définie à false.

vous pouvez même faire un appel ajax (de temps en temps) pour que vous puissiez modifier le comportement Activé/Désactivé sur le serveur, ce qui peut être très intéressant pour activer le débogage lorsque vous faites face à un problème dans un environnement de mise en scène ou autre.

vous pouvez utiliser logeek , il vous permet de contrôler la visibilité de vos messages log. Voici comment vous faites cela:

<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

vous pouvez aussi logeek.show('nothing') pour désactiver totalement chaque log message.

ceci devrait annuler toutes les méthodes de window.console. Vous pouvez le mettre en haut de votre section scripts, et si vous êtes sur un framework PHP, vous ne pouvez imprimer ce code que lorsque votre environnement app est la production, ou si une sorte de drapeau de débogage est désactivé. Vous aurez alors tous vos logs dans votre code travaillant sur des environnements de développement ou en mode de débogage.

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

ma solution complète pour désactiver/outrepasser toutes les fonctions console.* est ici .

bien sûr, s'il vous plaît assurez-vous que vous l'incluez après avoir vérifié le contexte nécessaire. Par exemple, en incluant seulement dans la version de production, il n'est pas bombarder d'autres composants essentiels, etc.

citant ici:

"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 vous utilisez gulfp, alors vous pouvez utiliser ce plugin:

installez ce plugin avec la commande:

npm install gulp-remove-logging

Ensuite, ajoutez cette ligne à votre gulffile:

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

enfin, ajoutez les paramètres de configuration (voir ci-dessous) à votre fichier gulffile.

Configuration Des Tâches

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