js数组相关

const { delete } = require("request");

/** 
 * 数组循环：forEach / map / for of
*/
// foreach适用于只是进行集合或数组遍历，for则在较复杂的循环中效率更高。
// foreach不能对数组或集合进行修改（添加删除操作），如果想要修改就要用for循环
// forEach就是for循环的简化没有返回值  map有返回值,可以操作数组
var myArray = [1, {}, []]

myArray.forEach((e, i) => {
    if(Object.prototype.toString.call(e) === '[object Object]'){
        e.a = 2;
    } else if( e.constructor === Array ) {
        e.push(3)
    }
})
console.log(myArray) // [1, { a: 2}, [3]]

var newMapList = myArray.map((e) => {
    if(e.constructor === Object){
        e.b = 2;
        if(e.hasOwnProperty('a')){  // hasOwnProperty 只能识别对象自身的属性
            delete e.a
        }
        if('b' in e){   // in运算符 不仅能识别对象自身的属性 也能识别继承的属性 (属性 in 对象)
            e.b = 'in'
        }
    }
    if(Array.isArray(e)){   //isArray() 方法用于判断一个对象是否为数组
        e.push(5)
    }
    return e
})
console.log(newMapList) // [1, { b: 'in'}, [3, 5]]

// for of 循环  可以使用break跳出循环
for(let n of myArray){
    if(typeof n !== "number") break;
    console.log('n--',n)    // 1
}

// entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
for(let [index, ele] of myArray.entries()) {
  if(typeof ele !== "number") break;
  console.log('n--',ele)    // 1
}

/**
 * 数组判断 findIndex / find / some / includes / every
 */
var fiList = [{
    name: 'lisi'
},{
    name: 'zhangsan'
},{
    name: 'wangwu'
}]

// some() 方法用于检测数组中的元素是否满足指定条件
fiList.some(e => {return e.name == 'zhangsan'})  // true

// findIndex() 判断数组中对象是否存在值
fiList.findIndex((e) => {return e.name == 'wangwu'})    // 2

// find() 方法返回通过测试（函数内判断）的数组的第一个元素的值
// 当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
// 如果没有符合条件的元素返回 undefined
fiList.find((e) => {return e.name == 'wangwu'}) //{ name: 'wangwu'}

// includes() 找到匹配则返回 true，否则返回 false / 也可用于检测字符串（区分大小写）
[1,2,3,4].includes(2)   //  true
'wangwu'.includes('wu') //  true
[{ name: 'wangwu'}].includes({ name: 'wangwu'})  //  false  不能检测对象

// every() 方法用于检测数组所有元素是否都符合指定条件。
//         every() 方法使用指定函数检测数组中的所有元素：
//         如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
//         如果所有元素都满足条件，则返回 true。
var ages = [32, 16, 40];
[].every(e => e === true) //true    // 注意： every() 不会对空数组进行检测。空数组检测返回 true。
ages.every((ele,index) => ele > 18) //false
ages.every((ele,index) => ele > 15) //true



/**
 * 数组过滤 filter
 */
[1,2,3,5].filter(e => e > 2)    // [3, 5]




/**
 * 数组计算 reduce / Math.max.apply
 */
// 数组累加 reduce():从数组的第一项开始，逐个遍历到最后
var values = [1,2,3];
var sum = values.reduce(function(prev, cur, index, array){
    return prev + cur;
});//求数组中所有值的和
console.log(sum) // 6

// 计算数组中最大值
var maxList = [1,2,3,4,5]
let _max = Math.max.apply(null, maxList)
// Math.max()方法，支持传递多个参数，比如：Math.max(1,4,2,3,7,5,6)
// 但是它不支持直接传递一个数组作为参数，比如：Math.max(new Array(1,4,2,3,7,5,6))。




/**
 * 数组结构
 */
