diff --git a/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md b/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md
index 3e3922c3cd..3070553be8 100644
--- a/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md
+++ b/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md
@@ -1,13 +1,13 @@
-这里有很多方法，比方说：
+这里有很多种方法，例如：
 
 
 获取 `<div>` DOM 节点：
 
 ```js
 document.body.firstElementChild
-// 或者
+// 或
 document.body.children[0]
-// 或者（第一个节点是空格，所有我们拿第二个）
+// 或（第一个节点是空格，所以我们应该获取的是第二个）
 document.body.childNodes[1]
 ```
 
@@ -15,13 +15,13 @@ document.body.childNodes[1]
 
 ```js
 document.body.lastElementChild
-// 或者
+// 或
 document.body.children[1]
 ```
 
-获取第二个 `<li>`（即包含 Pete 的节点）
+获取第二个 `<li>`（即包含 Pete 的节点）：
 
 ```js
-// 获取 <ul>, 然后拿它的最后一个子元素
+// 获取 <ul>，然后获取它的最后一个子元素
 document.body.lastElementChild.lastElementChild
 ```
diff --git a/2-ui/1-document/03-dom-navigation/1-dom-children/task.md b/2-ui/1-document/03-dom-navigation/1-dom-children/task.md
index b66bce81e3..d2a79470d1 100644
--- a/2-ui/1-document/03-dom-navigation/1-dom-children/task.md
+++ b/2-ui/1-document/03-dom-navigation/1-dom-children/task.md
@@ -18,7 +18,7 @@ importance: 5
 </html>
 ```
 
-如何能访问到以下内容：
+对于以下各项，请给出至少一种访问方式：
 - `<div>` DOM 节点？
--  `<ul>` DOM 节点？
+- `<ul>` DOM 节点？
 -  第二个 `<li>` 节点（即包含 Pete 的节点）？
diff --git a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
index d85ef0d8af..5f5825fc62 100644
--- a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
+++ b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
@@ -1,4 +1,6 @@
-1. 是的，这是真的。`elem.lastChild` 一直是最后一个元素，它就没有 `nextSibling` ，所有如果存在子节点，这个问题的答案就是正确。
-2. 不，这是错的，因为  `elem.children[0]` 是元素中的第一个子元素。但是或许有非元素的节点在它之前。所以 `previousSibling` 或许是一个文本节点。
+1. 是的，这是真的。`elem.lastChild` 就是最后一个元素，它没有 `nextSibling`。
+2. 不，这是错的，因为  `elem.children[0]` 是元素中的第一个子元素。但是在它前面可能存在非元素的节点。所以 `previousSibling` 可能是一个文本节点。
 
-请注意，对于这两种情况，如果没有子节点就会出现错误。比如说如果 `elem.lastChild` 是 `null`，我们就访问不到 `elem.lastChild.nextSibling`。
+请注意，对于这两种情况，如果没有子节点，那么就会报错。
+
+如果这里没有子节点，那么 `elem.lastChild` 是 `null`，所以我们就访问不到 `elem.lastChild.nextSibling`。并且 `elem.children` 是空的（像一个空数组一样 `[]`）。
diff --git a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md
index 0ecbb4f7ae..6d166d2314 100644
--- a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md
+++ b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md
@@ -6,5 +6,5 @@ importance: 5
 
 如果 `elem` 是任意一个 DOM 元素节点……
 
-- `elem.lastChild.nextSibling` 值一直都是 `null` 这个判定是不是真的？
-- `elem.children[0].previousSibling` 值一直都是 `null` 这个判定是不是真的？
+- `elem.lastChild.nextSibling` 值一直都是 `null`，这个判定是不是真的？
+- `elem.children[0].previousSibling` 值一直都是 `null`，这个判定是不是真的？
diff --git a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md
index 87369cc035..875b2b2ec4 100644
--- a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md
+++ b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# 选择所有对角线单元格
+# 选择所有对角单元格
 
 编写代码来把表中的对角单元格都绘制成红色。
 
-你需要用代码从 `<table>` 中获取到所有的对角线 `<td>`，然后绘制它们：
+你需要用代码从 `<table>` 中获取所有的对角单元格 `<td>`，然后绘制它们：
 
 ```js
 // td 表示的是对单元格的引用
