mianshiyan资料汇总

获取容器的宽度
浅析requestIdleCallback
SSR 与当年的 JSP、PHP 有什么区别？
btoa
defer不会影响浏览器的dcl，而async
vue项目工程中npm run dev 到底做了什么
Node中使用http-proxy-middleware实现代理跨域的方法步骤
ES6装饰器

antd源码 semi源码
计算机网络 CDN技术介绍
动态CDN和静态CDN有什么区别,普通cdn和高防cdn
php 静态 动态 cdn 加速,CDN静态加速跟动态加速的区别，动态加速好还是静态加速好？…
大文件传输
几款实用的VUE移动端UI框架
vux，Vonic，cube-ui，Mint-UI，Vant，NutUI

目前完美支持Vue3.0的移动端组件库——Vant&NutUI
vant
nutUI
Nuxt框架
Nuxt详解+案例

---

vite详解
Vite 2.0 发布了
【译】Vite2.0新特性
vite3

多框架支持，vue,react
全新插件机制和 API(很多 Rollup 插件可以跟 Vite 直接兼容)
基于 esbuild 的依赖预打包
更好的 CSS 支持(CSS 代码分割,自动 URL 改写)
服务端渲染 (SSR) 支持
批量引入（通配引入）(glob import)
支持Web Assembly引入
引入Web Workers
npm init vite(然后选择命令的名字，选择vue还是react)
---
全新的 VitePress 文档
---cli端口更新
---websocket的连接策略生效
---服务冷启动性能提升
---ssr产物默认使用esm格式
---relative base支持

webpack是目前整个前端使用最多的构建工具，但是除了webpack之后也存在其他一些构建工具。比如说rollup,parcel,gulp,vite等等。vite的官方定位是下一代前端开发和构建工具。
我们知道在实际开发中，我们在编写的代码往往是不能被浏览器直接识别的，比如ES6，TypeScript,Vue文件等。所以此时我们必须通过构建工具来对代码进行转换，编译，类似的工具有webpack,rollup,parcel.但是随着项目越来越大，需要处理的javascript呈指数级增长，模块越来越多。构建工具需要很长时间才能开启服务器，HMR也需要几秒钟才能在浏览器反应过来。所以出现了vite。

---

前端优化方式
es6特性，css3特性, html5的特性
flex, 移动端开发, 各种居中
反爬虫，加密，前端攻击，跨域
前端的几种存储方式
sessionin, token, jwt
js闭包
模块对比f
webpack
mysql, java, linux, docker
node
-------
es6
promise,var let,
...
object, array jiegou
class, extends, chaolei
() => {},
``
for of
------
css3
border-radius
media
box-shadow
::
text-overflow
text-shadow
backgroud: linear-gradient,radial-gradient
resize
outline
box-sizing
background-clip
transform
---
>一、语义标签header,footer,nav,article,aside,section,dd dt dl
二、增强型表单datalist,progress,meter,keygen,output
placehoder,required,pattern,multiple
三、视频和音频
四、Canvas绘图
五、SVG绘图
六、拖拉API
七、WebWorker,提供主线程和新线程之间数据交换的接口：postMessage、onmessage
八、WebStorage,localStorage
九、WebSocket
十、地理定位
---
canvas路径
fill() 填充当前绘图（路径）
stroke() 绘制已定义的路径
beginPath() 起始一条路径，或重置当前路径
moveTo() 把路径移动到画布中的指定点，不创建线条
closePath() 创建从当前点回到起始点的路径
lineTo() 添加一个新点，然后在画布中创建从该点到最后指定点的线条
clip() 从原始画布剪切任意形状和尺寸的区域
quadraticCurveTo() 创建二次贝塞尔曲线
bezierCurveTo() 创建三次方贝塞尔曲线
arc() 创建弧/曲线（用于创建圆形或部分圆）
arcTo() 创建两切线之间的弧/曲线
isPointInPath() 如果指定的点位于当前路径中，则返回 true，否则返回 false
rect(x,y,w,h) stroke() 绘制路径 fill() 填充图形

---

css点滴yan

移动端开发点滴yan

算法点滴yan
面试题
2022年最新前端面试题（大前端时代来临卷起来吧小伙子们…持续维护走到哪记到哪）
网易前端面试（灵犀部门）
2022年最新前端面试题
最近两周出去面试遇到的面试题（前端初级、长更）
三面面试官：运行 npm run xxx 的时候发生了什么？
【初/中级前端面经】中小型公司面试时都会问些什么?

h5面试题总结

前端面试（vue优化、移动端兼容问题、前端安全问题）
web前端面试题及答案
一个合格的中级前端工程师需要掌握的 28 个 JavaScript 技巧
html5新特性有哪些
最新的前端大厂面经（详解答案）
金九银十，你准备好面试了吗? (附30w字前端面试题总结)

es6软一峰

node点滴yan
正则点滴yan

koa

可视化

es6的新特性

JS语法 ES6、ES7、ES8、ES9、ES10、ES11、ES12新特性
ES6、ES7、ES8、ES9、ES10、ES11、ES12知识点总结

zf-总结

面试yan-原理性函数

浏览器渲染点滴yan

js陷阱缺陷点滴yan&js原生dom点滴yan

博客园-沉默

博客园-js点滴

npm点滴yan
git 点滴yan
requirejs源码学习笔记（一）

面试js数组和object string点滴yan

CSS中link和@import的区别

react点滴yan

后端点滴yan

白老师运维

lerna

---

版本 不同的版本之间有啥差异

webpack5
react 16.8
vue 2.*

---

前端优化方式

