JavaScript 中有八种数据类型。有七种原始类型，它们的值只包含一种东西（字符串，数字或者其他）。
对象则用来存储键值对和更复杂的实体。
我们可以通过使用带有可选 属性列表 的花括号 {…} 来创建对象。
一个属性就是一个键值对（“key: value”），其中键（key）是一个字符串（也叫做属性名），值（value）可以是任何值。

我们可以把对象想象成一个带有签名文件的文件柜。每一条数据都基于键（key）存储在文件中。这样我们就可以很容易根据文件名（也就是“键”）查找文件或添加/删除文件了。
object.svg
可以用下面两种语法中的任一种来创建一个空的对象（“空柜子”）：

  1. let user = new Object(); // “构造函数” 的语法
  2. let user = {};  // “字面量” 的语法

object-user-empty.svg
通常，我们用花括号。这种方式我们叫做字面量。

文本和属性

我们可以在创建对象的时候，立即将一些属性以键值对的形式放到 {…} 中。

  1. let user = {     // 一个对象
  2.   name: "John",  // 键 "name"，值 "John"
  3.   age: 30        // 键 "age"，值 30
  4. };

属性的键（或者也可以叫做“名字”或“标识符”），位于冒号 “:” 的前面，值在冒号的右边。
在 user 对象中，有两个属性：

  1. 第一个的键是 “name”，值是 “John”。
  2. 第二个的键是 “age”，值是 30。

生成的 user 对象可以被想象为一个放置着两个标记有 “name” 和 “age” 的文件的柜子。
object-user.svg
我们可以随时添加、删除和读取文件。
可以使用点符号访问属性值

  1. // 读取文件的属性：
  2. alert( user.name ); // John
  3. alert( user.age ); // 30

属性的值可以是任意类型，让我们加个布尔类型：

  1. user.isAdmin = true;

object-user-isadmin.svg
我们可以用 delete 操作符移除属性：

  1. delete user.age;

object-user-delete.svg
我们也可以用多字词语来作为属性名，但必须给它们加上引号：

  1. let user = {
  2.   name: "John",
  3.   age: 30,
  4.   "likes birds": true  // 多词属性名必须加引号
  5. };

object-user-props.svg
列表中的最后一个属性应以逗号结尾：

  1. let user = {
  2.   name: "John",
  3.   age: 30,
  4. }

这叫做尾随（trailing）或悬挂（hanging）逗号。这样便于我们添加、删除和移动属性，因为所有的行都是相似的。
使用 const 声明的对象是可以被修改的
请注意：用 const 声明的对象 能 被修改。
例如：

  1. const user = {
  2.   name: "John"
  3. };
  5. user.name = "Pete"; // (*)
  7. alert(user.name); // Pete

(*) 行似乎会触发一个错误，但实际并没有。const 声明仅固定了 user 的值，而不是值（该对象）里面的内容。
仅当我们尝试将 user=… 作为一个整体进行赋值时，const 会抛出错误。
有另一种将对象属性变为常量的方式，我们将在后面的 属性标志和属性描述符 一章中学习它。

方括号

对于多词属性，点操作就不能用了

  1. // 这将提示有语法错误
  2. user.likes birds = true

JavaScript 理解不了。它认为我们在处理 user.likes，然后在遇到意外的 birds 时给出了语法错误。
点符号要求 key 是有效的变量标识符。这意味着：不包含空格，不以数字开头，也不包含特殊字符（允许使用 $ 和 _）。
有另一种方法，就是使用方括号，可用于任何字符串：

  1. let user = {};
  3. // 设置
  4. user["likes birds"] = true;
  6. // 读取
  7. alert(user["likes birds"]); // true
  9. // 删除
  10. delete user["likes birds"];

现在一切都可行了。请注意方括号中的字符串要放在引号中，单引号或双引号都可以。
方括号同样提供了一种可以通过任意表达式来获取属性名的方法 —— 跟语义上的字符串不同 —— 比如像类似于下面的变量：

  1. let key = "likes birds";
  3. // 跟 user["likes birds"] = true; 一样
  4. user[key] = true;

在这里，变量 key 可以是程序运行时计算得到的，也可以是根据用户的输入得到的。然后我们可以用它来访问属性。这给了我们很大的灵活性。

  1. let user = {
  2.   name: "John",
  3.   age: 30
  4. };
  6. let key = prompt("What do you want to know about the user?", "name");
  8. // 访问变量
  9. alert( user[key] ); // John（如果输入 "name"）

点符号不能以类似的方式使用：

  1. let user = {
  2.   name: "John",
  3.   age: 30
  4. };
  6. let key = "name";
  7. alert( user.key ) // undefined

计算属性