diff --git a/2-ui/1-document/03-dom-navigation/article.md b/2-ui/1-document/03-dom-navigation/article.md
index 704a85a686..0eefd3db33 100644
--- a/2-ui/1-document/03-dom-navigation/article.md
+++ b/2-ui/1-document/03-dom-navigation/article.md
@@ -7,22 +7,22 @@ libs:
 
 # 遍历 DOM
 
-DOM 让我们可以对元素和它们其中的内容做任何事，但是首先我们需要获取到对应的 DOM 对象，把这个对象赋予一个变量，然后我们才能修改这个对象。
+DOM 让我们可以对元素和它们中的内容做任何事，但是首先我们需要获取到对应的 DOM 对象。
 
-对 DOM 的所有操作都是从 `document` 对象开始的。从这个对象我们可以到达任何节点。
+对 DOM 的所有操作都是以 `document` 对象开始。它是 DOM 的主“入口点”。从它我们可以访问任何节点。
 
-这里是一张描述对象间链接的图片，通过这些链接我们可以在 DOM 节点之间遍历。
+这里是一张描述对象间链接的图片，通过这些链接我们可以在 DOM 节点之间移动。
 
 ![](dom-links.svg)
 
-让我们更详细地讨论这些。
+让我们更详细地讨论它们吧。
 
-## 在最顶上的：documentElement 和 body
+## 在最顶层：documentElement 和 body
 
-最上面的树节点可以直接通过 `document` 属性来使用：
+最顶层的树节点可以直接作为 `document` 的属性来使用：
 
 `<html>` = `document.documentElement`
-: 最上面的 document 节点是  `document.documentElement`。这是对应 `<html>` 标签的 DOM 节点。
+: 最顶层的 document 节点是 `document.documentElement`。这是对应 `<html>` 标签的 DOM 节点。
 
 `<body>` = `document.body`
 : 另一个被广泛使用的 DOM 节点是 `<body>` 元素 — `document.body`。
@@ -33,9 +33,9 @@ DOM 让我们可以对元素和它们其中的内容做任何事，但是首先
 ````warn header="这里有个问题：`document.body` 的值可能是 `null`"
 脚本无法访问在运行时不存在的元素。
 
-特别要注意的是，如果一个脚本是在 `<head>` 标签中，那么脚本中是访问不到 `document.body` 元素的，因为浏览器还没有读到其中的内容。
+尤其是，如果一个脚本是在 `<head>` 中，那么脚本是访问不到 `document.body` 元素的，因为浏览器还没有读到它。
 
-所以在下面的例子中第一个 `alert` 函数显示的是 `null`：
+所以，下面例子中的第一个 `alert` 显示 `null`：
 
 ```html run
 <html>
@@ -43,7 +43,7 @@ DOM 让我们可以对元素和它们其中的内容做任何事，但是首先
 <head>
   <script>
 *!*
-    alert( "From HEAD: " + document.body ); // null, there's no <body> yet
+    alert( "From HEAD: " + document.body ); // null，这里目前还没有 <body>
 */!*
   </script>
 </head>
@@ -51,7 +51,7 @@ DOM 让我们可以对元素和它们其中的内容做任何事，但是首先
 <body>
 
   <script>
-    alert( "From BODY: " + document.body ); // HTMLBodyElement, now it exists
+    alert( "From BODY: " + document.body ); // HTMLBodyElement，现在存在了
   </script>
 
 </body>
@@ -59,18 +59,18 @@ DOM 让我们可以对元素和它们其中的内容做任何事，但是首先
 ```
 ````
 
-```smart header="在 DOM 世界中 `null` 就意味着“不存在”"
-在 DOM 中，`null` 值就意味着“不存在”或者“没有这样的节点”。 
+```smart header="在 DOM 的世界中，`null` 就意味着“不存在”"
+在 DOM 中，`null` 值就意味着“不存在”或者“没有这个节点”。 
 ```
 
-## 子元素：childNodes, firstChild, lastChild
+## 子节点：childNodes，firstChild，lastChild
 
 从现在开始，我们将使用下面这两个术语：
 
-- **子节点（或者叫做子）** —— 对应的是直系的子元素。换句话说它们会完全嵌套在指定的一个元素中。举个例子，`<head>` 和 `<body>` 就是 `<html>` 元素的子元素。
-- **子系元素** —— 对应的是所有嵌套在一个指定元素中的元素，包括这些元素的子元素，以此类推得到的所有元素。
+- **子节点（或者叫作子）** — 对应的是直系的子元素。换句话说，它们被完全嵌套在给定的元素中。例如，`<head>` 和 `<body>` 就是 `<html>` 元素的子元素。
+- **子孙元素** — 嵌套在给定元素中的所有元素，包括子元素，以及子元素的子元素等。
 
-比如说，在这里 `<body>` 有子元素 `<div>` 和 `<ul>`（以及一些空白的文本节点）：
+例如，这里 `<body>` 有子元素 `<div>` 和 `<ul>`（以及一些空白的文本节点）：
 
 ```html run
 <html>
