数据类型对象

具体来说，如果一个属性的 enumerable 为 false，下面三个操作不会取到该属性。

for..in 循环 可继承
Object.keys 方法 不可
JSON.stringify 方法 不可
object.getpropertynames 都可以遍历 不可继承

概述
生成方法
键名
对象的引用
表达式还是语句？加（）里都是表达式 不加为语句
属性的操作
属性的读取
属性的赋值
属性的查看
属性的删除：delete 命令
属性是否存在：in 运算符
属性的遍历：for…in 循环
with 语句
参考链接

1. 概述
1.1 生成方法
对象就是一组“键值对”（key-value）的集合，是一种无序的复合数据集合。

1.2 键名
1.2.1 对象的所有键名都是字符串（ES6 又引入了 Symbol 值也可以作为键名），所以加不加引号都可以
1.2.2 对象的所有键名都是字符串（ES6 又引入了 Symbol 值也可以作为键名），所以加不加引号都可以
var 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

1.2.3 如果键名不符合标识名的条件（比如第一个字符为数字，或者含有空格或运算符），且也不是数字，则必须加上引号，否则会报错

1.3 对象的引用

拷贝的是内存地址，指向同一个
如果不同的变量名指向同一个对象，那么它们都是这个对象的引用，也就是说指向同一个内存地址。修改其中一个变量，会影响到其他所有变量。

此时，如果取消某一个变量对于原对象的引用，不会影响到另一个变量。

var o1 = {};
var o2 = o1;

o1 = 1;
o2 // {}
上面代码中，o1 和 o2 指向同一个对象，然后 o1 的值变为 1，这时不会对 o2 产生影响，o2 还是指向原来的那个对象。

但是，这种引用只局限于对象，如果两个变量指向同一个原始类型的值。那么，变量这时都是值的拷贝。

var x = 1;
var y = x;

x = 2;
y // 1
上面的代码中，当 x 的值发生变化后，y 的值并不变，这就表示 y 和 x 并不是指向同一个内存地址。
1.4 表达式还是语句？

如果要解释为对象，最好在大括号前加上圆括号。因为圆括号的里面，只能是表达式，所以确保大括号只能解释为对象。

({foo: 123}) // 正确
({console.log(123) }) // 报错
这种差异在 eval 语句（作用是对字符串求值）中反映得最明显。

eval(‘{foo: 123}’) // 123
eval(‘({foo: 123})’) // {foo: 123

2. 属性的操作
2.1 属性的读取

obj.p
obj[‘p’]

2.1.1 如果使用方括号运算符，键名必须放在引号里面，否则会被当作变量处理。

var foo = ‘bar’;

var obj = {
foo: 1,
bar: 2
};

obj.foo // 1
obj[foo] // 2

2.1.2 方括号运算符内部还可以使用表达式。

obj[‘hello’ + ‘ world’]
obj[3 + 3]
2.1.3 数字键可以不加引号，因为会自动转成字符串。注意，数值键名不能使用点运算符（因为会被当成小数点），只能使用方括号运算符

var obj = {
0.7: ‘Hello World’
};

obj[‘0.7’] // “Hello World”
obj[0.7] // “Hello World”

2.2 属性的赋值
2.3 属性的查看
查看一个对象本身的所有属性，可以使用 Object.keys 方法。
不可遍历不可遍历的

2.4 属性的删除：delete 命令

返回真假
删除一个不存在的属性，delete 不报错，而且返回 true
删除一个 construct 不可的为假

delete 命令只能删除对象本身的属性，无法删除继承的属性（关于继承参见《面向对象编程》章节）。

var obj = {};
delete obj.toString // true
obj.toString // function toString() { [native code] }
2.5 属性是否存在：in 运算符
可以继承的无关遍历 在不在而已
这时，可以使用对象的 hasOwnProperty 方法判断一下，是否为对象自身的属性。

var obj = {};
if (‘toString’ in obj) {
console.log(obj.hasOwnProperty(‘toString’)) // false
}

2.6 属性的遍历：for…in 循环

跳过不可遍历 可以继承

举例来说，对象都继承了 toString 属性，但是 for…in 循环不会遍历到这个属性。

var obj = {};

// toString 属性是存在的
obj.toString // toString() { [native code] }

for (var p in obj) {
console.log(p);
} // 没有任何输出
上面代码中，对象 obj 继承了 toString 属性，该属性不会被 for…in 循环遍历到，因为它默认是“不可遍历”的

如果继承的属性是可遍历的，那么就会被 for…in 循环遍历到。但是，一般情况下，都是只想遍历对象自身的属性，所以使用 for…in 的时候，应该结合使用 hasOwnProperty 方法，在循环内部判断一下，某个属性是否为对象自身的属性。

var person = {name: ‘ 老张 ’};

for (var key in person) {
if (person.hasOwnProperty(key)) {

console.log(key);

}
}
// name

3.with 语句
里面必须是已有的属性，否则为全局变量
with (对象) {
语句;
}
它的作用是操作同一个对象的多个属性时，提供一些书写的方便

// 例一
var obj = {
p1: 1,
p2: 2,
};
with (obj) {
p1 = 4;
p2 = 5;
}
// 等同于
obj.p1 = 4;
obj.p2 = 5;

// 例二
with (document.links[0]){
console.log(href);
console.log(title);
console.log(style);
}
// 等同于
console.log(document.links[0].href);
console.log(document.links[0].title);
console.log(document.links[0].style

var obj = {};
with (obj) {
p1 = 4;
p2 = 5;
}

obj.p1 // undefined
p1 // 4

一个很大的弊病，就是绑定对象不明确，只能运营时判断，拖慢运行速度

不要使用 with 语句，可以考虑用一个临时变量代替 with。

with(obj1.obj2.obj3) {
console.log(p1 + p2);
}

// 可以写成
var temp = obj1.obj2.obj3;
console.log(temp.p1 + temp.p2);