Object 和C里的结构体和字典类似（但是Object可以有“功能”），是多组“键值对”（key-value）的集合，是一种无序的复合数据集合。
let obj = {
'foo': 'Hello',
'bar': 'World'
};
上面的代码声明了一个对象obj，obj内包含了两个成员：foo 和 bar。 成员foo的键名为“foo”，而成员foo的键值为：“Hello”。
对象的所有键名都是字符串（ES6 又引入了 Symbol 值也可以作为键名），所以加不加引号都可以。
如果键名是数值，会被自动转为字符串。
let obj = {
1: 'a',
3.2: 'b',
1e2: true,
1e-2: true,
.234: true,
0xFF: true
};
obj
// Object {
// 1: "a",
// 3.2: "b",
// 100: true,
// 0.01: true,
// 0.234: true,
// 255: true
// }
obj['100'] // true
上面代码中，对象obj的所有键名虽然看上去像数值，实际上都被自动转成了字符串。
如果键名不符合标识名的条件（比如第一个字符为数字，或者含有空格或运算符），且也不是数字，则必须加上引号，否则会报错。
// 报错
let obj = {
1p: 'Hello World'
};
// 不报错
let obj = {
'1p': 'Hello World',
'h w': 'Hello World',
'p+q': 'Hello World'
};
上面对象的三个键名，都不符合标识名的条件，所以必须加上引号。
对象的每一个键名又称为“属性”（property），它的“键值”可以是任何数据类型。如果一个属性的值为函数，通常把这个属性称为“方法”，它可以像函数那样调用。
对象的属性之间用逗号分隔，最后一个属性后面可以加逗号（trailing comma），也可以不加。
属性可以动态创建，不必在对象声明时就指定。
1. 对象的声明
在 JS 中可以通过两种方式声明新的对象。
方法一：使用 new Object()和Object.creat()语句
new Object()语句可以在()内初始化对象的成员，也可以在之后动态创建成员
//直接初始化对象
let obj1 = new Object({"foo1": "Hello"});
console.log(obj1); //{"foo1": "Hello"}
//动态创建对象成员
let obj = new Object();
obj.foo = "Hello";//动态创建成员
console.log(obj); //{"foo": "Hello"}
//声明一个空的对象
let o = new Object()
let o = new Object(undefined)
let o = new Object(null)
Object.creat()语句可以直接创建一个已存在的对象，或者声明一个初始值为“null”的对象使用空值和undefined均会报错。
//创建一个空对象,之后可以动态创建成员
let obj1 = Object.creat(null);
obj1.foo = "Hello";//动态创建成员
console.log(obj1); //{"foo": "Hello"}
//创建已存在的变量
//Object.create(proto[, propertiesObject])
let obj2 = Object.creat(obj1);
console.log(obj2); //{}
console.log(obj2.foo)//Hello
obj1.bar = "World";//动态创建成员
console.log(obj1.bar)//World
console.log(obj2.bar)//World
按照已存在的对象（obj1）创建的新对象（obj2）中，新对象（obj2）以旧对象（obj1）为原型，所以新对象是空的，但是其原型链和旧对象（obj1）一起更新。
方法二：使用简写语句
let obj = {
foo: 1,
bar: 2
};
但要注意以下情况：
{ foo: 123 }
对象采用大括号表示，这导致了一个问题：如果行首是一个大括号，它到底是表达式还是语句？ JavaScript 引擎读到上面这行代码，会发现可能有两种含义。
- 第一种可能是，这是一个表达式，表示一个包含foo属性的对象；
- 第二种可能是，这是一个语句，表示一个代码区块，里面有一个标签foo，指向表达式123。
为了避免这种歧义，JavaScript 引擎的做法是，如果遇到这种情况，无法确定是对象还是代码块，一律解释为代码块。
{ console.log(123) } // 123
上面的语句是一个代码块，而且只有解释为代码块，才能执行。
如果要解释为对象，最好在大括号前加上圆括号。因为圆括号的里面，只能是表达式，所以确保大括号只能解释为对象。
({ foo: 123 }) // 正确
({ console.log(123) }) // 报错
这种差异在eval语句（作用是对字符串求值）中反映得最明显。
eval('{foo: 123}') // 123
eval('({foo: 123})') // {foo: 123}
上面代码中，如果没有圆括号，eval将其理解为一个代码块；加上圆括号以后，就理解成一个对象。
2. 对象的引用
当不同的变量指向同一个对象时，那么它们都是这个对象的引用，也就是说指向同一个内存地址。修改其中一个变量，会影响到其他所有变量。
let o1 = {};
let o2 = o1;
o1.a = 1;
o2.a // 1
o2.b = 2;
o1.b // 2
此时，如果取消某一个变量对于原对象的引用，不会影响到另一个变量。
let o1 = {};
let o2 = o1;
o1 = 1;
o2 // {}
但是，这种引用只局限于对象，如果两个变量指向同一个原始类型的值。那么，变量这时都是值的拷贝。
let x = 1;
let y = x;
x = 2;
y // 1
上面的代码中，当x的值发生变化后，y的值并不变，这就表示y和x并不是指向同一个内存地址。
3.对象属性的读取
读取对象的属性，有两种方法，一种是使用点运算符，还有一种是使用方括号运算符。
let obj = {
p: 'Hello World'
};
obj.p // "Hello World"
obj['p'] // "Hello World"
上面代码分别采用点运算符和方括号运算符，读取属性p。
请注意，如果使用方括号运算符，键名必须放在引号里面，否则会被当作变量处理。
let foo = 'bar';
let obj = {
foo: 1,
bar: 2
};
obj.foo // 1
obj[foo] // 2
方括号运算符内部还可以使用表达式。数字键可以不加引号，因为会自动转成字符串。
obj['hello' + ' world']
obj[3 + 3]
let obj = {
0.7: 'Hello World'
};
obj['0.7'] // "Hello World"
obj[0.7] // "Hello World"
注意，数值键名不能使用点运算符（因为会被当成小数点），只能使用方括号运算符。
let obj = {
123: 'hello world'
};
obj.123 // 报错
obj[123] // "hello world"
上面代码的第一个表达式，对数值键名123使用点运算符，结果报错。第二个表达式使用方括号运算符，结果就是正确的。
4.对象属性的“增、删、改、查”
4.1 对象属性的增加及修改
对象的属性可以动态创建，所以可以直接引用对象进行创建。
let obj = { };
obj.a = "111"; 报错
obj[123] = 222;
obj["aaa"] = 111;
console.log(obj); //{"a":"111","123":222;"aaa":111}
另外，也可以使用Object.defineProperty(obj, 'key', descriptor)语句增加对象的属性这个有点长啊
可以使用Object.assign()将其它对象的值复制到对象这个只是拷贝值，而不是成为原型链
const obj = { a: 1 };
const copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }
如果目标对象中的属性具有相同的键，则属性将被源对象中的属性覆盖。后面的源对象的属性将类似地覆盖前面的源对象的属性。
const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const returnedTarget = Object.assign(target, source);
console.log(target);
// expected output: Object { a: 1, b: 4, c: 5 }
console.log(returnedTarget);
// expected output: Object { a: 1, b: 4, c: 5 }
4.2 对象属性的删除
可以直接将对象的属性赋值为空，达到属性值的删除。
let obj = { a:111, b:2222};
obj.a = null;
console.log(obj);//{ a:null, b:2222}
如果要删除对象的属性，则需要delet命令。delete命令用于删除对象的属性，删除成功后返回true。
let obj = { p: 1 };
Object.keys(obj) // ["p"]
delete obj.p // true
obj.p // undefined
Object.keys(obj) // []
上面代码中，delete命令删除对象obj的p属性。删除后，再读取p属性就会返回undefined，而且Object.keys方法的返回值也不再包括该属性。
注意，删除一个不存在的属性，delete不报错，而且返回true。因此，不能根据delete命令的结果，认定某个属性是存在的。只有一种情况，delete命令会返回false，那就是该属性存在，且不得删除。
let obj = Object.defineProperty({}, 'p', {
value: 123,
configurable: false
});
obj.p // 123
delete obj.p // false
上面代码之中，对象obj的p属性是不能删除的，所以delete命令返回false（关于Object.defineProperty方法的介绍，请看《标准库》的 Object 对象一章）。
另外，需要注意的是，delete命令只能删除对象本身的属性，无法删除继承的属性。
let obj = {};
delete obj.toString // true
obj.toString // function toString() { [native code] }
上面代码中，toString是对象obj继承的属性，虽然delete命令返回true，但该属性并没有被删除，依然存在。这个例子还说明，即使delete返回true，该属性依然可能读取到值。
4.3 对象属性的查看
查看一个对象本身的所有属性，可以使用Object.keys方法。
let obj = {
key1: 1,
key2: 2
};
Object.keys(obj);
// ['key1', 'key2']
查看一个对象的全部属性，可以使用console.dir()
查看属性是否存在：in 运算符 'name' in obj
in运算符用于检查对象是否包含某个属性（检查的是键名，不是键值），如果包含就返回true，否则返回false。它的左边是一个字符串，表示属性名，右边是一个对象。
let obj = { p: 1 };
'p' in obj // true
'toString' in obj // true
in运算符的一个问题是，它不能识别哪些属性是对象自身的，哪些属性是继承的。就像上面代码中，对象obj本身并没有toString属性，但是in运算符会返回true，因为这个属性是继承的。
这时，可以使用对象的hasOwnProperty方法判断一下，是否为对象自身的属性。
**查看属性是否为自身属性：obj.hasOwnProperty('name') **
var obj = {};
if ('toString' in obj) {
console.log(obj.hasOwnProperty('toString')) // false
}