----------------文件加载方面：压缩文件大小+ 图片+加载 + 缓存
—压缩文件大小:
压缩文件，去掉无用的代码，合理的压缩算法gzip，合理的切割文件和合并文件
—图片相关的：
雪碧图，字体图标，图片延迟加载，响应式图片，降低图片质量，尽可能利用 CSS3 效果代替图片，使用 webp 格式的图片
—加载相关的:
减少http请求，减少重定向，多域名(同一个域名最多处理6个TCP链接问题)，http2, dns缓存dns-prefetch，CDN缓存，懒加载，预加载,合并http请求，减少cookie, 分页加载，服务端渲染，加载优先级preload prefetch defer async,同一个域名最多处理6个TCP链接问题
—缓存相关的：
304浏览器对比缓存，强制缓存，内存缓存和磁盘缓存，接口缓存(servicework+apiCache)，合理的使用localStorage和indexDB

-----------------写代码方面：
html层面：
1 语义化HTML:代码简洁清晰，利于搜索引擎，便于团队开发维护
2 提前声明字符编码，让浏览器快速确定如何渲染网页内容
3 减少HTML嵌套关系，减少DOM节点数量
4 删除多余空格，空行、注释、及无用的属性等
5 避免table布局， table会影响页面呈现的速度，只有table里的内容全部加载完才会显示。
6 使用 flexbox 而不是较早的布局模型.
7 将 CSS 放在文件头部，JavaScript 文件放在底部。
8 少用iframe。

javascript优化
1 少操作dom，缓存DOM节点查找的结果，
2 少用全局变量。
3 避免页面卡顿 ，对于一些长时间运行的 JavaScript，我们可以使用定时器进行切分，延迟执行。
4 属性冻结。
5 requestAnimationFrame代替setTimeout，requestIdleCallback。
6 h5 的webwork用来计算。
7 switch代替if else.
8 虚拟滚动 vertual-scroll-list. 虚拟滚动 vertual-scroll-list
解决加载大量列表DOM导致浏览器性能瓶颈的虚拟滚动技术
9 IntersectionObserver 代替onscroll。监控滚动图片，图片到达可视区域才去赋值src属性，才会去真正请求,延迟加载
css 优化
1 降低 CSS 选择器的复杂性, 减少伪类选择器，减少样式层数，减少使用通配符.
2 减少重绘重排
3 多用GPU等面的代码写动画，transform 和 opacity 属性更改来实现动画，利用 CSS3 效果代替图片。
4 使用外链css,可以对css进行缓存。
5 添加媒体字段，只加载有效的css 文件。 6 减少@import使用，由于import采用的串行加载。
7 css will-change和contain。
8 使用事件委托，减少事件绑定个数
9 尽量使用canvas动画、css动画

---

执行上下文（Execution Context ）和范围（Scope） Variable object（变量对象） GO（全局对象） AO（激活对象）总结

前端系统化学习【JS篇】:（九）EC、STACK、VO、AO、GO浏览器底层运行机制
JS执行上下文
作用域与作用域链，GO/VO/AO/EC及作用域和执行上下文
JS作用域链详解

---Js代码在浏览器运行时的底层机制
我们编写的JS代码机器是不认识的，是需要一个环境来编译成机器码来执行的，对于JavaScript来说，这个环境可以是
浏览器（引擎）
node（基于v8引擎来渲染js）
webview（v8引擎）
---
ECS(Execution Context Stack)执行环境栈
在首次运行js代码时创建
---
EC(Execution Context)执行上下文(词法作用域)
在JS代码执行中，为了区分全局和函数执行所处的不同的作用域（目的是为了区分每个执行上下文中代码的独立性）.
分为了：global全局执行上下文，xx函数私有执行上下文。
---
VO(Variable Object)变量对象
1.VO(G)全局变量对象, 比如 全局var 定义，给就是VO(G) 定义，并且会挂载在GO window 上，而let const 定义，就是VO(G) 定义但是不会股灾GO window
2.带VAR和不带VAR的区别
3.AO(Active Object)私有变量对象(函数运行时产生的局部变量)
4.GO(Global Object)全局对象
5.VO(G)【全局变量对象】和GO【全局对象】的关系

深入理解JS预编译——AO对象及GO对象

代码性能优化

HTML优化
1、避免 HTML 中书写 CSS 代码，因为这样难以维护。 
2、使用 Viewport 加速页面的渲染。 
3、使用语义化标签，减少 CSS 代码，增加可读性和 SEO。 
4、减少标签的使用，DOM 解析是一个大量遍历的过程，减少不必要的标签，能降低遍历的次数。 
5、避免 src、href 等的值为空，因为即时它们为空，浏览器也会发起 HTTP 请求。 
6、减少 DNS 查询的次数

CSS优化
1、优化选择器路径：使用 .c {} 而不是 .a .b .c {}。
2、选择器合并：共同的属性内容提起出来，压缩空间和资源开销。
3、精准样式：使用 padding-left: 10px 而不是 padding: 0 0 0 10px。
4、雪碧图：将小的图标合并到一张图中，这样所有的图片只需要请求一次。
5、避免通配符：.a .b * {} 这样的选择器，根据从右到左的解析顺序在解析过程中遇到通配符 * {} 
6、会遍历整个 DOM，性能大大损耗。
7、少用 float：float 在渲染时计算量比较大，可以使用 flex 布局。
8、为 0 值去单位：增加兼容性。
9、压缩文件大小，减少资源下载负担。

JavaScript优化
1、尽可能把 <script> 标签放在 body 之后，避免 JS 的执行卡住 DOM 的渲染，最大程度保证页面尽快地展示出来
2、尽可能合并 JS 代码：提取公共方法，进行面向对象设计等……
3、CSS 能做的事情，尽量不用 JS 来做，毕竟 JS 的解析执行比较粗暴，而 CSS 效率更高。
4、尽可能逐条操作 DOM，并预定好 CSs 样式，从而减少 reflow 或者 repaint 的次数。
5、尽可能少地创建 DOM，而是在 HTML 和 CSS 中使用 display: none 来隐藏，按需显示。
6、压缩文件大小，减少资源下载负担。

