Merge remote-tracking branch 'upstream/cn' into cn

Author: dear-lizhihua

content/guides/code-splitting-require.md

@@ -6,28 +6,28 @@ contributors:
   - rahulcs
 ---
 
-In this section, we will discuss how webpack splits code using `require.ensure()`.
+在这一节，我们会讨论 webpack 如何使用 `require.ensure()` 进行代码拆分。
 
 ## `require.ensure()`
 
-webpack statically parses for `require.ensure()` in the code while building and adds the modules here into a separate chunk. This new chunk is loaded on demand by webpack through jsonp.
+webpack 在编译时，会静态地解析代码中的 `require.ensure()`，同时将模块添加到一个分开的 chunk 当中。这个新的 chunk 会被 webpack 通过 `jsonp` 来按需加载。
 
-The syntax is as follows
+语法如下：
 
 ```javascript
 require.ensure(dependencies: String[], callback: function(require), chunkName: String)
 ```
 
-#### dependencies
-This is an array of strings where we can declare all the modules that need to be made available before all the code in the callback function can be executed.
+#### 依赖 dependencies
+这是一个字符串数组，通过这个参数，在所有的回调函数的代码被执行前，我们可以将所有需要用到的模块进行声明。
 
-#### callback
-This is the callback function that webpack will execute once the dependencies are loaded. An implementation of the require object is sent as a parameter to this function. This is so that, we can further `require()` the dependencies and any other modules for execution.
+#### 回调 callback
+当所有的依赖都加载完成后，webpack会执行这个回调函数。`require` 对象的一个实现会作为一个参数传递给这个回调函数。因此，我们可以进一步 `require()` 依赖和其它模块提供下一步的执行。
 
-#### chunkName
-The chunkName is the name given to the chunk created by this particular `require.ensure()`. By giving the same name at different split points of `require.ensure()`, we can make sure all the dependencies are collectively put in the same bundle.
+#### chunk名称 chunkName
+chunkName 是提供给这个特定的 `require.ensure()` 的 chunk 的名称。通过提供 `require.ensure()` 不同执行点相同的名称，我们可以保证所有的依赖都会一起放进相同的 文件束(bundle)。
 
-Let us consider the following project
+让我们来看以下的项目
 
 ```bash
 \\ file structure
@@ -69,36 +69,37 @@ module.exports = function(env) {
     }
 }
 ```
-On running webpack on this project, we find that webpack has created two new bundles, `bundle.js` and `0.bundle.js`.
+通过执行这个项目的 webpack 构建，我们发现 webpack 创建了2个新的文件束， `bundle.js` 和 `0.bundle.js`。
 
-`entry.js` and `a.js` are bundled in `bundle.js`.
+`entry.js` 和 `a.js` 被打包进 `bundle.js`.
 
-`b.js` is bundled in `0.bundle.js`.
+`b.js` 被打包进 `0.bundle.js`.
 
