suchen

Heim  >  Artikel  >  Web-Frontend  >  JS-Dateien komprimieren und analysieren – die chinesische Dokumentation von UglifyJS3 erklärt ausführlich

JS-Dateien komprimieren und analysieren – die chinesische Dokumentation von UglifyJS3 erklärt ausführlich

php是最好的语言
php是最好的语言Original
2018-08-04 09:39:282460Durchsuche

UglifyJS Chinesisches Dokument

Dieses Dokument wurde aus dem UglifyJS3-Dokument übersetzt.

Die zuvor übersetzte chinesische UglifyJS2-Dokumentation wurde in den UglifyJS2-Zweig dieses Projekts verschoben.

Übersetzungssequenz

Da das Webpack selbst das UglifyJS-Plugin (webpack.optimize.UglifyJsPlugin) integriert, bedeutet sein Befehl webpack -p, dass UglifyJS aufgerufen wird, um den Code zu komprimieren. Es gibt auch viele Webpack-Plugins -ins wie html-webpack-plugin UglifyJS werden ebenfalls standardmäßig verwendet. Daher verwenden wir es tatsächlich oft, aber UglifyJS selbst hat eine komplizierte Konfiguration/viele Optionen und es gibt keine chinesische Dokumentation, was die Verwendung verwirrend macht. Da die Übersetzung dieses Artikels viele Fehler enthält, korrigieren Sie mich bitte.

Wörterbuch: 

parse       解释
compress    压缩
mangle      混淆
beautify    美化
minify      最小化
CLI         命令行工具
sourcemap   编译后代码对源码的映射，用于网页调试
AST         抽象语法树
name        名字，包括变量名、函数名、属性名
toplevel    顶层作用域
unreachable 不可达代码
option      选项/配置
STDIN       标准输入，指在命令行中直接输入
STDOUT      标准输出
STDERR      标准错误输出
side effects函数副作用，即函数除了返回外还产生别的作用，比如改了全局变量
shebang     释伴（#!）

Das Folgende ist der Text:

UglifyJS 3

UglifyJS ist ein JS-Interpreter, Minimierer, Kompressor und Verschönerungstool-Set ( Parser, Minifier, Kompressor oder Beautifier-Toolkit).

Hinweis: Die API und CLI von

  • uglify-js@3 wurden vereinfacht und sind nicht mehr abwärtskompatibel uglify-js@2.

  • UglifyJS 2.x Dokumentation hier.

  • uglify-js Unterstützt nur ECMAScript 5 (ES5).

  • Wenn Sie ES2015+ (ES6+)-Code komprimieren möchten, sollten Sie das Paket uglify-es verwenden. npm

Installation

Stellen Sie zunächst sicher, dass Sie die neueste node.js installiert haben (möglicherweise müssen Sie Ihren Computer nach der Installation neu starten)

Installation mit NPM CLI: 

npm install uglify-js -g

Verwenden Sie NPM zum Herunterladen in das Programm:

npm install uglify-js

CLI-Verwendung

Befehlszeilenverwendung

 uglifyjs [input files] [options]

UglifyJS kann mehrere Dateien eingeben. Es wird empfohlen, zuerst die Eingabedatei zu schreiben und dann die Optionen zu übergeben. UglifyJS stellt die Dateien in die Warteschlange und interpretiert sie der Reihe nach entsprechend den Komprimierungsoptionen. Alle Dateien befinden sich in derselben globalen Domäne. Wenn Variablen und Methoden in einer Datei von einer anderen Datei referenziert werden, passt UglifyJS sie angemessen an.

Wenn keine Datei angegeben ist, liest UglifyJS die Eingabezeichenfolge (STDIN).

Wenn Sie Optionen vor den Dateinamen schreiben möchten, fügen Sie vor den beiden einen doppelten Bindestrich ein, um zu verhindern, dass der Dateiname als Option betrachtet wird: 

 uglifyjs --compress --mangle -- input.js

CLI-Optionen:

Befehlszeilenoptionen

  -h, --help                  列出使用指南。
                              `--help options` 获取可用选项的详情。
  -V, --version               打印版本号。
  -p, --parse <options>       指定解析器配置选项:
                              `acorn`  使用 Acorn 来解析。
                              `bare_returns`  允许在函数外return。
                                              在压缩CommonJS模块或`.user.js `引擎调用被同步执行函数包裹的用户脚本 时会用到。
                              `expression`  不是解析文件，二是解析一段表达式 (例如解析JSON).
                              `spidermonkey`  输入文件是 SpiderMonkey
                                              AST 格式 (JSON).
  -c, --compress [options]    启用压缩（true/false）/指定压缩配置:
                              `pure_funcs`  传一个函数名的列表，当这些函数返回值没被利用时，该函数会被安全移除。
  -m, --mangle [options]       启用混淆（true/false）/指定混淆配置:
                              `reserved`  不被混淆的名字列表。
  --mangle-props [options]    混淆属性/指定压缩配置:
                              `builtins`  混淆那些与标准JS全局变量重复的名字。
                              `debug`  添加debug前缀和后缀。
                              `domprops`  混淆那些鱼DOM属性名重复的名字。
                              `keep_quoted`  只混淆没括起来的属性名。
                              
                              `regex`  只混淆匹配（该正则）的名字。
                              `reserved`  不需要混淆的名字的列表（即保留）。
  -b, --beautify [options]    是否美化输出（true/false）/指定输出配置：
                              `beautify`  默认是启用.
                              `preamble`  预设的输出文件头部。你可以插入一段注释，比如版权信息。它不会被解析，但sourcemap会因此调整。
                              `quote_style`  括号类型:
                                              0 - auto自动
                                              1 - single单引号
                                              2 - double双引号
                                              3 - original跟随原码
                              `wrap_iife`  把立即执行函数括起来。注意：你或许应禁用压缩配置中的`negate_iife`选项。 

 -o, --output <file>         输出文件路径 (默认 STDOUT). 指定 `ast` 或
                                `spidermonkey`的话分别是输出UglifyJS或SpiderMonkey AST。
    --comments [filter]         保留版权注释。默认像Google Closure那样，保留包含"@license"或"@preserve"这样JSDoc风格的注释。你可以传以下的参数：
                                - "all" 保留全部注释
                                - 一个合适的正则，如 `/foo/` 或 `/^!/`，保留匹配到的注释。 
                                注意，在启用压缩时，因为死代码被移除或压缩声明为一行，并非*所有*的注释都会被保留。
    --config-file <file>        从此JSON文件读取 `minify()` 配置。
    -d, --define <expr>[=value] 定义全局变量。
    --ie8                       支持IE8。
                                等同于在`minify()`的`compress`、 `mangle` 和 `output`配置设置`ie8: true`。UglifyJS不会默认兼容IE8。
    --keep-fnames               不要混淆、干掉的函数的名字。当代码依赖Function.prototype.name时有用。
    --name-cache <file>         用来保存混淆map的文件。
    --self                      把UglifyJS本身也构建成一个依赖包
                                (等同于`--wrap UglifyJS`)
    --source-map [options]      启用 source map（true/false）/指定sourcemap配置:
                                `base` 根路径，用于计算输入文件的相对路径。
                                `content`  输入sourcemap。假如的你要编译的JS是另外的源码编译出来的。
                                假如该sourcemap包含在js内，请指定"inline"。 
                                `filename`  输出文件的名字或位置。
                                `includeSources`  如果你要在sourcemap中加上源文件的内容作sourcesContent属性，就传这个参数吧。
                                `root`  此路径中的源码编译后会产生sourcemap.
                                `url`   如果指定此值，会添加sourcemap相对路径在`//#sourceMappingURL`中。
    --timings                   在STDERR显示操作运行时间。
    --toplevel                  压缩/混淆在最高作用域中声明的变量名。
    --verbose                   打印诊断信息。
    --warn                      打印警告信息。
    --wrap <name>               把所有代码包裹在一个大函数中。让“exports”和“global”变量有效。
                                你需要传一个参数来指定此模块的名字，以便浏览器引用。

Geben Sie

(--output) an, um die Datei explizit auszugeben, andernfalls erfolgt die Ausgabe (STDOUT) im Terminal -o

CLI-Sourcemap-Option

CLI-Quellzuordnungsoptionen

UglifyJS kann eine Quellzuordnungsdatei generieren, die Ihnen beim Debuggen des komprimierten JS-Codes sehr hilfreich ist. Übergeben Sie

, um die Sorcemap-Datei abzurufen (Sorcemap wird als --source-map --output output.js generiert). output.js.map

Zusätzliche Optionen:

  • Geben Sie den Namen der Quellkarte an. --source-map filename=244f00a3349fd07fa67e97687a6da12c

  • Übergeben Sie den Pfad einer Quelldatei. Andernfalls geht UglifyJS davon aus, dass HTTP --source-map root=258c40d94d8689854ad79c4076dd5f96 verwendet wurde, und lässt die X-SourceMap-Direktive weg. //＃sourceMappingURL=

  • Geben Sie den Pfad zum Generieren der Quellkarte an. --source-map url=258c40d94d8689854ad79c4076dd5f96

Zum Beispiel: 

    uglifyjs js/file1.js js/file2.js \
             -o foo.min.js -c -m \
             --source-map root="http://foo.com/src",url=foo.min.js.map

Die obige Konfiguration komprimiert und verschleiert

