Object 的一些知识点总结
1.hasOwnProperty
obj.hasOwnProperty(prop)
参数
prop: 要检测的属性字符串名称或者 Symbol
返回值
用来判断一个对象是否含有指定的属性的 Boolean
所有继承了 Object 的对象, 都会继承到 hasOwnProperty()方法。这个方法用来检测一个对象是否含有特定的自身属性。和 in 运算符不同，该方法会忽略那些从原型链上继承到的属性
Object.prototype.a = ‘aaa’;
var obj = {
b: ‘bbb’
}
console.log(obj.hasOwnProperty(a)); // false
for(var item in obj) {
console.log(item); // b a。此结果也找到了从原型链上继承过来的属性
}
如果 hasOwnProperty 作为属性名
var foo = {
hasOwnProperty: function() {
return false
},
bar: ‘bar’
}
foo.hasOwnProperty(‘bar’); // false
// 如果这种情况下, 想调用原型链上的方法
({}).hasOwnProperty.call(foo, ‘bar’); // 即 foo 对象调用了 {} 对象的方法。
// 等同于
Object.prototype.hasOwnProperty.call(foo, ‘bar’)
扩展：遍历一个对象的所有属性
for … in 只会循环可枚举的属性，所以不应该基于这个循环不可枚举的属性。
2.getOwnPropertyNames
Object.getOwnPropertyNames(obj)
参数
obj 一个对象，其自身的可枚举和不可枚举属性的名称被返回。
返回值
在给定对象上找到的自身属性对应的字符串数组。
Object.getOwnPropertyNames()返回一个数组, 数组中包含 obj 中可枚举和不可枚举的属性。
3.Object.keys()
Object.keys(obj)
参数
要返回其枚举自身属性的对象
返回值
一个表示给定对象的所有可枚举属性的字符串数组
描述
Object.keys()返回一个所有元素为字符串的数组，其元素来自于从给定的 object 上面可直接枚举的属性。这些属性的顺序与手动遍历该属性 (for…in…) 时一致。
var obj = {a:’a’,b:’b’,c:’c’};
console.log(Object.keys(obj));// [‘a’, ‘b’, ‘c’]
4.Object.values()
Object.keys()返回 key 值,Object.values()返回 value 值, 规则与 Object.keys()相同。
5.Object.assign()
Object.assign()用于将所有可枚举的值从一个对象复制到目标对象。它将返回目标对象。
Object.assign(target, …sources);
描述
如果目标对象中的属性与源对象中具有相同的属性。则目标对象中的属性将被覆盖。String 类型和 Symbol 类型的属性都会被拷贝。在出现错误的情况下，例如，如果属性不可写，会引发 TypeError，如果在引发错误之前添加了任何属性，则可以更改 target 对象。
const a = {a: ‘a’, b: ‘b’};
var b = Object.assign({}, a);
console.log(b); //{a: ‘a’, b: ‘b’}
深拷贝,Object.assign()只能拷贝对象第一层的属性。如果源对象的属性值是一个指向对象的引用, 它也只拷贝那个引用值。
let obj1 = {a: 0 , b: { c: 0}};
let obj2 = Object.assign({}, obj1);
console.log(JSON.stringify(obj2)); // {a: 0, b: { c: 0}}
obj1.a = 1;
console.log(JSON.stringify(obj1)); // {a: 1, b: { c: 0}}
console.log(JSON.stringify(obj2)); // {a: 0, b: { c: 0}}
obj2.a = 2;
console.log(JSON.stringify(obj1)); // {a: 1, b: { c: 0}}
console.log(JSON.stringify(obj2)); // {a: 2, b: { c: 0}}
obj2.b.c = 3;
console.log(JSON.stringify(obj1)); // {a: 1, b: { c: 3}}
console.log(JSON.stringify(obj2)); // {a: 2, b: { c: 3}}
// Deep Clone
obj1 = {a: 0 , b: { c: 0}};
let obj3 = JSON.parse(JSON.stringify(obj1));
obj1.a = 4;
obj1.b.c = 4;
console.log(JSON.stringify(obj3)); // {a: 0, b: { c: 0}}
合并对象
var o1 = {a: 1};
var o2 = {b: 2};
var o3 = {c: 3};
var obj = Object.assign(o1, o2, o3);
console.log(obj); // {a: 1, b: 2, c: 3}
console.log(o1); // {a: 1, b: 2, c: 3}, 注意目标对象自身也会改变。
合并具有相同属性的对象, 属性被后续参数中具有相同属性的其他对象覆盖。
var o1 = {a: 1, b: 1, c: 1};
var o2 = {b: 2, c: 2};
var o3 = {c: 3};
var obj = Object.assign({}, o1, o2, o3);
console.log(obj); // {a: 1, b: 2, c: 3}
拷贝 symbol 类型的属性
var o1 = {a: 1};
var o2 = {[Symbol(‘foo’)]: 2 };
var obj = Object.assign({}, o1, o2);
console.log(obj); // {a : 1, [Symbol(“foo”)]: 2 } (cf. bug 1207182 on Firefox)
Object.getOwnPropertySymbols(obj); // [Symbol(foo)]
继承属性和不可枚举属性是不能拷贝的
var obj = Object.create({foo: 1}, {// foo 是个继承属性。
bar: {
value: 2 // bar 是个不可枚举属性。
},
baz: {
value: 3,
enumerable: true // baz 是个自身可枚举属性。
}
});
var copy = Object.assign({}, obj);
console.log(copy); // {baz: 3}
原始类型会被包装为对象
var v1 = “abc”;
var v2 = true;
var v3 = 10;
var v4 = Symbol(“foo”)
var obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
// 原始类型会被包装，null 和 undefined 会被忽略。
// 注意，只有字符串的包装对象才可能有自身可枚举属性。
console.log(obj); // {“0”: “a”, “1”: “b”, “2”: “c”}
异常会打断后续拷贝任务
var target = Object.defineProperty({}, “foo”, {
value: 1,
writable: false
}); // target 的 foo 属性是个只读属性。
Object.assign(target, {bar: 2}, {foo2: 3, foo: 3, foo3: 3}, {baz: 4});
// TypeError: “foo” is read-only
// 注意这个异常是在拷贝第二个源对象的第二个属性时发生的。
console.log(target.bar); // 2，说明第一个源对象拷贝成功了。
console.log(target.foo2); // 3，说明第二个源对象的第一个属性也拷贝成功了。
console.log(target.foo); // 1，只读属性不能被覆盖，所以第二个源对象的第二个属性拷贝失败了。
console.log(target.foo3); // undefined，异常之后 assign 方法就退出了，第三个属性是不会被拷贝到的。
console.log(target.baz); // undefined，第三个源对象更是不会被拷贝到的。
拷贝访问器
var obj = {
foo: 1,
get bar() {
return 2;
}
};
var copy = Object.assign({}, obj);
// {foo: 1, bar: 2}
// copy.bar 的值来自 obj.bar 的 getter 函数的返回值
console.log(copy);
// 下面这个函数会拷贝所有自有属性的属性描述符
function completeAssign(target, …sources) {
sources.forEach(source => {
let descriptors = Object.keys(source).reduce((descriptors, key) => {
descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
return descriptors;
}, {});
// Object.assign 默认也会拷贝可枚举的 Symbols
Object.getOwnPropertySymbols(source).forEach(sym => {
let descriptor = Object.getOwnPropertyDescriptor(source, sym);
if (descriptor.enumerable) {
descriptors[sym] = descriptor;
}
});
Object.defineProperties(target, descriptors);
});
return target;
}
var copy = completeAssign({}, obj);
console.log(copy);
// {foo:1, get bar() {return 2} }