Comment désactiver rapidement et facilement toutes les instructions console.log dans mon code?

257

Existe-t-il un moyen de désactiver toutes les console.loginstructions dans mon code JavaScript, à des fins de test?

Zack Burt
la source
11
utiliser un éditeur de texte qui prend en charge "remplacer tout" et remplacer "console.log" par "//console.log"
helloandre
5
@helloandre - cela devient un peu ennuyeux si vous utilisez le journal, les informations, avertissez le débogage et l'erreur
UpTheCreek
J'espère que nous atteindrons un point où les implémentations du navigateur contourneront automatiquement les instructions de la console, à moins que l'outil de débogage du navigateur ne soit activé.
faintsignal
2
Les réponses ci-dessous sont excellentes, mais vous n'avez pas à réinventer la roue sur celle-ci. Jetez un oeil à picolog . Il possède une API compatible avec la console (de NodeJS), vous pouvez donc l'utiliser comme remplacement de remplacement. Il prend en charge les niveaux de journalisation prêts à l'emploi, fonctionne dans le navigateur, sur NodeJS et sur Nashorn, peut être facilement configuré à partir de la chaîne de requête (navigateur) ou de la variable d'environnement PICOLOG_LEVEL(nœud) et il est super petit. Moins de 900 octets minifiés et zippés. Avertissement: je suis l'auteur.
Stijn de Witt
Il existe un moyen simple de remplacer toutes les consolefonctions. Regardez simplement stapp.space/disable-javascript-console-on-production
Piotr Stapp

Réponses:

427

Redéfinissez la fonction console.log dans votre script.

console.log = function() {}

Voilà, plus de messages à consoler.

ÉDITER:

Développer l'idée de Cide. Un enregistreur personnalisé que vous pouvez utiliser pour activer / désactiver la connexion à partir de votre code.

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

Comment utiliser l'enregistreur ci-dessus? Dans votre événement prêt, appelez logger.disableLogger pour que les messages de la console ne soient pas enregistrés. Ajoutez des appels à logger.enableLogger et logger.disableLogger dans la méthode pour laquelle vous souhaitez consigner des messages sur la console.

SolutionYogi
la source
Veuillez fournir des détails sur ce qui ne fonctionne pas? La ligne ci-dessus vous donne-t-elle une erreur? Si oui, quel est le message d'erreur?
SolutionYogi
1
Fonctionne pour moi dans IE8. ;-)
Eugene Lazutkin
Le code écrase et restaure la fonction console.log. Si IE7 prend en charge la méthode console.log, cela devrait fonctionner.
SolutionYogi
3
console.log = function () {} ne semble pas fonctionner dans Firefox. Vous obtenez toujours une erreur «la console n'est pas définie».
DA.
2
Quelle horrible solution. Modification console.log... Pourquoi ne pas simplement avoir une fonction booléenne et conditionnelle pour la journalisation?
Dementic
76

Ce qui suit est plus approfondi:

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 supprimera les méthodes courantes de la console si elles existent, et elles peuvent être appelées sans erreur et pratiquement sans surcharge de performances. Dans le cas d'un navigateur comme IE6 sans console, les méthodes factices seront créées pour éviter les erreurs. Bien sûr, il y a beaucoup plus de fonctions dans Firebug, comme trace, profil, heure, etc. Elles peuvent être ajoutées à la liste si vous les utilisez dans votre code.

Vous pouvez également vérifier si le débogueur possède ou non ces méthodes spéciales (c'est-à-dire IE) et mettre à zéro celles qu'il ne prend pas en charge:

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(){};
    }
}
mwilcox
la source
Cela a fonctionné parfaitement pour moi, même si je l'ai légèrement modifié, j'ai vérifié l'environnement (je veux seulement qu'il soit désactivé en production)
Muganwas
27

Pour autant que je sache dans la documentation , Firebug ne fournit aucune variable pour basculer l'état de débogage. Au lieu de cela, enveloppez console.log () dans un wrapper qui l'appelle conditionnellement, 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 à modifier 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);
    }
}
Cide
la source
1
Merci, bien que cela signifie que je dois réécrire toutes mes instructions console.log en debug.log.
Zack Burt
C'est la bonne façon de le faire - bien sûr si vous partez de zéro.
OpenSource
3
C'est aussi la bonne façon de le faire si vous avez une bonne fonction de recherche / remplacement dans votre éditeur.
BaroqueBobcat
2
Pas besoin d'écrire votre propre wrapper, btw, du moins si vous utilisez jQuery. Le plugin de débogage jQuery fonctionne très bien. En prime, il fournit une émulation de console.log sur les navigateurs sans lui. trainofoughtts.org/blog/2007/03/16/jquery-plugin-debug
Nelson
Le seul problème [mineur], bien sûr, est que vous devez installer un plugin. :) Bon à savoir, cependant - merci!
Cide
17

