/*深度优先遍历三种方式*/
let deepTraversal1 = (node, nodeList = []) => {
  if (node !== null) {
    nodeList.push(node)
    let children = node.children
    for (let i = 0; i < children.length; i++) {
      deepTraversal1(children[i], nodeList)
    }
  }
  return nodeList
}
let deepTraversal2 = (node) => {
    let nodes = []
    if (node !== null) {
      nodes.push(node)
      let children = node.children
      for (let i = 0; i < children.length; i++) {
        nodes = nodes.concat(deepTraversal2(children[i]))
      }
    }
    return nodes
  }
// 非递归
let deepTraversal3 = (node) => {
  let stack = []
  let nodes = []
  if (node) {
    // 推入当前处理的node
    stack.push(node)
    while (stack.length) {
      let item = stack.pop()
      let children = item.children
      nodes.push(item)
      // node = [] stack = [parent]
      // node = [parent] stack = [child3,child2,child1]
      // node = [parent, child1] stack = [child3,child2,child1-2,child1-1]
      // node = [parent, child1-1] stack = [child3,child2,child1-2]
      for (let i = children.length - 1; i >= 0; i--) {
        stack.push(children[i])
      }
    }
  }
  return nodes
}

let widthTraversal2 = (node) => {
  let nodes = []
  let stack = []
  if (node) {
    stack.push(node)
    while (stack.length) {
      let item = stack.shift()
      let children = item.children
      nodes.push(item)
        // 队列，先进先出
        // nodes = [] stack = [parent]
        // nodes = [parent] stack = [child1,child2,child3]
        // nodes = [parent, child1] stack = [child2,child3,child1-1,child1-2]
        // nodes = [parent,child1,child2]
      for (let i = 0; i < children.length; i++) {
        stack.push(children[i])
      }
    }
  }
  return nodes
}

const debonce = (fn, timer) => {
  let loop = null;
  return function () {
    if (loop) {
      clearTimeout(loop);
    }
    loop = setTimeout(() => {
      fn.apply(this, arguments);
    }, timer);
  };
};

function demo(arg1, arg2) {
  console.log(arg1, arg2);
}

let debonceDemo = debonce(demo, 1000);
let i = 0;
let test = setInterval(() => {
  console.log(i);
  debonceDemo(1, 2);
  if (++i > 100) {
    clearInterval(test);
  }
}, 10);

const throttle = (fn, timer) => {
  let loop = true;
  return function () {
    if (!loop) {
      return;
    }
    loop = false;
    setTimeout(() => {
      fn.apply(this, arguments);
      loop = true;
    }, timer);
  };
};

function demo(arg1, arg2) {
  console.log(arg1, arg2);
}

let throttleDemo = throttle(demo, 1000);
let i = 0;
let test = setInterval(() => {
  console.log(i);
  throttleDemo(1, 2);
  if (++i > 100) {
    clearInterval(test);
  }
}, 100);

function debounce(fn) {
      let timeout = null; // 创建一个标记用来存放定时器的返回值
      return function () {
        clearTimeout(timeout); // 每当用户输入的时候把前一个 setTimeout clear 掉
        timeout = setTimeout(() => { // 然后又创建一个新的 setTimeout, 这样就能保证输入字符后的 interval 间隔内如果还有字符输入的话，就不会执行 fn 函数
          fn.apply(this, arguments);
        }, 500);
      };
    }
    function sayHi() {
      console.log('防抖成功');
    }

    var inp = document.getElementById('inp');
    inp.addEventListener('input', debounce(sayHi)); // 防抖

function throttle(fn) {
      let canRun = true; // 通过闭包保存一个标记
      return function () {
        if (!canRun) return; // 在函数开头判断标记是否为true，不为true则return
        canRun = false; // 立即设置为false
        setTimeout(() => { // 将外部传入的函数的执行放在setTimeout中
          fn.apply(this, arguments);
          // 最后在setTimeout执行完毕后再把标记设置为true(关键)表示可以执行下一次循环了。当定时器没有执行的时候标记永远是false，在开头被return掉
          canRun = true;
        }, 500);
      };
    }
    function sayHi(e) {
      console.log(e.target.innerWidth, e.target.innerHeight);
    }
    window.addEventListener('resize', throttle(sayHi));