, file1.js, Ausgabedateien file2.js und Sourcemap foo.min.js, Sourcemap wird erstellt werden und foo.min.js.map. (Tatsächlich ist das Stammverzeichnis der Quellkarte http://foo.com/src/js/file1.js, daher sind die entsprechenden Quelldateipfade http://foo.com/src/js/file2.js, http://foo.com/src) js/file1.jsjs/file2.jsZugehörige Quellkarte

Zusammengesetzte Quellkarte

Wenn Ihr JS-Code mit einem anderen Compiler (z. B. Coffeescript) generiert wird, ist die Zuordnung zum JS-Code nutzlos und Sie möchten auf jeden Fall eine Zuordnung zum CoffeeScript-Quellcode vornehmen. UglifyJS verfügt über eine Option zur Eingabe von Quellcode. Wenn Sie eine Zuordnung von CoffeeScript → Compiled JS haben, kann UglifyJS eine Zuordnung von CoffeeScript->Compressed JS zum Quellcodespeicherort generieren.

Sie können

übergeben oder, um diese Funktion auszuprobieren, wenn die Quellkarte in js enthalten ist, schreiben Sie

. --source-map content="/path/to/input/source.map"--source-map content=inlineCLI-Mangle-Optionen

CLI-Mangle-Optionen

Sie müssen

(

) übergeben, um die Verschleierungsfunktion zu aktivieren. Die folgenden Optionen werden unterstützt (durch Kommas getrennt): --mangle-m

  • – im höchsten Bereich deklarierte Variablennamen verschleiern (standardmäßig deaktiviert)

    toplevel

  • – Variablennamen verschleiern, die im Bereich

    oder eval erscheinen (standardmäßig deaktiviert) evalwith

    • Wenn die Verschleierung aktiviert ist und Sie verhindern möchten, dass einige Namen verschleiert werden, können Sie
verwenden, um einige Namen zu deklarieren (durch Kommas getrennt). Zum Beispiel: 

 uglifyjs ... -m reserved=[$,require,exports]&#39;
--mangle reserved Dadurch wird verhindert, dass

,

und require verwechselt und geändert werden. exports

CLI混淆属性名 (--mangle-props)

CLI mangling property names (--mangle-props)

**警告：**这能会搞崩你的代码。混淆属性名跟混淆变量名不一样，是相互独立的。传入--mangle-props会混淆对象所有可见的属性名，除了DOM属性名和JS内置的类名。例如：

// example.js
var x = {
    baz_: 0,
    foo_: 1,
    calc: function() {
        return this.foo_ + this.baz_;
    }
};
x.bar_ = 2;
x["baz_"] = 3;
console.log(x.calc());

混淆所有属性（除了JS内置的）:

$ uglifyjs example.js -c -m --mangle-props
var x={o:0,_:1,l:function(){return this._+this.o}};x.t=2,x.o=3,console.log(x.l());

混淆除了 reserved （保留）外的所有属性:

$ uglifyjs example.js -c -m --mangle-props reserved=[foo_,bar_]
var x={o:0,foo_:1,_:function(){return this.foo_+this.o}};x.bar_=2,x.o=3,console.log(x._());

混淆匹配regex（正则）的属性：

$ uglifyjs example.js -c -m --mangle-props regex=/_$/
var x={o:0,_:1,calc:function(){return this._+this.o}};x.l=2,x.o=3,console.log(x.calc());

混用多个混淆属性选项：

$ uglifyjs example.js -c -m --mangle-props regex=/_$/,reserved=[bar_]
var x={o:0,_:1,calc:function(){return this._+this.o}};x.bar_=2,x.o=3,console.log(x.calc());

为了混淆正常使用，我们默认避免混淆标准JS内置的名字（--mangle-props builtins可以强制混淆）。

tools/domprops.json 里有一个默认的排除名单，包括绝大部分标准JS和多种浏览器中的DOM属性名。传入--mangle-props domprops 可以让此名单失效。

可以用正则表达式来定义该混淆的属性名。例如--mangle-props regex=/^_/，只混淆下划线开头的属性。

当你压缩多个文件时，为了保证让它们最终能同时工作，我们要让他们中同样的属性名混淆成相同的结果。传入--name-cache filename.json，UglifyJS会维护一个共同的映射供他们复用。这个json一开始应该是空的，例如：

$ rm -f /tmp/cache.json  # start fresh
$ uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js
$ uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js

这样part1.js 和 part2.js会知晓对方混淆的属性名。

假如你把所有文件压缩成同一个文件，那就不需要启用名字缓存了。

混淆没括起来的名字(--mangle-props keep_quoted)

Mangling unquoted names (--mangle-props keep_quoted)

使用括号属性名 (o["foo"])以保留属性名(foo)。这会让整个脚本中其余此属性的引用(o.foo)也不被混淆。例如：

// stuff.js
var o = {
    "foo": 1,
    bar: 3
};
o.foo += o.bar;
console.log(o.foo);
$ uglifyjs stuff.js --mangle-props keep_quoted -c -m
var o={foo:1,o:3};o.foo+=o.o,console.log(o.foo);

调试属性名混淆

Debugging property name mangling

为了混淆属性时不至于完全分不清，你可以传入--mangle-props debug来调试。例如o.foo会被混淆成o._$foo$_。这让源码量大、属性被混淆时也可以debug，可以看清混淆会把哪些属性搞乱。

$ uglifyjs stuff.js --mangle-props debug -c -m
var o={_$foo$_:1,_$bar$_:3};o._$foo$_+=o._$bar$_,console.log(o._$foo$_);

你可以用--mangle-props-debug=XYZ来传入自定义后缀。让o.foo 混淆成 o._$foo$XYZ_， 你可以在每次编译是都改变一下，来辨清属性名怎么被混淆的。一个小技巧，你可以每次编译时传随机数来模仿混淆操作（例如你更新了脚本，有了新的属性名），这有助于识别混淆时的出错。

API参考

API Reference

假如是通过NPM安装的，你可以在你的应用中这样加载UglifyJS：

var UglifyJS = require("uglify-js");

这输出一个高级函数**minify(code, options)**，它能根据配置，实现多种最小化（即压缩、混淆等）。 minify()默认启用压缩和混淆选项。例子：

var code = "function add(first, second) { return first + second; }";
var result = UglifyJS.minify(code);
console.log(result.error); // runtime error, or `undefined` if no error
console.log(result.code);  // minified output: function add(n,d){return n+d}

你可以通过一个对象（key为文件名，value为代码）来同时最小化多个文件：

var code = {
    "file1.js": "function add(first, second) { return first + second; }",
    "file2.js": "console.log(add(1 + 2, 3 + 4));"
};
var result = UglifyJS.minify(code);
console.log(result.code);
// function add(d,n){return d+n}console.log(add(3,7));

toplevel选项例子：

var code = {
    "file1.js": "function add(first, second) { return first + second; }",
    "file2.js": "console.log(add(1 + 2, 3 + 4));"
};
var options = { toplevel: true };
var result = UglifyJS.minify(code, options);
console.log(result.code);
// console.log(3+7);

nameCache 选项例子:

var options = {
    mangle: {
        toplevel: true,
    },
    nameCache: {}
};
var result1 = UglifyJS.minify({
    "file1.js": "function add(first, second) { return first + second; }"
}, options);
var result2 = UglifyJS.minify({
    "file2.js": "console.log(add(1 + 2, 3 + 4));"
}, options);
console.log(result1.code);
// function n(n,r){return n+r}
console.log(result2.code);
// console.log(n(3,7));

你可以像下面这样把名字缓存保存在文件中：

var cacheFileName = "/tmp/cache.json";
var options = {
    mangle: {
        properties: true,
    },
    nameCache: JSON.parse(fs.readFileSync(cacheFileName, "utf8"))
};
fs.writeFileSync("part1.js", UglifyJS.minify({
    "file1.js": fs.readFileSync("file1.js", "utf8"),
    "file2.js": fs.readFileSync("file2.js", "utf8")
}, options).code, "utf8");
fs.writeFileSync("part2.js", UglifyJS.minify({
    "file3.js": fs.readFileSync("file3.js", "utf8"),
    "file4.js": fs.readFileSync("file4.js", "utf8")
}, options).code, "utf8");
fs.writeFileSync(cacheFileName, JSON.stringify(options.nameCache), "utf8");

综合使用多种minify()选项的例子：

var code = {
    "file1.js": "function add(first, second) { return first + second; }",
    "file2.js": "console.log(add(1 + 2, 3 + 4));"
};
var options = {
    toplevel: true,
    compress: {
        global_defs: {
            "@console.log": "alert"
        },
        passes: 2
    },
    output: {
        beautify: false,
        preamble: "/* uglified */"
    }
};
var result = UglifyJS.minify(code, options);
console.log(result.code);
// /* uglified */
// alert(10);"

生成警告提示：

var code = "function f(){ var u; return 2 + 3; }";
var options = { warnings: true };
var result = UglifyJS.minify(code, options);
console.log(result.error);    // runtime error, `undefined` in this case
console.log(result.warnings); // [ &#39;Dropping unused variable u [0:1,18]&#39; ]
console.log(result.code);     // function f(){return 5}

生成错误提示：

var result = UglifyJS.minify({"foo.js" : "if (0) else console.log(1);"});
console.log(JSON.stringify(result.error));
// {"message":"Unexpected token: keyword (else)","filename":"foo.js","line":1,"col":7,"pos":7}

Note: unlike uglify-js@2.x, the 3.x API does not throw errors. To achieve a similar effect one could do the following:

var result = UglifyJS.minify(code, options);
if (result.error) throw result.error;

最小化选项

Minify options

  • warnings (default false) — 传 true的话，会在result.warnings中返回压缩过程的警告。传 "verbose"获得更详细的警告。

  • parse (default {}) — 如果你要指定额外的解析配置parse options,传配置对象。

  • compress (default {}) — 传false就完全跳过压缩。传一个对象来自定义 压缩配置compress options。

  • mangle (default true) — 传 false就跳过混淆名字。传对象来指定混淆配置mangle options (详情如下).

  • mangle.properties (default false) — 传一个对象来自定义混淆属性配置mangle property options.

    • output (default null) — 要自定义就传个对象来指定额外的 输出配置output options. 默认是压缩到最优化。

  • sourceMap (default false) - 传一个对象来自定义 sourcemap配置source map options.

  • toplevel (default false) - 如果你要混淆（和干掉没引用的）最高作用域中的变量和函数名，就传true。

  • nameCache (default null) - 如果你要缓存 minify()多处调用的经混淆的变量名、属性名，就传一个空对象{}或先前用过的nameCache对象。 注意:这是个可读/可写属性。minify()会读取这个对象的nameCache状态，并在最小化过程中更新，以便保留和供用户在外部使用。

  • ie8 (default false) - 传 true 来支持 IE8.

最小化配置的结构

Minify options structure

{
    warnings: false,
    parse: {
        // parse options
    },
    compress: {
        // compress options
    },
    mangle: {
        // mangle options

        properties: {
            // mangle property options
        }
    },
    output: {
        // output options
    },
    sourceMap: {
        // source map options
    },
    nameCache: null, // or specify a name cache object
    toplevel: false,
    ie8: false,
}

sourcemap配置

Source map options

这样生成sourcemap：

var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
    sourceMap: {
        filename: "out.js",
        url: "out.js.map"
    }
});
console.log(result.code); // minified output
console.log(result.map);  // source map