Tu ne devrais pas!

Ce n'est pas une bonne pratique d'écraser des fonctions intégrées. Il n'y a également aucune garantie que vous supprimerez toutes les sorties, les autres bibliothèques que vous utilisez peuvent annuler vos modifications et il existe 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 DEBUG_MODEvariable et vous connecter de manière conditionnelle. En fonction de la complexité et de la nature de votre code, il peut être judicieux d'écrire votre propre objet / fonction d'enregistreur qui entoure l'objet console et intègre cette capacité. Ce serait le bon endroit pour traiter de l' instrumentation .

Cela dit, à des fins de «test», vous pouvez écrire des tests au lieu d'imprimer sur la console. Si vous ne faites aucun test et que ces console.log()lignes n'étaient qu'une aide pour écrire votre code, supprimez-les simplement .

istepaniuk
la source
7
"other libraries you use may revert your changes": si je les désactive console.logau tout début, ils ne peuvent pas revenir à l'ancienne fonction. Eh bien, ils peuvent réécrire le console.logcode source, mais pourquoi? "it may be a good idea to write your own logger object/function that wraps around the console object": Je l'ai fait dans le passé et c'est une mauvaise idée. La trace de la sortie de la console fait référence à l'encapsuleur et non à la ligne qui l'invoque, ce qui rend le débogage plus difficile.
Marco Sulla
3
@LucasMalor "au tout début" implique que le code est couplé à cette infrastructure limitant ainsi sa réutilisabilité. Il est cependant difficile de généraliser; Un jeu, certaines animations DOM ne sont pas identiques à la logique de domaine à l'intérieur d'un SPA complexe, la dernière ne devrait pas être compatible avec le navigateur, sans parler de quelque chose appelé "console". Dans ce cas, vous devriez avoir une stratégie de test appropriée au lieu d'en pirater certains console.log('Look ma, it reaches this point');dans votre code, lorsque tout le reste échoue, vous pouvez en effet utiliser l' debugger;instruction.
istepaniuk
"the code is coupled to that infrastructure": le code probablement, mais pas le motif. Si vous créez un modèle de base commun pour vos pages où les fonctions de journalisation sont désactivées, c'est une logique que vous pouvez appliquer partout. "the later shouldn't be browser-aware": eh bien, vous ne devriez donc pas utiliser JS: P
Marco Sulla
3
@MarcoSulla Je pense qu'il commence à écrire du code plus propre. Dire ".... vous ne devriez pas utiliser JS" est un peu lourd. Idéalement, en tant que programmeur, quel que soit votre environnement, vous devez modulariser autant que possible; s'il ne se soucie pas des navigateurs, vous pouvez le déployer dans plus d'endroits: c'est une dépendance de moins à craindre de casser vos affaires. Donc, à mon humble avis, il a en fait raison. Gardez à l'esprit que vous avez commencé par dire "Si vous créez un modèle de base commun ...", ce qui introduit en soi une dépendance. Ce type de réflexion complique les logiciels. Nourriture pour la pensée.
dudewad
1
Adobe SiteCatalyics jette beaucoup de courrier indésirable dans ma console et rend le débogage compliqué dans certains cas. Donc, pouvoir désactiver temporairement console.log lorsque j'exécute un appel tiers serait très utile pour moi
spinn
16

Je me rends compte que c'est un ancien article, mais il apparaît toujours en haut des résultats de Google, alors voici une solution non jQuery plus élégante 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);
Joey Schooley
la source
12

Je sais que vous avez demandé comment désactiver console.log, mais c'est peut-être ce que vous recherchez vraiment. De cette façon, vous n'avez pas à activer ou désactiver explicitement la console. Il empêche simplement ces erreurs de console embêtantes 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() {};
}
Scott Greenfield
la source
2
Pour la désactivation de la journalisation spécifique à IE, voir la réponse de Chris S.
GuruM
11

DEBUGModifiez simplement l'indicateur pour remplacer la fonction console.log. Cela devrait faire l'affaire.