<div id="app">
    <div v-for="i in dataList">{{ i }}</div>
</div>
var vm = new Vue({
  el: '#app',
  data: {
    dataList: [1, 2, 3, 4, 5]
  }
})

[
  '<div>1</div>', // id： A
  '<div>2</div>', // id:  B
  '<div>3</div>', // id:  C
  '<div>4</div>', // id:  D
  '<div>5</div>'  // id:  E
]

vm.dataList = [4, 1, 3, 5, 2] // 数据位置替换

// 没有key的情况， 节点位置不变，但是节点innerText内容更新了
 [
   '<div>4</div>', // id： A
   '<div>1</div>', // id:  B
   '<div>3</div>', // id:  C
   '<div>5</div>', // id:  D
   '<div>2</div>'  // id:  E
 ]

 // 有key的情况，dom节点位置进行了交换，但是内容没有更新
 // <div v-for="i in dataList" :key='i'>{{ i }}</div>
 [
   '<div>4</div>', // id： D
   '<div>1</div>', // id:  A
   '<div>3</div>', // id:  C
   '<div>5</div>', // id:  E
   '<div>2</div>'  // id:  B
 ]

vm.dataList = [3, 4, 5, 6, 7] // 数据进行增删

// 1. 没有key的情况， 节点位置不变，内容也更新了
[
  '<div>3</div>', // id： A
  '<div>4</div>', // id:  B
  '<div>5</div>', // id:  C
  '<div>6</div>', // id:  D
  '<div>7</div>'  // id:  E
]

// 2. 有key的情况， 节点删除了 A, B 节点，新增了 F, G 节点
// <div v-for="i in dataList" :key='i'>{{ i }}</div>
[
  '<div>3</div>', // id： C
  '<div>4</div>', // id:  D
  '<div>5</div>', // id:  E
  '<div>6</div>', // id:  F
  '<div>7</div>'  // id:  G
]

// vue项目  src/core/vdom/patch.js  -488行
// 以下是为了阅读性进行格式化后的代码

// oldCh 是一个旧虚拟节点数组
if (isUndef(oldKeyToIdx)) {
  oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
}
if(isDef(newStartVnode.key)) {
  // map 方式获取
  idxInOld = oldKeyToIdx[newStartVnode.key]
} else {
  // 遍历方式获取
  idxInOld = findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
}

function createKeyToOldIdx (children, beginIdx, endIdx) {
  let i, key
  const map = {}
  for (i = beginIdx; i <= endIdx; ++i) {
    key = children[i].key
    if (isDef(key)) map[key] = i
  }
  return map
}

// sameVnode 是对比新旧节点是否相同的函数
 function findIdxInOld (node, oldCh, start, end) {
    for (let i = start; i < end; i++) {
      const c = oldCh[i]
      
      if (isDef(c) && sameVnode(node, c)) return i
    }
  }

npm install -g hexo-cli

sudo npm install -g hexo-cli

$ hexo init <folder>
$ cd <folder>
$ npm install

deploy:
-  type: git
   repo: <github git地址>
-  type: ali-oss
   region: <regionName> # oss-cn-hangzhou oss-cn-beijing oss-cn-guangzhou 等
   accessKeyId: <AccessKeyID> 
   accessKeySecret: <AccessKeySecret>
   bucket: <bucketName> # wddv

const list = [1, 2, 3]
const square = num => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(num * num)
    }, 1000)
  })
}

function test() {
  list.forEach(async x=> {
    const res = await square(x)
    console.log(res)
  })
}
test()

async function test() {
    for(let i = 0 ;i < list.length ; i++){
        const res = await square(list[i])
        console.log(res)
    }
}

async function test() {
    for(let i of list){
        let res = await square(i)
        console.log(res)
    }
}