当创建一个对象时，我们可以在对象字面量中使用方括号。这叫做 计算属性。

  1. let fruit = prompt("Which fruit to buy?", "apple");
  3. let bag = {
  4.   [fruit]: 5, // 属性名是从 fruit 变量中得到的
  5. };
  7. alert( bag.apple ); // 5 如果 fruit="apple"

计算属性的含义很简单：[fruit] 含义是属性名应该从 fruit 变量中获取。
所以，如果一个用户输入 “apple”，bag 将变为 {apple: 5}。
本质上，这跟下面的语法效果相同：

  1. let fruit = prompt("Which fruit to buy?", "apple");
  2. let bag = {};
  4. // 从 fruit 变量中获取值
  5. bag[fruit] = 5;

……但是看起来更好。
我们可以在方括号中使用更复杂的表达式：

  1. let fruit = 'apple';
  2. let bag = {
  3.   [fruit + 'Computers']: 5 // bag.appleComputers = 5
  4. };

方括号比点符号更强大。它允许任何属性名和变量，但写起来也更加麻烦。
所以，大部分时间里，当属性名是已知且简单的时候，就使用点符号。如果我们需要一些更复杂的内容，那么就用方括号。

属性值简写

在实际开发中，我们通常用已存在的变量当做属性名。

  1. function makeUser(name, age) {
  2.   return {
  3.     name: name,
  4.     age: age,
  5.     // ……其他的属性
  6.   };
  7. }
  9. let user = makeUser("John", 30);
  10. alert(user.name); // John

属性名跟变量名一样。这种通过变量生成属性的应用场景很常见，在这有一种特殊的 属性值缩写 方法，使属性名变得更短。
可以用 name 来代替 name:name 像下面那样：

  1. function makeUser(name, age) {
  2.   return {
  3.     name, // 与 name: name 相同
  4.     age,  // 与 age: age 相同
  5.     // ...
  6.   };
  7. }

我们可以把属性名简写方式和正常方式混用：

  1. let user = {
  2.   name,  // 与 name:name 相同
  3.   age: 30
  4. };

属性名称限制

我们已经知道，变量名不能是编程语言的某个保留字，如 “for”、“let”、“return” 等……
但对象的属性名并不受此限制：

  1. // 这些属性都没问题
  2. let obj = {
  3.   for: 1,
  4.   let: 2,
  5.   return: 3
  6. };
  8. alert( obj.for + obj.let + obj.return );  // 6

简而言之，属性命名没有限制。属性名可以是任何字符串或者 symbol（一种特殊的标志符类型，将在后面介绍）。
其他类型会被自动地转换为字符串。
例如，当数字 0 被用作对象的属性的键时，会被转换为字符串 “0”：

  1. let obj = {
  2.   0: "test" // 等同于 "0": "test"
  3. };
  5. // 都会输出相同的属性（数字 0 被转为字符串 "0"）
  6. alert( obj["0"] ); // test
  7. alert( obj[0] ); // test (相同的属性)

一个名为 proto 的属性。我们不能将它设置为一个非对象的值：

  1. let obj = {};
  2. obj.__proto__ = 5; // 分配一个数字
  3. alert(obj.__proto__); // [object Object] — 值为对象，与预期结果不同

这里有个小陷阱：一个名为 proto 的属性。我们不能将它设置为一个非对象的值：

  1. let obj = {};
  2. obj.__proto__ = 5; // 分配一个数字
  3. alert(obj.__proto__); // [object Object] — 值为对象，与预期结果不同

我们从代码中可以看出来，把它赋值为 5 的操作被忽略了。
我们将在 后续章节 中学习 proto 的特殊性质，并给出了 解决此问题的方法

属性存在性测试，“in” 操作符

相比于其他语言，JavaScript 的对象有一个需要注意的特性：能够被访问任何属性。即使属性不存在也不会报错！
读取不存在的属性只会得到 undefined。所以我们可以很容易地判断一个属性是否存在：

  1. let user = {};
  3. alert( user.noSuchProperty === undefined ); // true 意思是没有这个属性

这里还有一个特别的，检查属性是否存在的操作符 “in”。
语法是：

  1. "key" in object

例如：

  1. let user = { name: "John", age: 30 };
  3. alert( "age" in user ); // true，user.age 存在
  4. alert( "blabla" in user ); // false，user.blabla 不存在

请注意，in 的左边必须是 属性名。通常是一个带引号的字符串。
如果我们省略引号，就意味着左边是一个变量，它应该包含要判断的实际属性名。例如：

  1. let user = { age: 30 };
  3. let key = "age";
  4. alert( key in user ); // true，属性 "age" 存在

为何会有 in 运算符呢？与 undefined 进行比较来判断还不够吗？
确实，大部分情况下与 undefined 进行比较来判断就可以了。但有一个例外情况，这种比对方式会有问题，但 in 运算符的判断结果仍是对的。
那就是属性存在，但存储的值是 undefined 的时候：

  1. let obj = {
  2.   test: undefined
  3. };
  5. alert( obj.test ); // 显示 undefined，所以属性不存在？
  7. alert( "test" in obj ); // true，属性存在！