@@ -86,11 +86,11 @@ DOM 让我们可以对元素和它们其中的内容做任何事，但是首先
 </html>
 ```
 
-...如果我们要找的是 `<body>` 的子系元素，那我们可以先得到它直系子元素 `<div>`，`<ul>` 以及像 `<li>`（`<ul>` 的子元素）和 `<b>`（`<li>` 的子元素）这样嵌套更深的元素 — 这就是 `<body>` 元素包含的整个子树。
+……`<body>` 元素的子孙元素不仅包含直接的子元素 `<div>` 和 `<ul>`，还包含像 `<li>`（`<ul>` 的子元素）和 `<b>`（`<li>` 的子元素）这样的元素 — 整个子树。
 
-**`childNodes` 集合提供了对所有子节点包括其中文本节点的访问。**
+**`childNodes` 集合列出了所有子节点，包括文本节点。**
 
-下面的例子显示了 `document.body` 的子元素：
+下面这个例子显示了 `document.body` 的子元素：
 
 ```html run
 <html>
@@ -115,11 +115,11 @@ DOM 让我们可以对元素和它们其中的内容做任何事，但是首先
 </html>
 ```
 
-请注意在这边有一个有趣的细节。如果我们运行上面的例子，所展示代码中最后的元素是 `<script>`。实际上，文档下面还有很多东西，但是在这个脚本执行的时候，浏览器还没有读到下面的内容，所以这个脚本并不能看到它们。
+请注意这里的一个有趣的细节。如果我们运行上面这个例子，所显示的最后一个元素是 `<script>`。实际上，文档下面还有很多东西，但是在这个脚本运行的时候，浏览器还没有读到下面的内容，所以这个脚本也就看不到它们。
 
-**`firstChild` 和 `lastChild` 属性是访问第一个和最后一个子元素的快捷方式**
+**`firstChild` 和 `lastChild` 属性是访问第一个和最后一个子元素的快捷方式。**
 
-它们只是简写。如果元素存在子节点，那么下面的脚本运行结果一直都是 true：
+它们只是简写。如果元素存在子节点，那么下面的脚本运行结果将是 true：
 ```js
 elem.childNodes[0] === elem.firstChild
 elem.childNodes[elem.childNodes.length - 1] === elem.lastChild
@@ -129,52 +129,52 @@ elem.childNodes[elem.childNodes.length - 1] === elem.lastChild
 
 ### DOM 集合
 
-正如我们看到的那样，`childNodes` 看起来就像一个数组。但是它实际上并不是一个数组，而是一个**集合** —— 一个类似数组的可迭代对象。
+正如我们看到的那样，`childNodes` 看起来就像一个数组。但实际上它并不是一个数组，而是一个 **集合** — 一个类数组的可迭代对象。
 
 这个性质会导致两个重要的结果：
 
-1. 我们可以使用 `for..of` 语法来迭代它：
+1. 我们可以使用 `for..of` 来迭代它：
   ```js
   for (let node of document.body.childNodes) {
-    alert(node); // shows all nodes from the collection
+    alert(node); // 显示集合中的所有节点
   }
   ```
   这是因为集合是可迭代的（提供了所需要的 `Symbol.iterator` 属性）。
 
-2. 并不能使用数组的方法，因为它并不是一个数组：
+2. 无法使用数组的方法，因为它不是一个数组：
   ```js run
-  alert(document.body.childNodes.filter); // undefined (there's no filter method!)
+  alert(document.body.childNodes.filter); // undefined（这里没有 filter 方法！）
   ```
 
