进阶之JSON对象大详解（二）
1、JSON 格式
JSON 格式（JavaScript Object Notation 的缩写）是一种用于数据交换的文本格式，2001年由 Douglas Crockford 提出，目的是取代繁琐笨重的 XML 格式。
相比 XML 格式，JSON 格式有两个显著的优点：书写简单，一目了然；符合 JavaScript 原生语法，可以由解释引擎直接处理，不用另外添加解析代码。所以，JSON 迅速被接受，已经成为各大网站交换数据的标准格式，并被写入标准。
每个 JSON 对象就是一个值，可能是一个数组或对象，也可能是一个原始类型的值。总之，只能是一个值，不能是两个或更多的值。
JSON 对值的类型和格式有严格的规定。
- 复合类型的值只能是数组或对象，不能是函数、正则表达式对象、日期对象。
- 原始类型的值只有四种：字符串、数值（必须以十进制表示）、布尔值和
null（不能使用NaN,Infinity,-Infinity和undefined）。- 字符串必须使用双引号表示，不能使用单引号。
- 对象的键名必须放在双引号里面。
- 数组或对象最后一个成员的后面，不能加逗号。
以下都是合法的 JSON。
["one", "two", "three"]
{ "one": 1, "two": 2, "three": 3 }
{"names": ["张三", "李四"] }
[ { "name": "张三"}, {"name": "李四"} ]以下都是不合法的 JSON。
{ name: "张三", 'age': 32 } // 属性名必须使用双引号
[32, 64, 128, 0xFFF] // 不能使用十六进制值
{ "name": "张三", "age": undefined } // 不能使用 undefined
{ "name": "张三",
"birthday": new Date('Fri, 26 Aug 2011 07:13:10 GMT'),
"getName": function () {
return this.name;
}
} // 属性值不能使用函数和日期对象注意，null、空数组和空对象都是合法的 JSON 值。
2、JSON 对象
JSON对象是 JavaScript 的原生对象，用来处理 JSON 格式数据。它有两个静态方法：JSON.stringify()和JSON.parse()。
3、JSON.stringify() 转为JSON字符串
3.1 基本用法
JSON.stringify方法用于将一个值转为 JSON 字符串。该字符串符合 JSON 格式，并且可以被JSON.parse方法还原。
// 单个字符串、数值、布尔值、null、空数组、空对象，都是合法json格式。
JSON.stringify('abc') // ""abc"" 注意：字符串会转json字符串会有两对双引号
JSON.stringify(1) // "1"
JSON.stringify(false) // "false"
JSON.stringify(null) // "null"
JSON.stringify([]) // "[]"
JSON.stringify({}) // "{}"
JSON.stringify([1, "false", false])
// '[1,"false",false]'
JSON.stringify({ name: "张三" })
// '{"name":"张三"}'上面代码将各种类型的值，转成 JSON 字符串。
注意，对于原始类型的字符串，转换结果会带双引号。
JSON.stringify('foo') === "foo" // false
JSON.stringify('foo') === "\"foo\"" // true上面代码中，字符串foo，被转成了"\"foo\""。这是因为将来还原的时候，内层双引号可以让 JavaScript 引擎知道，这是一个字符串，而不是其他类型的值。
JSON.stringify(false) // "false"
JSON.stringify('false') // "\"false\""上面代码中，如果不是内层的双引号，将来还原的时候，引擎就无法知道原始值是布尔值还是字符串。
如果对象的属性是undefined、函数或 XML 对象，该属性会被JSON.stringify过滤。
var obj = {
a: undefined,
b: function () {}
};
JSON.stringify(obj) // "{}" 对象属性是undefined、函数或 XML 对象会被过滤掉上面代码中，对象obj的a属性是undefined，而b属性是一个函数，结果都被JSON.stringify过滤。
如果数组的成员是undefined、函数或 XML 对象，则这些值被转成null。
var arr = [undefined, function () {}];
JSON.stringify(arr) // "[null,null]" 数组成员是undefined、函数或 XML 对象会被转成null上面代码中，数组arr的成员是undefined和函数，它们都被转成了null。
正则对象会被转成空对象。
JSON.stringify(/foo/) // "{}"JSON.stringify方法会忽略对象的不可遍历的属性。
var obj = {};
Object.defineProperties(obj, {
'foo': {
value: 1,
enumerable: true
},
'bar': {
value: 2,
enumerable: false
}
});
JSON.stringify(obj); // "{"foo":1}"上面代码中，bar是obj对象的不可遍历属性，JSON.stringify方法会忽略这个属性。
3.2 第二个参数 （一个数组，对象属性白名单；或一个函数，改写返回值）
JSON.stringify方法还可以接受一个数组，作为第二个参数，指定需要转成字符串的属性。
var obj = {
'prop1': 'value1',
'prop2': 'value2',
'prop3': 'value3'
};
var selectedProperties = ['prop1', 'prop2']; // 指定prop1、prop2属性转成字符串
JSON.stringify(obj, selectedProperties)
// "{"prop1":"value1","prop2":"value2"}"上面代码中，JSON.stringify方法的第二个参数指定，只转prop1和prop2两个属性。
这个类似白名单的数组，只对对象的属性有效，对数组无效。
JSON.stringify(['a', 'b'], ['0'])
// "["a","b"]"
JSON.stringify({0: 'a', 1: 'b'}, ['0'])
// "{"0":"a"}"上面代码中，第二个参数指定 JSON 格式只转0号属性，实际上对数组是无效的，只对对象有效。
第二个参数还可以是一个函数，用来更改JSON.stringify的返回值。
function f(key, value) { // 接收两个参数：键名、键值
if (typeof value === "number") {
value = 2 * value;
}
return value;
}
JSON.stringify({ a: 1, b: 2 }, f)
// '{"a": 2,"b": 4}'上面代码中的f函数，接受两个参数，分别是被转换的对象的键名和键值。如果键值是数值，就将它乘以2，否则就原样返回。
注意，这个处理函数是递归处理所有的键。
var o = {a: {b: 1}};
function f(key, value) { // 每一次处理的对象，都是前一次返回的值
console.log("["+ key +"]:" + value);
return value;
}
JSON.stringify(o, f)
// []:[object Object] 第一次键名 空，键值是o整个对象
// [a]:[object Object] 第二次键名 a，键值是{b:1}
// [b]:1 第三次键名 b，键值是 1
// '{"a":{"b":1}}'上面代码中，对象o一共会被f函数处理三次，最后那行是JSON.stringify的输出。第一次键名为空，键值是整个对象o；第二次键名为a，键值是{b: 1}；第三次键名为b，键值为1。
递归处理中，每一次处理的对象，都是前一次返回的值。
var o = {a: 1};
function f(key, value) {
if (typeof value === 'object') {
return {b: 2};
}
return value * 2;
}
JSON.stringify(o, f)
// "{"b": 4}"上面代码中，f函数修改了对象o，接着JSON.stringify方法就递归处理修改后的对象o。
如果处理函数返回undefined或没有返回值，则该属性会被忽略。
function f(key, value) {
if (typeof(value) === "string") {
return undefined;
}
return value;
}
JSON.stringify({ a: "abc", b: 123 }, f)
// '{"b": 123}上面代码中，a属性经过处理后，返回undefined，于是该属性被忽略了。
3.3 第三个参数 （增加返回JSON字符串的可读性；json格式）
JSON.stringify还可以接受第三个参数，用于增加返回的 JSON 字符串的可读性。如果是数字，表示每个属性前面添加的空格（最多不超过10个）；如果是字符串（不超过10个字符），则该字符串会添加在每行前面。
JSON.stringify({ p1: 1, p2: 2 }, null, 2);
/*
"{
"p1": 1,
"p2": 2
}"
*/
// 参数三是数值在使用JSON.parse()解析时正常
JSON.stringify({ p1:1, p2:2 }, null, '|-');
/*
"{
|-"p1": 1,
|-"p2": 2
}"
*/
// 参数三是字符串在使用JSON.parse()解析时报错3.4 参数对象的 toJSON 方法（对象自定义toJSON方法，转字符串只取该方法返回值）
如果参数对象有自定义的toJSON方法，那么JSON.stringify会使用这个方法的返回值作为参数，而忽略原对象的其他属性。
下面是一个普通的对象。
var user = {
firstName: '三',
lastName: '张',
get fullName(){
return this.lastName + this.firstName;
}
};
JSON.stringify(user)
// "{"firstName":"三","lastName":"张","fullName":"张三"}"现在，为这个对象加上toJSON方法。
var user = {
firstName: '三',
lastName: '张',
get fullName(){
return this.lastName + this.firstName;
},
toJSON: function () { // 只使用toJSON的返回值作为参数，忽略user对象的其他参数
return {
name: this.lastName + this.firstName
};
}
};
JSON.stringify(user)
// "{"name":"张三"}"上面代码中，JSON.stringify发现参数对象有toJSON方法，就直接使用这个方法的返回值作为参数，而忽略原对象的其他参数。
Date对象就有一个自己的toJSON方法。
var date = new Date('2015-01-01');
date.toJSON() // "2015-01-01T00:00:00.000Z"
JSON.stringify(date) // ""2015-01-01T00:00:00.000Z""上面代码中，JSON.stringify发现处理的是Date对象实例，就会调用这个实例对象的toJSON方法，将该方法的返回值作为参数。
toJSON方法的一个应用是，将正则对象自动转为字符串。因为JSON.stringify默认不能转换正则对象，但是设置了toJSON方法以后，就可以转换正则对象了。
var obj = {
reg: /foo/
};
// 不设置 toJSON 方法时
JSON.stringify(obj) // "{"reg":{}}"
// 设置 toJSON 方法时
RegExp.prototype.toJSON = RegExp.prototype.toString;
JSON.stringify(/foo/) // ""/foo/""上面代码在正则对象的原型上面部署了toJSON()方法，将其指向toString()方法，因此转换成 JSON 格式时，正则对象就先调用toJSON()方法转为字符串，然后再被JSON.stringify()方法处理。
4、JSON.parse()
JSON.parse方法用于将 JSON 字符串转换成对应的JSON值。
JSON.parse('{}') // {}
JSON.parse('true') // true
JSON.parse('"foo"') // "foo"
JSON.parse('[1, 5, "false"]') // [1, 5, "false"]
JSON.parse('null') // null
var o = JSON.parse('{"name": "张三"}');
o.name // 张三如果传入的字符串不是有效的 JSON 格式，JSON.parse方法将报错。
JSON.parse("'String'") // illegal single quotes
// SyntaxError: Unexpected token ILLEGAL上面代码中，双引号字符串中是一个单引号字符串，因为单引号字符串不符合 JSON 格式，所以报错。
为了处理解析错误，可以将JSON.parse方法放在try...catch代码块中。
try {
JSON.parse("'String'");
} catch(e) {
console.log('parsing error');
}JSON.parse方法可以接受一个处理函数，作为第二个参数，用法与JSON.stringify方法类似。
function f(key, value) {// 参数：键名、键值
if (key === 'a') {
return value + 10;
}
return value;
}
JSON.parse('{"a": 1, "b": 2}', f)
// {a: 11, b: 2}上面代码中，JSON.parse的第二个参数是一个函数，如果键名是a，该函数会将键值加上10。
文档
更多干货请公众号:龙哥手记 点击「加群进阶」, 进龙歌唯一的读者群。 如果有错误或者不严谨的地方，请务必得出指正，非常感谢。如果喜欢或者 有所启发，欢迎star, 对作者也是一种鼓励。 跟着龙哥一起掉亿点点秀发吧~, `别忘给我点赞 大帅比大漂亮们再走啊！！！
二、再来看 属性描述对象
1、啥意思
JavaScript 提供了一个内部数据结构，用来描述对象的属性，控制它的行为，比如该属性是否可写、可遍历等等。这个内部数据结构称为“属性描述对象”（attributes object）。每个属性都有自己对应的属性描述对象，保存该属性的一些元信息。
下面是属性描述对象的一个例子哈
{
value: 123, // 该属性的属性值，默认undefined
writable: false, // 属性值是否可改变，默认为true
enumerable: true, // 该属性是否可遍历，默认为true
configurable: false, //属性描述对象的可配置性,默认为true
get: undefined, // 该属性的取值函数（getter），默认为undefined
set: undefined // 该属性的存值函数（setter），默认为undefined
}属性描述对象提供6个元属性
（1）value
value是该属性的属性值，默认为undefined。
（2）writable
writable是一个布尔值，表示属性值（value）是否可改变（即是否可写），默认为true。
（3）enumerable
enumerable是一个布尔值，表示该属性是否可遍历，默认为true。如果设为false，会使得某些操作（比如for...in循环、Object.keys()）跳过该属性。
（4）configurable
configurable是一个布尔值，表示可配置性，默认为true。如果设为false，将阻止某些操作改写该属性，比如无法删除该属性，也不得改变该属性的属性描述对象（value属性除外）。也就是说，configurable属性控制了属性描述对象的可写性。
（5）get
get是一个函数，表示该属性的取值函数（getter），默认为undefined。
（6）set
set是一个函数，表示该属性的存值函数（setter），默认为undefined。
我估计你也记不到，记得常回来看哈
2、Object.getOwnPropertyDescriptor()
Object.getOwnPropertyDescriptor()方法可以获取属性描述对象。它的第一个参数是目标对象，第二个参数是一个字符串，对应目标对象的某个属性名。
var obj = {p:'a'}
Object.getOwnPropertyDescriptor(obj,'p')
// Object { value: "a", // 属性值'a'
// writable: true, // 属性值'a' 可改写
// enumerable: true, // 'p'属性可被遍历
// configurable: true // 属性描述对象的可配置性
// }
// getOwnPropertyDescriptor 中文含义：获取自己的属性描述符注意，Object.getOwnPropertyDescriptor()方法只能用在对象自身的属性，不能用于继承的属性哦
var obj = { p: 'a' };
Object.getOwnPropertyDescriptor(obj, 'toString')
// undefined上面代码里面，toString是obj对象继承的属性，Object.getOwnPropertyDescriptor()无法获取。
3、Object.getOwnPropertyNames()
Object.getOwnPropertyNames方法返回一个数组，成员是参数对象自身的全部属性的属性名，不管该属性要不要遍历。
返回对象的全部属性名
var obj = Object.defineProperties({}, {
p1: { value: 1, enumerable: true },
p2: { value: 2, enumerable: false }
});
Object.getOwnPropertyNames(obj)
// ["p1", "p2"]上面代码中，obj.p1是它可遍历的，obj.p2是不可遍历的。Object.getOwnPropertyNames则会将它们都返回。
这跟Object.keys的行为不同，Object.keys只返回对象自身的可遍历属性的全部属性名。
Object.keys([]) // []
Object.getOwnPropertyNames([]) // [ 'length' ]
Object.keys(Object.prototype) // []
Object.getOwnPropertyNames(Object.prototype)
/*[
"constructor", // 构造函数
"__defineGetter__",
"__defineSetter__",
"hasOwnProperty", // 检测属性名
"__lookupGetter__",
"__lookupSetter__",
"isPrototypeOf",
"propertyIsEnumerable",
"toString", // 返回类型字符串
"valueOf",
"__proto__", // 原型链
"toLocaleString"
]
*/上面代码中，数组自身的length属性是不可遍历的，Object.keys不会返回该属性。第二个例子的Object.prototype也是一个对象，所有实例对象都会继承它，它自身的属性都是不可遍历的哈。
4、Object.defineProperty()，Object.defineProperties()
Object.defineProperty()方法允许通过属性描述对象，定义或修改一个属性，然后返回修改后的对象，它的用法如下。
Object.defineProperty(object, propertyName, attributesObject)Object.defineProperty方法它接受三个参数，依次如下
- object：属性所在的对象
- propertyName：字符串，表示属性名
- attributesObject：属性描述对象
举例来说，定义obj.p可以写成下面这样子
var obj = Object.defineProperty({}, 'p', {
value: 123,
writable: false, // 设置为false，无法被改写
enumerable: true, // 可遍历
configurable: false // 属性描述不可再被配置
});
obj.p // 123
obj.p = 246; // 由于writable为false,改写无效
obj.p // 123上面代码中，Object.defineProperty()方法定义了obj.p属性。由于属性描述对象的writable属性为false，所以obj.p属性不可写。注意，这里的Object.defineProperty方法的第一个参数是{}（一个新建的空对象），p属性直接定义在这个空对象上面，然后返回这个对象，这是Object.defineProperty()的常见用法，请你一定要记住！ 
如果属性已经存在，Object.defineProperty()方法相当于更新该属性的属性描述对象。
如果一次性定义或修改多个属性，可以用Object.defineProperties()方法。
var obj = Object.defineProperties({}, {
p1: { value: 123, enumerable: true },
p2: { value: 'abc', enumerable: true },
p3: { get: function () { return this.p1 + this.p2 },
enumerable:true,
configurable:true
}
});
obj.p1 // 123
obj.p2 // "abc"
obj.p3 // "123abc"上面代码中，Object.defineProperties()同时定义了obj对象的三个属性。其中，p3属性定义了取值函数get，即每次读取该属性，都会调用这个取值函数。
敲黑板敲黑板，再不敲看你都要梦到外婆那里去了哈，这里一旦定义了取值函数
get（或存值函数set），就不能将writable属性设为true，或者同时定义value属性，否则会报错。
var obj = {};
Object.defineProperty(obj, 'p', {
value: 123,
get: function() { return 456; }
});
// TypeError: Invalid property.
// A property cannot both have accessors and be writable or have a value
Object.defineProperty(obj, 'p', {
writable: true,
get: function() { return 456; }
});
// TypeError: Invalid property descriptor.
// Cannot both specify accessors and a value or writable attribute上面代码中，同时定义了get属性和value属性，以及将writable属性设为true，就会报错。
Object.defineProperty()和Object.defineProperties()参数里面的属性描述对象，writable、configurable、enumerable这三个属性的默认值都为false。
var obj = {};
Object.defineProperty(obj, 'foo', {});
Object.getOwnPropertyDescriptor(obj, 'foo')
// { // 默认值
// value: undefined,
// writable: false,
// enumerable: false,
// configurable: false
// }上面代码中，定义obj.foo时用了一个空的属性描述对象，就可以看到各个元属性的默认值。
5、Object.prototype.propertyIsEnumerable()
实例对象的propertyIsEnumerable()方法返回一个布尔值，用来判断某个属性是否可遍历。注意，这个方法只能用于判断对象自身的属性，对于继承的属性一律返回false。
var obj = {};
obj.p = 123;
obj.propertyIsEnumerable('p') // true
obj.propertyIsEnumerable('toString') // false上面代码中，obj.p是可遍历的，而obj.toString是继承的属性哦
6、元属性
属性描述对象的各个属性叫做“元属性”，因为它们可以看作是控制属性的属性，好理解吧。
value目标属性的值
value属性是目标属性的值。
var obj = {};
obj.p = 123;
Object.getOwnPropertyDescriptor(obj, 'p').value
// 123
Object.defineProperty(obj, 'p', { value: 246 });
obj.p // 246上面代码是通过value属性，读取或改写obj.p的例子。
writable可写性
writable属性是一个布尔值，决定了目标属性的值（value）是否可以被改变。
var obj = {};
Object.defineProperty(obj, 'a', {
value: 37,
writable: false
});
obj.a // 37
obj.a = 25; // 可写性为false，值无法被修改
obj.a // 37上面代码中，obj.a的writable属性是false。然后，改变obj.a的值，不会有任何效果的。
再次我敲黑板，正常模式下，对
writable为false的属性赋值不会报错，它只会默默失败。但是，严格模式下会报错，即使对a属性重新赋予一个同样的值。
'use strict';
var obj = {};
Object.defineProperty(obj, 'a', {
value: 37,
writable: false
});
obj.a = 37;
// Uncaught TypeError: Cannot assign to read only property 'a' of object上面代码是严格模式，对obj.a任何赋值行为都会报错。
如果原型对象的某个属性的writable为false，那么子对象将无法自定义这个属性。
var proto = Object.defineProperty({}, 'foo', {
value: 'a',
writable: false
});
var obj = Object.create(proto); // obj对象继承proto对象
obj.foo = 'b';
obj.foo // 'a'上面代码中，proto是原型对象，它的foo属性不可写。obj对象继承proto，也不可以再自定义这个属性了。如果是严格模式，这样做还会抛出一个错误。
但是，有一个规避方法，就是通过覆盖属性描述对象，绕过这个限制。原因是这种情况下，原型链会被完全忽视。
var proto = Object.defineProperty({}, 'foo', {
value: 'a',
writable: false
});
var obj = Object.create(proto);
Object.defineProperty(obj, 'foo', {
value: 'b'
});
obj.foo // "b"enumerable可遍历性
enumerable（可遍历性）返回一个布尔值，表示目标属性是否可遍历。
JavaScript 的早期版本，for...in循环是基于in运算符的。我们知道，in运算符不管某个属性是对象自身的还是继承的，都会返回true的哈
var obj = {};
'toString' in obj // true上面代码中，toString不是obj对象自身的属性，但是in运算符也返回true，这导致了toString属性也会被for...in循环遍历。
这显然不太合理，后来咱们就引入了“可遍历性”这个概念。只有可遍历的属性，才会被for...in循环遍历，同时还规定toString这一类实例对象继承的原生属性，都是不可遍历的，这样就可保证了for...in循环的可用性了啦
具体来说，如果一个属性的enumerable为false，下面三个操作不会取到该属性。
for..in循环Object.keys方法JSON.stringify方法
因此，enumerable可以用来设置“秘密”属性。
var obj = {};
Object.defineProperty(obj, 'x', {
value: 123,
enumerable: false
});
obj.x // 123
for (var key in obj) {
console.log(key);
}
// undefined
Object.keys(obj) // []
JSON.stringify(obj) // "{}"上面代码中，obj.x属性的enumerable为false，所以一般的遍历操作都没有办法获取该属性，使得它有点像“秘密”属性，但不是真正的私有属性，还是可以直接获取它的值。
敲黑板了哈，
for...in循环包括继承的属性，Object.keys方法不包括继承的属性。如果需要获取对象自身的所有属性，不管是否可遍历，可以使用Object.getOwnPropertyNames方法。
另外，JSON.stringify方法会排除enumerable为false的属性，有时可以利用这一点。如果对象的 JSON 格式输出要排除某些属性，就可以把这些属性的enumerable设为false。
configurable可配置性
configurable(可配置性）返回一个布尔值，决定了是否可以修改属性描述对象。也就是说，configurable为false时，value、writable、enumerable和configurable都不能被修改了，不懂没关系直接上代码
var obj = Object.defineProperty({}, 'p', {
value: 1,
writable: false,
enumerable: false,
configurable: false
});
Object.defineProperty(obj, 'p', {value: 2})
// TypeError: Cannot redefine property: p
Object.defineProperty(obj, 'p', {writable: true})
// TypeError: Cannot redefine property: p
Object.defineProperty(obj, 'p', {enumerable: true})
// TypeError: Cannot redefine property: p
Object.defineProperty(obj, 'p', {configurable: true})
// TypeError: Cannot redefine property: p上面代码中，obj.p的configurable为false。然后，改动value、writable、enumerable、configurable，结果都报错。
注意，writable只有在false改为true会报错，true改为false它是允许的哈
var obj = Object.defineProperty({}, 'p', {
writable: true,
configurable: false
});
Object.defineProperty(obj, 'p', {writable: false})
// 修改成功至于value，只要writable和configurable有一个为true，就允许改动。
var o1 = Object.defineProperty({}, 'p', {
value: 1,
writable: true,
configurable: false
});
Object.defineProperty(o1, 'p', {value: 2})
// 修改成功
var o2 = Object.defineProperty({}, 'p', {
value: 1,
writable: false,
configurable: true
});
Object.defineProperty(o2, 'p', {value: 2})
// 修改成功另外，writable为false时，直接给目标属性赋值，不报错，但不会成功。
var obj = Object.defineProperty({}, 'p', {
value: 1,
writable: false,
configurable: false
});
obj.p = 2;
obj.p // 1上面代码中，obj.p的writable为false，对obj.p直接赋值不会生效。如果是严格模式，它还会报错。
可配置性决定了目标属性是否可以被删除（delete），比如
var obj = Object.defineProperties({}, {
p1: { value: 1, configurable: true },
p2: { value: 2, configurable: false }
});
delete obj.p1 // true
delete obj.p2 // false
obj.p1 // undefined
obj.p2 // 2上面代码中，obj.p1的configurable是true，所以可以被删除，obj.p2就无法删除。
7、存取器（get和set）
除了直接定义以外，属性还可以用存取器（accessor）定义。其中，存值函数称为setter，使用属性描述对象的set属性；取值函数称为getter，使用属性描述对象的get属性。
一旦对目标属性定义了存取器，那么存取的时候，都将执行对应的函数。利用这个功能，可以实现许多高级特性，比如某个属性禁止赋值这些用法
var obj = Object.defineProperty({}, 'p', {
get: function () { // 获取属性时执行
return 'getter' // 这里相当于定义了p属性的值，如果设置了get则不能再设置value
},
set: function (value) { // 设置属性时执行
console.log('setter: ' + value);
}
});
obj.p // "getter"
obj.p = 123 // "setter: 123"上面代码中，obj.p定义了get和set属性。obj.p取值时，就会调用get；赋值时，就会调用set。
JavaScript 还提供了存取器的另一种写法。
var obj = {
get p(){ // 相当于为obj对象创建一个p属性，并且赋值为‘getter’
return 'getter'
},
ser p(value){
console.log('setter'+value)
}
}上面的写法与定义属性描述对象是等价的，而且使用更广泛。
注意，取值函数get不能接受参数，存值函数set只能接受一个参数（即属性的值）。
不能拉多，
大爷说的对啊
存取器往往用于，属性的值依赖对象内部数据的场合。
var obj ={
$n : 5,
get next() { return this.$n++ },
set next(n) {
if (n >= this.$n) this.$n = n;
else throw new Error('新的值必须大于当前值');
}
};
obj.next // 5
obj.next = 10;
obj.next // 10
obj.next = 5;
// Uncaught Error: 新的值必须大于当前值上面代码中，next属性的存值函数和取值函数，都依赖于内部属性$n。
vue框架就是通过存取器来实现的数据响应式的哈，这个下面你可了解下
8、对象的拷贝
有时，我们需要将一个对象的所有属性，拷贝到另一个对象，可以用下面的方法实现。
var extend = function (to, from){
for(var property in from) {
to[property] = from[property]
}
return to
}
extend({}, {a: 1}) // {a:1}上面这个方法的问题在于，如果遇到存取器定义的属性，会只拷贝到属性和值，并不能拷贝到存取器
extend({}, {
get a() { return 1 }
})
// {a: 1} // 这里并没有拷贝到get方法为了解决这个问题，我们可以通过Object.defineProperty方法来拷贝属性。
var extend = function (to, from){
for(var property in from){
if(!from.hasOwnProperty()) continue //过滤继承属性 continue 终止本次循环，继续剩余循环
Object.defineProperty(
to,
property,
Object.getOwnPropertyDescriptor(from,property)
)
}
return to
}
extend({},{get a(){return 1}}) // {get a(){return 1}}上面代码中，hasOwnProperty那一行用来过滤掉继承的属性，否则可能会报错，因为Object.getOwnPropertyDescriptor读不到继承属性的属性描述对象。
9、控制对象读写状态
有时需要冻结对象的读写状态，防止对象被改变。
JavaScript 也提供了三种冻结方法：
-
最弱的一种是
Object.preventExtensions(不能新增，但能被删除和修改) -
其次是
Object.seal(不能新增和删除，但能修改) -
最强的是
Object.freeze(不能新增、删除和修改)
- 点赞
- 收藏
- 关注作者
评论（0）