要注意，此时sourcemap并不会保存为一份文件，它只会返回在result.map中。 sourceMap.url 传入的值只用来在result.code中设置//# sourceMappingURL=out.js.map ，filename 的值只用来在sourcemap文件中设置 file属性(详情看 规范)。

你可以把sourceMap.url设为true ，这样sourcemap会加在代码末尾。

你也可以指定sourcemap中的源文件根目录（sourceRoot）属性：

var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
    sourceMap: {
        root: "http://example.com/src",
        url: "out.js.map"
    }
});

如果你要压缩从其他文件编译得来的带一份sourcemap的JS文件，你可以用sourceMap.content参数：

var result = UglifyJS.minify({"compiled.js": "compiled code"}, {
    sourceMap: {
        content: "content from compiled.js.map",
        url: "minified.js.map"
    }
});
// same as before, it returns `code` and `map`

如果你要用X-SourceMap请求头，你可以忽略 sourceMap.url。

解析配置

Parse options

  • bare_returns (default false) -- 支持在顶级作用域中 return 声明。

  • html5_comments (default true)

  • shebang (default true) -- 支持在第一行用 #!command

压缩配置

Compress options

  • sequences(default: true) -- 连续声明变量，用逗号隔开来。可以设置为正整数来指定连续声明的最大长度。如果设为true 表示默认200个，设为false或0则禁用。 sequences至少要是2,1的话等同于true（即200)。默认的sequences设置有极小几率会导致压缩很慢，所以推荐设置成20或以下。

  • properties -- 用.来重写属性引用，例如foo["bar"] → foo.bar

  • dead_code -- 移除没被引用的代码

  • drop_debugger -- 移除 debugger;

  • unsafe (default: false) -- 使用 "unsafe"转换 (下面详述)

  • unsafe_comps (default: false) -- 保留6d031c2184dc753521b5b9bb3e278389 和 >=。假如某些运算对象是用get或 valueOfobject得出的时候，转换可能会不安全，可能会引起运算对象的改变。此选项只有当 comparisons和unsafe_comps 都设为true时才会启用。

  • unsafe_Func (default: false) -- 当 Function(args, code)的args 和 code都是字符串时，压缩并混淆。

  • unsafe_math (default: false) -- 优化数字表达式，例如2 * x * 3 变成 6 * x, 可能会导致不精确的浮点数结果。

  • unsafe_proto (default: false) -- 把Array.prototype.slice.call(a) 优化成 [].slice.call(a)

  • unsafe_regexp (default: false) -- 如果RegExp 的值是常量，替换成变量。

  • conditionals – Optimieren Sie Urteile wie if und Bedingungsauswahl
  • comparisons – Optimieren Sie Operationen mit unvermeidlichen Ergebnissen in binäre Operationen wie !(a 4fa1384b0656ffaecf93a77cabf1ffe5 b (nur wenn unsafe_comps ist). set Es wird nur wirksam); versuchen Sie es in „Keine Operation“ umzuwandeln. Zum Beispiel a = !b && !c && !d && !e → a=!(b||c||d||e)

  • evaluate – versuchen Sie, den konstanten Ausdruck auszuwerten.

  • booleans – optimieren Sie den Booleschen Wert Operationen, zum Beispiel !!a? b : c → a ? b : c

  • typeofs – Standardmäßig true in typeof foo == "undefined" konvertieren oder niedriger, da dies der Fall ist. Bei unbekannten Fragen wird empfohlen, es auf foo === void 0 zu setzen. false

  • – Wenn die Beurteilungsbedingungen der Schleifen loops, do und while bestimmt werden können, optimieren Sie sie. for

  • – Entfernen Sie nicht referenzierte Funktionen und Variablen. (Solange unused nicht festgelegt ist, wird eine einfache direkte Zuweisung einer Variablen nicht als Referenz gezählt.) "keep_assign"

  • – Töte Funktionen, auf die in nicht verwiesen wird der Gültigkeitsbereich der obersten Ebene (toplevel) und/oder Variablen ("funcs") (der Standardwert ist "vars", wenn false alle Funktionsvariablen gelöscht werden) true

  • - - Wenn top_retain festgelegt ist, behalten Sie bestimmte Funktionsvariablen im Bereich der obersten Ebene bei. (Kann als Array, durch Kommas getrennt oder mit regulären Ausdrücken oder Funktionen geschrieben werden. Siehe unused) toplevel

  • – Boost-Funktionsdeklaration hoist_funs

  • (Standard: false) – hoist_vars-Deklaration fördern (Standard ist var, da dadurch die Dateigröße erhöht wird) false

  • -- if/return und if/continue optimierenif_return

  • -- Einfache Funktionen umschließen. inline

  • – aufeinanderfolgende join_vars Deklarationen zusammenführen var

  • – schwach optimierte kontinuierliche Deklaration wandeln Sie sofort cascade in x, x, x in x = something(), xx = something()

  • um – wenn collapse_vars und var bei alleiniger Verwendung Versuchen Sie, const

  • zusammenzuführen, um die Situation zu optimieren, in der einige Variablen tatsächlich zugewiesen und als konstante Werte verwendet werden. reduce_vars

  • – Zeigt eine Warnung an, wenn nutzloser Code gelöscht wird. warnings

  • – Bei der Rückkehr Wenn der Wert einer sofort ausgeführten Funktion (IIFE) nicht mehr nützlich ist, brechen Sie ihn ab. Vermeiden Sie das Einfügen von Klammern durch den Codegenerator. negate_iife

  • – Standard ist pure_getters. Wenn Sie false übergeben, geht UglifyJS von einem Verweis auf eine Objekteigenschaft aus (z. B. true oder). foo.bar ) hat keine funktionellen Nebenwirkungen. foo["bar"]

  • – Standard pure_funcs Sie können ein Array von Namen übergeben und UglifyJS geht davon aus, dass diese Funktionen keine Funktionsnebeneffekte haben. **WARNUNG:** Wenn der Name im Gültigkeitsbereich neu definiert wird, wird er nicht erneut überprüft. Wenn beispielsweise null nicht auf die Variable var q = Math.floor(a/b) verwiesen wird, wird sie von UglifyJS gelöscht, q bleibt jedoch erhalten und niemand weiß, was sie tut. Sie können Math.floor(a/b) so festlegen, dass davon ausgegangen wird, dass die Funktion keine Funktionsnebenwirkungen hat und die gesamte Deklaration verworfen wird. In der aktuellen Implementierung erhöht dies den Overhead (die Komprimierung wird langsamer sein). pure_funcs: [ 'Math.floor' ]

  • – Die Standardeinstellung ist drop_console, wodurch die Funktion false beendet wird. Wenn Sie eine bestimmte Funktion wie true entfernen möchten und die Nebenwirkungen in ihren Parametern nach dem Löschen beibehalten möchten, verwenden Sie console.*, um damit umzugehen. console.infopure_funcs

  • – Standard

    . Übergeben Sie expression, um Abschlusswerte in Terminalanweisungen ohne „return“ beizubehalten. Zum Beispiel in Bookmarklets. falsetrue

  • – Standard

    . Verhindert, dass der Kompressor nicht verwendete Funktionsargumente entfernt. Sie benötigen es, um bestimmte Funktionen zu schützen, die von keep_fargs abhängen. trueFunction.length

  • – Standard

    . Übergeben Sie keep_fnames, um zu verhindern, dass der Kompressor den Funktionsnamen beendet. Nützlich für Funktionen, die auf false basieren. Erweiterte Lektüre: trueVerschleierungsoptionen.Function.prototype.namekeep_fnames
  • passes -- 默认 1。运行压缩的次数。在某些情况下，用一个大于1的数字参数可以进一步压缩代码大小。注意：数字越大压缩耗时越长。

  • keep_infinity -- 默认 false。传true以防止压缩时把1/0转成Infinity，那可能会在chrome上有性能问题。

  • side_effects -- 默认 true. 传false禁用丢弃纯函数。如果一个函数被调用前有一段/*@__PURE__*/ or /*#__PURE__*/注释，该函数会被标注为纯函数。例如 /*@__PURE__*/foo();

