From 5cbe27d94327eecb4a5f7f44e35df6a62dfd9418 Mon Sep 17 00:00:00 2001
From: athena0304 <athena0304@users.noreply.github.com>
Date: Mon, 10 Sep 2018 18:30:15 +0800
Subject: [PATCH 01/10] Update article.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修正：
花括号：`{}`
方括号：`[]`
---
 1-js/04-object-basics/01-object/article.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index be575251e0..05ab16c3c7 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -4,7 +4,7 @@
 正如我们从《引言：类型》那章中知道的那样，JavaScript 中有很多种类型。有六种原始类型，因为他们只包含一种东西（字符串，数值或者什么之类）。
 相反，对象用来存储键值对和更复杂的实体。在 JavaScript 中，对象深入到这门语言的方方面面。所以在我们深入理解这门语言之前，我们必须理解对象。
 
-对象可以通过中括号 `{…}` 和其中包含一些可选的**属性**来创建。属性是一个键值对，键是一个字符串（也叫做属性名），值可以是任何类型。
+对象可以通过花括号 `{…}` 和其中包含一些可选的**属性**来创建。属性是一个键值对，键是一个字符串（也叫做属性名），值可以是任何类型。
 
 我们可以把对象想象成存放文件的橱柜。文件按照他们的名字来排列。这样根据文件名我们就很容易找到，添加或删除一个文件了。
 
@@ -19,7 +19,7 @@ let user = {};  // “字面量” 的语法
 
 ![](object-user-empty.png)
 
-通常，我们用中括号。这种方式我们叫做**字面量**。
+通常，我们用括号。这种方式我们叫做**字面量**。
 
 ## 文本和属性
 
@@ -102,7 +102,7 @@ user.likes birds = true
 
 这是因为点操作需要的键是一个有效的标识符，不能有空格和其他的一些限制。
 
-有另一种方法，就是使用中括号，可以对任何字符串有效：
+有另一种方法，就是使用方括号，可以对任何字符串有效：
 
 
 ```js run
@@ -118,9 +118,9 @@ alert(user["likes birds"]); // true
 delete user["likes birds"];
 ```
 
-现在一切都很可行了。注意中括号中的字符串要放在引号中，单引号双引号都可以的。
+现在一切都很可行了。注意方括号中的字符串要放在引号中，单引号双引号都可以的。
 
-中括号同样提供了通过其他表达式来获取属性名的方式 —— 跟语义上的字符串不同 —— 比如像下面一样的变量：
+方括号同样提供了通过其他表达式来获取属性名的方式 —— 跟语义上的字符串不同 —— 比如像下面一样的变量：
 
 ```js
 let key = "likes birds";
@@ -149,7 +149,7 @@ alert( user[key] ); // John (如果输入 "name" )
 
 ### 计算属性
 
-我们可以用中括号包裹一个属性语法。这叫做**计算属性**。
+我们可以在对象字面量中使用方括号。这叫做**计算属性**。
 
 例如：
 
@@ -180,7 +180,7 @@ bag[fruit] = 5;
 
 ...但是看起来好多了。
 
-我们在中括号中可以用更复杂的表达式：
+我们在方括号中可以用更复杂的表达式：
 
 ```js
 let fruit = 'apple';
