Compressez tous les fichiers .js avec l'application Google Closure Compiler dans un seul fichier

Je voudrais Compresser tous mes fichier .js dans un même répertoire dans un fichier avec Google Closure compiler en ligne de commande.

Pour un fichier c'est :

java -jar compiler.jar --js test.js --js_output_file final.js

Mais je n'ai pas trouvé dans la doc comment mettre mon autre fichier à la fin de final.js sans écrire sur le dernier fichier de compression ?

Je voudrais quelque chose comme ça :

java -jar compiler.jar --js --option *.js --js_output_file final.js

C'est possible ou je dois faire un programme qui ajouter tous les fichiers dans un fichier et ensuite le compresser ?
Je vous remercie si vous pouvez m'aider !

source d'informationauteur j3j3

java -jar path/to/closure-compiler/build/compiler.jar \ 
--js input_one.js \ 
--js input_two.js \ 
... \ 
--js_output_file compiled_output.js

7

J'ai essayé Orbites de réponse, mais Il n'a pas vraiment peut-être la version que j'utilise est une version plus récente. La commande que j'utilise est :
```
java -jar compiler.jar --js file1.js file2.js file3.js  --js_output_file --js_output_file compiled_output.js. 
```
6

En supposant que vous avez installé le Compilateur de Fermeture avec Homebrew sur un Mac, vous pouvez également concaténer tous les fichiers et ensuite la pipe à la Fermeture (cela devrait également travailler dans l' java -jar façon, mais je n'ai pas vérifié):
```
cat $(ls scripts/*.js) | closure-compiler --js_output_file main.js
```
2

Vous pouvez utiliser KjsCompiler: https://github.com/knyga/kjscompiler
. Compile plusieurs fichiers JavaScript avec Google Closure compiler l'application dans un bon ordre

Comment faire pour résoudre votre problème:
1. Ajouter des annotations à la js fichiers, comme ceci:

/** * @depends {lib/somefile.js} **/
Si vous ne vous souciez pas de la chaîne de compilation, vous pouvez ignorer cette étape.
2. java -jar kjscompile.jar

Vous pouvez regarder ici par exemple: https://github.com/knyga/kjscompiler/tree/master/examples
1

Voici cinq techniques d'expansion pour inclure plusieurs fichiers d'entrée, avec de la documentation extraite de la CommandLineRunner classe:

(1) C'est une variante de muka de la technique dele retrait de la --js drapeau, ce qui n'est pas nécessaire:
```
java -jar compiler.jar \
    --js_output_file build/out.js `find ./src/*.js`
```
De la documentation:

La --js nom d'option est facultative, car les arguments sont interprétées comme des fichiers par défaut.

Cela inclura toutes les .js fichiers dans /src/mais ne pas inclure tous les fichiers dans des sous-répertoires de /src/.

(2) Similaire à 1mais incluent également toutes .js fichiers dans /src/ et tous ses sous-répertoires:
```
java -jar compiler.jar \
    --js_output_file build/out.js `find ./src/-name '*.js'`
```
(3) Similaire à 2mais utilise xargs:
```
find ./src/ -name '*.js' \
    | xargs java -jar compiler.jar \
                --js_output_file build/out.js \
                --manage_closure_dependencies
```
De la documentation:
Il est commode de tirer parti de la arguments supplémentaires fonctionnalité lors de l'utilisation de la
Compilateur de fermeture en combinaison avec find et xargs:
```
find MY_JS_SRC_DIR -name '*.js' \
    | xargs java -jar compiler.jar --manage_closure_dependencies
```
La find commande permet d'obtenir une liste de"*.js fichiers source dans
le MY_JS_SRC_DIR répertoire tout en xargs va les convertir en
pour un seul, l'espace délimité par ensemble d'arguments qui sont ajoutés à l'
java commande pour exécuter le Compilateur.

Noter qu'il est important d'utiliser la
--manage_closure_dependencies option dans ce cas parce que le
commande produit par find est rare d'être triés correctement avec
le respect de goog.provide() et goog.requires().
(4) La v20140625
version a ajouté le support pour le ** (globstar générique, qui de manière récursive
correspond à toutes les sous-répertoires.

Par exemple, cela inclut toutes .js fichiers dans /src/ et tous ses sous-répertoires:
```
java -jar compiler.jar \
    --js_output_file build/out.js './src/**.js'
```
Plus d'infos ici. À partir de la documentation:
Vous pouvez également utiliser minimatch de style glob modèles. Par exemple, utiliser:
```
--js='**.js' --js='!**_test.js'
```
à inclure de manière récursive tous les fichiers js qui ne se terminent pas dans _test.js
De la Java docs:
Les règles suivantes sont utilisées pour interpréter glob motifs:
- La * caractère correspond à zéro ou plusieurs caractères d'un nom de composant sans franchir les limites de répertoire.
- La ** caractères correspond à zéro ou plusieurs caractères en traversant les limites de répertoire.
(5) La v20140625
communiqué a également ajouté une nouvelle fonctionnalité: si le chemin d'entrée est un répertoire, tous .js fichiers
dans ce répertoire et tous les sous-répertoires seront inclus.

Par exemple, cela inclut toutes .js fichiers dans /src/ et tous ses sous-répertoires:
```
java -jar compiler.jar \
    --js_output_file build/out.js './src/'
```
Plus d'infos ici.

    <exec executable="java">
        <arg line="-jar ../lib/compiler.jar --compilation_level SIMPLE_OPTIMIZATIONS --language_in ECMASCRIPT5 --js_output_file=${compressdir}/js/controllers/jscontrollersfiles.js ${webappdir}/js/controllers/*.js" />
    </exec>

Le github de google fermeture doc donne la commande ci-dessous.

Si vous avez plusieurs scripts, vous devez compiler tous ensemble avec une compilation de commande.

java -jar compiler.jar --js_output_file=out.js in1.js in2.js in3.js ...

Vous pouvez également utiliser minimatch de style globs.

# Recursively include all js files in subdirs
java -jar compiler.jar --js_output_file=out.js 'src/**.js'

# Recursively include all js files in subdirs, excluding test files.
# Use single-quotes, so that bash doesn't try to expand the '!'
java -jar compiler.jar --js_output_file=out.js 'src/**.js' '!**_test.js'

Source : https://github.com/google/closure-compiler#compiling-multiple-scripts

Vous devez vous connecter pour publier un commentaire.