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

Author: dear-lizhihua

src/api/index.md

@@ -1184,7 +1184,7 @@ type: api
 
 - **示例：**
 
-  迫使Vue实例重修渲染。注意它仅仅影响实例本身和插入插槽内容的子组件，而不是所有子组件。
+  迫使Vue实例重新渲染。注意它仅仅影响实例本身和插入插槽内容的子组件，而不是所有子组件。
 
 <h3 id="vm-nextTick">vm.$nextTick( callback )</h3>
 

src/guide/comparison.md

@@ -29,7 +29,7 @@ Vue.component('my-component', {
 })
 ```
 
-<p class="tip">对于自定义标签名字， Vue.js 不强制要求遵循 W3C 规则（小写，并且包含一个短杠），尽管遵循这个规则比较好。</p>
+<p class="tip">对于自定义标签名，Vue.js 不强制要求遵循 [W3C规则](https://www.w3.org/TR/custom-elements/#concepts) （小写，并且包含一个短杠），尽管遵循这个规则比较好。</p>
 
 组件在注册之后，便可以在父实例的模块中以自定义元素 `<my-component></my-component>` 的形式使用。要确保在初始化根实例 **之前** 注册了组件：
 
@@ -83,7 +83,7 @@ var Child = {
 new Vue({
   // ...
   components: {
-    // <my-component> will only be available in parent's template
+    // <my-component> 将只在父模板可用
     'my-component': Child
   }
 })
@@ -228,16 +228,16 @@ new Vue({
 
 ### 使用Props传递数据
 
-**组件实例的作用域是孤立的**。这意味着不能并且不应该在子组件的模板内直接引用父组件的数据。可以使用 props 把数据传给子组件。
+组件实例的作用域是**孤立的**。这意味着不能并且不应该在子组件的模板内直接引用父组件的数据。可以使用 props 把数据传给子组件。
 
-prop 是父组件用来传递消息的一个自定义属性。子组件需要显式地用 [`props` 选项](/api/#props) 声明 props ：
+prop 是父组件用来传递数据的一个自定义属性。子组件需要显式地用 [`props` 选项](/api/#props) 声明 “prop”：
 
 ``` js
 Vue.component('child', {
   // 声明 props
   props: ['message'],
-  // 就像 data 一样， prop 也可以用在模板内
-  // and is also made available in the vm as this.message
+  // 就像 data 一样, prop 可以用在模板内
+  // 同样也可以在 vm 实例中像 “this.message” 这样使用
   template: '<span>{{ message }}</span>'
 })
 ```
@@ -333,7 +333,7 @@ new Vue({
 初学者常犯的一个错误是使用字面量语法传递数值:
 
 ``` html