在上面的代码中，属性 obj.test 事实上是存在的，所以 in 操作符检查通过。
这种情况很少发生，因为通常情况下不应该给对象赋值 undefined。我们通常会用 null 来表示未知的或者空的值。因此，in 运算符是代码中的特殊来宾。

“for…in” 循环

为了遍历一个对象的所有键（key），可以使用一个特殊形式的循环：for..in。这跟我们在前面学到的 for(;;) 循环是完全不一样的东西。
语法：

  1. for (key in object) {
  2.   // 对此对象属性中的每个键执行的代码
  3. }

例如，让我们列出 user 所有的属性：

  1. let user = {
  2.   name: "John",
  3.   age: 30,
  4.   isAdmin: true
  5. };
  7. for (let key in user) {
  8.   // keys
  9.   alert( key );  // name, age, isAdmin
  10.   // 属性键的值
  11.   alert( user[key] ); // John, 30, true
  12. }

注意，所有的 “for” 结构体都允许我们在循环中定义变量，像这里的 let key。
同样，我们可以用其他属性名来替代 key。例如 “for(let prop in obj)” 也很常用。

像对象一样排序

对象“有特别的顺序”：整数属性会被进行排序，其他属性则按照创建的顺序显示。

  1. let codes = {
  2.   "49": "Germany",
  3.   "41": "Switzerland",
  4.   "44": "Great Britain",
  5.   // ..,
  6.   "1": "USA"
  7. };
  9. for(let code in codes) {
  10.   alert(code); // 1, 41, 44, 49
  11. }

对象可用于面向用户的建议选项列表。如果我们的网站主要面向德国观众，那么我们可能希望 49 排在第一。
但如果我们执行代码，会看到完全不同的现象：

  • USA (1) 排在了最前面
  • 然后是 Switzerland (41) 及其它。

因为这些电话号码是整数，所以它们以升序排列。所以我们看到的是 1, 41, 44, 49。
整数属性？那是什么？
这里的“整数属性”指的是一个可以在不做任何更改的情况下与一个整数进行相互转换的字符串。
所以，“49” 是一个整数属性名，因为我们把它转换成整数，再转换回来，它还是一样的。但是 “+49” 和 “1.2” 就不行了：

  1. // Math.trunc 是内置的去除小数部分的方法。
  2. alert( String(Math.trunc(Number("49"))) ); // "49"，相同，整数属性
  3. alert( String(Math.trunc(Number("+49"))) ); // "49"，不同于 "+49" ⇒ 不是整数属性
  4. alert( String(Math.trunc(Number("1.2"))) ); // "1"，不同于 "1.2" ⇒ 不是整数属性

……此外，如果属性名不是整数，那它们就按照创建时的顺序来排序，例如：

  1. let user = {
  2.   name: "John",
  3.   surname: "Smith"
  4. };
  5. user.age = 25; // 增加一个
  7. // 非整数属性是按照创建的顺序来排列的
  8. for (let prop in user) {
  9.   alert( prop ); // name, surname, age
  10. }

所以，为了解决电话号码的问题，我们可以使用非整数属性名来 欺骗 程序。只需要给每个键名加一个加号 “+” 前缀就行了。
像这样：

  1. let codes = {
  2.   "+49": "Germany",
  3.   "+41": "Switzerland",
  4.   "+44": "Great Britain",
  5.   // ..,
  6.   "+1": "USA"
  7. };
  9. for (let code in codes) {
  10.   alert( +code ); // 49, 41, 44, 1
  11. }

总结

对象是具有一些特殊特性的关联数组。
它们存储属性（键值对），其中：

  • 属性的键必须是字符串或者 symbol（通常是字符串）。
  • 值可以是任何类型。

我们可以用下面的方法访问属性：

  • 点符号: obj.property。
  • 方括号 obj[“property”]，方括号允许从变量中获取键，例如 obj[varWithKey]。

其他操作：

  • 删除属性：delete obj.prop。
  • 检查是否存在给定键的属性：”key” in obj。
  • 遍历对象：for(let key in obj) 循环。

我们在这一章学习的叫做“普通对象（plain object）”，或者就叫对象。
JavaScript 中还有很多其他类型的对象：

  • Array 用于存储有序数据集合，
  • Date 用于存储时间日期，
  • Error 用于存储错误信息。
  • ……等等。

它们有着各自特别的特性，我们将在后面学习到。有时候大家会说“Array 类型”或“Date 类型”，但其实它们并不是自身所属的类型，而是属于一个对象类型即 “object”。它们以不同的方式对 “object” 做了一些扩展。