---

js垃圾回收机制

垃圾回收的方式：
① 标记清除：
垃圾回收器会在运行的时候给存储在内存中的所有变量加上标记，然后去掉环境中的变量以及被环境中变量所引用的变量（闭包），在这些完成之后仍存在标记的就是要删除的变量了，因为环境中的变量已经无法访问到这些变量了，然后垃圾回收器相会这些带有标记的变量机器所占空间。至于怎么标记有很多种方式，比如特殊位的反转、维护一个列表等，这些并不重要。
②引用计数：
在低版本IE中经常会出现内存泄露，很多时候就是因为其采用引用计数方式进行垃圾回收。引用计数的策略是跟踪记录每个值被使用的次数，当声明了一个变量并将一个引用类型赋值给该变量的时候这个值的引用次数就加1，如果该变量的值变成了另外一个，则这个值得引用次数减1，当这个值的引用次数变为0的时候，说明没有变量在使用，这个值没法被访问了，因此可以将其占用的空间回收，这样垃圾回收器会在运行的时候清理掉引用次数为0的值占用的空间。为什么很少有浏览器采用，还会带来内存泄露问题呢？主要是因为这种方式没办法解决循环引用问题。

Js 内存管理机制 垃圾回收 内存泄露的4个点

1.全局变量
2.被遗忘的定时器或回调函数
3.闭包
4.DOM的引用
var elements = document.getElementById('button')
function doStuff() {
    elements.innerHTML = '听风是风';
};
// 清除引用
elements = null;
document.body.removeChild(document.getElementById('button'));

js内存 添加链接描述

v8的垃圾回收机制 添加链接描述

新生代算法
老生代算法：标记清除算法 搭配 标记整理算法
增量标记：增量标记可以将上述步骤拆成更细的“粒度”，让回收中的标记阶段和应用逻辑交替进行，v8引入这个方式后最大停顿减少到原本1/6。
空闲时间回收  (延迟清除、增量式整理)

v8的新生代算法和老生代算法详解 添加链接描述

---

【面试】前端路由hash和history的区别

hash模式
1 hash值的变化不会导致浏览器向服务器发送请求，不会引起页面刷新
2 hash值变化会触发hashchange事件
3 url带有#符号，略丑
4 兼容性好，支持低版本和IE浏览器
5 实现前端路由无需服务端支持
---
history模式
1 pushState，replaceState
2 对比hash的hashchange方法，history的变化不会触发任何事件，我们可以通过罗列可能触发history变化的情况，对这些情况进行拦截，以此监听history的变化。
3 点击浏览器的前进/后退按钮，onpopstate可以监听到。

---
两种模式的区别
1 外观：hash的url有个#符号，history没有，history外观更好看。
2 服务端支持：hash（#及后面的内容）的变化不会导致浏览器向服务器发起请求；history刷新会重新向服务器发起请求，需要在服务端做处理：如果没有匹配到资源，就返回同一个html页面。
3 兼容性：hash能兼容到IE8，history只能兼容到IE10。
4 原理：hash通过监听浏览器的onhashchange()事件，查找对应的路由规则；history利用H5新增的pushState()和replaceState()方法改变url。
5 记录：hash模式只有#后面的内容被修改才会添加新的记录栈；history通过pushState()设置的url于当前url一模一样也会被记录到历史记录栈。

对于单页面的history模式而言，url的改变只能由以下情况引起：
1.点击浏览器的前进/后退按钮，onpopstate可以监听到
2.点击a标签
3.在JS代码中触发history.pushState()或history.replaceState()

---

反爬虫

----限制访问频率,
    针对IP、UA、设备指纹，帆布指纹（canvas）识别和FingerPrint
----登录限制
----Heaher 封杀
-----JavaScript脚本动态获取网站数据, 携程
-----验证码
-----ip限制
-----网站内容反爬
    猫眼字体处理，
    美团的图片处理，
    去哪里的元素background,字符集替换式
    字符串分隔
    汽车之家伪元素隐藏
    debugger

有关于反爬策略的整理

网络爬虫

---

加密

RSA加密、非对称加密 jsencrypt.js
AES加密、对称加密  CryptoJS.AES
MD5加密、SHA256加密   这样用来防止用户篡改传递大文件信息
base64之类的
国密SM1

RSA 双向加密解密
如果一定要aes，那么应该使用非对称加密手段保护对称密钥，或者用DH算法即时协商，并附加数字签名校验。如果不放心CryptoJS，那可以更进一步把加解密代码做成WebAssembly。

加密方式
加密前端处理方式
使用CryptoJS AES加密，秘钥暴露在js中，这种安全怎么保障 ! 有什么解决办法吗？
rsa具体代码

RSA加密web前端用户名密码加密传输至后台并解

---

前端攻击

1、xss攻击
  防御：过滤特殊字符，HttpOnly 浏览器禁止页面的JS访问带有HttpOnly属性的Cookie。
  防御2： 转义：通过使用htmlspecialchars等函数，将提交内容中的字符"<"（小于）和">"(大于)转换为HTML实体。
2、CSRF攻击： 在自己的网站放入银行转账链接，用户一点击，自动访问了银行的接口并且发生了转账。
3、网络劫持攻击
  防御：最好是采用https进行加密，这种通过请求网络地址攻击的我们可以通过对http进行加密，来防范，这样不法分子即使或得到，也无法解密。
  防御2：referer防范：通过判断请求头中的referer头确定请求的来源，从而避免CSRF攻击。
  防御3：token防范：通过在表单请求中添加token，标识表单的合法性，来避免CSRF攻击。
4、控制台注入代码
5、钓鱼
6、DDoS攻击
   防御：最直接的方法增加带宽。但是攻击者用各地的电脑进行攻击，他的带宽不会耗费很多钱，但对于服务器来说，带宽非常昂贵。
