记第一次导师考题

这个数据就像是工作时后端传过来的JSON格式，但是key值不是我们想要的，所以需要更换部分key值，所以写的代码需要保持一个可扩展性（可直接拿来用，在外配置一些数据即可）

const config = [
    {
        a1: 1,
        a2: 2,
        a3: [{ b1: 1, b2: 2, b3: [{ c1: 11 }] }],
    },
    {
        a1: 'a1b1c1a3',
        a2: 2,
        a3: [
            { b1: 1, b2: 2, b3: [{ c1: 11 }] },
            { b1: 1, b2: 2, b3: [{ c1: 11 }] },
        ],
    },
];

//a1 => ia1, a2 => ia2, a3 => ia3, b1 => ib1, c1 => ic1

代码规范需要牢记，自己找的答案，出现的问题：代码可扩展性太差，需要抽象同样的代码出来，定义函数使用箭头函数，空白使用4个空格，不使用tab，

const getType = v => {
    switch (Object.prototype.toString.call(v)) {
        case "[object Object]":
            return "Object";
        case "[object Array]":
            return "Array";
        default:
            return false;
    }
};
const copy = source => {
    let dest = Array.isArray(source) ? [] : {};
    const queue = [{ source, dest }];

    const set = new Set([]);

    while (queue.length) {
        const { dest, source } = queue.shift();
        const type = getType(source);
        if (type === "Array") {
            // 数组
            source.forEach((x, index) => {
                const xType = getType(x);
                if (!getType(x)) {
                    dest[index] = x;
                    return;
                }
                if (xType === "Array") {
                    dest[index] = [];
                    queue.push({
                        source: x,
                        dest: dest[index]
                    });
                    return;
                }
                if (xType === "Object") {
                    if (set.has(x)) {
                        dest[index] = x;
                        return;
                    }
                    dest[index] = {};
                    queue.push({
                        source: x,
                        dest: dest[index]
                    });
                    return;
                }
            });
        } else {
            // 对象
            for (let [k, v] of Object.entries(source)) {
                let temp = (k !== 'b2' & k !== 'b3') ? 'i' + k : k;
                const vType = getType(v);
                if (!vType) {
                    dest[temp] = v;
                    continue;
                }
                if (vType === "Array") {
                    dest[temp] = [];
                    queue.push({
                        source: v,
                        dest: dest[temp]
                    });
                }
                if (vType === "Object") {
                    if (set.has(v)) {
                        dest[temp] = v;
                        continue;
                    }
                    dest[temp] = {};
                    queue.push({
                        source: v,
                        dest: dest[temp]
                    });
                }
            }
        }
        set.add(source);
    }
    return dest;
};


const fun = (target) => {
    if (typeof target === 'object') {
        let result = Array.isArray(target) ? [] : {};
        for (const key in target) {
            let newKey = (result instanceof Array) ? key : 'i' + key;
            if (newKey == 'ib2') newKey = key
            if (newKey == 'ib3') newKey = key
            result[newKey] = fun(target[key]);
        }
        return result;
    } else {
        return target;
    }
};
// fun(config)
// console.log(copy(config));

参考导师给的答案：

const converterMap = {
    a1: 'ia1',
    a2: 'ia2',
    a3: 'ia3',
    b1: 'ib1',
    c1: 'ic1',
};

const converter = (config, converterMap) =>
    config.map((item) => {
        const result = {};
        Object.keys(item).forEach((key) => {
            result[converterMap[key] || key] = Array.isArray(item[key])
                ? converter(item[key], converterMap)
                : item[key];
        });
        return result;
    });

const converter1 = (config, converterMap) => {
    const configClone = JSON.parse(JSON.stringify(config));
    const queue = [configClone];
    while (queue.length) {
        const item = queue.shift();
        if (Array.isArray(item)) {
            queue.unshift(...item);
        } else {
            Object.keys(item).forEach((key) => {
                const value = item[key];
                delete item[key];
                if (Array.isArray(value)) {
                    queue.unshift(...value);
                }
                item[converterMap[key] || key] = value;
            });
        }
    }
    return configClone;
};

console.log(converter(config, converterMap));

console.log(converter1(config, converterMap));