// 数组中的对象排序
var arrObjSort = {
    _compare(property){
        // 从大到小
        return function(a,b){
            var value1 = a[property];
            var value2 = b[property];
            return value2 - value1;
        }
    },
    _overdueSort(property){
        // 从小到大
        return function(a,b){
            var value1 = a[property];
            var value2 = b[property];
            return value1 - value2;
        }
    },
    _sort(){
        let overdueList = [{num:1},{num:2},{num:5},{num:3}]
        overdueList.sort(this._overdueSort('num'))
        console.log(overdueList)
    }
}
arrObjSort._sort()


// 按照首字母排序
let retn = ['Bas', 'D', 'C', 'K', 'A', 'Z']
retn.sort((a, b) => {
    return a.charCodeAt(0) - b.charCodeAt(0)
        // charCodeAt() 方法可返回指定位置的字符的 Unicode 编码。
        // 字符串中第一个字符的位置为 0， 第二个字符位置为 1，以此类推。
})
console.log(retn)


/** 单层数组生成树状结构 */
let account_subject_list = [
    {
        "subject":"1221",
        "name":"其他应收款",
        "parent":""
    },{
        "subject":"1221.01",
        "name":"单位往来",
        "parent":"1221"
    },{
        "subject":"1231.01",
        "name":"其他应收款",
        "parent":"1231"
    },{
        "subject":"2221",
        "name":"应交税费",
        "parent":""
    },{
        "subject":"2221.01",
        "name":"增值税",
        "parent":"2221"
    },{
        "subject":"2221.01.01",
        "name":"进项税额",
        "parent":"2221.01"
    },{
        "subject":"2221.01.02",
        "name":"销项税额",
        "parent":"2221.01"
    },{
        "subject":"2221.01.02.01",
        "name":"销项税额",
        "parent":"2221.01.02"
    }
]
function getTree(list) {
    const tree = {}
    const arr = []
    list.forEach(item => {
        tree[item.subject] = item
    })
    list.forEach(item => {
        if(!tree[item.parent]){
            arr.push(item)
        } else {
            tree[item.parent].children = tree[item.parent].children || []
            tree[item.parent].children.push(item)
        }
    })
    return arr
}
const tree = getTree(account_subject_list)
console.log('tree',tree)

/**
 * 树状结构铺平
 */
function flat(tree) {
    let arr= [];
    const expanded = datas => {
        if (datas && datas.length > 0){
            datas.forEach(e => {
                arr.push({
                    subject: e.subject,
                    name: e.name,
                    parent: e.parent
                });
                expanded(e.children);
            })
        }
    };
    expanded(tree);
    return arr;
}
const flatTree = flat(tree)
console.log("铺平===", flatTree)


/**
 * 深拷贝
 */
// JSON.stringfy()和JSON.parse()即可搞定。但是这种简单粗暴的方法有其局限性。当值为undefined、function、symbol 会在转换过程中被忽略
// 自定义深拷贝
function deepCopy(obj) {
    var result = Array.isArray(obj) ? [] : {};
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
            if (typeof obj[key] === 'object' && obj[key] !== null) {
                result[key] = deepCopy(obj[key]);   //递归复制
            } else {
                result[key] = obj[key];
            }
        }
    }
    return result;
}

 

// 数组转对象
const optArr = ["id",, "remark"];
const optObj = optArr.reduce((opt, key) => {
    opt[key] = formOpt[key];
    return opt
}, {
    temp_only_key: Math.random() + '' // 初始值: 唯一key
});

 // 唯一key用于删除列表时更新DOM，:key="index"视图层每次都是删除组后一个
 e.temp_only_key = Math.random() + '';

 将日期时间转换为本地时间格式的字符串: new Date().toLocaleString()

async createDiagram() {
    await bpmnModeler.importXML(xml);
}

return new Promise((resolve, reject) => {
    resolve();
    // return reject()
})

 

// entries / break 中断数组循环
let allData = [1, 2, 3, {}]
for (let [i, ele] of allData.entries()) {
    console.log('i, ele==', i, ele)
    const isLoop = ele === 3
    if (!isLoop) break;
}