-因为集合性质所得到的第一个结果很不错。第二个结果也还可以忍受，因为如果我们想调用数组的方法的话可以通过 `Array.from` 方法来从集合中创建一个“真”的数组：
+集合的性质所得到的第一个结果很不错。第二个结果也还可以忍受，因为如果我们想要使用数组的方法的话，我们可以使用 `Array.from` 方法来从集合创建一个“真”数组：
 
   ```js run
-  alert( Array.from(document.body.childNodes).filter ); // now it's there
+  alert( Array.from(document.body.childNodes).filter ); // function
   ```
 
 ```warn header="DOM 集合是只读的"
-DOM 集合甚至可以说本章中列出的**所有**导航属性都是只读的。
+DOM 集合，甚至可以说本章中列出的 **所有** 导航（navigation）属性都是只读的。
 
 我们不能通过类似 `childNodes[i] = ...` 的操作来替换一个子节点。
 
-修改子节点需要使用其它的方法，我们将会在下一章中看到它们。
+修改子节点需要使用其它方法。我们将会在下一章中看到它们。
 ```
 
 ```warn header="DOM 集合是实时的"
-除小部分例外之外几乎所有的 DOM 集合都是**实时**的。换句话说，它们都反映的是 DOM 的实时状态。
+除小部分例外，几乎所有的 DOM 集合都是 **实时** 的。换句话说，它们反映了 DOM 的当前状态。
 
-如果我们保留一个对 `elem.childNodes` 的引用，然后在 DOM 中添加/移除节点，那么这些新加的节点就会自动出现在这个集合中。
+如果我们保留一个对 `elem.childNodes` 的引用，然后向 DOM 中添加/移除节点，那么这些节点的更新会自动出现在集合中。
 ```
 
-````warn header="不要使用 `for..in` 来循环遍历集合"
-在使用 `for..of` 的情况下集合是可迭代的。但是有时候人们会尝试使用 `for..in` 来迭代集合。
+````warn header="不要使用 `for..in` 来遍历集合"
+可以使用 `for..of` 对集合进行迭代。但有时候人们会尝试使用 `for..in` 来迭代集合。
 
-请不要这么做。`for..in` 循环遍历的是所有列举的属性。集合会有一些“额外”很少用到的属性，这些属性我们通常不会获取到：
+请不要这么做。`for..in` 循环遍历的是所有可枚举的（enumerable）属性。集合还有一些“额外的”很少被用到的属性，通常这些属性也是我们不期望得到的：
 
 ```html run
 <body>
 <script>
-  // 显示 0、1、length、item、values 以及其它值。
+  // 显示 0，1，length，item，values 及其他。
   for (let prop in document.body.childNodes) alert(prop);
 </script>
 </body>
@@ -182,66 +182,74 @@ DOM 集合甚至可以说本章中列出的**所有**导航属性都是只读的
 
 ## 兄弟节点和父节点
 
-**兄弟节点**是指有同一个父节点的节点。比如说 `<head>` 和 `<body>` 就是兄弟节点：
+**兄弟节点（Sibling）** 是指有同一个父节点的节点。
+
+例如，`<head>` 和 `<body>` 就是兄弟节点：
+
+```html
+<html>
+  <head>...</head><body>...</body>
+</html>
+```
 
 - `<body>` 可以说是 `<head>` 的“下一个”或者“右边”兄弟节点。
 - `<head>` 可以说是 `<body>` 的“前一个”或者“左边”兄弟节点。
 
-父节点可以通过 `parentNode` 访问。
+下一个兄弟节点在 `nextSibling` 属性中，上一个是在 `previousSibling` 属性中。
 
-在同一个父节点中一个节点的下一个节点（下一个兄弟节点）可以通过 `nextSibling` 访问，上一个节点可以通过 `previousSibling` 访问。
+可以通过 `parentNode` 来访问父节点。
 
-比如说：
+例如：
 
-```html run
-<html><head></head><body><script>
-  //  HTML 代码是“密集”的用来避免额外的“空白”文本节点。
-  HTML is "dense" to evade extra "blank" text nodes.
-
-  // <body> 的父节点是 <html>
-  alert( document.body.parentNode === document.documentElement ); // true
+```js run
+// <body> 的父节点是 <html>
+alert( document.body.parentNode === document.documentElement ); // true
 
-  // <head> 的下一个兄弟节点是  <body>
-  alert( document.head.nextSibling ); // HTMLBodyElement
+// <head> 的后一个是 <body>
+alert( document.head.nextSibling ); // HTMLBodyElement
 
-  // <body> 的上一个兄弟节点是  <head>
-  alert( document.body.previousSibling ); // HTMLHeadElement
-</script></body></html>
+// <body> 的前一个是 <head>
+alert( document.body.previousSibling ); // HTMLHeadElement
 ```
 
