Merge pull request webpack#104 from lcxfs1991/cn

bundle-loader and code-splitting-require

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");