云服务提供商有自己的一套完整DDoS解决方案，并且能提供丰富的带宽资源。------如果是阿里云推荐使用高防。
7、SQL注入攻击
   防御：md5加密
8、点击劫持。
9、文件上传漏洞
 防御：权限防御：文件上传的目录设置为不可执行；
 防御2：文件名防御：使用随机数改写文件名和文件路径。

安全方式 防范攻击
前端常见的攻击方式
csrf攻击的方式

---

cookie session jwt相关
cookie session token jwt
项目中使用jwt

sessionid 就是特殊的cookie，需要后端存储sessionid到用户的一个映射关系，但后端要处理分布式问题。
token 把信息存储到客户端中，服务端不管理，简单 token 的组成：uid(用户唯一的身份标识)、time(当前时间的时间戳)、sign（签名，token 的前几位以哈希算法压缩成的一定长度的十六进制字符串）
	分为Acesss Token 和  Refresh Token
JWT 直接把用户json信息放到jwt中。JWT是特殊的token。而除了用户信息，还有签名，签名只有后端可以判断是否正确。
SSO 登录。

前端关于单点登录各种协议

面试必问的4种单点登录的实现方式，你知道几个？

---

react 是mvvm框架么

MVVM一个最显著的特征：双向绑定。
React没有这个，它是单向数据绑定的。
React是一个单向数据流的库，状态驱动视图。
react整体是函数式的思想，把组件设计成纯组件，状态和逻辑通过参数传入，所以在react中，是单向数据流，推崇结合immutable来实现数据不可变。

angular是MVC模式还是MVVM架构模式

js的作用域

全局,函数作用域，块级作用域

const obj = {
    aaa: 123,
    bbb: function(){
        console.log('====>>>', this)
    }
};
obj.bbb(); // window
const fun = function () {
    console.log(this);
}
fun(); // window
const funa = function () {
   return function (){
    console.log(this);
   }
}
funa()(); // window
const func = function () {
    console.log(this);
}
new func(); // func

js的各种继承

ajax的优点和缺点

// ajax的优点
1、无刷新更新数据（在不刷新整个页面的情况下维持与服务器通信）
2、异步与服务器通信（使用异步的方式与服务器通信，不打断用户的操作）
3、前端和后端负载均衡（将一些后端的工作交给前端，减少服务器与宽度的负担）
4、界面和应用相分离（ajax将界面和应用分离也就是数据与呈现相分离）
// ajax的缺点
1、ajax不支持浏览器back按钮
2、安全问题 Aajax暴露了与服务器交互的细节
3、对搜索引擎的支持比较弱
4、破坏了Back与History后退按钮的正常行为等浏览器机制

使用箭头函数应注意什么？

1.用了箭头函数，this就不是指向window，而是父级（指向是可变的）
2、不能够使用arguments对象
3、不能用作构造函数，这就是说不能够使用new命令，否则会抛出一个错误
4、不可以使用yield命令，因此箭头函数不能用作 Generator 函数

+和Number的效果一样
+true 为 1
+NaN NaN
+'asdf’ NaN
+null 0
+undefined NaN

Ps: null==undefined 并且,+null 0,+undefined NaN

防抖 与 节流的区别 例子一 例子二

用一句话总结防抖和节流的区别：防抖是将多次执行变为最后一次执行，节流是将多次执行变为每隔一段时间执行
防抖的应用场景
1. 表单验证
2. 按钮提交事件。
3. 浏览器窗口缩放，resize事件(如窗口停止改变大小之后重新计算布局)等
4. 搜索框输入查询

节流函数的作用
1. 按钮点击事件
2. 拖拽事件
3. onScoll
4. 计算鼠标移动的距离(mousemove)

JavaScript中in操作符(for…in)、Object.keys()和Object.getOwnPropertyNames()的区别

javaScript ES6 class多重继承实践与总结 例子一

ES6中，class原生是不支持多重继承的，根据阮一峰ES6参考资料中的方法，通过以下方式即可实现class继承多个类：

Npm 的各种命令集合 博客

npm脚本命令npm run script的使用 博客

Js 内存

Js 闭包实际的用途

把函数内部的变量扩展出来，供函数外边使用，就形成了闭包行为。
方式可以是，1.方法内部在返回一个新的方法。2.方法返回可以操作这个内部变量的obj。
闭包

1.保护变量，只有自己这个方法可以操作变量,自己知道这个编程的存在和使用情况
var warnUser = function (msg) {
    var calledCount = 0;
    return function() {
       calledCount++;
       alert(msg + '\nYou have been warned ' + calledCount + ' times.');
    };
};
var warnForTamper = warnUser('You can not tamper with our HTML.');
warnForTamper();
warnForTamper();
2. 模拟面向对象编程
function counter() {
    var a = 0;
    return {
        inc: function() { ++a; },
        dec: function() { --a; },
        get: function() { return a; },
        reset: function() { a = 0; }
    }
}    
3.解决this问题
4. 高阶函数

原型链

原型是什么？
js 每一个对象__proto__属性，都有constructor属性。
而obj.__proto__ === parentClass.prototype;
obj.constructor = parentClass.prototype.constuctor;
而parentClass的prototype又有__proto__和constructor属性，就形成了一个无限的上下链。
又因为js当时10天太仓促设计出来，偶然间又成了非常流行的语言，但是不具备class这些特征，所以圆链条无形中用来模拟类和类的继承等面向对象的语言特征。
原型链也是有终点的，方法的__proto__指向了Function类的.prototype，但是方法类的prototype.__proto__又指向了Object.prototype, 而Object.prototype.__proto__指向了null。
Function.__proto__ === Function.prototype;
Function.prototype.__proto__ === Object.prototype;
Object.__proto__ === Function.prototype;
Object.prototype.__proto__ === null;