-## 只在元素中导航
+## 纯元素导航
 
-上面列出的导航属性涉及到**所有**节点。比如说，在 `childNodes` 中我们可以看到文本节点，元素节点，甚至如果存在注释节点的话，也能访问到。 
+上面列出的导航（navigation）属性引用 **所有** 节点。例如，在 `childNodes` 中我们可以看到文本节点，元素节点，甚至如果注释节点存在的话，也能访问到。 
 
-但是对于很多任务来说，我们并不想要文本或者注释节点。我们希望可以操纵代表标签的元素节点以及构建整个页面的结构。
+但是对于很多任务来说，我们并不想要文本节点或注释节点。我们希望操纵的是代表标签的和形成页面结构的元素节点。
 
-所以让我们看看当只考虑**元素节点**时更多的导航链接：
+所以，让我们看看更多只考虑 **元素节点** 的导航链接（navigation link）：
 
 ![](dom-links-elements.svg)
 
-这些链接和之前上面的相似，只是在词中间加了 `Element`：
+这些链接和我们在上面提到过的类似，只是在词中间加了 `Element`：
 
-- `children` —— 只获取类型为元素节点的子节点。
-- `firstElementChild`，`lastElementChild` —— 第一个和最后一个子元素。
-- `previousElementSibling`，`nextElementSibling` —— 兄弟元素。
-- `parentElement` —— 父元素。
+- `children` — 仅那些作为元素节点的子代的节点。
+- `firstElementChild`，`lastElementChild` — 第一个和最后一个子元素。
+- `previousElementSibling`，`nextElementSibling` — 兄弟元素。
+- `parentElement` — 父元素。
 
 ````smart header="为什么是 `parentElement`? 父节点可以不是一个元素吗？"
-`parentElement` 属性返回的是“元素”父节点，而 `parentNode` 返回的是“任何类型”的父节点。这些属性通常来说是一样的：它们都获取父节点。
+`parentElement` 属性返回的是“元素类型”的父节点，而 `parentNode` 返回的是“任何类型”的父节点。这些属性通常来说是一样的：它们都是用于获取父节点。
 
-除了有一个例外就是 `document.documentElement`：
+唯一的例外就是 `document.documentElement`：
 
 ```js run
 alert( document.documentElement.parentNode ); // document
 alert( document.documentElement.parentElement ); // null
 ```
 
-换句话说，`documentElement`（对应 `<html>` 标签）是根节点。形式上来讲，它有 `document` 作为它的父节点。但是 `document` 并不是一个元素节点，所以 `parentNode` 返回了 `document` 而 `parentElement` 却没有。
+因为根节点 `document.documentElement`（`<html>`）的父节点是 `document`。但 `document` 不是一个元素节点，所以 `parentNode` 返回了 `document`，但 `parentElement` 返回的是 `null`。
 
-有时候，当我们要遍历父节点并且在每个遍历的节点调用方法时这很重要，但是 `document` 并没有父元素节点，所以我们要将它排除在外。
+当我们想从任意节点 `elem` 到 `<html>` 而不是到 `document` 时，这个细节可能很有用：
+```js
+while(elem = elem.parentElement) { // 向上，直到 <html>
+  alert( elem );
+}
+```
 ````
 
