JavaScript递归封装：实现数组字段转换与深层嵌套处理

const list = [{ name: '张三' }];
// 转换为
const list = [{ title: '张三' }];

const list = [{ name: '张三' }];
console.log(list.map(v=>{
return { title: v.name }
}));

const list = [
{
  name: '张三',
  id: 6,
  children: [
    { name: '张三-第一个儿子', id: 1 },
    { name: '张三-第二个儿子', id: 2 },
  ]
},
{
  name: '李四',
  id: 5,
  children: [
    { name: '李四-第一个儿子', id: 3 },
    { name: '李四-第二个儿子', id: 4 },
  ]
}
];

/**
* props 示例: { title: 'name', children: 'children' }，
* key值是生成新数组的值，value是旧数组的值
* */
function recursion(list, props) {
let data = [];
// 如果不是数据或者props为空就直接返回
if (!Array.isArray(list) || !props) return list; 
// .遍历数组
for (let i = 0; i < list.length; i++) {
  // 保存一个对象
  let propsItem = {};
  // 遍历修改值
  for (const key in props) {
    if (!list[i][props[key]]) continue;
    propsItem[key] = list[i][props[key]];
  }
  data.push(propsItem);
  // 如果子级是一个数组就递归赋值
  if (propsItem.children && Array.isArray(propsItem.children)) {
    data[i]['children'] = recursion(propsItem.children, props);
  }
};
return data;
};

const res = recursion(list, {
title: 'name',
children: 'children'
});
console.log('66', res);

const list = [
    {
        id: 6,
        obj: { name: '张三' },
        children: [
            { obj: { name: '张三-第一个儿子', }, id: 1 },
            { obj: { name: '张三-第二个儿子', }, id: 2 },
        ]
    },
    {
        obj: { name: '李四' },
        id: 5,
        children: [
            { obj: { name: '李四-第一个儿子', }, id: 1 },
            { obj: { name: '李四-第二个儿子', }, id: 2 },
        ]
    }
];

/**
* props 示例: { title: 'obj.name', children: 'children' }，
* key值是生成新数组的值，value是旧数组的值
* */
function recursion(list, props) {
    let data = [];
    // 如果不是数据或者props为空就直接返回
    if (!Array.isArray(list) || !props) return list;
    // .遍历数组
    for (let i = 0; i < list.length; i++) {
        // 保存一个对象
        let propsItem = {};
        // 遍历修改值
        for (const key in props) {
            // 将字符串转为数组
            const propsKey = props[key].toString().split('.');
            // 如果数组大于等于2取其对象里面的值，反之直接拿key值
            const propsChild = propsKey.length >= 2 ? list[i][propsKey[0]][propsKey[1]] :
                propsKey.length === 1 ? list[i][propsKey[0]] : null;
            // 如果为空跳槽循环
            if (!propsChild) continue;
            propsItem[key] = propsChild;
        }
        data.push(propsItem)
        // 如果子级是一个数组就递归赋值
        if (propsItem.children && Array.isArray(propsItem.children)) {
            data[i]['children'] = recursion(propsItem.children, props);
        }
    };
    return data;
};

const res = recursion(list, {
    title: 'obj.name',
    children: 'children'
});
console.log('66', res);