js原型链

nodejs

koa-router源码分析

如果项目a用了第三方库b,a最后打包成为了npm包，C在引用项目包的时候如果

caller和callee的区别 https://blog.csdn.net/laijieyao/article/details/43404953

Ejs使用手册

堆和栈的区别

v8引擎的高级地方 博客1 博客2 博客3

第一个优化就是尽可能最大的内联.
第二个优化就隐藏类。
第三个是内联缓存
第四 Compilation to machine code。字节码的中间表示
第五，垃圾回收机制  V8使用了渐进式标记

PWA

—PWA（Progressive Web App，渐进式网页应用，逐渐接近原生app的web app）是一种理念，使用多种技术来增强web app的功能，可以让网站的体验变得更好，能够模拟一些原生功能，比如通知推送。在移动端利用标准化框架，让网页应用呈现和原生应用相似的体验。
—PWA不能包含原生OS相关代码。PWA仍然是网站，只是在缓存、通知、后台功能等方面表现更好。Electron程序相当于包裹OS原生启动器（Launcher）的网站，未来，许多Electron程序可能转化为PWA。

---

大数据量的解决方案

「前端进阶」高性能渲染十万条数据(时间分片)

requestIdleCallback和requestAnimationFrame详解

requestIdleCallback笔记

documentFragment，requestIdleCallback，requestAnimationFrame

什么是时间分片（Time Slicing）
时间切片（Time Slicing）
「前端进阶」高性能渲染十万条数据(时间分片)
虚拟列表

---

js解释器

JS解释器：
     就是执行你的javascript代码的东东，就像你的java代码由JVM执行，javascript是由javascript解释器执行，浏览器中一般都会包含这个。
 每个浏览器的并不一样，一般都包含在各浏览器的内核中
 浏览器内核一般包含两个引擎：页面排版引擎 和 JS引擎
 IE的 使用的自己的Trident 内核
 FireFox 是Gecko内核
Opera 是Presto内核
Safari 使用的Webkit 内核
Chrome 是Google自己的 javascript V8引擎 而其页面排版采用的Webkit 内核

javaScript 代码解释执行过程

JS的内存分配

Js 内存管理机制 垃圾回收 内存泄露的4个点 添加链接描述

堆和栈的区别 添加链接描述

内存中的栈区处于相对较高的地址以地址的增长方向为上的话，栈地址是向下增长的。

使用箭头函数应注意什么？

用了箭头函数，this就不是指向window，而是父级（指向是可变的）
2、不能够使用arguments对象
3、不能用作构造函数，这就是说不能够使用new命令，否则会抛出一个错误
4、不可以使用yield命令，因此箭头函数不能用作 Generator 函数

js 设计模式

六大原则
开闭原则（一个软件实体，如类、模块和函数应该对扩展开放，对修改关闭）
单一职责原则
里氏替换原则（子类对父类的方法尽量不要重写和重载）
接口隔离原则（减少依赖）
最少知道原则（一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。）
合成复用原则（尽量使用对象组合/聚合，而不是继承关系达到软件复用的目的）

// 单例模式
// 工厂模式
// 订阅者模式
// 观察者模式（一个Subject(arr, state, attch, setState)观察多个Observer(update方法)）
class Subject { // 被观察者 小宝宝
    constructor(){
        this.arr = []; // [o1,o2]
        this.state = '我很开心'
    }
    attach(o){ // 原型上的方法
        this.arr.push(o);
    }
    setState(newState){
        this.state = newState;
        this.arr.forEach(o=>o.update(newState))
    }
}
//观察者模式包含发布订阅
class Observer{ // 观察者 我 我媳妇
    constructor(name){
        this.name = name
    }
    update(newState){
        console.log(this.name + '小宝宝:'+newState)
    }
}
let s = new Subject('小宝宝'); // 小宝宝
let o1 = new Observer('我');
let o2 = new Observer('我媳妇')
s.attach(o1);
s.attach(o2);
s.setState('不开心了');

桥接模式

js的in不仅可以遍历对象，更可以遍历所有的东西

JS实现JSON.stringify

上边这个我测试了，确实好用。

for in 和 for of

简析2

函数式编程和面向对象编程

RPC与HTTP的区别与联系

---

监控监听三个方面的信息： 性能，错误，辅助信息(用户信息，用户行为信息，设备信息)

前端监控SDK开发分享

Performance前端性能监控利器

报错

promise报错的捕获 reject, catch,unhandledrejection
javascript报错 window.onerror | unhandledrejection | console.error

---收集js报错、静态资源加载错误、ajax接口加载错误，这些常规错误收集都很好理解。下面主要说明一下"业务接口错误(bussiness)":
---辅助信息(性为，用户，设备)
----性能
收集页面加载、静态资源、ajax接口等性能信息，指标有加载时间、http协议版本、响应体大小等，这是为业务整体质量提升提供数据支撑，解决慢查询问题等。
new PerformanceObserver监听器，我们可以监听所有资源（css,script,img,ajax等）加载的性能数据：加载时间，响应大小，http协议版本
const observer = new PerformanceObserver((list) => {
   for (const entry of list.getEntries()) {
       console.groupCollapsed(entry.name);
       console.log(entry.entryType);
       console.log(entry.startTime);
       console.log(entry.duration);
       console.groupEnd(entry.name);
   }
})
observer.observe({ entryTypes: ['longtask', 'navigation', 'resource', 'mark', 'measure', 'paint'] });

// js异常上报方式
动态创建 img 标签的形式
或者ajax(考虑跨域)

前端异常监控

JS原生错误 除了try catch中捕获住的错误，我们还需要上报没有被捕获住的错误——通过error事件和unhandledrejection事件去监听。

unhandledrejection 只能捕获未显式处理的Promise异常

