抱歉,您的浏览器无法访问本站

本页面需要浏览器支持(启用)JavaScript


了解详情 >

Mr.wang

Time flies and people come and go

记录开发中的对象的方法

class 类方法的使用

技巧及有趣的方法

for...in 语句以原始插入顺序迭代对象的可枚举属性

for...of 语句遍历可迭代对象定义要迭代的数据。

对象结构之分配剩余对象

1
2
3
4
5
6
7
8
9
10
let obj = { 1: { id: 1, a: 2, b: 3 }, 2: { id: 1, a: 2, b: 3 } };
const {
1: {},
...afterDel
} = obj;
console.log(afterDel);

let obj = { a: {}, b: { a: 2 } };
let { a, ...aa } = obj;
console.log(aa);

for in 去掉对象中为空的键值

1
2
3
4
5
for (const key in filter) {
if (filter[key] === "") {
delete filter[key];
}
}

对象的键值不仅仅只是一个字符串

1
2
3
4
5
6
7
8
9
10
11
let user = {
name: "wang",
age: 20,
};
let key = "name";
user[key]; //=> 输出wang

//key 可以是一个变量
let key = prompt("What do you want to know about the user?", "name");
//prompt 浏览器的输入弹窗 在输入后会返回输入的值给key(默认输入name)
user[key]; //==> John(如果输入 "name")

我们对于变量的键值应该是灵活的使用

key 是一个变量可以通过变量的赋值进而改变对象的输出

对象内的计算属性

我们可以在对象字面量中使用方括号。这叫做 计算属性

1
2
3
4
5
6
7
let key = prompt("What do you want to know about the user?", "name");

let user = {
[key]: "wang", // 属性名是从 key 变量中得到的
};

alert(user.name); // 5 如果 key="name"

对象的属性判断是否存在

1
2
user.key === undefined  返回true表示不存在
“key” in user 返回true表示存在

过滤空值(对象)

1
2
3
4
let obj = { a: "", b: 2, c: "wang" };
let target = {};
Object.keys(obj).map((v) => (obj[v] !== "" ? (target[v] = obj[v]) : ""));
console.log(target); //=>{b: 2, c: "wang"}

创建空对象(适用于发送请求传参)

创建一个空对象,我们可能大多数时候会使用对象字面量为{}的方式,然而这种方式创建的对象并不是纯粹的,它仍然有__proto__属性以及继承自Object原型的一些方法,这种方式创建的对象容易被修改,比如:

1
2
3
4
5
6
7
8
9
10
11
let o = {};
let p = Object.create(null);
Object.prototype.say = function(){
console.log('hello')
}
console.log(o.say)
console.log(p.say)

>> f(){}
>> undefined

对象深拷贝的处理

1
2
3
4
let val = { 1: { a: 1, b: 3 }, 2: { a: 2, b: 5 } };
let newVal = { ...val["1"], b: 4 };
val = { ...val, 1: newVal };
//outinput {"1":{a:1,b:4},"2":{a:2,b:5}}

class 类使用

递归 find 属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class A {
constructor() {
this.nameA = "a";
}
wangA() {
console.log("A");
}
}

class B extends A {
constructor() {
super();
this.nameB = "b";
}
wangB() {
console.log("B");
}
}

class C extends B {
constructor() {
super();
this.nameC = "c";
}
wangC() {
console.log("C");
}
}

var c = new C();
let arr = [];
function FindMembers(L, att, method) {
if (L.__proto__) {
let Att = Object.keys(L).filter((a) => a.indexOf(att) > -1);
let Method = Object.getOwnPropertyNames(L.__proto__).filter(
(m) => m.indexOf(method) > -1
);
arr = arr.concat(Att, Method);
FindMembers(L.__proto__, att, method);
}
return arr;
}
const members = FindMembers(c, "name", "wang");
console.log("members", members);

评论