var DEBUG = false;
// ENABLE/DISABLE Console Logs
if(!DEBUG){
  console.log = function() {}
}
Swanidhi
la source
2
J'irais un peu plus loin et j'envelopperais cela dans une fonction / classe d'enregistreur. Quelque chose comme ça:function myLog(msg) { if (debug) { console.log(msg); } }
sleblanc
Si vous utilisez Angular, vous pouvez l'utiliser comme configuration globale dans votre fichier application.js et l'utiliser comme propriété globale pour activer / désactiver les journaux. N'oubliez pas que la console ne sera pas indéfinie si la barre d'outils des développeurs est ouverte dans IE.
Swanidhi
10

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

  • Pas de requête
  • Fonction anonyme pour ne pas polluer l'espace de noms global
  • Gérer le cas où window.console n'est pas défini
  • Modifiez simplement la fonction .log de la console

J'irais pour ça:

(function () {

    var debug = false

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

Après avoir également recherché ce problème et l'avoir essayé dans mon application cordova, je veux simplement avertir chaque développeur que Windows Phone ne doit pas écraser

    console.log

car l'application se bloque au démarrage.

Il ne plantera pas si vous développez local si vous êtes chanceux, mais le soumettre en magasin entraînera le crash de l'application.

Écraser

    window.console.log 

Si tu as besoin de.

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

    }
graphefruit
la source
Merci pour cet "avertissement". CEPENDANT, j'ai fait publier mon application basée sur cordova sur la boutique GooglePlay, je l'ai testée avec des appareils téléphoniques et tout allait bien. Je peux supposer que votre avertissement était limité à l'App Store "basé sur Windows"? ... CEPENDANT, il est conseillé de placer les ops dans le support try-catch au cas où il exploserait. D'où le pouce levé.
Panini Luncher
8

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

if (typeof console == "undefined" || typeof console.log == "undefined") 
{
   var console = { log: function() {} }; 
}
Chris S
la source
5

C'est un hybride de réponses de SolutionYogi et Chris S. Il maintient les numéros de ligne et le nom de fichier console.log. 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');
});
Justin
la source
3

J'ai utilisé ce qui suit pour régler le problème: -

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

Définissez le débogage sur 1 pour activer le débogage. Utilisez ensuite la fonction de journalisation 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");

utilisation

logger("my","log");
Michae Pavlos Michael
la source
3

J'ai utilisé l' enregistreur Winston plus tôt.

Aujourd'hui, j'utilise ci-dessous un code plus simple d'expérience:

  1. Définissez la variable d'environnement à partir de cmd / ligne de commande (sous Windows):

    cmd
    setx LOG_LEVEL info

Ou, vous pouvez avoir une variable dans votre code si vous le souhaitez, mais au-dessus c'est mieux.

  1. Redémarrez cmd / ligne de commande, ou, IDE / éditeur comme Netbeans

  2. Avoir ci-dessous comme le 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;
    }
  3. Utilisez maintenant toutes les consoles. * 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, en fonction de vos paramètres LOG_LEVEL définis au point 1 (comme, setx LOG_LEVEL log et redémarrer la ligne de commande), certains des éléments ci-dessus s'impriment, d'autres ne s'impriment pas

J'espère que cela a aidé.

Manohar Reddy Poreddy
la source
2

Attention: fiche sans vergogne!

Vous pouvez également utiliser quelque chose comme mon objet JsTrace pour avoir un suivi modulaire avec une capacité de "commutation" au niveau du module pour activer uniquement ce que vous voulez voir à ce moment-là.

http://jstrace.codeplex.com

(A également un package NuGet, pour ceux qui s'en soucient)

Tous les niveaux sont définis par défaut sur "erreur", mais vous pouvez les désactiver "off". Cependant, je ne vois pas pourquoi vous ne voudriez PAS voir d'erreurs

Vous pouvez les changer comme ceci:

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

Pour plus de documents, consultez la documentation

T

Tom McKearney
la source
2

J'ai trouvé un morceau de code un peu plus avancé dans cette URL. Astuce 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() {};
}
kikeenrique
la source
2

J'ai développé une bibliothèque pour ce cas d'utilisation: https://github.com/sunnykgupta/jsLogger

Fonctionnalités:

  1. Il remplace en toute sécurité le console.log.
  2. Prend soin si la console n'est pas disponible (oh oui, vous devez également en tenir compte.)
  3. Stocke tous les journaux (même s'ils sont supprimés) pour une récupération ultérieure.
  4. Poignées principales fonctions de la console comme log, warn, error, info.

Est ouvert aux modifications et sera mis à jour chaque fois que de nouvelles suggestions émergeront.

Sunny R Gupta
la source
2

Cela devrait remplacer toutes les méthodes de window.console. Vous pouvez le mettre tout en haut de votre section de scripts, et si vous êtes sur un framework PHP, vous ne pouvez imprimer ce code que lorsque votre environnement d'application est en production, ou si une sorte d'indicateur de débogage est désactivée. Ensuite, vous auriez tous vos journaux dans votre code travaillant sur des environnements de développement ou en mode 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);
agm-dev
la source
1

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, cela ne fonctionne pas en mode strict.