-<!-- 传递一个字符串"1" -->
+<!-- 传递了一个字符串"1" -->
 <comp some-prop="1"></comp>
 ```
 
@@ -346,9 +346,9 @@ new Vue({
 
 ### 单向数据流
 
-prop 是单向绑定：当父组件的属性变化时，将传导给子组件，但是反过来不会。这是为了防止子组件无意修改了父组件的状态——这会让应用的数据流难以理解。
+prop 是单向绑定的：当父组件的属性变化时，将传导给子组件，但是不会反过来。这是为了防止子组件无意修改了父组件的状态——这会让应用的数据流难以理解.
 
-另外，每次父组件更新时，子组件的所有 prop 都会更新为最新值。这意味着你不应该在子组件内部改变 prop 。如果你这么做了， Vue 会在控制台给出警告。
+另外，每次父组件更新时，子组件的所有 prop 都会更新为最新值。这意味着你**不应该**在子组件内部改变 prop 。如果你这么做了，Vue 会在控制台给出警告。
 
 通常有两种改变 prop 的情况：
 
@@ -362,18 +362,18 @@ prop 是单向绑定：当父组件的属性变化时，将传导给子组件，
 
 2. 定义一个基于 prop 值的计算属性。
 
-<p class="tip">注意在 JavaScript 中对象和数组是通过引用传递的，如果 prop 是一个对象或数组，在子组件内部改变它**会**影响父组件的状态。</p>
+<p class="tip">注意在 JavaScript 中对象和数组是通过引用传递的，如果 prop 是一个对象或数组，在子组件内部改变它**会影响**父组件的状态。</p>
 
 ### Prop 验证
 
-组件可以为 props 指定验证要求。如果未指定要求， Vue 会发出警告。当组件给其他人使用时这很有用。
+组件可以为 props 指定验证要求。如果未指定验证要求，Vue会发出警告。当组件给其他人使用时这很有用。
 
 prop 是一个对象而不是字符串数组时，它包含验证要求:
 
 ``` js
 Vue.component('example', {
   props: {
-    // 基础类型检测 (`null` 意思是任何类型都可以)
+    // 基础类型检测 （`null` 意思是任何类型都可以）
     propA: Number,
     // 多种类型
     propB: [String, Number],
@@ -428,7 +428,7 @@ Vue.component('example', {
 - 使用 `$on(eventName)` 监听事件
 - 使用 `$emit(eventName)` 触发事件
 
-另外，父组件可以在模版中监听子组件直接使用 `v-on` 发出的事件。
+另外，父组件可以在使用子组件的地方直接用 `v-on` 来监听子组件触发的事件。
 
 下面是一个例子:
 
@@ -504,7 +504,7 @@ new Vue({
 </script>
 {% endraw %}
 
-在本例中，子组件仍然和它外部完全解耦合了。它所做的只是将父组件可能会关心的发生在它内部的事情告知给父组件了。
+在本例中，子组件已经和它外部完全解耦了。它所做的只是触发一个父组件关心的内部事件。
 
 #### 给组件绑定原生事件
 
@@ -516,7 +516,7 @@ new Vue({
 
 ### 使用自定义事件的表单输入组件
 
-也可以用 `v-model` 来创建自定义表单输入。记住：
+自定义事件也可以用来创建自定义的表单输入组件，使用 `v-model` 来进行数据双向绑定。记住，表单控件进行数据绑定时的语法：
 
 ``` html
 <input v-model="something">
@@ -528,7 +528,7 @@ new Vue({
 <input v-bind:value="something" v-on:input="something = $event.target.value">
 ```
 
-在组件中使用时，它相当于下面的简写：
+所以在组件中使用时, 它相当于下面的简写：
 
 ``` html
 <input v-bind:value="something" v-on:input="something = arguments[0]">
@@ -617,7 +617,7 @@ new Vue({
 </script>
 {% endraw %}
 
-这个接口不仅仅可以用来联系组件内部的表单输入，也很容易集成你自己写的输入类型。想象一下：
+这个接口不仅仅可以用来连接组件内部的表单输入，也很容易集成你自己创造的输入类型。想象一下：
 
 ``` html
 <voice-recognizer v-model="question"></voice-recognizer>
@@ -633,11 +633,11 @@ new Vue({
 var bus = new Vue()
 ```
 ``` js
-// 组件 A 的方法
+// 触发组件 A 中的事件
 bus.$emit('id-selected', 1)
 ```
 ``` js
-// 组件 B 创建的钩子
+// 在组件 B 创建的钩子中监听事件
 bus.$on('id-selected', function (id) {
   // ...
 })
@@ -705,7 +705,7 @@ Vue.component('child-component', {
 
 ### 单个 Slot
 
-父组件的内容将被**抛弃**，除非子组件模板包含 `<slot>` 。如果子组件模板只有一个没有特性的 slot ，父组件的整个内容将插到 slot 所在的地方并替换它。
+父组件的内容将被**抛弃**，除非子组件模板包含 `<slot>` 。如果子组件模板只有一个没有特性的 slot，父组件整个内容片段 将插到 slot 所在的 DOM 位置并替换掉 slot 标签。
 
 `<slot>` 标签的内容视为**回退内容**。回退内容在子组件的作用域内编译，当宿主元素为空并且没有内容供插入时显示这个回退内容。
 
@@ -938,7 +938,7 @@ Vue.component(
 
 ### 组件命名约定
 
-当定义组件时(或者 props )，可以使用 kebab-case ， camelCase 或 TitleCase 。 Vue 不关心这个。
+当注册组件时（或者 props ），可以使用 kebab-case ，camelCase ，或 TitleCase 。Vue 不关心这个。
 
 ``` js
 // 在组件定义中
@@ -950,7 +950,7 @@ components: {
 }
 ```
 
-在 HTML 模版中，请使用 kebab-case 形式:
+在 HTML 模版中，请使用 kebab-case形式：
 
 ``` html
 <!-- 在HTML模版中始终使用 kebab-case -->
@@ -962,19 +962,19 @@ components: {
 当使用字符串模式时，可以不受 HTML 的 case-insensitive 限制。这意味即使是在模版中，引用、组件和 prop 可以使用 camelCase 、 PascalCase 或者 kebab-case：
 
 ``` html
-<!-- 在字符串模版中用你想用! -->
+<!-- 在字符串模版中可以用任何你喜欢的方式! -->
 <my-component></my-component>
 <myComponent></myComponent>
 <MyComponent></MyComponent>
 ```
 
-如果组件未经 `slot` 元素传递内容,你甚至可以在组件名后使用 `/` 使其自闭和：
+如果组件未经 `slot` 元素传递内容，你甚至可以在组件名后使用 `/` 使其自闭和：
 
 ``` html
 <my-component/>
 ```
 
-当然，这只在字符串模版中有效。因为自闭和的自定义元素是无效的 HTML ，浏览器原生的解析器也无法识别它。
+当然，这只在字符串模版中有效。因为自闭的自定义元素是无效的 HTML ，浏览器原生的解析器也无法识别它。
 
 ### 递归组件
 
@@ -985,7 +985,7 @@ name: 'stack-overflow',
 template: '<div><stack-overflow></stack-overflow></div>'
 ```
 
-上面组件会导致一个错误 “max stack size exceeded” ，所以要确保递归调用有终止条件 (也就是使用 `v-if` )。当使用 `Vue.component()` 全局注册一个组件时，组件 ID 自动设置为组件的 `name` 选项。
+上面组件会导致一个错误 “max stack size exceeded” ，所以要确保递归调用有终止条件 (比如递归调用时使用 `v-if` 并让他最终返回 false )。当使用 `Vue.component()` 全局注册一个组件时，全局的组件 ID 自动设置为该组件的 `name` 选项。
 
 ### 内联模版
 
@@ -1002,7 +1002,7 @@ template: '<div><stack-overflow></stack-overflow></div>'
 
 ### X-Templates
 
-另一种定义模版的方式是在 javascript 标签里使用 `text/x-template` 类型，并且指定一个id。例如:
+另一种定义模版的方式是在 JavaScript 标签里使用 `text/x-template` 类型, 并且指定一个id。例如:
 
 ``` html
 <script type="text/x-template" id="hello-world-template">
@@ -1016,11 +1016,11 @@ Vue.component('hello-world', {
 })
 ```
 
-这在有很多模版或者小的应用中有用，否则应该避免使用,因为它将模版和组件的其他定义隔离了。
+这在有很多模版或者小的应用中有用，否则应该避免使用，因为它将模版和组件的其他定义隔离了。
 
 ### Cheap Static Components with `v-once`
 
-尽管在 Vue 中渲染 HTML 很快，不过当组件中包含**大量**静态内容时, 可以考虑使用 `v-once` 将渲染结果缓存起来，就像这样:
+尽管在 Vue 中渲染 HTML 很快，不过当组件中包含**大量**静态内容时, 可以考虑使用 `v-once` 将渲染结果缓存起来, 就像这样:
 
 ``` js
 Vue.component('terms-of-service', {

src/guide/components.md

@@ -226,7 +226,7 @@ var watchExampleVM = new Vue({
   methods: {
     // _.debounce 是一个通过 lodash 限制操作频率的函数。
     // 在这个例子中，我们希望限制访问yesno.wtf/api的频率
-    // 一直等待直到用户发出ajax请求之前
+    // ajax请求直到用户输入完毕才会发出
     // 学习更多关于 _.debounce function (and its cousin
     // _.throttle), 参考: https://lodash.com/docs#debounce
     getAnswer: _.debounce(

src/guide/computed.md

@@ -6,7 +6,7 @@ order: 16
 
 ## 简介
 
-除了默认设置的核心指令(`v-model`和`v-show`),Vue也允许注册自定义指令。注意，在vue2.0里面，代码复用的主要形式和抽象是组件——然而，有的情况下,你仍然需要对纯DOM元素进行底层操作,这时候就会用到自定义指令。下面这个例子聚焦一个input元素，像这样：
+除了默认设置的核心指令( `v-model` 和 `v-show` ),Vue 也允许注册自定义指令。注意，在 Vue2.0 里面，代码复用的主要形式和抽象是组件——然而，有的情况下,你仍然需要对纯 DOM 元素进行底层操作,这时候就会用到自定义指令。下面这个例子将聚焦一个 input 元素，像这样：
 
 {% raw %}
 <div id="simplest-directive-example" class="demo">
@@ -24,20 +24,20 @@ new Vue({
 </script>
 {% endraw %}
 
-页面加载时，元素将获得焦点。事实上，你访问后还没点击任何内容，input就获得了焦点。现在让我们完善这个指令：
+当页面加载时，元素将获得焦点。事实上，你访问后还没点击任何内容，input 就获得了焦点。现在让我们完善这个指令：
 
 ``` js
 // 注册一个全局自定义指令 v-focus
 Vue.directive('focus', {
-  // 当绑定元素插入到DOM中。
+  // 当绑定元素插入到 DOM 中。
   inserted: function (el) {
     // 聚焦元素
     el.focus()
   }
 })
 ```
 
-也可以注册局部指令，组件中接受一个 `directives`的选项：
+也可以注册局部指令，组件中接受一个 `directives` 的选项：
 
 ``` js
 directives: {
@@ -48,7 +48,7 @@ directives: {
 }
 ```
 
-然后你可以在模板中任何元素上使用新的`v-focus`属性：
+然后你可以在模板中任何元素上使用新的 `v-focus` 属性：
 
 ``` html
 <input v-focus>
@@ -61,31 +61,31 @@ directives: {
 - `bind`: 只调用一次, 指令第一次绑定到元素时调用，用这个钩子函数可以定义一个在绑定时执行一次的初始化动作。
 
 - `inserted`: 被绑定元素插入父节点时调用（父节点存在即可调用，不必存在于 document 中）。
-
+  
 - `update`: 被绑定元素所在的模板更新时调用，而不论绑定值是否变化。通过比较更新前后的绑定值，可以忽略不必要的模板更新（详细的钩子函数参数见下）。
 
 - `componentUpdated`: 被绑定元素所在模板完成一次更新周期时调用。
 
 - `unbind`: 只调用一次， 指令与元素解绑时调用。
 
-接下来我们来看一下钩子函数的参数 (包括 `el`， `binding`， `vnode`， `oldVnode`) 。
+接下来我们来看一下钩子函数的参数 (包括 `el`，`binding`，`vnode`，`oldVnode`) 。
 
 ## 钩子函数参数
 
 钩子函数被赋予了以下参数：
 
-- **el**: 指令所绑定的元素，可以用来直接操作 dom 。
+- **el**: 指令所绑定的元素，可以用来直接操作 DOM 。
 - **binding**: 一个对象，包含以下属性：
   - **name**: 指令名，不包括 `v-` 前缀。
   - **value**: 指令的绑定值， 例如： `v-my-directive="1 + 1"`, value 的值是 `2`。
   - **oldValue**: 指令绑定的前一个值, 仅在 `update` 和 `componentUpdated` 钩子中可用。无论值是否改变都可用。
   - **expression**: 绑定值的字符串形式。 例如 `v-my-directive="1 + 1"` ， expression 的值是 `"1 + 1"`。
   - **arg**: 传给指令的参数。例如 `v-my-directive:foo`， arg 的值是 `"foo"`。
-  - **modifiers**: 一个包含编辑器的对象。 例如： `v-my-directive.foo.bar`, 编辑器对象 modifiers的值是 `{ foo: true, bar: true }`。
-- **vnode**: Vue 编译生成的虚拟节点, 参考 [VNode API](/api/#VNode-Interface) 详情。
+  - **modifiers**: 一个包含修饰符的对象。 例如： `v-my-directive.foo.bar`, 修饰符对象 modifiers 的值是 `{ foo: true, bar: true }`。
+- **vnode**: Vue 编译生成的虚拟节点, 查阅 [VNode API](/api/#VNode-Interface) 了解更多详情。
 - **oldVnode**: 上一个虚拟节点, 仅在 `update` 和 `componentUpdated` 钩子中可用。
 
-<p class="tip">除了 `el` 之外, 其它参数都应该是只读的，尽量不要修改他们。如果需要在钩子之间共享数据，建议通过元素的 [dataset] 来进行。(https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dataset).</p>
+<p class="tip">除了 `el` 之外, 其它参数都应该是只读的，尽量不要修改他们。如果需要在钩子之间共享数据，建议通过元素的 [dataset](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dataset) 来进行。</p>
 
 一个使用了这些参数的自定义钩子样例：
 
@@ -141,16 +141,16 @@ new Vue({
 
 ## 函数简写
 
-大多数情况下，只需要在 `bind` 和 `update` 钩子中做重复动作，而不关心其它钩子函数。可以这样写:
+大多数情况下，我们可能想在 `bind` 和 `update` 钩子上做重复动作，并且不想关心其它的钩子函数。可以这样写:
 
 ``` js
 Vue.directive('color-swatch', function (el, binding) {
   el.style.backgroundColor = binding.value
 })
 ```
-## 对象常量
+## 对象字面量
 
-如果自定义指令需要复杂的值，也可以传递 javascript 对象。要知道，指令函数能够接受所有类型的 javascript 常量。
+如果指令需要多个值，可以传入一个 JavaScript 对象字面量。记住，指令函数能够接受所有合法类型的 Javascript 表达式。
 
 ``` html
 <div v-demo="{ color: 'white', text: 'hello!' }"></div>
@@ -167,4 +167,4 @@ Vue.directive('demo', function (el, binding) {
 
 > 原文：http://vuejs.org/guide/custom-directive.html
 
-***
+***

src/guide/custom-directive.md

@@ -6,7 +6,7 @@ order: 2
 
 ## Vue.js 是什么
 
-Vue.js（读音 /vjuː/, 类似于 **view**） 是一套构建用户界面的 **先进框架**。与其他单层框架（ monolithic frameworks）不同的是，Vue 采用自底向上增量开发的设计。Vue 的核心库只关注视图层，并且非常容易学习，非常容易与其它库或已有项目整合。另一方面，Vue 完全有能力驱动采用[单文件组件](single-file-components.html)和[Vue生态系统支持的库](//github.com/vuejs/awesome-vue#libraries--plugins)开发的复杂单页应用。 
+Vue.js（读音 /vjuː/, 类似于 **view**） 是一套构建用户界面的 **先进框架**。与其他单层框架（ monolithic frameworks）不同的是，Vue 采用自底向上增量开发的设计。Vue 的核心库只关注视图层，并且非常容易学习，非常容易与其它库或已有项目整合。另一方面，Vue 完全有能力驱动采用[单文件组件](single-file-components.html)和[Vue生态系统支持的库](//github.com/vuejs/awesome-vue#libraries--plugins)开发的复杂单页应用。
 
 Vue.js 的目标是通过尽可能简单的 API 实现**响应的数据绑定**和**组合的视图组件**。
 
@@ -283,7 +283,8 @@ Vue.component('todo', {
     <todo v-for="todo in todos" v-bind:todo="todo"></todo>
   </ol>
 </div>
-``` 
+```
+
 ``` js
 var app7 = new Vue({
   el: '#app-7',
@@ -316,7 +317,7 @@ var app7 = new Vue({
 </script>
 {% endraw %}
 
-这只是一个人为的例子，但是我们已经将我们的应用分割成了两小的单元，子元素通过 `props` 接口实现了与父亲元素很好的解耦。我们现在可以在不影响到父应用的基础上，进一步为我们的 `todo` 组件改进更多复杂的模板和逻辑。
+这只是一个人为的例子，但是我们已经将我们的应用分割成了两个更小的单元，子元素通过 `props` 接口实现了与父亲元素很好的解耦。我们现在可以在不影响到父应用的基础上，进一步为我们的 `todo` 组件改进更多复杂的模板和逻辑。
 
 在一个大型应用中，为了使得开发过程可控，有必要将应用整体分割成一个个的组件。在[后面的教程](/guide/components.html)中我们将详述组件，不过这里有一个（假想）的例子，看看使用了组件的应用模板是什么样的：
 

src/guide/index.md

@@ -1384,7 +1384,7 @@ vm.$el.remove()
 {% raw %}
 <div class="upgrade-path">
   <h4>升级方式</h4>
-  <p>运行 <a href="https://github.com/vuejs/vue-migration-helper">migration helper</a>找到<code>vm.$remove</code>.。如有遗漏，请参考<strong>控制台错误信息</strong>。</p>
+  <p>运行 <a href="https://github.com/vuejs/vue-migration-helper">migration helper</a>找到<code>vm.$remove</code>。如有遗漏，请参考<strong>控制台错误信息</strong>。</p>
 </div>
 {% endraw %}