js实用方法

• js数组去重方法

const arr = [
    {a: 1,b: 2},
    {b: 2,a: 1}, 
    {a: 1,b: 2,c: {d: 4,e: 5}}, 
    {c: {d: 4,e: 5},b: 2,a: 1}];
let _arr = singleArr(arr);
// console.log(_arr);
// [ { a: 1, b: 2 }, { a: 1, b: 2, c: { d: 4, e: 5 } } ]


// 数组去重函数
function singleArr(arr){
    const newArr = [...arr];
    for (let i = 0; i < newArr.length; i++) {
        // 去掉i+1开始的重复值
        for (let j = i + 1; j < newArr.length; j++) {
            if (equals(newArr[j], newArr[i])) {
                newArr.splice(j, 1);
                j--;
            }
        }
    }
    return newArr
}
// 判断是否为object
function isObject(val) {
    return typeof val === 'object' && val
}

// 判断两个值是否相等
function equals(val1, val2) {
    // 如果都是对象
    if (isObject(val1) && isObject(val2)) {
        const keys1 = Object.keys(val1),
            keys2 = Object.keys(val2);
        // 长度不等,必不等    
        if (keys1.length != keys2.length) {
            return false;
        }
        // 长度相等时,循环某一个即可
        for (const k of keys1) {
            // 某一个不存在该属性,必不等
            if (!keys2.includes(k)) {
                return false;
            }
            // 递归调用
            if (!equals(keys1[k], keys2[k])) {
                return false;
            };
        }
        // 一套流程走完，必相等
        return true;
    } else {
        return val1 === val2
    }

}

• 实现js链接调用方法

function test(taskId) {
    const task = [];
    task.push(() => {
        console.log(`${taskId} is notified`)
    })
    async function execte() {
        for (const i of task) {
            await i()
        }
    }

    function doSomething(something) {
        task.push(() => {
            console.log(`Start to ${something}`);
        })
        return this;
    }

    function wait(duration) {
        task.push(() => new Promise((resolve,reject)=>{
          setTimeout(resolve,duration*1000)
        }))
       return this;
    }

    function waitFirst(duration) {
        task.unshift(() => new Promise((resolve,reject)=>{
            setTimeout(resolve,duration*1000)
          }))
         return this;
    }
    return {
        execte: execte,
        do: doSomething,
        wait: wait,
        waitFirst: waitFirst
    }
}
test("gfd").do("sf1").wait(3).do("sf2").execte()
// gfd is notified
// Start to sf1
// 等待了3秒
// Start to sf2

reduce()生成笛卡尔积

function product(xList,yList){
    return xList.reduce((v,t)=>{
       return v.concat(yList.map((item)=>[t,item]))
    },[])
  }
console.log(product([1,2],[3,4]));
// [[1,3],[1,4],[2,3],[2,4]]

Nodejs事件驱动理解

微任务:
1.next tick queue:  process.nextTick
2.other queue:      Promise的then回调,   queueMicrotask
宏任务:
3.timer queue:      setTimeout,  setInterval
4.poll queue:        IO事件
5.check queue:     setImmediate
6.close queue:      close事件
执行顺序按照1->6

async function async1() {
  console.log("async1 start")
  await async2()
  console.log("async1 end")
}
async function async2() {
  console.log("async2")
 
}
console.log("script start")
setTimeout(function () {
  console.log("setTimeout0")
}, 0)
setTimeout(function () {
  console.log("setTimeout2")
}, 300)
setImmediate(()=>console.log('setImmediate'));
process.nextTick(()=>console.log('nextTick1'));
async1();
process.nextTick(()=>console.log('nextTick2'));
new Promise(function(resolve:any){
    console.log('promise1');
    resolve();
    console.log('promise2');
}).then(function(){
    console.log('promise3');
    
})
console.log("script end")
// 打印顺序如下
script start (同步任务,输出script start)
async1 start (执行async1函数,同步任务)
async2       (执行async2函数,同步任务)
promise1   (立即执行函数,输出)
promise2   (立即执行函数,输出)
script end  (同步任务,输出script start,)
------------第一轮循环结束---------------------
nextTick1 (同步任务结束后,异步任务,微任务执行)
nextTick2 (同步任务结束后,异步任务,微任务执行)
------------第二轮循环开始,去队列中寻找---------------------
async1 end (进入微任务,等待下一轮,队列中第一个)
promise3 (微任务promise.then()执行)
setTimeout0 (回调函数,放到宏任务第一个)
setImmediate (回调函数,放到宏任务第二个)
setTimeout2 (回调函数,放到宏任务等待了300毫秒)