从对象或数组中深度删除所有假值

JS 中数组或者对象中,深度删除所有的假值.包含嵌套的情况.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//   需求 深度删除对象或者数组中的假值
//   const obj = {
//   a: null,
//   b: false,
//   c: true,
//   d: 0,
//   e: 1,
//   f: '',
//   g: 'a',
//   h: [null, false, '', true, 1, 'a'],
//   i: { j: 0, k: false, l: 'a' }
// };
// output
// { c: true, e: 1, g: 'a', h: [ true, 1, 'a' ], i: { l: 'a' } }

过滤对象中的假值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function compactObject(val) {
  return Object.keys(val).reduce((acc, key) => {
    const value = val[key];
    if (value) {
      acc[key] = value;
    }
    return acc;
  }, {});
}

const obj = {
  a: null,
  b: false,
  c: true,
  d: 0,
  e: 1,
  f: "",
  g: "a",
};
console.log("result", compactObject(obj));

验证结果

过滤数组中的假值

1
2
3
4
5
6
function compactArray(arr) {
  return arr.filter(Boolean);
}

const arr = [null, false, "", true, 1, "a"];
console.log(compactArray(arr)); // [true,1,'a']

对象中嵌套数组,数组中也有对象的情况:

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
function compactObject(val) {
  // 值是数组的情况
  const data = Array.isArray(val) ? val.filter(Boolean) : val;
  return Object.keys(data).reduce(
    (acc, key) => {
      const value = data[key];
      if (value) {
        acc[key] = typeof value === "object" ? compactObject(value) : value;
        // acc[key] = value;
      }
      return acc;
    },
    Array.isArray(data) ? [] : {}
  );
}

const obj = {
  a: null,
  b: false,
  c: true,
  d: 0,
  e: 1,
  f: "",
  g: "a",
  h: [null, false, "", true, 1, "a", { a: 0, b: false, c: 123 }],
  i: { j: 0, k: false, l: "a" },
};

console.log("result", compactObject(obj));

嵌套情况



在这个例子中学到的几个小知识点:

  • [0,1,2].filter(Boolean) 这样写可以直接过滤掉数组中的假值
  • Object.keys()也可以用于数组,返回的就是数组中的索引.
  • 数组的索引可以是字符串格式的数字,比如:[“4”,”5”][“0”]的值就是”4”