@@ -189,9 +189,9 @@ let bag = {
 };
 ```
 
-中括号比点方法获取属性更强大。它允许属性名和变量，它写起来也笨重多了。
+方括号比点方法获取属性更强大。它允许属性名和变量，它写起来也笨重多了。
 
-大部分时间里，当属性名是简答和确切的时候，用点方法。如果有一些复杂的操作，那么就用中括号。 
+大部分时间里，当属性名是简答和确切的时候，用点方法。如果有一些复杂的操作，那么就用方括号。 
 
 
 
@@ -709,7 +709,7 @@ alert(clone.sizes.width); // 51，在这里查看属性的值
 
 我们可以用下面的方法获取属性：
 - 点符号: `obj.property`。
-- 中括号 `obj["property"]`，中括号中可以使用变量 `obj[varWithKey]`。
+- 方括号 `obj["property"]`，方括号中可以使用变量 `obj[varWithKey]`。
 
 其他操作：
 - 删除属性：`delete obj.prop`。

From 270c4f10cbe1716b9ce5f77e27293d08a14e0c54 Mon Sep 17 00:00:00 2001
From: athena0304 <athena0304@users.noreply.github.com>
Date: Mon, 10 Sep 2018 18:32:30 +0800
Subject: [PATCH 02/10] Update article.md

---
 1-js/04-object-basics/01-object/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 05ab16c3c7..1b21c1047a 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -19,7 +19,7 @@ let user = {};  // “字面量” 的语法
 
 ![](object-user-empty.png)
 
-通常，我们用括号。这种方式我们叫做**字面量**。
+通常，我们用花括号。这种方式我们叫做**字面量**。
 
 ## 文本和属性
 

From df3ba5dca888ef2bc647c04e39e857dc6c24728b Mon Sep 17 00:00:00 2001
From: ouxuewen <ouxuewen@360.cn>
Date: Tue, 11 Sep 2018 16:24:38 +0800
Subject: [PATCH 03/10] update

---
 1-js/04-object-basics/01-object/article.md | 143 +++++++++++----------
 1 file changed, 72 insertions(+), 71 deletions(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 1b21c1047a..fcb153ef67 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -1,12 +1,12 @@
 
 # 对象
 
-正如我们从《引言：类型》那章中知道的那样，JavaScript 中有很多种类型。有六种原始类型，因为他们只包含一种东西（字符串，数值或者什么之类）。
-相反，对象用来存储键值对和更复杂的实体。在 JavaScript 中，对象深入到这门语言的方方面面。所以在我们深入理解这门语言之前，我们必须理解对象。
+正如我们从《引言：类型》那章中知道的那样，JavaScript 中有很七种类型。有六种原始类型，因为他们的值只包含一种东西（字符串，数值或者其他）。
+相反，对象用来存储键值对和更复杂的实体。在 JavaScript 中，对象深入到这门语言的方方面面。所以在我们深入理解这门语言之前，必须先理解对象。
 
 对象可以通过花括号 `{…}` 和其中包含一些可选的**属性**来创建。属性是一个键值对，键是一个字符串（也叫做属性名），值可以是任何类型。
 
-我们可以把对象想象成存放文件的橱柜。文件按照他们的名字来排列。这样根据文件名我们就很容易找到，添加或删除一个文件了。
+我们可以把对象想象成存放文件的橱柜。文件按照他们的名字来排列。这样根据文件名我们就很容易找到、添加或删除一个文件了。
 
 ![](object.png)
 
@@ -19,11 +19,11 @@ let user = {};  // “字面量” 的语法
 
 ![](object-user-empty.png)
 
-通常，我们用花括号。这种方式我们叫做**字面量**。
+通常，我们使用花括号。这种方式叫做**字面量**。
 
 ## 文本和属性
 
-我们可以在创建的时候立马给对象一些属性，在 `{...}` 里面放置一些键值对。
+我们可以在创建的时候立即给对象一些属性，在 `{...}` 里面放置一些键值对。
 
 ```js
 let user = {     // 一个对象
@@ -69,13 +69,13 @@ delete user.age;
 
 ![user object 3](object-user-delete.png)
 
-我们也可以用多字词语来作为属性名，但是他们必须被包在一起：
+我们也可以用多字词语来作为属性名，但是他们必须加上引号：
 
 ```js
 let user = {
   name: "John",
   age: 30,
-  "likes birds": true  // 两个单词被包在一起
+  "likes birds": true  // 多词属性名必须加引号
 };
 ```
 
@@ -93,7 +93,7 @@ let user = {
 
 ## 方括号
 
-对于多字词语表示的属性，点操作就不能用啦。
+对于多词属性，点操作就不能用了：
 
 ```js run
 // 语法错误
@@ -189,9 +189,9 @@ let bag = {
 };
 ```
 
-方括号比点方法获取属性更强大。它允许属性名和变量，它写起来也笨重多了。
+方括号比点符号更强大。它允许任何属性名和变量，但写起来也更加麻烦。
 
-大部分时间里，当属性名是简答和确切的时候，用点方法。如果有一些复杂的操作，那么就用方括号。 
+大部分时间里，当属性名是已知且简单的时候，用点方法。如果有一些复杂的操作，那么就用方括号。
 
 
 
@@ -200,7 +200,7 @@ let bag = {
 
 对于对象的属性，没有这些限制，都可以的：
 
-```js run
+​```js run
 let obj = {
   for: 1,
   let: 2,
@@ -224,17 +224,18 @@ alert(obj.__proto__); // [object Object]，这样不行
 
 比如，访问者可能选择 "__proto__" 作为键，这个赋值的逻辑就失败了（像上面那样）。
 
-有一种让对象把 `__proto__` 作为属性的方法，我们随后会讲到，现在我们再来学习对象的更多知识。
+有一种让对象把 `__proto__` 作为属性的方法，在后面章节会讲到，现在我们先来学习对象的更多知识。
 还有另外一种数据结构 [Map](info:map-set-weakmap-weakset)，我们会在后面章节学到，它支持任意的键值。
+
 ````
 
-## 便利的对象属性名
+## 属性值简写
 
 在实际应用中，我们通常用存在的变量当做属性名。
 
 例如：
 
-```js run
+​```js run
 function makeUser(name, age) {
   return {
     name: name,
@@ -245,13 +246,13 @@ function makeUser(name, age) {
 
 let user = makeUser("John", 30);
 alert(user.name); // John
-```
+​```
 
 在上面的例子中，属性名跟变量名一样。这种应用场景很常见，所以提供一种很便利的方式来定义对象的属性值。
 
 可以用 `name` 来代替 `name:name` 像下面那样：
 
-```js
+​```js
 function makeUser(name, age) {
 *!*
   return {
@@ -261,58 +262,58 @@ function makeUser(name, age) {
   };
 */!*
 }
-```
+​```
 
-我们可以把简便方式和正常方式混用：
+我们可以把简写方式和正常方式混用：
 
-```js
+​```js
 let user = {
   name,  // 与 name:name 相同
   age: 30
 };
-```
+​```
 
 ## 存在值检查
 
 对象的一个显著的特点就是可以访问任何属性，如果这个属性名没有值也不会有错误。访问一个不存在的属性会返回 `undefined`。它提供一种普遍的方法去检查属性是否存在 —— 获得值来与 undefined 比较：
 
-```js run
+​```js run
 let user = {};
 
 alert( user.noSuchProperty === undefined ); // true 意思是没有这个属性
-```
+​```
 
 同样也有一个特别的操作符 `"in"` 来检查是否属性存在。
 
 语法是：
-```js
+​```js
 "key" in object
-```
+​```
 
 例如：
 
-```js run
+​```js run
 let user = { name: "John", age: 30 };
 
 alert( "age" in user ); // true，user.age 存在
 alert( "blabla" in user ); // false，user.blabla 不存在。
-```
+​```
 
 注意 `in` 的左边必须是**属性名**。通常是一个字符串，如果不用字符串，那就是一个字符串变量。
 
-```js run
+​```js run
 let user = { age: 30 };
 
 let key = "age";
 alert( *!*key*/!* in user ); // true，获取键的名字和检查这个键的属性 
-```
+​```
 
-````smart header="Using \"in\" 属性中存储 `undefined`"
+​````smart header="Using \"in\" 属性中存储 `undefined`"
 通常，严格比较 `"=== undefined"` 就够用，但是也有一些特殊情况，`"in"` 就可以胜任。
 
 那就是属性存在，但是存储 `undefined`：
 
-```js run
+​```js run
 let obj = {
   test: undefined
 };
@@ -320,7 +321,7 @@ let obj = {
 alert( obj.test ); //  它是 undefined，所以难道它不存在吗？
 
 alert( "test" in obj ); // true，属性不存在！
-```
+​```
 
 
 在上面的代码中，属性 `obj.test` 事实上是存在的，所以 `in` 操作符可以。
@@ -364,11 +365,11 @@ for(let key in user) {
 
 ### 像对象一样排序
 
-对象有顺序吗？换句话说，如果我们便利一个对象，我们会按我们赋值属性的顺序来获得属性吗？这靠谱吗？
+对象有顺序吗？换句话说，如果我们遍历一个对象，我们会按照赋值属性的顺序来获得属性吗？这靠谱吗？
 
-简短的回答是：”有特别的顺序“：整数值属性有顺序，其他是按照创建的顺序，细节如下：
+简短的回答是：”有特别的顺序“：整数属性有顺序，其他是按照创建的顺序，细节如下：
 
-我们考虑下下面电话号码的例子：
+例如，让我们考虑一个带有电话号码的对象：
 
 ```js run
 let codes = {
@@ -386,29 +387,29 @@ for(let code in codes) {
 */!*
 ```
 
-对象会给用户一些建议，如果我们是为德国用户使用的网站，我们可能想 `49` 来当做第一个。
+对象可用于向用户建议选项列表。如果我们的网站主要面向德国用户，可能想让 `49` 来当做第一个。
 
-然而如果我们执行代码，我们会看到完全不同的景象：
+然而如果我们执行代码，会看到完全不同的景象：
 
-- USA (1) goes first
-- then Switzerland (41) and so on.
+- USA (1) 在最前面
+- 然后是 Switzerland (41) 以及其它内容
 
-这些电话码升序排序，因为他们是数字，所以我们看到 `1, 41, 44, 49`。
+因为这些电话号码是整数，所以它们以升序来排列。所以我们看到的是 `1, 41, 44, 49`。
 
-````smart header="数字属性？那是啥？"
-数字属性这里代表一个表示属性的字符串能不做改变的转换成整数。
+````smart header="整数属性？那是什么？"
+这里的“整数属性”术语指的是一个字符串，可以在不改变的情况下对整数进行转换。
 
-所以，"49" 是一个数字属性名，因为我们把它转换成整数，再转换回来，它还是一样。但是 "+49" 和 "1.2" 就不行了：
+所以，"49" 是一个整数属性名，因为我们把它转换成整数，再转换回来，它还是一样。但是 "+49" 和 "1.2" 就不行了：
 
-```js run
+​```js run
 // Math.trunc 是内置的去除小数点的方法。
-alert( String(Math.trunc(Number("49"))) ); // "49"，同样，数字属性
-alert( String(Math.trunc(Number("+49"))) ); // "49"，不同于 "+49" ⇒ 不是数字属性
-alert( String(Math.trunc(Number("1.2"))) ); // "1"，不同于 "1.2" ⇒ 不是数字属性
-```
+alert( String(Math.trunc(Number("49"))) ); // "49"，同样，整数属性
+alert( String(Math.trunc(Number("+49"))) ); // "49"，不同于 "+49" ⇒ 不是整数属性
+alert( String(Math.trunc(Number("1.2"))) ); // "1"，不同于 "1.2" ⇒ 不是整数属性
+​```
 ````
 
-...另外一边，如果属性值不是数字，那它按照创建时候的顺序排序：
+...另外一边，如果属性名不是整数，那它们就按照创建时候的顺序来排序：
 
 ```js run
 let user = {
@@ -418,14 +419,14 @@ let user = {
 user.age = 25; // 增加一个
 
 *!*
-// 非数字属性是按照创建的顺序来排的。
+// 非整数属性是按照创建的顺序来排列的。
 */!*
 for (let prop in user) {
   alert( prop ); // name, surname, age
 }
 ```
 
-所以，这就解决了电话码的问题，我们把数字属性转换成非数字的，在前面增加一个 `"+"` 就行了。
+所以，这就解决了电话号码的问题，我们把整数属性转换成非整数的，在前面增加一个 `"+"` 就行了。
 
 像这样：
 
@@ -464,7 +465,7 @@ let phrase = message;
 
 对象跟这个不一样。
 
-**变量不存对象本身，只是对象的“内存地址”，是对象的引用。**
+**变量存储的不是对象本身，而是对象的“内存地址”，是对象的引用。**
 
 下面是对象的存储结构图：
 
@@ -508,7 +509,7 @@ admin.name = 'Pete'; //  改变 "admin" 的引用
 alert(*!*user.name*/!*); // 'Pete', changes are seen from the "user" reference
 ```
 
-上面的例子展示了只存在一个对象，如果我们的抽屉有两把钥匙，如果一个钥匙去使用了抽屉，另外一个钥匙打开的时候就会看到改变了。
+上面的例子展示了只存在一个对象，就像我们的抽屉有两把钥匙，如果一个钥匙（`admin`）去使用了抽屉，稍后使用另外一个钥匙（`user`）打开的时候，就会看到有变化。
 
 ### 比较引用
 
@@ -526,7 +527,7 @@ alert( a == b ); // true，两个变量指向同一个对象
 alert( a === b ); // true
 ```
 
-如果是两个不同的属性，他们就不相等，甚至他们都是空的。
+如果是两个不同的属性，他们就不相等，即使都是空的。
 
 ```js run
 let a = {};
@@ -535,11 +536,11 @@ let b = {}; // 两个独立的对象
 alert( a == b ); // false
 ```
 
-如果比较两个对象 `obj1 > obj2` 或者用一个对象比较原始值 `obj == 5`，对象被转换成原始值。我们不久就会学习到对象的转化是如何实现的，但是事实上，上面的比较真的没用，要不就是你代码写错了。
+如果比较两个对象 `obj1 > obj2` 或者用一个对象比较原始值 `obj == 5`，对象被转换成原始值。我们不久就会学习到对象的转化是如何实现的，但是事实上，上面的比较真的极少用到，要不就是你代码写错了。
 
 ### 常量对象
 
-一个被 `const` 修饰的对象**可以**修改。
+一个被 `const` 修饰的对象**可以**被修改。
 
 例如：
 
@@ -555,7 +556,7 @@ user.age = 25; // (*)
 alert(user.age); // 25
 ```
 
-看起来好像 `(*)` 这行会报错，但是不是的，这根本没问题。这是因为 `const` 仅仅修饰 `user`。在这里 `user` 存的是一个对象的引用。引用的地址没有变，只是引用的对象被修改了。
+看起来好像 `(*)` 这行会报错，但是不是的，这完全没问题。这是因为 `const` 仅仅修饰 `user`。在这里 `user` 始终存储的都是同一个对象的引用。引用的地址没有变，只是引用的对象被修改了。
 
 如果你想把 `user` 赋值给其他的什么，那就会报错了，例如：
 
@@ -582,7 +583,7 @@ user = {
 
 这也是可行的，但是有一点麻烦，因为JS并没有原生的方法支持这么做。实际上，我们很少这么做。复制引用很多时候是好用的。
 
-如果我们真的想这么做，我们需要创建一个新的对象并且遍历现有对象的属性并且在原始值的状态下复制给新的对象。
+如果我们真的想这么做，就需要创建一个新的对象，遍历现有对象的属性，在原始值的状态下复制给新的对象。
 
 像这样：
 
@@ -615,8 +616,8 @@ alert( user.name ); // 原对象属性值不变
 Object.assign(dest[, src1, src2, src3...])
 ```
 
-- 参数 `dest` 和 `src1, ..., srcN` 可以是对象。
-- 这个方法复制了的所有对象到 `dest`。换句话说，第二个参数里面的对象的所有属性都复制给了第一个参数对象，然后返回 `dest`。
+- 参数 `dest` 和 `src1, ..., srcN` （可以有很多个）是对象。
+- 这个方法复制了 `src1, ..., srcN` 的所有对象到 `dest`。换句话说，从第二个参数开始，所有对象的属性都复制给了第一个参数对象，然后返回 `dest`。
 
 例如，我们可以用这个方法来把几个对象合并成一个：
 ```js
@@ -638,7 +639,7 @@ Object.assign(user, permissions1, permissions2);
 ```js
 let user = { name: "John" };
 
-// 重新 name，增加 isAdmin
+// 覆盖 name，增加 isAdmin
 Object.assign(user, { name: "Pete", isAdmin: true });
 
 // 现在 user = { name: "Pete", isAdmin: true }
@@ -657,7 +658,7 @@ let clone = Object.assign({}, user);
 */!*
 ```
 
-它复制了所有 `user` 对象的属性给了一个空对象，然后返回拷贝后的对象。事实上，这跟循环赋值一样，但是更短。
+它复制了 `user` 对象所有的属性给了一个空对象，然后返回拷贝后的对象。事实上，这跟循环赋值一样，但是更短。
 
 直到现在，我们是假设所有的 `user` 属性都是原始值，但是如果对象属性指向对象呢？
 
@@ -701,10 +702,10 @@ alert(clone.sizes.width); // 51，在这里查看属性的值
 
 ## 总结
 
-对象是联合的数组加上一些特别的特性。
+对象是具有一些特殊特性的关联数组。
 
 他们存储键值对：
-- 属性的键必须是字符串或者符号（通常也是字符串）。
+- 属性的键必须是字符串或者符号（通常是字符串）。
 - 值可以是任何类型。
 
 我们可以用下面的方法获取属性：
@@ -714,23 +715,23 @@ alert(clone.sizes.width); // 51，在这里查看属性的值
 其他操作：
 - 删除属性：`delete obj.prop`。
 - 检查属性是否存在：`"key" in obj`。
-- 枚举属性：`for(let key in obj)` 循环。
+- 遍历对象：`for(let key in obj)` 循环。
 
-对象根据引用来赋值或者复制。换句话说，对象中不存 "值"，而是 "引用" (内存地址)。 
+对象根据引用来赋值或者复制。换句话说，变量存的不是对象的"值"，而是值的 "引用" (内存地址)。 
 所以复制变量或者传递变量到方法中只是复制了对象的引用。
 所有的引用操作（像增加，删除属性）都作用于同一个对象。
 
-深拷贝的话我们用 `Object.assign` 或者 [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep)。
+深拷贝的话我们可以使用 `Object.assign` 或者 [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep)。
 
-我们在这里学到的叫做“基本对象” -- 对象。
+我们在这一章学习的叫做“基本对象” -- 对象。
 
-还有其他一些对象。
+JavaScript 中还有很多其他类型的对象：
 
-- `Array` 存储队列数组。
+- `Array` 存储有序数据集合。
 - `Date` 存储时间日期。
 - `Error` 存储错误信息
 - ...等等。
 
-他们有一些特别的特性，我们将在后面学习到。有时候大家说“数组类型”，“时间类型”，他们都属于对象类型的一种，都对对象类型做了一些延伸。
+他们有一些特别的特性，我们将在后面学习到。有时候大家说“数组类型”，“时间类型”，他们都属于对象类型的一种，都以不同的方式对对象类型做了一些扩展。
 
-对象在 JavaScript 中是很强大的，我们仅仅抓住庞然大物的表面一点谈了谈。我们将在后面的章节更进一步学习。
+对象在 JavaScript 中是很强大的，这里我们只接触了冰山一角。我们将在后面的章节更进一步学习。

From add430cdddbb400f4c625f2d401ddda7999f741a Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Wed, 12 Sep 2018 08:36:56 +0800
Subject: [PATCH 04/10] Update article.md

---
 1-js/04-object-basics/01-object/article.md | 46 +++++++++++-----------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index fcb153ef67..010221693c 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -200,7 +200,7 @@ let bag = {
 
 对于对象的属性，没有这些限制，都可以的：
 
-​```js run
+```js run
 let obj = {
   for: 1,
   let: 2,
@@ -235,7 +235,7 @@ alert(obj.__proto__); // [object Object]，这样不行
 
 例如：
 
-​```js run
+```js run
 function makeUser(name, age) {
   return {
     name: name,
@@ -246,13 +246,13 @@ function makeUser(name, age) {
 
 let user = makeUser("John", 30);
 alert(user.name); // John
-​```
+```
 
 在上面的例子中，属性名跟变量名一样。这种应用场景很常见，所以提供一种很便利的方式来定义对象的属性值。
 
 可以用 `name` 来代替 `name:name` 像下面那样：
 
-​```js
+```js
 function makeUser(name, age) {
 *!*
   return {
@@ -262,58 +262,58 @@ function makeUser(name, age) {
   };
 */!*
 }
-​```
+```
 
 我们可以把简写方式和正常方式混用：
 
-​```js
+```js
 let user = {
   name,  // 与 name:name 相同
   age: 30
 };
-​```
+```
 
 ## 存在值检查
 
 对象的一个显著的特点就是可以访问任何属性，如果这个属性名没有值也不会有错误。访问一个不存在的属性会返回 `undefined`。它提供一种普遍的方法去检查属性是否存在 —— 获得值来与 undefined 比较：
 
-​```js run
+```js run
 let user = {};
 
 alert( user.noSuchProperty === undefined ); // true 意思是没有这个属性
-​```
+```
 
 同样也有一个特别的操作符 `"in"` 来检查是否属性存在。
 
 语法是：
-​```js
+```js
 "key" in object
-​```
+```
 
 例如：
 
-​```js run
+```js run
 let user = { name: "John", age: 30 };
 
 alert( "age" in user ); // true，user.age 存在
 alert( "blabla" in user ); // false，user.blabla 不存在。
-​```
+```
 
 注意 `in` 的左边必须是**属性名**。通常是一个字符串，如果不用字符串，那就是一个字符串变量。
 
-​```js run
+```js run
 let user = { age: 30 };
 
 let key = "age";
 alert( *!*key*/!* in user ); // true，获取键的名字和检查这个键的属性 
-​```
+```
 
-​````smart header="Using \"in\" 属性中存储 `undefined`"
+````smart header="Using \"in\" 属性中存储 `undefined`"
 通常，严格比较 `"=== undefined"` 就够用，但是也有一些特殊情况，`"in"` 就可以胜任。
 
 那就是属性存在，但是存储 `undefined`：
 
-​```js run
+```js run
 let obj = {
   test: undefined
 };
@@ -321,7 +321,7 @@ let obj = {
 alert( obj.test ); //  它是 undefined，所以难道它不存在吗？
 
 alert( "test" in obj ); // true，属性不存在！
-​```
+```
 
 
 在上面的代码中，属性 `obj.test` 事实上是存在的，所以 `in` 操作符可以。
@@ -401,12 +401,12 @@ for(let code in codes) {
 
 所以，"49" 是一个整数属性名，因为我们把它转换成整数，再转换回来，它还是一样。但是 "+49" 和 "1.2" 就不行了：
 
-​```js run
+```js run
 // Math.trunc 是内置的去除小数点的方法。
 alert( String(Math.trunc(Number("49"))) ); // "49"，同样，整数属性
 alert( String(Math.trunc(Number("+49"))) ); // "49"，不同于 "+49" ⇒ 不是整数属性
 alert( String(Math.trunc(Number("1.2"))) ); // "1"，不同于 "1.2" ⇒ 不是整数属性
-​```
+```
 ````
 
 ...另外一边，如果属性名不是整数，那它们就按照创建时候的顺序来排序：
@@ -616,7 +616,7 @@ alert( user.name ); // 原对象属性值不变
 Object.assign(dest[, src1, src2, src3...])
 ```
 
-- 参数 `dest` 和 `src1, ..., srcN` （可以有很多个）是对象。
+- 参数 `dest` 和 `src1, ..., srcN`（可以有很多个）是对象。
 - 这个方法复制了 `src1, ..., srcN` 的所有对象到 `dest`。换句话说，从第二个参数开始，所有对象的属性都复制给了第一个参数对象，然后返回 `dest`。
 
 例如，我们可以用这个方法来把几个对象合并成一个：
@@ -717,13 +717,13 @@ alert(clone.sizes.width); // 51，在这里查看属性的值
 - 检查属性是否存在：`"key" in obj`。
 - 遍历对象：`for(let key in obj)` 循环。
 
-对象根据引用来赋值或者复制。换句话说，变量存的不是对象的"值"，而是值的 "引用" (内存地址)。 
+对象根据引用来赋值或者复制。换句话说，变量存的不是对象的"值"，而是值的 "引用"（内存地址）。 
 所以复制变量或者传递变量到方法中只是复制了对象的引用。
 所有的引用操作（像增加，删除属性）都作用于同一个对象。
 
 深拷贝的话我们可以使用 `Object.assign` 或者 [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep)。
 
-我们在这一章学习的叫做“基本对象” -- 对象。
+我们在这一章学习的叫做“基本对象” — 对象。
 
 JavaScript 中还有很多其他类型的对象：
 

From be67c200958ed9152724b420229ed8ac73d5430b Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Wed, 12 Sep 2018 08:39:30 +0800
Subject: [PATCH 05/10] resolve conflict

---
 1-js/04-object-basics/01-object/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 010221693c..47ba074096 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -19,7 +19,7 @@ let user = {};  // “字面量” 的语法
 
 ![](object-user-empty.png)
 
-通常，我们使用花括号。这种方式叫做**字面量**。
+通常，我们花括号。这种方式叫做**字面量**。
 
 ## 文本和属性
 

From 7bfe13acd7e31867f01e232e4257de942c4e4482 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Wed, 12 Sep 2018 08:40:02 +0800
Subject: [PATCH 06/10] Update article.md

---
 1-js/04-object-basics/01-object/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 47ba074096..1823506446 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -19,7 +19,7 @@ let user = {};  // “字面量” 的语法
 
 ![](object-user-empty.png)
 
-通常，我们花括号。这种方式叫做**字面量**。
+通常，我们用花括号。这种方式叫做**字面量**。
 
 ## 文本和属性
 

From 766cb8fefc39b98250382a8660b956361b84ad90 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Wed, 12 Sep 2018 08:40:44 +0800
Subject: [PATCH 07/10] Update article.md

---
 1-js/04-object-basics/01-object/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 1823506446..450b834240 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -19,7 +19,7 @@ let user = {};  // “字面量” 的语法
 
 ![](object-user-empty.png)
 
-通常，我们用花括号。这种方式叫做**字面量**。
+通常，我们用花括号。这种方式我们叫做**字面量**。
 
 ## 文本和属性
 

From 6bc9e772fe49a7822d41ca131abaec94b728ef33 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Wed, 12 Sep 2018 08:44:19 +0800
Subject: [PATCH 08/10] Update article.md

---
 1-js/04-object-basics/01-object/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index 450b834240..c38aabe6e0 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -189,7 +189,7 @@ let bag = {
 };
 ```
 
-方括号比点符号更强大。它允许任何属性名和变量，但写起来也更加麻烦。
+方括号比点方法获取属性更强大。它允许属性名和变量，它写起来也笨重多了。
 
 大部分时间里，当属性名是已知且简单的时候，用点方法。如果有一些复杂的操作，那么就用方括号。
 

From fe49af45b82e875a2f92cd0dcb232dc084ff4be6 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Wed, 12 Sep 2018 08:45:36 +0800
Subject: [PATCH 09/10] Update article.md

---
 1-js/04-object-basics/01-object/article.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index c38aabe6e0..b7f985c566 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -191,9 +191,7 @@ let bag = {
 
 方括号比点方法获取属性更强大。它允许属性名和变量，它写起来也笨重多了。
 
-大部分时间里，当属性名是已知且简单的时候，用点方法。如果有一些复杂的操作，那么就用方括号。
-
-
+大部分时间里，当属性名是简答和确切的时候，用点方法。如果有一些复杂的操作，那么就用方括号。 
 
 ```smart header="保留字段可以用作属性名"
 变量名不能用保留字段，像："for", "let", "return" 等。

From 8d15cfb3c1dfa10b17a31a9d8497de72ec9f6cd9 Mon Sep 17 00:00:00 2001
From: LeviDing <imdingxuewen@gmail.com>
Date: Wed, 12 Sep 2018 08:47:42 +0800
Subject: [PATCH 10/10] Update article.md

---
 1-js/04-object-basics/01-object/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md
index b7f985c566..14b8a92bfd 100644
--- a/1-js/04-object-basics/01-object/article.md
+++ b/1-js/04-object-basics/01-object/article.md
@@ -189,9 +189,9 @@ let bag = {
 };
 ```
 
-方括号比点方法获取属性更强大。它允许属性名和变量，它写起来也笨重多了。
+方括号比点符号更强大。它允许任何属性名和变量，但写起来也更加麻烦。
 
-大部分时间里，当属性名是简答和确切的时候，用点方法。如果有一些复杂的操作，那么就用方括号。 
+大部分时间里，当属性名是已知且简单的时候，用点方法。如果有一些复杂的操作，那么就用方括号。
 
 ```smart header="保留字段可以用作属性名"
 变量名不能用保留字段，像："for", "let", "return" 等。