灯的个人博客

forever young,forever weeping.

0%

发表于 更新于 分类于

介绍下 Set、Map、WeakSet 和 WeakMap 的区别？

个人题解

Set

目前用到Set的功能,是用来去重

Map

跟object很像,比object多了一些实用的操作方法,object的key只能是字符串,这个的key值可以是对象,数字等

WeakSet 和 WeakMap

没用过

最高赞题解

Set

  1. 成员不能重复
  2. 只有健值，没有健名，有点类似数组。
  3. 可以遍历，方法有add, delete,has

weakSet

成员都是对象
成员都是弱引用，随时可以消失。 可以用来保存DOM节点，不容易造成内存泄漏
不能遍历，方法有add, delete,has

Map

本质上是健值对的集合，类似集合
可以遍历，方法很多，可以干跟各种数据格式转换

weakMap

  1. 直接受对象作为健名（null除外），不接受其他类型的值作为健名
  2. 健名所指向的对象，不计入垃圾回收机制
  3. 不能遍历，方法同get,set,has,delete

相关链接

第 4 题：介绍下 Set、Map、WeakSet 和 WeakMap 的区别？
ECMAScript 6 入门 – Set 和 Map 数据结构

发表于 更新于 分类于

什么是防抖和节流？有什么区别？如何实现？

个人题解

防抖

在一个时间段内,如果有触发多次,只执行一次.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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);

节流

不论执行速度有多快,固定时间内执行的次数只有一次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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);

最高赞题解

防抖

触发高频事件后n秒内函数只会执行一次，如果n秒内高频事件再次被触发，则重新计算时间

思路：

每次触发事件时都取消之前的延时调用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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)); // 防抖

节流

高频事件触发，但在n秒内只会执行一次，所以节流会稀释函数的执行频率

思路：

每次触发事件时都判断当前是否有等待执行的延时函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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));

相关链接

第 3 题：什么是防抖和节流？有什么区别？如何实现？

发表于 更新于 分类于

React / Vue 项目时为什么要在列表组件中写 key，其作用是什么？

题解

个人猜想是diff算法的优化办法，固定key以后，如果更新数据，可以确定需要替换的数据，减少dom替换的开销

赞同最高题解

受楼下答案的一些特殊情况影响，导致很多人都认为key不能”提高”diff速度。在此继续重新梳理一下答案。

在楼下的答案中，部分讨论都是基于没有key的情况diff速度会更快。确实，这种观点并没有错。没有绑定key的情况下，并且在遍历模板简单的情况下，会导致虚拟新旧节点对比更快，节点也会复用。而这种复用是就地复用，一种鸭子辩型的复用。以下为简单的例子:

1
2
3
4
5
6
7
8
9
<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]
  }
})

以上的例子，v-for的内容会生成以下的dom节点数组，我们给每一个节点标记一个身份id：

1
2
3
4
5
6
7
[
  '<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
]

改变dataList数据，进行数据位置替换，对比改变后的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
 ]

增删dataList列表项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
]

从以上来看，不带有key，并且使用简单的模板，基于这个前提下，可以更有效的复用节点，diff速度来看也是不带key更加快速的，因为带key在增删节点上有耗时。这就是vue文档所说的默认模式。但是这个并不是key作用，而是没有key的情况下可以对节点就地复用，提高性能。

这种模式会带来一些隐藏的副作用，比如可能不会产生过渡效果，或者在某些节点有绑定数据（表单）状态，会出现状态错位。VUE文档也说明了 这个默认的模式是高效的，但是只适用于不依赖子组件状态或临时 DOM 状态 (例如：表单输入值) 的列表渲染输出

楼下 @yeild 也提到，在不带key的情况下，对于简单列表页渲染来说diff节点更快是没有错误的。但是这并不是key的作用呀。

但是key的作用是什么？
我重新梳理了一下文字，可能这样子会更好理解一些。

key是给每一个vnode的唯一id,可以依靠key,更准确, 更快的拿到oldVnode中对应的vnode节点。

  1. 更准确
    因为带key就不是就地复用了，在sameNode函数 a.key === b.key对比中可以避免就地复用的情况。所以会更加准确。

  2. 更快
    利用key的唯一性生成map对象来获取对应节点，比遍历方式更快。(这个观点，就是我最初的那个观点。从这个角度看，map会比遍历更快。)

原答案 ———————–

vue和react都是采用diff算法来对比新旧虚拟节点，从而更新节点。在vue的diff函数中（建议先了解一下diff算法过程）。
在交叉对比中，当新节点跟旧节点头尾交叉对比没有结果时，会根据新节点的key去对比旧节点数组中的key，从而找到相应旧节点（这里对应的是一个key => index 的map映射）。如果没找到就认为是一个新增节点。而如果没有key，那么就会采用遍历查找的方式去找到对应的旧节点。一种一个map映射，另一种是遍历查找。相比而言。map映射的速度更快。
vue部分源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 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)
}

创建map函数

1
2
3
4
5
6
7
8
9
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
}

遍历寻找

1
2
3
4
5
6
7
8
// 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
    }
  }

链接

写 React / Vue 项目时为什么要在列表组件中写 key，其作用是什么？

发表于 更新于 分类于

安装hexo

1
npm install -g hexo-cli

mac电脑可能需要使用sudo权限

1
sudo npm install -g hexo-cli

初始化项目，安装依赖

1
2
3
$ hexo init <folder>
$ cd <folder>
$ npm install

各类配置项参考hexo中文文档

发布到github pages

  1. 创建一个github仓库<yourname>.github.com，比如我的lampofaladdin.github.io
  2. 在_config.yml中增加配置项
    1
    2
    3
    4
    deploy:
     type: git
     repo: <github git地址>
     # 例如git@github.com:lampofaladdin/lampofaladdin.github.io.git
  3. 发布到github hexo deploy

使用阿里云oss静态页关联自己域名

  1. 创建阿里云Bucket,不开通版本控制，读写为公共读，其他默认
  2. 创建ram用户，给用户oss的控制权限
  3. 创建ram用户的AccessKey，获取到AccessKeyID，AccessKeySecret
  4. 进入bucket,基础设置，静态页面，默认首页为index.html,子目录首页开通
  5. 传输管理，绑定你已经购买备案好的域名。
  6. 安装hexo-deployer-ali-oss，npm i hexo-deployer-ali-oss --save
  7. 在_config.yml中增加配置
    1
    2
    3
    4
    5
    6
    deploy:
      type: ali-oss
      region: <regionName> # oss-cn-hangzhou oss-cn-beijing oss-cn-guangzhou 等
      accessKeyId: <AccessKeyID> 
      accessKeySecret: <AccessKeySecret>
      bucket: <bucketName> # wddv
  8. npm deploy

同时发布在githubPage 与 阿里云oss

1
2
3
4
5
6
7
8
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

TODO

  • git push的时候depoly
  • 标签分类怎么做

相关链接

发表于 更新于 分类于

第 160 题：输出以下代码运行结果，为什么？如果希望每隔 1s 输出一个结果，应该如何改造？注意不可改动 square 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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()

题解

因为foreach是并行执行的,并不支持异步，需要改成for或者 for of 

1
2
3
4
5
6
7
8
9
10
11
12
13
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)
    }
}

发表于 更新于 分类于

聊聊生活,写写技术.

欢迎加入前端交流群·VUE|JS|TS|全栈|前端交流·群号:318195769