属性
（一）数据属性：包含一个数据值的位置，在该位置可以对数据值进行读写
var person = {
name:"cxk",
age:18,
sex:null
}
如上代码所示，name,age,sex均为对象person的数据属性。
数据属性包含四个特征：
- configurable:表示能否对该属性进行配置，比如使用delete删除，能否修改属性特性等。默认为true
- enumerable:表示是否能被枚举，比如是否可以用for-in循环获取属性,默认为true。
- writable:表示是否可写，是否能修改属性的值。默认为true。
- value:包含属性的数据值，默认为undefined。
使用Object.getOwnPropertyDescriptor()方法可以获取指定属性的描述。
（二）访问器属性：访问器属性不包含数据值，它们包含一对getter和setter函数，通过定义访问器属性，可以实现设置一个属性的值会导致其它属性发生变化。
let person = {
name:"jack"
}
let temp = null;
Object.defineProperty(person,'name',{
get:function(){
console.log('被读取')
return temp;
},
set:function(val){
console.log('被设置')
temp = val
}
})
person.name = 'lucy';
console.log(person.name)
方法
原型方法
-
Object.prototype.hasOwnProperty()方法会返回一个布尔值，指对象自身是否具有指定的属性（也就是指定的key值）；该方法会忽略掉那些从原型链上继承到的属性类似于Object.keys(),不同于for-in。
function Fun(){}
var obj = new Fun();
obj.name = 'tll';
obj.age = 18;
Fun.prototype.sex = 'male';
console.log(obj.sex); //male
console.log(obj.hasOwnProperty('sex')); //false
console.log(obj.hasOwnProperty('name')); //true
-------------------------------------------------------------------
for(var key in obj){
console.log(key)； // name age sex 访问到原型上属性sex
}
console.log(Object.keys(obj)) // ["name","age"] 过滤掉原型上属性sex
-
Object.prototype.isPrototypeOf()返回一个布尔值，用来测试一个对象是否存在另外一个对象的原型链上。
语法：prototypeObj.isPrototypeOf(object),也就是判断对象prototypeObj是否在对象object的原型链上。也可以理解为对象object是否继承自对象prototypeObj。
var Fun = function(){};
var a = {
a:1
}
Fun.prototype = a;
var b = new Fun();
console.log(a.isPrototypeOf(b)); //true
-
Object.prototype.propertyIsEnumerable()方法返回一个布尔值，表示指定的属性是否可枚举。
function Person(){}
Person.prototype.age = 17;
var o = new Person();
o.name = 'zhangsan';
console.log(o.propertyIsEnumerable('name')); //true
console.log(o.propertyIsEnumerable('age')); //false
-
Object.prototype.toString()方法返回一个表示该对象的字符串。可以用来检测对象类型。
var obj = {};
console.log(obj.toString()); // [object Object]
var toString = Object.prototype.toString;
console.log(toString.call(new Date)); // [object Date]
console.log(toString.call(new String)); // [object String]
console.log(toString.call(Math)); // [object Math]
console.log(toString.call(undefined)); // [object Undefined]
console.log(toString.call(null)); // [object Null]
-
Object.prototype.watch()Object.prototype.unwatch()方法会监视属性是否被赋值并在赋值时运行相关函数。
var o = {p:1};
o.watch("p",
function (id, oldval, newval) {
console.log("o." + id + "由" + oldval + " 变为 " + newval);
return newval;
});
o.p = 2;
o.p = 3;
delete o.p;
o.p = 4;
o.unwatch('p');
o.p = 5;
//输出
o.p 由 1 变为 2
o.p 由 2 变为 3
o.p 由 undefined 变为 4
MDN说：通常来讲,你应该尽量避免使用 watch()和 [unwatch()] 这两个方法。因为只有 Gecko 实现了这两个方法，并且它们主要是为了在调试方便。另外，使用 watchpoint 对性能有严重的负面影响，在全局对象（如 window）上使用时尤其如此。你可以使用 setters and getters 或者 proxy 代替。参见 Compatibility 了解详情
-
Object.prototype.valueOf()方法返回指定对象的原始值。
var array = [1,2,3,4];
console.log(array.valueOf() === array); //true
var string = 'aaaaaaaaaa';
console.log(string.valueOf() === string); //true
var string1 = new String('aaaaaaaaa');
console.log(string1.valueOf() === string1); //false
string1.valueOf()值类型为string,string1的值类型时object。
对象方法
-
Object.assign()方法将所有可枚举属性的值从一个或多个源对象复制到目标对象，它将返回目标对象。
var target = {a:1,b:2,c:666}
var source = {c:3,d:4}
var assignObj = Object.assign(target,source);
console.log(target); //{a:1,b:2,c:3,d:4}
console.log(assignObj); //{a:1,b:2,c:3,d:4}
根据概念以及以上代码理解：
合并的对象仅仅只是将可枚举属性拿过来合并，也就是说继承属性和不可枚举属性是不能拷贝的。
合并对象时目标对象target会被改变
合并对象时相同属性的值，source的属性会覆盖之前其他对象的相同属性。比如target的c属性。
此方法不能实现深拷贝，假如源对象的属性值是一个对象的引用，那么它也只指向那个引用。
-
Object.create()方法创建一个新对象，使用现有对象来提供新创建对象的__proto__。
如上图所示，使用现有对象obj，来提供新对象o的__proto__。
Object.create()方法接收两个参数，
第二个参数可省略,具体可参考我总结的这篇文章《JavaScript ES6数据类型》
留个代码图，注意看o.p的值是不可修改的。
-
Object.entries()方法返回一个给定对象自身可枚举属性的键值对数组。
var obj = {name:"zhang",age:100,sex:"male"};
console.log(Object.entries(obj));
/*
[ ["name", "zhang"], ["age", 100], ["sex", "male"] ]
*/
-
Object.freeze()方法可以冻结一个对象。一个被冻结的对象再也不能被修改，也不能添加新属性，不能删除新属性，也不能修改其数据属性,该对象的原型也不能修改。freeze()返回和传入的参数相同的对象。
var obj = {
name:"tll",
age:18
}
Object.freeze(obj);
obj.name = "zhangsan";
console.log(obj); // obj{ name:"tll",age:18}
console.log(obj === Object.freeze(obj)); //true
-
Object.getOwnPropertyDescriptor(obj,prop)方法返回指定对象上自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）。
var obj = {
name:"lucy"
}
Object.getOwnPropertyDescriptor(obj,"name");
/*
{
configurable: true
enumerable: true
value: "lucy"
writable: true
}
*/
Object.getOwnPropertyDescriptors(obj)方法用来获取一个对象的所有自身属性的描述符。
-
Object.getOwnPropertyNames()方法返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。
var obj = {a:1,b:2,c:3}
Object.getOwnPropertyNames(obj);
//["a","b","c"]
obj.__proto__.d = 4;
Object.getOwnPropertyNames(obj);
//["a","b","c"]
-
Object.keys()方法会返回一个由一个给定对象的自身可枚举属性组成的数组。
var obj = {
a:1,
b:2,
c:3
}
Object.keys(obj);
// ["a","b","c"]
var o = Object.create(obj);
o.name = "oooo";
Object.keys(o);
// ["name"]
这里有个重点需要注意一下就是Object.getOwnPropertyNames()，Object.keys(),for-in都是可以获取到对象的属性的，但是他们是有区别的这里简单总结一下。
for in:使用for..in循环时，返回的是所有能够通过对象访问的、可枚举的属性，既包括存在于实例中的属性，也包括存在于原型中的属性。
Object.keys():用于获取对象自身所有的可枚举的属性值，但不包括原型中的属性，然后返回一个由属性名组成的数组
Object.getOwnPropertyNames():方法返回对象的所有自身属性的属性名（包括不可枚举的属性）组成的数组，但不会获取原型链上的属性
差异主要在属性是否可枚举，是来自原型，还是实例。
-
Object.getPrototypeOf()方法返回指定对象的原型。
var protoobj = {};
var obj = Object.create(protoobj);
Object.getPrototypeOf(obj) === protoobj // true
Object.getPrototypeOf(obj) === obj.__proto__// true
注意：Object.getPrototypeOf(Object)不是Object.prototype。这个仔细想想，想不明白可以查看我之前文章JavaScript原型理解
-
Object.setPrototypeOf()方法设置一个指定的对象的原型为另一个对象或null。
var obj = {a:1}
Object.setPrototypeOf(obj,{b:2});
这个方法作用实际上跟obj.__proto__.b = 2实际上是一样的，只不过由于规范原因，所以其实两者都可以使用。MDN上是这么说的：Object.setPrototypeOf()是ECMAScript 6最新草案中的方法，相对于 Object.prototype.__proto__，它被认为是修改对象原型更合适的方法。
学习参考：
MDN
JavaScript中in操作符(for..in)、Object.keys()和Object.getOwnPropertyNames()的区别
js中Object对象常用方法和属性