Object 对象系列

如有错误请小伙伴们指正哦~~

遍历

遍历对象键名

keys()

keys() 是 Object 的静态函数，专门用来遍历对象获取键名。Object.keys() 函数的参数是一个对象，返回一个数组，元素是该对象所以本地属性名。如果使用该函数迭代数组，可以汇集数组的所有元素下标值。

使用 keys 还可以间接统计对象的长度

var o = {a : "A", b : "B", c : "C"};
console.log(Object.keys(o));  //返回["a","b","c"]
var a = ["A", "B", "C"];
console.log(Object.keys(a));  //返回["0","1","2"]

getOwnPropertyNames()

与 keys 用法相同

Object 还有一个类似的静态函数：getOwnPropertyNames(),与 keys 用法相同，参数都是对象，返回值都是一个数组，数组元素都是属性名。

不同点：keys 仅能迭代本地、可枚举的属性，getOwnPropertyNames 可以迭代所有本地属性

var o = {a : "A", b : "B", c : "C"};
console.log(Object.keys(o));  //返回["a","b","c"]
console.log(Object.getOwnPropertyNames (o));  //返回["a","b","c"]
var a = ["A", "B", "C"];
console.log(Object.keys(a));  //返回["0","1","2"]
console.log(Object.getOwnPropertyNames (a));  //返回["0","1","2"]

for in

var o = {a : "A", b : "B", c : "C"};
for (let a in o){
    console.log(a)
}
输出
a
b
c

事例：

对时间作为key的对象，就像先后排序

data = {
    '2021-02-03':[],
    '2021-02-01':[],
    '2021-02-04':[],
    '2021-02-02':[],
}
Xdata = Object.keys(data)
Xdata.sort((a, b) => this.sortByTime(a) - this.sortByTime(b));
//Xdata 输出排序时间顺序
//函数
sortByTime (entry) {
  return new Date(entry);
},

遍历对象键值

values()

var o = {a : "A", b : "B", c : "C"};
console.log(Object.values(o));  //返回 ['A', 'B', 'C']

遍历键值对数组

entries

var o = {a : "A", b : "B", c : "C"};
console.log(Object.entries(o));  
//返回  [['a', 'A'], ['b', 'B'], ['c', 'C']]

获取所有属性和方法名

Reflect.ownKeys(obj); 获取到对象所有属性和方法名，包括Symbol属性

Object方法

 new Object()

简洁写法

const foo = 'bar';
const baz = {foo};
baz  // {foo: "bar"}
// 等同于
const baz = {foo: foo};

解构赋值 ...

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };

x // 1
y // 2
z // { a: 3, b: 4 }

链判断运算符 ?.

const firstName = (message && message.body && message.body.user && message.body.user.firstName) || 'default';
简写
const firstName = message?.body?.user?.firstName || 'default';

对象的操作

Object.assign() 复制修改

Object.assign() 方法将所有可枚举（Object.propertyIsEnumerable() 返回 true）和自有（Object.hasOwnProperty() 返回 true）属性从一个或多个源对象复制到目标对象，返回修改后的对象

语法

Object.assign(target, ...sources)

参数

• target 目标对象，接收源对象属性的对象，也是修改后的返回值。
• sources 源对象，包含将被合并的属性。

返回值

        目标对象

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
// { a: 1, b: 4, c: 5 }

console.log(returnedTarget);
//  { a: 1, b: 4, c: 5 }

Object.create() 创建新对象

Object.create() 方法用于创建一个新对象，使用现有的对象来作为新创建对象的原型（prototype）

const person = {
    isHuman: false,
    printIntroduction: function() {
        console.log(My name is ${this.name}. Am I human? ${this.isHuman});
    }
};
const me = Object.create(person);
me.name = 'Matthew';
me.isHuman = true;
me.printIntroduction();
// "My name is Matthew. Am I human? true"
语法
Object.create(proto)
Object.create(proto, propertiesObject)

参数
proto 新创建对象的原型对象。
propertiesObject （可选）如果该参数被指定且不为 undefined，则该传入对象的自有可枚举属性（即其自身定义的属性，而不是其原型链上的枚举属性）将为新创建的对象添加指定的属性值和对应的属性描述符。这些属性对应于 Object.defineProperties() 的第二个参数。
返回值
一个新对象，带着指定的原型对象及其属性。

Object.is() 判断是否相同

Object.is({}, {})// false
+0 === -0 //true
NaN === NaN // false
Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

如果下列任何一项成立，则两个值相同：

• 两个值都是 undefined
• 两个值都是 null
• 两个值都是 true 或者都是 false
• 两个值是由相同个数的字符按照相同的顺序组成的字符串
• 两个值指向同一个对象
• 两个值都是数字并且
  • 都是正零  +0
  • 都是负零  -0
  • 都是NaN
  • 都是除零和 NaN 外的其它同一个数字

Object.fromEntries() 数组转对象

Object.entries的反向操作，把array转换为object 。

该方法可以把键值对列表转化为一个对象，入参可以是一个Map、Set、Array类型，或者其他实现了可迭代协议的可迭代对象。

Object.fromEntries([['a', 'A'], ['b', 'B'], ['c', 'C']])
输出
{a: 'A', b: 'B', c: 'C'}

delete 删除属性

var o = {a : "A", b : "B", c : "C"};
delete o.c
console.log(o)    输出 {a: 'A', b: 'B'}

Reflect.deleteProperty(0,"c"); //true
console.log(o)  //{a: 'A', b: 'B'}

不常用

冻结属性 不能修改属性，不能删除属性，不能添加属性

Object.freeze(obj);

判断对象是否被冻结

Object.isFrozen(obj) 

可以修改，不能删除，不能添加属性

Object.seal(obj);

判断是否使用seal

Object.isSealed(obj)

可以修改，可以删除，但是不能添加新属性，不能扩展

Object.preventExtensions(obj);

判断是否可以扩展

Object.isExtensible(obj)

获取对象中所有属性的描述对象列表对象

Object.getOwnPropertyDescriptors(obj)

获取obj对象的原型链

Object.getPrototypeOf(obj)