如何写js高质量代码，js操蛋代码分析

【创建对象时，键不要用字符串，又不是写JSON数据，这样写键值都是字符串，就难易辨认键还是值】
[{ 'code': '_rid', 'name': '序号', 'data_type': 'C' },
 { 'code': 'Z16__A', 'name': '附件名称', 'data_type': 'C'},
 ...items.map(item => ({ 'code': item.icode, 'name': item.iname, 'data_type': item.data_type }))]

【【2、循环滥用的-------------------】】
【这个用了三个循环，其中排序需要循环，剩下的两个完全能放在嵌套一个循环中，条件完成，跳出循环，节省开销】
FORM = FORM.filter(v => v.frequence == 'DD')
    .sort((a, b) => a.sn - b.sn)
    .map(v => {
        return { code: v.icode, name: v.iname };
    });

【【3、数据类型频繁转换的-------------------】】
【数据类型转换频繁的最好多分几步去完成，不要集成在一个语句，辨认难，调试难，修改bug更难】
let lastYear = +_arg.year - 1 + '';
var y = d.getFullYear();
    var m = d.getMonth() + 1;
    var d1 = d.getDate();
    return '' + y + (m > 9 ? m : '0' + m) + (d1 > 9 ? d1 : '0' + d1);

【【4、不懂函数参数封装多态的-------------------】】
【功能得封装成函数，多态得封装成参数】
ret5.reverse();
ret6.reverse();
ret7.reverse();
save(ret5, "5");
save(ret6, "6");
save(ret7, "7");

【【5、链式循环地狱的】】
【这代码一看，二看，三看是人写的吗？不要求你把算法写的高性能，但最起码的排序算法，递归算法得烂熟于心吧，这个循环用递归函数或者栈不是更好实现吗】
p.filter.forEach(function (v) {
            if (v[0] == '$or') {
                var o = { $or: [] };
                v[1].forEach(function (v1) {
                    if (v1.length == 2) {
                        if (v1[0] == '$and') {
                            var a = { $and: [] };
                            v1[1].forEach(function (v2) {
                                if (v2.length == 2) {
                                    if (v2[0] == '$or') {
                                        var oo = { $or: [] };
                                        v2[1].forEach(function (v3) {
                                            if (v3.length == 2) {
                                                oo.$or.push({
                                                    [v3[0]]: v3[1],
                                                });
                                            } else {
                                                oo.$or.push({
                                                    [v3[0]]: {
                                                        [v3[1]]: v3[2],
                                                    },
                                                });
                                            }
                                        });
                                        a.$and.push(oo);
                                    } else {
                                        a.$and.push({
                                            [v2[0]]: v2[1],
                                        });
                                    }
                                } else {
                                    a.$and.push({
                                        [v2[0]]: {
                                            [v2[1]]: v2[2],
                                        },
                                    });
                                }
                            });
                            o.$or.push(a);
                        } else {
                            o.$or.push({
                                [v1[0]]: v1[1],
                            });
                        }
                    } else {
                        o.$or.push({
                            [v1[0]]: {
                                [v1[1]]: v1[2],
                            },
                        });
                    }
                });
                filter.$and.push(o);
            } else {
                if (v.length == 2) {
                    filter.$and.push({
                        [v[0]]: v[1],
                    });
                } else {
                    filter.$and.push({
                        [v[0]]: {
                            [v[1]]: v[2],
                        },
                    });
                }
            }
        });


【【6、语法难懂的】】
【这个for语法，一看有点懵逼，再一看，还是懵逼，我才又把for语法重新看了一遍，才看懂这个循环，for第一个参数是循环前执行的，
	第二个是循环条件，第三个是每次循环时执行的，这个循环利用的是循环条件为0跳出循环做的，确实是不大好理解，
	最好还是写易读的代码，不要做这种剑走偏锋的思路】
function encode_col(col) {
    var s = '';
    for (++col; col; col = Math.floor((col - 1) / 2)) s = String.fromCharCode(((col - 1) % 26) + 65) + s;
    return s;
}