// 能触发 unhandledrejection ，因为未显式处理
Promise.reject('test').then()
// 能触发 unhandledrejection ，因为未显式处理
Promise.reject('test').then(console.log)
// 不能触发 unhandledrejection ，因为已处理
Promise.reject('test').then(console.log, console.log)
// 不能触发 unhandledrejection ，因为没处理，直接抛出异常
Promise.reject('test')

---

BFF给前端提供的能力

api
插件:node 提供了多种内置插件，包括logger，http client，rpc client等，也可以通过配置加载第三方插件. 
中间件:Gatway实现方式之一，我们通过中间件实现了sso，限流，熔断等.
路由: 通过路由，给不同Appcation提供了不同形式的API，不管是H5，PC，小程序还是Open Api
渲染: 这层可以直接渲染Client端构建生成的index.html，也可以实现SSR
----BFF优势
1、可以降低沟通成本,前端边界提升，更加独立。
2、UI多端适配，展示不同数据，灵活配置同一个接口，对接口做额外处理，PC端与移动端可以自由调节字段，同时也能聚会API来减少HTTP请求。
3、提供给第三方api。
4、性能优化，高并发与负载均衡：常见的情况下，高并发的性能制约包括了大量的I/O操作时CPU利用率较低，而Node在处理I/O密集型操作时有自己的优势。
5、访问控制，可以把服务中的权限集中控制在BFF层，使下层服务更加纯粹和独立
6、应用缓存，可以增加一些缓存临时数据，更快的响应数据。
-----BFF的痛点
1、重复开发：每个设备开发一个 BFF 应用，也会面临一些重复开发的问题展示，增加开发成本
2、维护问题：需要维护各种 BFF 应用、以往前端也不需要关心并发，现在并发压力却集中到了 BFF上
3、链路复杂：流程变得繁琐、BFF引入后，要同时走前端、服务端的研发流程，多端发布、互相依赖，导致流程繁琐浪费
4、浪费资源: BFF层多了，资源占用就成了问题，会浪费资源，除非有弹性伸缩扩容
5、分布式事务（微服务的通病）

为啥node来做BFF层

前端图片懒加载和预加载
图片的懒加载和预加载？

预加载方法
1.使用CSS进行图片预加载。
2.使用CSS+JS进行图片预加载
3.仅使用JS实现预加载（通过new Image）
4.使用Ajax实现预加载(通过ajax，赋值new Image().src)

Symbol的使用场景
get方法和post方法的区别及常用的请求方式
get方法和post方法的区别和联系

Js的Generator函数（一）

js和原生通信的一般方法大纲
JSBridge的原理及使用

JSBridge 的通信原理:
js调用native,1.1 注入API, 拦截 URL SCHEME.
Native 调用 JavaScript 的方式, 直接执行拼接好的 JavaScript 代码即可.

Blob

JavaScript中的Blob你知道多少

学习HTML5 Canvas这一篇文章就够了

fetch与axios的区别

fetch优点：
1.w3e标准, 原生。
2.基于promise,支持async, await
3.语法简洁，更加语义化.
fetch缺点：
1.fetch只对网络请求报错，对400,500都当做成功的请求，服务器返回400,500错误码时并不会reject,只有网络错误导致这些请求不能完成时，fetch才会被reject。
2.fetch默认不会带cookie,需要添加配置项:fetch(url,{credentials:‘include’})
3. fetch不支持abort,
4. 不支持超时控制，使用setTimeout及Promise.reject的实现的超时控制并不能阻止过程继续在后台运行，造成了流量的浪费
5. fetch没有办法原生检测请求的进度，而XHR可以（进度条）。

axios的优点
axios是一个基于Promise用于浏览器和nodejs的http客户端，本质上也是对原生XHR的封装，只不过它是Promise的实现版本，符合最新的ES规范，它本身具有以下特征：

从浏览器中创建XMLHttpRequest
支持Promise API
客户端支持防止CSRF: 就是让我们的每个请求都带一个从 cookie 中拿到的 key，根据浏览器同源策略，假冒的网站是拿不到你 cookie 中的 key 的，这样，后台就可以轻松辨别出这个请求是否是用户在假冒网站上的误导输入，从而采取正确的策略。
提供了一些并发请求的接口（！方便了很多操作）
从node.js创建http请求
拦截请求和响应
转换请求和响应数据（请求A服务器可以转换到B服务器）
中断请求
自动转换JSON数据（fetch API需要手动处理返回的数据）

---

小程序
京东的小程序框架Taro
微信小程序面试题大全（持续更新）

---

模块化

Js模块化——CommonJS AMD CMD UMD ES6 Module 比较 博客一

为什么CommonJS和ES6可以混合使用?

commonjs es6怎么解决循环引用问题

commonjs 和 esmodule方式的区别

commonjs 和 esModule模块 AMD

commonjs
1. 值的拷贝，普通类型是拷贝，而引用类型是浅拷贝(类似赋值=，并不是Object.assign)
2. require 同步引入，动态导入，引入的时候模块会执行。但是有缓存机制，第二次引入，就是拷贝过程。
3. node真正导入的是module.exports,exports和module.exports本来是一回事，一般不要手动去改。所以当我们手动更改exports = {},这样就会报错，我们只能改属性。
esModule的优势
1 es6提出的一种打包和导入的机制。
2-静态导入，可以更好的Treeshaking去掉无用代码。引用导入，模块不会执行，更不会做缓存之类的事情。
3-只读导入，不可以修改。
4- import可以当方法使用，可以做一些动态加载。
5-异步加载。
amd
1-requirejs时代了，define定义，require引用。
2-规范加载模块是异步的，并允许函数回调，不必等到所有模块都加载完成，后续操作可以正常执行。
3-依赖前置。
cmd
1-seajs时代。define定义，seajs.use() 
2-依赖就近。

