Exclusion du code JavaScript de débogage pendant la minification

Question

Je cherche différentes façons de réduire mon code JavaScript, y compris la méthode habituelle. JSMin Packer, et YUI solutions. Je suis vraiment intéressé par le nouveau Compilateur Google Closure car il semble exceptionnellement puissant.

J'ai remarqué que Dean Edwards emballeur possède une fonction permettant d'exclure les lignes de code qui commencent par trois points-virgules. C'est pratique pour exclure le code de débogage. Par exemple :

;;;     console.log("Starting process");

Je passe un peu de temps à nettoyer ma base de code et j'aimerais ajouter des conseils comme celui-ci pour exclure facilement le code de débogage. Pour préparer cela, j'aimerais savoir si c'est la meilleure solution ou s'il existe d'autres techniques.

Comme je n'ai pas encore choisi le mode de minification, j'aimerais nettoyer le code de manière à ce qu'il soit compatible avec le minificateur que je choisirai. Mes questions sont donc les suivantes :

1. L'utilisation des points-virgules est-elle une technique standard, ou existe-t-il d'autres façons de procéder ?

2. Packer est-il la seule solution qui offre cette fonctionnalité ?

3. Les autres solutions peuvent-elles être adaptées pour fonctionner de cette façon également, ou ont-elles d'autres moyens d'y parvenir ?

4. Je vais probablement commencer à utiliser Closure Compiler éventuellement. Y a-t-il quelque chose que je devrais faire maintenant pour m'y préparer ?

Answer 1

Voici la réponse (ultime) pour le compilateur de fermeture :

/** @const */
var LOG = false;
...
LOG && log('hello world !'); // compiler will remove this line
...

cela fonctionnera même avec SIMPLE_OPTIMIZATIONS et non --define= est nécessaire !

Answer 2

Voici ce que j'utilise avec Closure Compiler. D'abord, vous devez définir une variable DEBUG comme ceci :

/** @define {boolean} */
var DEBUG = true;

Il utilise l'annotation JS pour la fermeture, que vous pouvez lire à ce sujet dans la documentation .

Maintenant, si vous voulez du code de débogage uniquement, il suffit de l'inclure dans une instruction if, comme ceci :

if (DEBUG) {
  console.log("Running in DEBUG mode");
}

Lorsque vous compilez votre code pour la version, ajoutez les éléments suivants à votre commande de compilation : --define='DEBUG=false' -- tout code contenu dans la déclaration de débogage sera complètement laissé de côté dans le fichier compilé.

Answer 3

Une bonne solution dans ce cas pourrait être js-build-tools qui prend en charge la "compilation conditionnelle".

En bref, vous pouvez utiliser des commentaires tels que

// #ifdef debug
var trace = debug.getTracer("easyXDM.Rpc");
trace("constructor");
// #endif

où vous définissez un pragma tel que debug .

Ensuite, lors de sa construction (il a une tâche ant)

//this file will not have the debug code
<preprocess infile="work/easyXDM.combined.js" outfile="work/easyXDM.js"/>
//this file will        
<preprocess infile="work/easyXDM.combined.js" outfile="work/easyXDM.debug.js" defines="debug"/>

Answer 4

Si vous utilisez le compilateur de fermetures en mode avancé, vous pouvez faire quelque chose comme :

if (DEBUG) console.log = function() {}

Le compilateur supprimera alors tous vos appels à console.log. Bien sûr, vous devez --define la variable DEBUG dans la ligne de commande.

Cependant, cela ne concerne que Mode avancé . Si vous utilisez le mode simple, vous devrez exécuter un préprocesseur sur votre fichier source.

Pourquoi ne pas envisager la boîte à outils Dojo ? Il possède des pragmes intégrés basés sur les commentaires pour inclure/exclure des sections de code en fonction d'une construction. De plus, il est compatible avec le compilateur Closure en mode avancé (voir le lien ci-dessous) !

http://dojo-toolkit.33424.n3.nabble.com/file/n2636749/Using_the_Dojo_Toolkit_with_the_Closure_Compiler.pdf?by-user=t

Answer 5

Même si c'est une vieille question. Je suis tombé sur le même problème aujourd'hui et j'ai découvert qu'il est possible d'y parvenir en utilisant les éléments suivants Options du compilateur .

J'ai suivi ce fil .

Nous exécutons le compilateur, à partir de Java, sur notre serveur avant d'envoyer le code au client. Cela a fonctionné pour nous en mode simple.

private String compressWithClosureCompiler(final String code) {
    final Compiler compiler = new Compiler();
    final CompilerOptions options = new CompilerOptions();
    Logger.getLogger("com.google.javascript.jscomp").setLevel(Level.OFF);
    if (compressRemovesLogging) {
        options.stripNamePrefixes = ImmutableSet.of("logger");
        options.stripNameSuffixes = ImmutableSet.of("debug", "dev", "info", "error",
                "warn", "startClock", "stopClock", "dir");
    }
    CompilationLevel.SIMPLE_OPTIMIZATIONS.setOptionsForCompilationLevel(options);

    final JSSourceFile extern = JSSourceFile.fromCode("externs.js", "");
    final JSSourceFile input = JSSourceFile.fromCode("input.js", code);
    compiler.compile(extern, input, options);
    return compiler.toSource();
}

Cela supprimera tous les appels à logger.debug, logger.dev...etc.etc...