JS数据的扁平化处理

1.纯数组扁平化

// 给定的数组
const arr = [1, [2, [3, 4, [5], 6], 7], 8, [9, [10, 11], 1], 2];

// 定义一个函数，用于将嵌套数组展平为一维数组
function flattenArray(obj = [], res = []) {
    // 如果输入为空数组，直接返回空数组
    if (!obj) return;

    // 遍历数组中的每个元素
    if (Array.isArray(obj)) {
        obj.forEach((item) => {
            // 如果元素是数组，则递归调用 flattenArray
            if (Array.isArray(item)) {
                flattenArray(item, res);
            } else {
                // 如果元素不是数组，将其添加到结果数组中
                res.push(item);
            }
        });
    }

    // 返回展平后的结果数组
    return res;
}

// 调用函数，将给定的嵌套数组展平为一维数组
const flattenedArray = flattenArray(arr);

// 打印展平后的数组
console.log(flattenedArray);

2.纯对象扁平化

// 给定的嵌套对象
const obj = { a: { b: { c: 1, d: 2 }, e: 3 }, f: { g: 2 } };

// 定义一个函数，用于将嵌套对象的键展平为字符串
function flattenKeys(obj, preKey = "", res = {}) {
  // 使用 Object.entries 遍历对象的键值对数组
  Object.entries(obj).forEach(([key, value]) => {
    // 检查值是否为对象且非空
    if (value && typeof value === "object") {
      // 如果值是对象且非空，递归调用 flattenKeys，并传递更新的键前缀
      flattenKeys(value, preKey + key + ".", res);
    } else {
      // 如果值不是对象，将键和值添加到结果对象中
      res[preKey + key] = value;
    }
  });

  // 返回展平后的结果对象
  return res;
}

// 调用函数，将给定的嵌套对象的键展平为字符串
const flattenedKeys = flattenKeys(obj);

// 打印展平后的键值对对象
console.log(flattenedKeys);

3.复杂类型扁平化

// 给定的对象数组
const obj1 = [1, 2, 3, { a: 1, b: { c: 2, d: { e: 3 } } }, [4, [5, 6, [7]]]];

// 给定的嵌套对象
const obj2 = { a: [1, [2, [3]], b: { c: { d: 1 } }, e: 2, f: 3 };

// 给定的对象数组
const obj3 = [{ a: 1, b: [2, { c: 3 }] }];

// 定义一个函数，用于将嵌套数组和对象的键展平为字符串
function flatten(obj = {}, preKey = "", res = {}) {
  // 空值判断，如果 obj 是空，直接返回
  if (!obj) return;

  // 获取 obj 对象的所有 [key, value] 数组并且遍历，forEach 的箭头函数中使用了解构
  Object.entries(obj).forEach(([key, value]) => {
    if (Array.isArray(value)) {
      // 如果 value 是数组，那么 key 就是数组的 index，value 就是对应的 value
      // obj 是数组的话就用 [] 引起来
      // 因为 value 是数组，数组后面是直接跟元素的，不需要 . 号
      let temp = Array.isArray(obj) ? `${preKey}[${key}]` : `${preKey}${key}`;
      flatten(value, temp, res);
    } else if (typeof value === 'object') {
      // 因为 value 是对象类型，所以在末尾需要加 . 号
      let temp = Array.isArray(obj) ? `${preKey}[${key}].` : `${preKey}${key}.`;
      flatten(value, temp, res);
    } else {
      // 如果 value 既不是数组也不是对象，将键和值添加到结果对象中
      let temp = Array.isArray(obj) ? `${preKey}[${key}]` : `${preKey}${key}`;
      res[temp] = value;
    }
  });

  // 返回展平后的结果对象
  return res;
}

// 调用函数，将给定的嵌套数组和对象的键展平为字符串
const flattenedObj1 = flatten(obj1);
const flattenedObj2 = flatten(obj2);
const flattenedObj3 = flatten(obj3);

// 打印展平后的键值对对象
console.log(flattenedObj1);
console.log(flattenedObj2);
console.log(flattenedObj3);