UMD
1. UMD 是AMD 和 CommonJS的糅合。UMD 先判断是否支持 Node.js 的模块（exports）是否存在，存在则使用 Node.js 模块模式。再判断是否支持 AMD（define 是否存在），存在则使用 AMD 方式加载模块。
2. 

为什么说ESModule是异步的?

这里说的esmodule,指的是<script type="module" src="a.js"></script>

你对前端模块化的理解

什么是模块化？ 模块化就是为了减少系统耦合度，提高高内聚，减少资源循环依赖，增强系统框架设计。
模块的历程：
namespace
sass,less
AMD&CMD
html模版
grunt,gulp,webpack
FIS,YUI,KISSY

---

angular
rxjs
rxjs2学习
Angular 面试题汇总1-基本知识 (Angular v8+)

Observable（可观察对象）,表示一个概念，这个概念是一个可调用的未来值或事件的集合
Observer（观察者）： 一个回调函数的集合.
subject解决多播,可以监听多个oberable.

BehaviorSubject:并且当有新的观察者订阅时，会立即从 BehaviorSubject 那接收到“当前值”。
ReplaySubject:它可以发送旧值给新的订阅者
AsyncSubject:只有当 Observable 执行完成时(执行 complete())，它才会将执行的最后一个值发送给观察者。

angular https://www.jianshu.com/p/f03c6df14956

angular的脏检测机制，
不论哪种异步，都会触发angualr大的检测，
从上到下，更新所有的数据。
ng-zone把所有的异步都包裹了。
依赖注入概念。

---

常看哪些技术类的书籍和博客

JavaScript高级程序设计 JavaScript+DOM编程艺术 设计模式 JavaScript权威指南 mdn 掘金 公众号 奇舞周刊 csdn 社区 大会

对前端工程师这个职位是怎么样理解的？它的前景会怎么样？

1.实现界面交互
2.提升用户体验
3.有了Node.js，前端可以实现服务端的一些事情
4.前端是最贴近用户的程序员，前端的能力就是能让产品从 90分进化到 100 分，甚至更好.
5.与团队成员，UI设计，产品经理的沟通；
6.做好的页面结构，页面重构和用户体验；

你觉得前端工程的价值体现在哪？

1、为简化用户使用提供技术支持（交互部分）
2、为多个浏览器兼容性提供支持
3、为提高用户浏览速度（浏览器性能）提供支持
4、为跨平台或者其他基于webkit或其他渲染引擎的应用提供支持
5、为展示数据提供支持（数据接口）

移动端（Android IOS）怎么做好用户体验?

清晰的视觉纵线、
信息的分组、极致的减法、
利用选择代替输入、
标签及文字的排布方式、
依靠明文确认密码、
合理的键盘利用

编写可维护性质的代码

1.公用二次以上的代码必须抽象出来。
2.不能用if else if else 解决多个类型判断的问题，必须注意抽象出来，写成一个数组。
3.写代码的时候，要有一写，编程的思想或者设计模式在里边，工厂模式了，代理模式了，js的颗粒化了，适配模式了，订阅者发布者模式了.
4 js url变化监听 https://blog.csdn.net/yanyan19880509/article/details/48229511
如果页面没有#或者location.hash
5 方法如果return {}这个对象和new的效果一样都是新的，但是如果return function() {} 你多次调用这个方法，返回的匿名函数的指针也是不同的。
6 js的继承应该看的https://www.cnblogs.com/lishuxue/p/6097575.html
7 js mdn 中文版本 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Classes