Donc, en utilisant console.fn.setEnabled = setEnabledet console.fn.setEnabled(false)fnpourrait être presque n'importe quelle fonction de console. Car votre cas serait:

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

J'ai aussi é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);

donc il vous suffit de mettre la FLAGSvaleur par défaut (avant d'exécuter le code ci-dessus), comme FLAGS.LOG = falseet la fonction de journal serait désactivée par défaut, et vous pourriez toujours l'activer en appelantconsole.log.setEnabled(true)

Gabriel De Oliveira Rohden
la source
pensez-vous que cela pourrait être utilisé pour activer le console.log dans l'environnement de production à la volée? comme la console Chrome ouverte, exécutez console.log.setEnabled(true)et commencez à voir les journaux
Rodrigo Assis
1
@RodrigoAssis oui, cela fonctionnera. J'ai créé cela juste pour ne pas perdre la ligne d'appel et l'activer n'importe où, mais ce n'est pas la meilleure façon de le faire. La meilleure façon pour les journaux est d'utiliser la manière de court-circuit comme: var debug = false; debug && console.log(1/3)parce que vous n'avez pas besoin d'évaluer le contenu du journal s'il n'est pas activé (dans ce cas 1/3ne sera pas évalué), ne perdez pas la ligne de l'appelant et pouvez activer facilement aussi (si ne variez pas comme consts).
Gabriel De Oliveira Rohden
1

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

Bien sûr, assurez-vous de l'inclure après avoir vérifié le contexte nécessaire. Par exemple, uniquement dans la version de production, il ne bombarde aucun autre composant crucial, 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");
})();

kmonsoor
la source
1

Si vous utilisez gulp, vous pouvez utiliser ce plugin:

Installez ce plugin avec la commande:

npm install gulp-remove-logging

Ensuite, ajoutez cette ligne à votre gulpfile:

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

Enfin, ajoutez les paramètres de configuration (voir ci-dessous) à votre gulpfile.

Configuration des tâches

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

Une simplification 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() {};
}
7ynk3r
la source
0

Vous pouvez utiliser javascript AOP (par exemple jquery-aop ) pour intercepter tous les appels à console.debug / log (autour) et ne pas procéder à l'appel réel si une variable globale est définie sur false.

Vous pouvez même faire un appel ajax (de temps en temps) afin de pouvoir modifier le comportement de journal activé / désactivé sur le serveur, ce qui peut être très intéressant pour activer le débogage face à un problème dans un environnement de transfert ou autre.

Stijn Geukens
la source
Je n'ai pas mis en œuvre une telle solution, je ne l'ai pas vue. C'est théorique jusqu'à présent.
Stijn Geukens
0

Vous pouvez utiliser logeek , il vous permet de contrôler la visibilité de vos messages de journal. Voici comment procéder:

<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 également logeek.show('nothing')désactiver totalement chaque message de journal.

Iman Mohamadi
la source
0

Après avoir fait quelques recherches et développements pour ce problème, je suis tombé sur cette solution qui masquera les avertissements / erreurs / journaux selon votre choix.

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

Ajoutez ce code avant le plugin JQuery (par exemple /../jquery.min.js) même s'il s'agit d'un code JavaScript qui ne nécessite pas JQuery. Parce que certains avertissements sont dans JQuery lui-même.

Merci!!

Sunny_Sid
la source
0

J'ai écrit une ES2015 solution (utiliser uniquement avec 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);
  }
}

La description:

  1. En plus de logger.enable et logger.disable, vous pouvez utiliser les méthodes console. ['Log', 'warn', 'error'] ainsi que la classe logger.
  2. En utilisant la classe logger pour afficher, activer ou désactiver les messages, le code est beaucoup plus propre et maintenable.
  3. Le code ci-dessous vous montre comment utiliser la classe logger:
    • logger.disable() - désactiver tous les messages de la console
    • logger.enable() - activer tous les messages de la console
    • logger.log('message1', 'message2') - fonctionne exactement comme console.log.
    • logger.warn('message1', 'message2') - fonctionne exactement comme console.warn.
    • logger.error('message1', 'message2')- fonctionne exactement comme console.error. Bon codage ..
Jaskaran Singh
la source