混淆配置

Mangle options

  • reserved (default [])。 传一个不需要混淆的名字的数组。 Example: ["foo", "bar"].

  • toplevel (default false)。混淆那些定义在顶层作用域的名字（默认禁用）。ß

  • keep_fnames(default false)。传true的话就不混淆函数名。对那些依赖Function.prototype.name的代码有用。延展阅读：keep_fnames 压缩配置.

  • eval (default false)。混淆那些在with或eval中出现的名字。

// test.js
var globalVar;
function funcName(firstLongName, anotherLongName) {
    var myVariable = firstLongName +  anotherLongName;
}
var code = fs.readFileSync("test.js", "utf8");

UglifyJS.minify(code).code;
// &#39;function funcName(a,n){}var globalVar;&#39;

UglifyJS.minify(code, { mangle: { reserved: [&#39;firstLongName&#39;] } }).code;
// &#39;function funcName(firstLongName,a){}var globalVar;&#39;

UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
// &#39;function n(n,a){}var a;&#39;

混淆属性的配置

Mangle properties options

  • reserved (default: []) -- 不混淆在reserved 数组里的属性名.

    regex (default: null) -— 传一个正则，只混淆匹配该正则的属性名。

  • keep_quoted (default: false) -— 只混淆不在括号内的属性名.

  • debug (default: false) -— 用原名字来组成混淆后的名字. 传空字符串"" 来启用,或者非空字符串作为debu后缀。（例如"abc", foo.barfoo.barabc)

  • builtins (default: false) -- 传 true的话，允许混淆内置的DOM属性名。不推荐使用。

输出配置

Output options

代码生成器默认会尽量输出最简短的代码。假如你要美化一下输出代码，可以传--beautify (-b)。你也可以传更多的参数来控制输出代码：

  • ascii_only (default false) -- 忽略字符串和正则（导致非ascii字符失效）中的Unicode字符。

  • beautify (default true) -- 是否美化输出代码。传-b的话就是设成true。假如你想生成最小化的代码同时又要用其他设置来美化代码，你可以设-b beautify=false。

  • bracketize (default false) -- 永远在if, for,do, while, with后面加上大括号，即使循环体只有一句。

  • comments (default false) -- 传 true 或 "all"保留全部注释,传 "some"保留部分，传正则 (例如 /^!/) 或者函数也行。

  • indent_level (default 4) 缩进格数

  • indent_start (default 0) -- 每行前面加几个空格

  • inline_script (default false) -- 避免字符串中出现</script中的斜杠

  • keep_quoted_props (default false) -- 如果启用，会保留对象属性名的引号。

  • max_line_len (default 32000) -- 最大行宽（压缩后的代码）

  • space-colon (default true) -- 在冒号后面加空格

  • preamble (default null) -- 如果要传的话，必须是字符串。它会被加在输出文档的前面。sourcemap会随之调整。例如可以用来插入版权信息。

  • preserve_line (default false) -- 传 true 就保留空行，但只在beautify 设为false时有效。ß

  • quote_keys (default false) -- 传true的话会在对象所有的键加上括号

  • quote_style (default 0) -- 影响字符串的括号格式（也会影响属性名和指令）。

  • 0 -- 倾向使用双引号，字符串里还有引号的话就是单引号。

  • 1 -- 永远单引号

  • 2 -- 永远双引号

  • 3 -- 永远是本来的引号

  • semicolons (default true) -- 用分号分开多个声明。如果你传false,则总会另起一行，增强输出文件的可读性。（gzip前体积更小，gzip后稍大一点点）

  • shebang (default true) -- 保留开头的 shebang #! (bash 脚本)

  • width (default 80) -- 仅在美化时生效，设定一个行宽让美化器尽量实现。这会影响行中文字的数量（不包括缩进）。当前本功能实现得不是非常好，但依然让美化后的代码可读性大大增强。

  • wrap_iife (default false) --传true的话，把立即执行函数括起来。 更多详情看这里 #640

综合应用

Miscellaneous

保留版权告示或其他注释

你可以传入--comments让输出文件中保留某些注释。默认时会保留JSDoc-style的注释（包含"@preserve","@license" 或 "@cc_on"（为IE所编译））。你可以传入--comments all来保留全部注释，或者传一个合法的正则来保留那些匹配到的注释。例如--comments /^!/会保留/*! Copyright Notice */这样的注释。

注意，无论如何，总会有些注释在某些情况下会丢失。例如：

function f() {
    /** @preserve Foo Bar */
    function g() {
        // this function is never called
    }
    return something();
}

即使里面带有"@preserve"，注释依然会被丢弃。因为内部的函数g（注释所依附的抽象语法树节点）没有被引用、会被压缩器干掉。

书写版权信息（或其他需要在输出文件中保留的信息）的最安全位置是全局节点。

unsafe``compress配置

The unsafe compress option

在某些刻意营造的案例中，启用某些转换有可能会打断代码的逻辑，但绝大部分情况下是安全的。你可能会想尝试一下，因为这毕竟会减少文件体积。以下是某些例子：

  • new Array(1, 2, 3) 或 Array(1, 2, 3) → [ 1, 2, 3 ]

  • new Object() → {}

  • String(exp) 或 exp.toString() → "" + exp

  • new Object/RegExp/Function/Error/Array (...) → 我们干掉用new的

  • void 0 → undefined (假如作用域中有一个变量名叫"undefined";我们这么做是因为变量名会被混淆成单字符）

编译条件语句

Conditional compilation

Uglify会假设全局变量都是常量(不管是否在局部域中定义了)，你可以用--define (-d)来实现定义全局变量。例如你传--define DEBUG=false，UglifyJS会在输出中干掉下面代码：

if (DEBUG) {
    console.log("debug stuff");
}

你可以像--define env.DEBUG=false这样写嵌套的常量。

在干掉那些永否的条件语句以及不可达代码时，UglifyJS会给出警告。现在没有选项可以禁用此特性，但你可以设置 warnings=false 来禁掉所有警告。

另一个定义全局常量的方法是，在一个独立的文档中定义，再引入到构建中。例如你有一个这样的build/defines.js：

const DEBUG = false;
const PRODUCTION = true;
// 等等

这样构建你的代码：

  uglifyjs build/defines.js js/foo.js js/bar.js... -c

UglifyJS会注意到这些常量。因为它们无法改变，所以它们会被认为是没被引用而被照样干掉。如果你用const声明，构建后还会被保留。如果你的运行环境低于ES6、不支持const，请用var声明加上reduce_vars设置（默认启用）来实现。

编译条件语句API

你也可以通过程序API来设置编译配置。其中有差别的是一个压缩器属性global_defs：

var result = UglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
    compress: {
        dead_code: true,
        global_defs: {
            DEBUG: false
        }
    }
});

在global_defs配"@"前缀的表达式，UglifyJS才会替换成语句表达式：

UglifyJS.minify("alert(&#39;hello&#39;);", {
    compress: {
        global_defs: {
            "@alert": "console.log"
        }
    }
}).code;
// returns: &#39;console.log("hello");&#39;

否则会替换成字符串:

UglifyJS.minify("alert(&#39;hello&#39;);", {
    compress: {
        global_defs: {
            "alert": "console.log"
        }
    }
}).code;
// returns: &#39;"console.log"("hello");&#39;

使用minify()获得原生UglifyJS ast

Using native Uglify AST with minify() 

// 例子: 只解析代码，获得原生Uglify AST

var result = UglifyJS.minify(code, {
    parse: {},
    compress: false,
    mangle: false,
    output: {
        ast: true,
        code: false  // optional - faster if false
    }
});

// result.ast 即是原生 Uglify AST
// 例子: 输入原生 Uglify AST，接着把它压缩并混淆，生成代码和原生ast

var result = UglifyJS.minify(ast, {
    compress: {},
    mangle: {},
    output: {
        ast: true,
        code: true  // 可选，false更快
    }
});

// result.ast 是原生 Uglify AST
// result.code 是字符串格式的最小化后的代码

使用 Uglify AST

Working with Uglify AST

可以通过TreeWalker和TreeTransformer分别横截（？transversal）和转换原生AST。

ESTree/SpiderMonkey AST

UglifyJS有自己的抽象语法树格式；为了某些现实的原因 我们无法在内部轻易地改成使用SpiderMonkey AST。但UglifyJS现在有了一个可以输入SpiderMonkeyAST的转换器。 例如Acorn ，这是一个超级快的生成SpiderMonkey AST的解释器。它带有一个实用的迷你CLI，能解释一个文件、把AST转存为JSON并标准输出。可以这样用UglifyJS来压缩混淆：

    acorn file.js | uglifyjs --spidermonkey -m -c

-p --spidermonkey选项能让UglifyJS知道输入文件并非JavaScript，而是SpiderMonkey AST生成的JSON代码。这事我们不用自己的解释器，只把AST转成我们内部AST。

使用 Acorn 来解释代码

Use Acorn for parsing

更有趣的是，我们加了 -p --acorn选项来使用Acorn解释所有代码。如果你传入这个选项，UglifyJS会require("acorn")

Acorn确实非常快（650k代码原来要380ms，现在只需250ms），但转换Acorn产生的SpiderMonkey树会额外花费150ms。所以总共比UglifyJS自己的解释器还要多花一点时间。

Uglify快速最小化模式

Uglify Fast Minify Mode

很少人知道，对大多数js代码而言，其实移除空格和混淆符号已经占了减少代码体积之中到的95%--不必细致地转换。简单地禁用压缩compress能加快UglifyJS的构建速度三四倍。我们可以比较一下 butternut和只使用混淆mangle的模式的Uglify的压缩速度与gzip大小： butternut:

d3.js minify size gzip size minify time (seconds)
original 451,131 108,733 -
uglify-js@3.0.24 mangle=false, compress=false 316,600 85,245 0.70
uglify-js@3.0.24 mangle=true, compress=false 220,216 72,730 1.13
butternut@0.4.6 217,568 72,738 1.41
uglify-js@3.0.24 mangle=true, compress=true 212,511 71,560 3.36
babili@0.1.4 210,713 72,140 12.64

在CLI中，这样启用快速最小化模式:

uglifyjs file.js -m

API这样用:

UglifyJS.minify(code, { compress: false, mangle: true });

相关文章：

JS文件压缩成PNG图像存储方法   

压缩文件解压器: 文件解压压缩 

Das obige ist der detaillierte Inhalt vonJS-Dateien komprimieren und analysieren – die chinesische Dokumentation von UglifyJS3 erklärt ausführlich. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

JavaScript bash node.js json 正则表达式 chrome ecmascript html es6 npm coffeescript webpack httpx String Array Object NULL 常量 define if for while require throw Error math const 全局变量 字符串 void 循环 Length Regex Conditional Property var map JS console undefined function regexp 对象 作用域 default typeof dom prototype input ASCII http
Stellungnahme：
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel：Detaillierte Erläuterung der Verwendung von JavaScript in der R-SpracheNächster Artikel：Detaillierte Erläuterung der Verwendung von JavaScript in der R-Sprache

In Verbindung stehende Artikel

Mehr sehen