-让我们修改上面的其中一个例子：用 `children` 来替换 `childNodes`。现在它就只显示元素：
+让我们修改上面的一个示例：用 `children` 来替换 `childNodes`。现在它只显示元素：
 
 ```html run
 <html>
@@ -268,29 +276,29 @@ alert( document.documentElement.parentElement ); // null
 
 ## 更多链接：表 [#dom-navigation-tables]
 
-到现在为止我们描述了基本的导航属性。
+到现在，我们已经描述了基本的导航（nabigation）属性。
 
-为了方便起见，某些类型的 DOM 元素会提供特定于其类型的额外属性。
+方便起见，某些类型的 DOM 元素可能会提供特定于其类型的其他属性。
 
-Tables 是其中一个很好也是很重要的例子。
+表（Table）是一个很好的例子，它代表了一个特别重要的情况：
 
-**`<table>`** 元素支持 (除了上面给出的之外) 以下这些属性:
-- `table.rows` — 用于表示表中 `<tr>` 元素的集合。
-- `table.caption/tHead/tFoot` — 用于访问元素 `<caption>`、`<thead>`、`<tfoot>`。
-- `table.tBodies` — `<tbody>` 元素的集合（根据标准该元素数量可以很多）。
+**`<table>`** 元素支持 (除了上面给出的，之外) 以下这些属性:
+- `table.rows` — `<tr>` 元素的集合。
+- `table.caption/tHead/tFoot` — 引用元素 `<caption>`，`<thead>`，`<tfoot>`。
+- `table.tBodies` — `<tbody>` 元素的集合（根据标准还有很多元素，但是这里至少会有一个 — 即使没有被写在 HTML 源文件中，浏览器也会将其放入 DOM 中）。
 
-**`<thead>`、`<tfoot>`、`<tbody>`** 元素提供了 `rows` 属性：
+**`<thead>`，`<tfoot>`，`<tbody>`** 元素提供了 `rows` 属性：
 - `tbody.rows` — 表内部 `<tr>` 元素的集合。
 
 **`<tr>`：**
-- `tr.cells` — 在给定 `<tr>` 元素下 `<td>` 和 `<th>` 单元格的集合。
-- `tr.sectionRowIndex` — 在封闭的 `<thead>/<tbody>` 中 `<tr>` 的编号。
-- `tr.rowIndex` — 在表中 `<tr>` 元素的编号。
+- `tr.cells` — 在给定 `<tr>` 中的 `<td>` 和 `<th>` 单元格的集合。
+- `tr.sectionRowIndex` — 给定的 `<tr>` 在封闭的 `<thead>/<tbody>/<tfoot>` 中的位置（索引）。
+- `tr.rowIndex` — 在整个表中 `<tr>` 的编号（包括表的所有行）。
 
 **`<td>` 和 `<th>`：**
 - `td.cellIndex` — 在封闭的 `<tr>` 中单元格的编号。
 
-下面是使用这些属性的例子：
+用法示例：
 
 ```html run height=100
 <table id="table">
@@ -303,22 +311,23 @@ Tables 是其中一个很好也是很重要的例子。
 </table>
 
 <script>
-  // 获取第一行中第二个单元格的内容
-  alert( table.*!*rows[0].cells[1]*/!*.innerHTML ) // "two"
+  // 获取带有 "two" 的 td（第一行，第二列）
+  let td = table.*!*rows[0].cells[1]*/!*;
+  td.style.backgroundColor = "red"; // highlight it
 </script>
 ```
 
 规范：[tabular data](https://html.spec.whatwg.org/multipage/tables.html)。
 
-HTML 表单还有其它额外的导航属性。我们稍后会在开始使用表单时看到它们。
+HTML 表单还有其它导航（navigation）属性。稍后当我们开始使用表单时，我们将对其进行研究。
 
-# 总结
+## 总结
 
-给一个 DOM 节点，我们可以使用导航属性来立即访问和它直接相邻的节点。
+给定一个 DOM 节点，我们可以使用导航（navigation）属性访问其直接的邻居。
 
-这些属性主要分两组：
+这些属性主要分为两组：
 
-- 对于所有的节点：`parentNode`、`childNodes`、`firstChild`、`lastChild`、`previousSibling` 和 `nextSibling`。
-- 仅用于元素节点：`parentElement`、`children`、`firstElementChild`、`lastElementChild`、`previousElementSibling` 和 `nextElementSibling`。
+- 对于所有节点：`parentNode`，`childNodes`，`firstChild`，`lastChild`，`previousSibling`，`nextSibling`。
+- 仅对于元素节点：`parentElement`，`children`，`firstElementChild`，`lastElementChild`，`previousElementSibling`，`nextElementSibling`。
 
-某些类型的 DOM 元素，比如说像 tables，提供了额外的属性和集合用于访问其内容。
+某些类型的 DOM 元素，例如 table，提供了用于访问其内容的其他属性和集合。