[面向对象的6大原则](https://www.cnblogs.com/cmt/p/14580194.html?from=https://www.cnblogs.com/silencer/p/10812417.html

面向对象的三大特征 博客1

json-bigint处理大整数问题（详解）

云计算服务类型都是什么？IaaS、PaaS、SaaS、BaaS、FaaS

实现一个基本功能的diff算法(包含注释讲解）

ES6 一共有 5 种方法可以遍历对象的属性。

（1）for...in
for...in循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）。
（2）Object.keys(obj)
Object.keys返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）的键名。
（3）Object.getOwnPropertyNames(obj)
Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名。
（4）Object.getOwnPropertySymbols(obj)
Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性的键名。
（5）Reflect.ownKeys(obj)
Reflect.ownKeys返回一个数组，包含对象自身的（不含继承的）所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举。
以上的 5 种方法遍历对象的键名，都遵守同样的属性遍历的次序规则。
首先遍历所有数值键，按照数值升序排列。
其次遍历所有字符串键，按照加入时间升序排列。
最后遍历所有 Symbol 键，按照加入时间升序排列。
Reflect.ownKeys({ [Symbol()]:0, b:0, 10:0, 2:0, a:0 })
// ['2', '10', 'b', 'a', Symbol()]
上面代码中，Reflect.ownKeys方法返回一个数组，包含了参数对象的所有属性。这个数组的属性次序是这样的，首先是数值属性2和10，其次是字符串属性b和a，最后是 Symbol 属性。

JavaScript浅拷贝与深拷贝的几种方法。

可以跨浏览器标签的通信方法

 worker.onmessage= function (event) { 
		// 把子线程返回的结果添加到 div 上
		 document.getElementById("result").innerHTML += 
		    event.data+"
"; 
	 }; 
 } 
----
postMessage("Before computing,"+new Date()); 

html5 webwork的使用方式

---检测浏览器是否支持 Web Worker
function startWorker() {
    if(typeof(Worker) !== "undefined") {
        if(typeof(w) == "undefined") {
            w = new Worker("demo_workers.js");
        }
        w.onmessage = function(event) {
            document.getElementById("result").innerHTML = event.data;
        };
    } else {
        document.getElementById("result").innerHTML = "抱歉，你的浏览器不支持 Web Workers...";
    }
}

function stopWorker() 
// ----
var i=0;
function timedCount() {
    i=i+1;
    postMessage(i);
    setTimeout("timedCount()",500);
}
timedCount();

---

深拷贝 浅拷贝
1.普通类型的话，不存在深浅拷贝，他们值存在栈里边。每次都是复制都是值的拷贝。
2.引用类型存在存在深拷贝和浅拷贝两种类型。
浅拷贝有两种解释，
1-只是引用的复制。
2-第一层的拷贝。

0.1+0.2 等于 0.3 吗？（数字相加结果有无限小数的原因及解决方式）

0.1+0.2 不等于 0.3 ，因为在 0.1+0.2 的计算过程中发生了两次精度丢失。第一次是在 0.1 和 0.2 转成双精度二进制浮点数时，由于二进制浮点数的小数位只能存储52位，导致小数点后第53位的数要进行为1则进1为0则舍去的操作，从而造成一次精度丢失。第二次在 0.1 和 0.2 转成二进制浮点数后，二进制浮点数相加的过程中，小数位相加导致小数位多出了一位，又要让第53位的数进行为1则进1为0则舍去的操作，又造成一次精度丢失。最终导致 0.1+0.2 不等于0.3 。
---拓展
若你回答出来，面试官还可能继续问你：“ 0.1+0.2 不等于 0.3 会引起那些BUG？”
可以这样回答：“ 会引起统计页面展示错乱的BUG，还有 300.01 优惠300 元后，支付金额不足0.01 元等类似的BUG。”
---解决方式1
(0.1+0.2).toFixed(6) === 0.3.toFixed(6)
---解决方案2
Math.round(Math.pow(10, 6) * (0.1+0.2)) / Math.pow(10, 6)
---解决方案3 (toFixed返回的是字符串)
parseFloat((0.1 + 0.2).toFixed(10))

js方法构造器和不构造器的时候，返回不同的结果

function Obj(name) {
    // 浏览器中是window
  if (this === global)
    return {name}
}
Obj.prototype.name = "name2"
var a = Obj("name1")
var b = new Obj;
console.log(a.name); // name1
console.log(b.name); // name2

---

分析vite
浅谈vite与webpack的区别及Vite为什么那么快
Vue 2 中，使用Vite作为前端构建开发工具，替代webpack（二）常见问题——和webpack 入口文件同名冲突 & 将commonjs转化为es module-cjs2esmodule

vite快的原因

1. 原理角度：vite使用浏览器支持的esmodule，esbuild是采用go语言编写，因为go语言的操作是纳秒级别，而js是以毫秒计数，所以vite比用js编写的打包器快10-100倍。
2. 启动阶段：vite因为它在启动的时候不需要打包，所以不用分析模块与模块之间的依赖关系，不用进行编译。 
3. 热更新阶段：vite在浏览器访问devServer的时候，直接返回对应的渲染文件，而webpack是把所有都整合成bundle，返回结果。

---

Tree-Shaking原理
Webpack 原理系列九：Tree-Shaking 实现原理

DCE (Dead code elimination)
代码不会被执⾏，不可到达
代码执⾏的结果不会被⽤到
代码只会影响死变量（只写不读）
Tree-Shaking是DCE的一种方式。
基于esmodule
uglify对帮忙删除同一模块的没有使用的方法模块，和没有使用的变量或者语句，uglify目前不会跨文件去做DCE

WeakMap与Map

1.WeakMap的key只能是obj，map可以是字符串简单类型。
2.当WeakMap的key引用为null时，WeakMap中设置的值也会销毁，而map会保留，内存中也会保留。
---测试方法
class MyFn { }
let mf=newMyFn();
let map = new WeakMap();
map.set(mf, 'ok');
mf = null; // 对于map来说这里写不写mf都会保留在map中，在内存中搜索变量newMyFn可是可以搜索到的
console.log(map);

内存中搜索变量

锚点

1 使用标签实现锚点

优点：实现方式简单；
缺点：点击锚点之后，浏览器的URL会发生变化，这样，遇到页面刷新很可能会出现问题。
在herf属性中写入div标签的id，例：

...
<a href="#div1">go to div1</a>
<a href="#div2">go to div2</a>
...
<div id="div1">div1</div>
<div id="div2">div2</div>
...

2使用js事件中window.location.hash="div标签的id值"实现锚点

优点：实现方式简单；
缺点：点击锚点之后，浏览器的URL会发生变化，这样，遇到页面刷新很可能会出现问题。

3使用jQuery中的animate属性实现锚点

优点：引入jQuery框架后，实现方式简单，有优雅的动画滚动效果，没有URL改变的情况。
缺点：得引入jQuery框架，有一定框架限制；如果页面复杂的话，偏移值如发生变化需要借助算法辅助。

...
<script src="放jquery的路径/jquery.min.js"></script>
<script type="text/javascript">
	$(document).ready(function() {
		$("#div1Link").click(function() {
			$("html, body").animate({scrollTop: $("#div1").offset().top },{duration: 500,easing: "swing"});
			return;
		});
		$("#div2Link").click(function() {
			$("html, body").animate({scrollTop: $("#div2").offset().top }, {duration: 500,easing: "swing"});
			return;
		});
</script>

4使用js的scrollIntoView()方法实现锚点（推荐使用）这个用来实现页面。（注意scrollIntoView平滑滚动可以设置参数，CSS scroll-behavior，）

优点：实现方式简单；
缺点：暂无。

document.getElementById("div标签的id值").scrollIntoView();
----

平滑滚动 类似 (CSS scroll-behavior) 平滑滚动(可以查看)
scrollIntoView({
behavior: “smooth”
})

5 parent.scrollTo(0, children.offset)

scrollTo是两个参数

scrollTop 和 scrollTo对应的，而offsetTop距离父元素的距离

scrollIntoView 和 scrollTo可以配合使用。
遇到一次scrollIntoView用了之后，scrollTo使用没有效果了，然后用父元素的第一个元素去再次执行scrollIntoView