-?> `require.ensure` relies on `Promises` internally. If you use `require.ensure` with older browsers, remember to shim `Promise.` [es6-promise polyfill](https://github.com/stefanpenner/es6-promise).
+?> `require.ensure` 内部依赖于 `Promises`。 如果你在旧的浏览器中使用 `require.ensure` 请记得 去 shim `Promise.` [es6-promise polyfill](https://github.com/stefanpenner/es6-promise).
 
-## Gotchas for `require.ensure()`
+## `require.ensure()` 的坑点
 
-### Empty Array as Parameter
+### 空数组作为参数
 
 ```javascript
 require.ensure([], function(require){
     require('./a.js');
 });
 ```
 
-The above code ensures that a split point is created and `a.js` is bundled separately by webpack.
+以上代码保证了拆分点被创建，而且 `a.js` 被 webpack 分开打包。
 
-### Dependencies as Parameter
+### 依赖作为参数
 
 ```javascript
 require.ensure(['./a.js'], function(require) {
     require('./b.js');
 });
 ```
 
-In the above code, `a.js` and `b.js` are bundled together and split from the main bundle. But only the contents of `b.js` are executed. The contents of `a.js` are only made available and not executed.
-To execute `a.js`, we will have to require it in a sync manner like `require('./a.js')` for the JavaScript to get executed.
+上面代码， `a.js` 和 `b.js` 都被打包到一起，而且从主文件束中拆分出来。但只有 `b.js` 的内容被执行。`a.js` 的内容仅仅是可被使用，但并没有被输出。
+
+想去执行 `a.js`，我们需要异步地引用它，如 `require('./a.js')`，让它的 JavaScritp 被执行。
 
 ***
 

generated/loaders/bundle-loader.md

@@ -3,37 +3,37 @@ title: bundle-loader
 source: https://raw.githubusercontent.com/webpack/bundle-loader/master/README.md
 edit: https://github.com/webpack/bundle-loader/edit/master/README.md
 ---
-# bundle loader for webpack
+# webpack 的文件束加载器
 
 ## Usage
 
-[Documentation: Using loaders](http://webpack.github.io/docs/using-loaders.html)
+[文档: 使用加载器](http://webpack.github.io/docs/using-loaders.html)
 
 ``` javascript
-// The chunk is requested, when you require the bundle
+// 当你引用 文件束 (bundle) 的时候，chunk 会被浏览器加载。
 var waitForChunk = require("bundle-loader!./file.js");
 
-// To wait until the chunk is available (and get the exports)
-//  you need to async wait for it.
+// 为了等待 chunk 的加载完成 (而且为了拿到 exports 输出)
+// 你需要异步去等待它
 waitForChunk(function(file) {
-	// use file like is was required with
+	// 这里可以使用file，就像是用下面的代码require进来一样
 	// var file = require("./file.js");
 });
-// wraps the require in a require.ensure block
+// 将 require 包裹在 require.ensure 的代码块中
 ```
 
-The file is requested when you require the bundle loader. If you want it to request it lazy, use:
+当你引用文件束的时候，chunk 会被浏览器加载。如果你想它懒加载，请用：
 
 ``` javascript
 var load = require("bundle-loader?lazy!./file.js");
 
-// The chunk is not requested until you call the load function
+// 文件束不会被加载，除非你调用了 call 函数
 load(function(file) {
 
 });
 ```
 
-You may set name for bundle (`name` query parameter). See [documentation](https://github.com/webpack/loader-utils#interpolatename).
+你可能会给文件束设名称(`name` 查询参数)。请查看[documentation](https://github.com/webpack/loader-utils#interpolatename).
 
 ``` javascript
 require("bundle-loader?lazy&name=my-chunk!./file.js");

generated/loaders/html-loader.md

@@ -3,23 +3,23 @@ title: html-loader
 source: https://raw.githubusercontent.com/webpack/html-loader/master/README.md
 edit: https://github.com/webpack/html-loader/edit/master/README.md
 ---
-## Install
+## 安装
 
 ```bash
 npm i -D html-loader
 ```
 
 ## Usage
 
-By default every local `<img src="image.png">` is required (`require('./image.png')`). You may need to specify loaders for images in your configuration (recommended `file-loader` or `url-loader`).
+默认情况下，每个本地的 `<img src="image.png">` 都需要通过 require （`require('./image.png')`）来进行加载。您可能需要在配置中为图片指定 loader（推荐 `file-loader` 或 `url-loader` ）
 
-You can specify which tag-attribute combination should be processed by this loader via the query parameter `attrs`. Pass an array or a space-separated list of `<tag>:<attribute>` combinations. (Default: `attrs=img:src`)
+您可以通过查询参数 `attrs`，来指定哪个标签属性组合(tag-attribute combination)应该被此 loader 处理。传递数组或以空格分隔的 `<tag>:<attribute>` 组合的列表。（默认值：`attrs=img:src`）
 
-To completely disable tag-attribute processing (for instance, if you're handling image loading on the client side) you can pass in `attrs=false`.
+要完全禁用对标签属性的处理（例如，如果你在客户端处理图片加载），你可以传入 `attrs=false`。
 
-## Examples
+## 示例
 
-With this configuration:
+使用此配置：
 
 ```js
 {
@@ -67,14 +67,14 @@ require("html-loader?-attrs!./file.html");
 // => '<img  src="image.jpg"  data-src="image2x.png" >'
 ```
 
-minimized by running `webpack --optimize-minimize`
+通过运行 `webpack --optimize-minimize` 来最小化
 
 ```html
 '<img src=http://cdn.example.com/49eba9f/a9f92ca.jpg
       data-src=data:image/png;base64,...>'
 ```
 
-or specify the `minimize` query in your `webpack.conf.js`
+或者在 `webpack.conf.js` 中指定 `minimize` 查询参数
 
 ```js
 module: {
@@ -90,11 +90,9 @@ module: {
 
 ### 'Root-relative' URLs
 
-For urls that start with a `/`, the default behavior is to not translate them.
-If a `root` query parameter is set, however, it will be prepended to the url
-and then translated.
+对于以 `/` 开头的 url，默认行为是不转换它们。如果设置了 `root` 查询参数，它将被添加到 URL 之前，然后进行转换。
 
-With the same configuration as above:
+和上面配置相同：
 
 ``` html
 <!-- file.html -->
@@ -113,9 +111,9 @@ require("html-loader?root=.!./file.html");
 // => '<img  src="http://cdn.example.com/49eba9f/a992ca.jpg">'
 ```
 
-### Interpolation
+### 插值
 
-You can use `interpolate` flag to enable interpolation syntax for ES6 template strings, like so:
+您可以使用 `interpolate` 标记，为 ES6 模板字符串启用插值语法，就像这样：
 
 ```js
 require("html-loader?interpolate!./file.html");
@@ -126,7 +124,7 @@ require("html-loader?interpolate!./file.html");
 
 <div>${require('./components/gallery.html')}</div>
 ```
-And if you only want to use `require` in template and any other `${}` are not to be translated, you can set `interpolate` flag to `require`, like so:
+如果你只想在模板中使用 `require`，任何其它的 `${}` 不被转换，你可以设置 `interpolate` 标记为 `require`，就像这样：
 
 ```js
 require("html-loader?interpolate=require!./file.ftl");
@@ -143,17 +141,17 @@ require("html-loader?interpolate=require!./file.ftl");
 <div>${require('./components/gallery.html')}</div>
 ```
 
-### Export formats
+### 导出格式
 
-There are different export formats available:
+这里有几种不同的可用导出格式：
 
-+ ```module.exports``` (default, cjs format). "Hello world" becomes ```module.exports = "Hello world";```
-+ ```exports.default``` (when ```exportAsDefault``` param is set, es6to5 format). "Hello world" becomes ```exports.default = "Hello world";```
-+ ```export default``` (when ```exportAsEs6Default``` param is set, es6 format). "Hello world" becomes ```export default "Hello world";```
++ ```module.exports```（默认配置，cjs 格式）。"Hello world" 转为 ```module.exports = "Hello world";```
++ ```exports.default``` (当设置了 ```exportAsDefault``` 参数，es6to5 格式）。"Hello world" 转为 ```exports.default = "Hello world";```
++ ```export default``` (当设置了 ```exportAsEs6Default``` 参数，es6 格式)。"Hello world" 转为 ```export default "Hello world";```
 
-### Advanced options
+### 高级选项
 
-If you need to pass [more advanced options](https://github.com/webpack/html-loader/pull/46), especially those which cannot be stringified, you can also define an `htmlLoader`-property on your `webpack.config.js`:
+如果你需要传递[更多高级选项](https://github.com/webpack/html-loader/pull/46)，特别是那些不能被字符串化，你还可以在 `webpack.config.js` 中定义一个 `htmlLoader` 属性：
 
 ```js
 var path = require('path')
@@ -176,7 +174,7 @@ module.exports = {
 };
 ```
 
-If you need to define two different loader configs, you can also change the config's property name via `html-loader?config=otherHtmlLoaderConfig`:
+如果你需要定义两个不同的 loader 配置，你也可以通过 `html-loader?config=otherHtmlLoaderConfig` 改变配置的属性名：
 
 ```js
 module.exports = {
@@ -195,20 +193,15 @@ module.exports = {
 };
 ```
 
-### Export into HTML files
+### 导出到 HTML 文件
 
-A very common scenario is exporting the HTML into their own _.html_ file, to
-serve them directly instead of injecting with javascript. This can be achieved
-with a combination of 3 loaders:
+一个很常见的场景，将 HTML 导出到 _.html_ 文件中，直接访问它们，而不是使用 javascript 注入。这可以通过3个 loader 的组合来实现：
 
 - [file-loader](https://github.com/webpack/file-loader)
 - [extract-loader](https://github.com/peerigon/extract-loader)
 - html-loader
 
-The html-loader will parse the URLs, require the images and everything you
-expect. The extract loader will parse the javascript back into a proper html
-file, ensuring images are required and point to proper path, and the file loader
-will write the _.html_ file for you. Example:
+html-loader 将解析 URL，并请求图片和你所期望的一切资源。extract-loader 会将 javascript 解析为合适的 html 文件，确保引用的图片指向正确的路径，file-loader 将结果写入 .html 文件。示例：
 
 ```js
 {
@@ -217,7 +210,7 @@ will write the _.html_ file for you. Example:
 }
 ```
 
-## Maintainers
+## 维护人员
 
 <table>
   <tbody>
@@ -309,4 +302,4 @@ SOFTWARE.
 
 ***
 
-> 原文：https://webpack.js.org/loaders/html-loader/
+> 原文：https://webpack.js.org/loaders/html-loader/

generated/loaders/multi-loader.md

@@ -5,11 +5,11 @@ edit: https://github.com/webpack/multi-loader/edit/master/README.md
 ---
 # multi-loader
 
-This loader requires a module multiple times, each time loaded with a different loader. Like in a multi entry point the exports of the last item are exported.
+这个loader多次需要一个模块，每次被加载一个不同的loader。像在多入口点中，导出最后一个loader的导出。
 
-A normal user probably don't need this loader, but it's useful in combination with other loaders.
+普通用户可能不需要这个loader，但它与其它loader结合使用还是很有用的。
 
-Example:
+例：
 
 ``` javascript
 var multi = require("multi-loader");
@@ -37,4 +37,4 @@ MIT (http://www.opensource.org/licenses/mit-license.php)
 
 ***
 
-> 原文：https://webpack.js.org/loaders/multi-loader/
+> 原文：https://webpack.js.org/loaders/multi-loader/

generated/loaders/react-proxy-loader.md

@@ -5,24 +5,24 @@ edit: https://github.com/webpack/react-proxy-loader/edit/master/README.md
 ---
 # react-proxy-loader
 
-Wraps a react component in a proxy component to enable Code Splitting (loads a react component and its dependencies on demand).
+在代理组件中封装react组件以启用代码拆分（加载一个react组件及其依赖需求）
 
-## installation
+## 安装
 
 `npm install react-proxy-loader`
 
-## Usage
+## 使用
 
-[Documentation: Using loaders](http://webpack.github.io/docs/using-loaders.html)
+[文档：使用loaders](http://webpack.github.io/docs/using-loaders.html)
 
 ``` js
 var Component = require("react-proxy-loader!./Component");
-// => returns the proxied component (It loads on demand.)
-// (webpack creates an additional chunk for this component and its dependencies)
+// => 返回代理组件（它按需加载。）
+// （webpack为此组件及其依赖项创建一个附加块）
 
 var ComponentProxyMixin = require("react-proxy-loader!./Component").Mixin;
-// => returns a mixin for the proxied component
-// (This allows you to setup rendering for the loading state for the proxy)
+// => 返回代理组件的mixin
+// （这允许您为prox的加载状态设置渲染）
 var ComponentProxy = React.createClass({
 	mixins: [ComponentProxyMixin],
 	renderUnavailable: function() {
@@ -31,11 +31,12 @@ var ComponentProxy = React.createClass({
 });
 ```
 
-The proxy is a react component. All properties are transferred to the wrapped component.
+代理是一个react组件。所有属性都将传输到包装组件。
 
 ### Configuration
+### 配置
 
-Instead of (or in addition to) inlining the loader call you can also specify the proxied components in your configuration:
+代替（或除了）内联加载器调用之外，还可以在配置中指定代理组件：
 
 ``` js
 module.exports = {
@@ -55,9 +56,9 @@ module.exports = {
 };
 ```
 
-### Chunk name
+### 块名称
 
-You can give the chunk a name with the `name` query parameter:
+您可以使用 `name` 查询参数为该块提供名称：
 
 ``` js
 var Component = require("react-proxy-loader?name=chunkName!./Component");
@@ -69,4 +70,4 @@ MIT (http://www.opensource.org/licenses/mit-license.php)
 
 ***
 
-> 原文：https://webpack.js.org/loaders/react-proxy-loader/
+> 原文：https://webpack.js.org/loaders/react-proxy-loader/