面试题库
前端面试题总汇
HTML+CSS、移动端、JS 基础、Vue、React、工程化、性能优化、Node.js、小程序、场景题与技术方案精讲,合并去重版总汇。
- 前端
- 面试
前端面试题总汇
由原《前端面试真题汇总 2026》《Vue 面试题 100 问》《小程序面试题 100 问》《Web 网页面试题》《JS 面试题精讲》《前端技术方案面试题精讲》六篇合并去重而成:同题仅保留更详细的版本,按主题重组为十一章,全文连续编号。
一、HTML + CSS
1. 标签语义化的意义
- 开发者更容易理解,减少差异化,方便团队开发和维护
- 机器更容易理解结果(搜索爬虫、方便其他设备解析(读屏幕软件、盲人设备、移动设备)
2. 写页面结构应该注意什么
- 尽可能少的使用没有语义的 div 和 span 元素
- 块级元素和内联元素的嵌套一定要符合 web 标准,比如内联元素就是不能嵌套块级元素
3. HTML5 新特性
- 新的语义化元素:article 、footer 、header 、nav 、section
- 表单增强,新的表单控件:calendar 、date 、time 、email 、url 、search
- 新的 API:音频(用于媒介回放的 video 和 audio 元素)、图形(绘图 canvas 元素)
- 新的 API:离线,通过创建 cache manifest 文件,创建应用程序缓存
- 新的 API:本地存储,localStorage-没有时间限制的数据存储,sessionStorage-session 数据存储(关闭浏览器窗口数据删除)
- 新的 API:实时通讯,设备能力
4. CSS3 新特性
- CSS3实现圆角(border-radius),阴影(box-shadow),
- 对文字加特效(text-shadow),线性渐变(gradient),旋转(transform)
- transform:rotate(9deg) scale(0.85,0.90) translate(0px,-30px) skew(-9deg,0deg);//旋转,缩放,定位,倾斜
- 增加了更多的CSS选择器 多背景 rgba
- 在CSS3中唯一引入的伪元素是::selection.
- 媒体查询,多栏布局
5. BFC
块级格式化上下文,是一个独立的渲染区域,让处于 BFC 内部的元素与外部的元素相互隔离,使内外元素的定位不会相互影响。
IE 下为 Layout,可通过 zoom:1 触发
- 触发条件:
- 根元素
position: absolute/fixeddisplay: inline-block / tablefloat元素overflow!==visible
- 规则:
- 属于同一个 BFC 的两个相邻 Box 垂直排列
- 属于同一个 BFC 的两个相邻 Box 的 margin 会发生重叠
- BFC 中子元素的 margin box 的左边, 与包含块 (BFC) border box 的左边相接触 (子元素 absolute 除外)
- BFC 的区域不会与 float 的元素区域重叠
- 计算 BFC 的高度时,浮动子元素也参与计算 - 文字层不会被浮动层覆盖,环绕于周围
- 应用:
- 阻止
margin重叠 - 可以包含浮动元素 —— 清除内部浮动(清除浮动的原理是两个
div都位于同一个 BFC 区域之中) - 自适应两栏布局
- 可以阻止元素被浮动元素覆盖
- 阻止
6. 选择器优先级
!important> 行内样式 >#id>.class>tag> * > 继承 > 默认- 选择器 从右往左 解析
7. 去除浮动影响,防止父级高度塌陷
- 通过增加尾元素清除浮动
:after / <br> : clear: both- 创建父级 BFC
- 父级设置高度
8. link 与 @import 的区别
link功能较多,可以定义 RSS,定义 Rel 等作用,而@import只能用于加载 css- 当解析到
link时,页面会同步加载所引的 css,而@import所引用的 css 会等到页面加载完才被加载 @import需要 IE5 以上才能使用link可以使用 js 动态引入,@import不行
9. CSS 预处理器(Sass/Less/Postcss)
CSS 预处理器的原理: 是将类 CSS 语言通过 Webpack 编译 转成浏览器可读的真正 CSS。在这层编译之上,便可以赋予 CSS 更多更强大的功能,常用功能:
- 嵌套
- 变量
- 循环语句
- 条件语句
- 自动前缀
- 单位转换
- mixin 复用
10. 单行文本溢出
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
11. 多行文本溢出
overflow: hidden;
text-overflow: ellipsis;
display: -webkit-box;
-webkit-line-clamp: 2; /*2*/
-webkit-box-orient: vertical;
12. flex布局
- Flex是Flexible Box的缩写,意为”弹性布局”,用来为盒状模型提供最大的灵活性。
- 布局的传统解决方案,基于盒状模型,依赖display属性 + position属性 + float属性。它对于那些特殊布局非常不方便,比如,垂直居中就不容易实现。
- 分清主轴和交叉轴
- flex-direction 为 row 时,主轴是横向的,相反的为 column 时,主轴是纵向的。
- 简单的分为容器属性和元素属性
-
容器的属性:
flex-direction:决定主轴的方向(即子item的排列方法)
flex-wrap:决定换行规则
flex-flow:flex-direction
和flex-wrap的简写形式,默认值为row nowrapjustify-content:对其方式,水平主轴对齐方式
align-items:对齐方式,竖直轴线方向
-
项目的属性(元素的属性):
flex:是flex-grow和flex-shrink、flex-basis的简写,默认值为0 1 auto。
order属性:定义项目的排列顺序,顺序越小,排列越靠前,默认为0
flex-grow属性:定义项目的放大比例,即使存在空间,也不会放大
flex-shrink属性:定义了项目的缩小比例,当空间不足的情况下会等比例的缩小,如果定义个item的flow-shrink为0,则为不缩小
flex-basis属性:定义了在分配多余的空间,项目占据的空间。
-
13. 圣杯布局
- 圣杯特点简单记为:有头、有尾、包三列,圣杯布局中间有container大容器包裹着左、中、右三列区域
- 左、中、右是独立的三个区域,都处于一个层级
14. 双飞翼布局
- 左、中、右是独立的三个区域,中间区域属于最上面的层级
15. 基本选择器
| 选择器 | 说明 |
|---|---|
#id | 根据给定的 ID 匹配一个元素 |
element | 根据给定的元素标签名匹配所有元素 |
.class | 根据给定的 css 类名匹配元素 |
* | 匹配所有元素 |
selector1,selector2,selectorN | 将每一个选择器匹配到的元素合并后一起返回 |
16. 层级选择器
| 选择器 | 说明 |
|---|---|
ancestor descendant | 在给定的祖先元素下匹配所有的后代元素 |
parent > child | 在给定的父元素下匹配所有的子元素 |
prev + next | 匹配紧接在 prev 元素后的 next 元素 |
prev ~ siblings | 匹配 prev 元素之后的所有 siblings 元素 |
17. 过滤选择器
| 选择器 | 说明 |
|---|---|
:first | 获取第一个元素 |
:not(selector) | 去除所有与给定选择器匹配的元素 |
:even | 匹配所有索引值为偶数的元素,从 0 开始计数 |
:odd | 匹配所有索引值为奇数的元素,从 0 开始计数 |
:eq(index) | 匹配一个给定索引值的元素 |
:gt(index) | 匹配所有大于给定索引值的元素 |
:lt(index) | 匹配所有小于给定索引值的元素 |
:header | 匹配如 h1、h2、h3 之类的标题元素 |
:lang | 选择指定语言的所有元素(1.9+) |
:last | 获取最后一个元素 |
:animated | 匹配所有正在执行动画效果的元素 |
:focus | 匹配当前获取焦点的元素 |
:root | 选择该文档的根元素(1.9+) |
:target | 选择由文档 URI 的格式化识别码表示的目标元素(1.9+) |
18. 内容选择器
| 选择器 | 说明 |
|---|---|
:contains(text) | 匹配包含给定文本的元素 |
:empty | 匹配所有不包含子元素或者文本的空元素 |
:has(selector) | 匹配含有选择器所匹配的元素的元素 |
:parent | 匹配含有子元素或者文本的元素 |
19. 可见性选择器
| 选择器 | 说明 |
|---|---|
:hidden | 匹配所有不可见元素,或 type 为 hidden 的元素 |
:visible | 匹配所有的可见元素 |
20. 属性选择器
| 选择器 | 说明 |
|---|---|
[attribute] | 匹配包含给定属性的元素 |
[attribute=value] | 匹配给定的属性是某个特定值的元素 |
[attribute!=value] | 匹配所有不含有指定的属性,或者属性不等于特定值的元素 |
[attribute^=value] | 匹配给定的属性是以某些值开始的元素 |
[attribute$=value] | 匹配给定的属性是以某些值结尾的元素 |
[attribute*=value] | 匹配给定的属性是包含某些值的元素 |
[attrSel1][attrSel2][attrSelN] | 复合属性选择器,需要同时满足多个条件时使用 |
21. 子元素选择器
| 选择器 | 说明 |
|---|---|
:first-child | 匹配所给选择器的第一个子元素 |
:first-of-type | 结构化伪类,匹配 E 的父元素的第一个 E 类型的孩子(1.9+) |
:last-child | 匹配最后一个子元素 |
:last-of-type | 结构化伪类,匹配 E 的父元素的最后一个 E 类型的孩子(1.9+) |
:nth-child() | 匹配其父元素下的第 N 个子或奇偶元素 |
:nth-last-child() | 选择其父元素的第 n 个子元素,计数从最后一个元素开始(1.9+) |
:nth-last-of-type() | 选择其父级元素的第 n 个同类型子元素,计数从最后一个元素开始 |
:nth-of-type() | 选择同属于一个父元素且标签名相同的子元素中的第 n 个(1.9+) |
:only-child | 如果某个元素是父元素中唯一的子元素,那将会被匹配 |
:only-of-type | 选择所有没有兄弟元素且具有相同元素名称的元素 |
22. 表单选择器
| 选择器 | 说明 |
|---|---|
:input | 匹配所有 input、textarea、select 和 button 元素 |
:text | 匹配所有的单行文本框 |
:password | 匹配所有密码框 |
:radio | 匹配所有单选按钮 |
:checkbox | 匹配所有复选框 |
:submit | 匹配所有提交按钮,type=“submit” 的 input 或 button |
:image | 匹配所有图像域 |
:reset | 匹配所有重置按钮 |
:button | 匹配所有按钮 |
:file | 匹配所有文件域 |
23. 表单对象选择器
| 选择器 | 说明 |
|---|---|
:enabled | 匹配每个启用的元素(主要用于表单元素) |
:disabled | 匹配每个被禁用的元素(主要用于表单元素) |
:checked | 匹配每个已被选中的元素(复选框、单选按钮等) |
:selected | 选取被选择的 |
24. 混淆选择器
$.escapeSelector(selector):转义选择器中的特殊字符(如 #、[、(),用于把含特殊字符的 id/类名安全地传给 jQuery 选择器(3.0+)。
25. Animista
网站地址:http://animista.net/ 网站描述:在线生成css动画 Animista是一个在线动画生成器,同时也是一个动画库,它为我们提供了以下功能
26. Animate CSS
网站地址:http://daneden.github.io/anim… 网站描述:齐全的CSS3动画库 想必这个不用介绍,大部分人都知道了。Animate CSS可能是最著名的动画库之一。
27. Vivify
网站地址:http://vivify.mkcreative.cz/ 网站描述:一个更加丰富css动画库 Vivify是一个动画库,可以看作是Animate CSS的增强版。它们的工作方式完全相同,有Animate CSS 的大多数类且还扩展了一些。
28. Magic Animations CSS3
网站地址:https://www.minimamente.com/p… 网站描述: Magic CSS3 Animations 是 CSS3 动画的包,伴有特殊的效果,用户可以自由的在 web 项目 中使用。 这个动画库有一些非常漂亮和流畅的动画,特别是3D的。没什么好说的,自己去尝试。
29. Angrytools
网站地址:https://angrytools.com/css/an… 如果使用不同的生成器,Angrytools实际上是一个集合,其中还包括CSS动画生成器。
30. Hover.css
网站地址:http://ianlunn.github.io/Hover/ 网站描述:纯CSS3鼠标滑过效果动画库 Hover.css是许多CSS动画的集合,与上面的动画不同,每次将元素悬停时都会触发。
31. WickedCSS
网站地址:http://kristofferandreasen.gi… WickedCSS是一个小的CSS动画库,它没有太多的动画变体,但至少有很大的变化。其中大多数是我们 已经熟悉的基础知识,但它们确实很干净。
32. Three Dots
网站地址:https://nzbin.github.io/three Three Dots是一组CSS加载动画,它由三个点组成,而这些点仅由单个元素组成。
33. CSShake
网站地址:https://elrumordelaluz.github 顾名思义,CSShake是一个CSS动画库,其中包含不同类型的震动动画。
二、JS的常用动画库
34. Three.js
网站地址:https://threejs.org/ 网站描述:最强大的 WebGL 3D 引擎。封装 WebGL 底层 API,用于创建 3D 场景、模型、光照与相机动画,是网页 3D 的事实标准。
35. Anime.js
网站地址:https://animejs.com/ 网站描述:轻量级 JS 动画库。支持 CSS 属性、SVG、DOM 属性和普通 JS 对象的动画,时间线编排能力强,API 简洁。
36. Mo.js
网站地址:https://mojs.tools/ 网站描述:运动图形特效库。擅长粒子、爆发(burst)类运动图形效果,常用于制作炫酷的交互特效。
37. Velocity
网站地址:http://velocityjs.org/ 网站描述:加速的 JS 动画库。API 与 jQuery.animate 一致但性能更好,可作为 jQuery 动画的直接替代,独立使用时不需要 jQuery。
38. Popmotion
网站地址:https://popmotion.io/ 网站描述:函数式运动引擎。提供 tween、spring、keyframes 等动作原语,按帧组合出复杂动画,配合 React 使用顺手。
39. Vivus
网站地址:https://maxwellito.github.io/vivus/ 网站描述:SVG 描边动画库。让 SVG 图形按笔画画出(stroke 动画),零依赖、体积小,常用作 Logo 描边入场效果。
40. GreenSock JS
网站地址:https://greensock.com/ 网站描述:业界标准动画库(GSAP)。TweenMax/TimelineMax 时间线体系强大,性能好、兼容性强,DOM/SVG/JS 对象通吃,商业项目首选。
41. Scroll Reveal
网站地址:https://scrollrevealjs.org/ 网站描述:滚动入场动画库。元素进入视口时触发配置好的动画(支持 3D 旋转、缩放、位移),声明式配置即可。
42. Typed.js
43. 过渡动画(transition)
1概念
允许 CSS 的属性值在一定时间区间内平滑的过渡,在鼠标点击,鼠标滑过或对元素任何改变中触发,并 圆滑地以动画改变css的属性值 1.2CSS3 过渡语法 transition-delay :检索或设置对象延迟过渡的时间 transition-duration :检索或设置对象过渡的持续时间 transition-property :检索或设置对象中的参与过渡的属性 all | none | property,property … all:所有可以进行过渡的css属性 none:不指定过渡的css属性 property:指定要进行过渡的css属性 transition-timing-function:检索或设置对象中过渡的动画类型 transition-timing-function:linear | ease | ease-in | ease-out | ease-in-out | cubic- bezier(number, number, number, number) 检索或设置对象中过渡的动画类型 如果提供多个属性值,以逗号进行分隔 http://cubic-bezier.com/(贝塞尔曲线生成器)
3注意事项
并不是所有元素都支持过渡 元素没有渲染完的情况下,过渡不生效 2.关键帧动画(animation)
1概念
通过 CSS 提供的@keyframes规则整合多个简单的动画,它会指定某个动画的名称以及相应的规则: 哪个属性,何时以及何地渲染动画。然后使用animation属性把动画绑定到相应的元素上,并为其添 加额外的参数
2关键帧
CSS3 动画语法-关键帧: keyframes 控制关键位置,并不是所有的位置 keyframes-selector:必写项,动画持续时间的百分比 0% - 100%之间,或者使用from和to关键字也可以设置,from代表0%,to代表100%
3关键帧的使用
基础语法: animation-name:move; 动画属性名,前面keyframes样例定义的动画名 animation-duration: 10s; 动画持续时间 animation-timing-function: ease-in-out; 检测的是关键帧的区间,并不是整个动画过程 animation-delay: 2s; 动画延迟时间 animation-iteration-count: 10; 动画循环次数,infinite为无限次 animation-direction: normal; 定义动画播放方式 动画的暂停和播放 animation-play-state 属性 paused:规定动画已暂停 running:规定动画正在播放 动画开始和结束状态 animation-fill-mode 属性 none:使用得动画不会对动画等待和动画完成的元素样式产生改变 forwards:告诉浏览器动画结束后,元素的样式将设置为动画的最后一帧的样式 backwards :那么在动画等待的那段时间内,元素的样式将设置为动画第一帧的样式 both:在动画等待和动画结束状态,元素将分别应用动画第一帧和最后一帧的样式
二、js动画
44. 使用 setInterval
通过一个定时器setInterval间隔来改变元素样式,动画结束时clearInterval即可 2.使用 requestAnimationFrame requestAnimationFrame是另一种Web API,原理与setTimeout和setInterval类似,都是通过 javascript持续循环的方法调用来触发动画动作。 但它与setTimeOut()不同的是,它是根据浏览器的刷新同步进行动画。而定时器是按照自己的思路走 的
45. Jquery的animate函数
@keyframesname{
[keyframes-selector] { Properties:Propertiesvalue; }
[keyframes-selector] { Properties:Propertiesvalue; }
}
三、html5动画
canvas svg webgl
四.对比css动画和js动画
46. 使用场景选择
使用 CSS 动画来实现较简单的“一次性”转换,例如切换 UI 元素状态。 需要高级效果(例如弹跳、停止、暂停、倒退或减速)时,使用 JavaScript 动画 如果选择使用 JavaScript 来编写动画,可选用 Web Animations API 或用起来顺手的现代框架
47. css动画性能
优点 不足: 1、不能动态的修改或定义动画内容 2、不同的动画无法实现同步 3、多个动画彼此无法堆叠
48. js动画性能
优点:
- js动画控制能力强,可以在动画博凡过程中对动画进行精细控制,开始、暂停、终止、取消都是可 以做到的
- 动画效果比css3动画丰富,比如曲线运动,冲击闪烁,视差滚动效果,只有js动画才能完成
- js动画大多数情况下没有兼容性问题,而css3动画有兼容性问题 不足:
- js动画的复杂度高于css3
- js在动画浏览器的主线程中执行,而主线程还有其他javaScript脚本,样式计算、布局、绘制任务 等,对其干扰可能出现阻塞从而出现丢帧的情况
- js动画往往需要频繁操作DOM的css属性来实现视觉上的动画效果,这个时候浏览器要不停地执行 重绘和重排,这对于性能的消耗是很大的,尤其是在分配给浏览器的内存没那么宽裕的移动端。
49. CSS动画比JS流畅的前提
在Chromium基础上的浏览器中 JS在执行一些昂贵的任务 同时CSS动画不触发layout或paint 在CSS动画或JS动画触发了paint或layout时,需要main thread进行Layer树的重计算,这时CSS动 画或JS动画都会阻塞后续操作。 1、css3动画相比JS更轻量,性能更好,更易于实现 2、不必担心缺乏标准和增加带宽消耗的问题 3、不依赖于主线程,采用硬件加速(GPU) 4、move.js是一个封装了css3动画效果的轻量级js动画库
50. 共有的选择器(JQ & CSS)
| 选择器 | 说明 |
|---|---|
#id | ID 选择器 |
.class | 类选择器 |
element element | 后代选择器,用于选择元素内部的元素 |
element,element | 多选择器组合 |
element+element | 兄弟选择器,选择指定元素之后紧跟的元素 |
element>element | 子代选择器,选择直接子元素而不包括后代 |
element1~element2 | 选择排在自己之后的所有符合条件的兄弟元素 |
[attribute] | 用于选取带有指定属性的元素 |
[attribute=value] | 匹配给定的属性是某个特定值的元素 |
| `[attribute | =value]` |
[attribute*=value] | 选取属性值包含指定字符串的元素 |
[attribute$=value] | 匹配属性值以指定值结尾的每个元素 |
[attribute^=value] | 选取属性值以指定字符串开头的元素 |
[attribute~=value] | 选取属性值包含指定词汇的元素——“title test” 可以而 “titletest” 不行 |
:not() | 非匹配指定元素/选择器的每个元素 |
:first-child | 选取属于其父元素的首个子元素 |
:first-of-type | 匹配元素是其父元素的第一个同类型子元素 |
:last-child | 匹配属于其父元素的最后一个子元素 |
:last-of-type | 匹配元素是其父元素的最后一个同类型子元素 |
:nth-child() | 匹配属于其父元素的第 N 个子元素,不论元素类型 |
:nth-last-child() | 匹配其父元素的第 N 个子元素,从最后一个开始计数 |
:only-child | 匹配属于其父元素的唯一子元素 |
:only-of-type | 匹配属于其父元素的特定类型的唯一子元素 |
:checked | 匹配每个已被选中的 input 元素(单选按钮和复选框) |
:disabled | 匹配被禁用的元素 |
:empty | 匹配没有子元素(包括文本节点)的每个元素 |
:enabled | 匹配每个启用的元素(主要用于表单元素) |
:focus | 选取获得焦点的元素 |
51. css 独有的选择器
| 选择器 | 说明 |
|---|---|
:active | 用于选择活动链接 |
:after | 在被选元素的内容后面插入内容 |
:before | 在被选元素的内容前面插入内容 |
:first-letter | 选取指定选择器的首字母 |
:first-line | 选取指定选择器的首行 |
:hover | 选取鼠标指针浮动在上面的元素 |
:lang | 选取带有以指定值开头的 lang 属性的元素 |
:link | 选取未被访问的链接 |
:visited | 选取已被访问的链接 |
:default | 只能作用在表单元素上,表示默认状态的表单元素 |
:valid | 匹配输入值为合法的元素 |
:invalid | 匹配输入值为非法的元素 |
:in-range | 匹配值在指定区间之内的 input 元素 |
:out-of-range | 匹配值在指定区间之外的 input 元素 |
:required | 匹配设置了 “required” 属性的元素 |
:read-only | 匹配设置 “readonly”(只读)属性的元素 |
:read-write | 匹配可读及可写的元素 |
:optional | 匹配可选的输入元素 |
::placeholder | 控制表单输入框占位符的外观,默认为浅灰色 |
::selection | 匹配被用户选取的部分,只可应用于 color、background、cursor、outline |
52. jQuery 特有
| 选择器 | 说明 |
|---|---|
:animated | 选取当前处于动画中的元素 |
:contains() | 选取包含指定字符串的元素 |
:eq() | 选取带有指定 index 值的元素 |
:even | 选取带有偶数索引号的元素(0、2、4…) |
:odd | 选取带有奇数索引号的元素(1、3、5…) |
:first | 选取第一个元素 |
:last | 选取最后一个元素 |
:gt() | 选取 index 值大于指定数字的元素 |
:lt() | 选取 index 值小于指定数字的元素 |
:header | 选取所有标题元素(-) |
:has() | 选取包含一个或多个匹配指定选择器的元素在内的元素 |
:hidden | 选取隐藏的元素 |
:visible | 选取当前可见的每个元素 |
:parent | 选取是其他元素的父元素且包含文本节点的元素 |
:submit | 选取类型为 submit 的 |
:selected | 选取被选择的 |
CSS的不足
语法不够强大,比如无法嵌套书写导致模块化开发中需要书写很多重复的选择器 没有变量和合理的样式复用机制,使得逻辑上相关的属性值必须以字面量的形式重复输出,导致难 以维护; 于是,就诞生了CSS预处理器。CSS预处理器用一种专门的编程语言,进行Web页面样式设计,然 后再编译成正常的CSS文件,以供项目使用。CSS预处理器为CSS增加一些编程的特性,无需考虑浏 览器的兼容性问题。
css 预处理的作用
帮助开发者更好地组织 css 代码 提高代码的复用性 代码的可维护性增强
使用预编译样式语言的优势
文件切分
页面越来越复杂,需要还在的 css 文件也越来越大,我们有必要把大文件切分开,css 预处理器扩 展了 @import 指令的能力,通过编译环节将切分后的文件重新合并成一个大文
选择符嵌套
选择符且套语法可以很容易地表达出规则之间的层级关系
变量
当某个特定的值在多处用到时,变量就是一种简单而有效的抽象方法,可以把这种重复消灭掉。这 对换肤功能很有用。
运算
光有变量还不够,我们还需要运算,让值和值建立关联
函数
把常用的运算抽象出来,我们就得到了函数,开发者可以自定义函数,也可以用预处理器内置的函 数。
二、有哪些预编译语言
less、sass/scss、stylus
三、什么是:less、sass、stylus?
sass
2007年诞生,最早也最成熟的 css 预处理器,是一种动态样式语言,语法属于缩排语法,是最早也是 最成熟的CSS预处理器,拥有ruby社区的支持和compass这一最强大的css框架,目前受LESS影响,已经 进化到了全面兼容CSS的SCSS。
less
2009年诞生,受 sass 影响,但又使用 css 语法;是一种动态样式语言,属于css预处理器。它扩展了 CSS 语言,增加了变量、Mixin、函数等特性,使 CSS 更易维护和扩展 LESS 既可以在客户端上运行, 也可以借助Node.js在服务端运行。
stylus
2010年产生于node社区,主要用来给Node项目进行CSS预处理支持,一种革命性的新语言提供一个 高效、动态、和使用表达方式来生成CSS,以供浏览器使用。Stylus同时支持缩进和CSS常规样式书写规 则。需要安装nodeStylus的语法花样多一些,它的文件扩展名是“.styl”。Stylus也接受标准的CSS语法, 但是他也像Sass老的语法规则,使用缩进控制,同时Stylus也接受不带大括号{ }和分号的语法。
less 和 sass 的区别
编译环境不同 变量符不同,less 是@,sass 是$, 而且变量的作用域也不一样 sass 不用花括号,像 python 一样,使用缩进,scss 用花括号 sass 支持条件语句,less 不支持
四、一般情况预编译样式语言需要掌握的主要知识内容
以less为例:注释、变量、less运算、嵌套、混合、模式匹配与守卫、函数、文件导入、转义;
53. 注释
以// 开头的注释,不会被编译到css文件中 以/**/ 包裹的注释会被编译到css文件中
54. 变量
@开头定义变量,并且使用时直接键入@ 名称。
值变量
选择器变量
属性变量
url变量
@color: #999;@bgColor: skyblue;//不要添加引号@width: 50%;#wrap { color: @color;
background: @bgColor; width: @width;}
@mySelector: #wrap;@{mySelector}{ //变量名必须使用大括号包裹 color: #999; width:
50%;}
@borderStyle: border-style;@Soild:solid;#wrap{ @{borderStyle}: @Soild;//变量名必
须使用大括号包裹}
@images: "../img";//需要加引号body { background: url("@{images}/dog.png");//变量名
必须使用大括号包裹}
55. Less运算
任何数值,颜色,变量都可以运算 less会给你自动推算单位,所以不需要每一个都加单位,但保证至少有一个加了单位 运算符与数值之间要以空格分开,涉及优先级时以()进行优先级计算
56. 嵌套
嵌套规则允许在一个选择器中嵌套另一个选择器,这更容易设计出精简的代码,并且样式之间的关系 一目了然; 使用&:代表前边的所有父级元素,常用在伪元素伪类 css结构类等需求上 内层选择器前面的 & 符号就表示对父选择器的引用。在一个内层选择器的前面,如果没有 & 符号,则 它被解析为父选择器的后代;如果有 & 符号,它就被解析为父元素
57. 混合
定义一些通用的属性集为一个class,然后在另一个class中去调用这些属性。混合就是将一系列属性从 一个规则引入到另一个规则中。
普通混合
混合的定义:使用.+混合名+()+{属性的合集} 混合的使用:.+混合名+();
带参数的混合
在声明混合的时候,可以在小括号中声明形参。形参由@+变量名定义。 调用的时候可以传入实参
参数有默认值的混合
可以直接在混合中定义形参的时候,给形参设置默认值,比如(@color:red)。 当使用混合的时候,如果有实参传递,则使用实参的值,否则使用形参的默认值
58. 模式守卫与模式匹配
@num1 : 30;.box{ width: 30px * @num1; height: 1000px / 3; .con{
// 普通数值的加减法 width: 100px - 30%; height: (100px + 10) * 20;
} .inner{ // 颜色的运算是先转换成10进制的rgba然后再计算再转换成16进制
background-color: #fff-55; }}
.mine(){ border: 1pxsolid#000; border-radius: 10px; background-color:
red;}.box{ width: 100px; height: 100px; //调用Mixin的时候,可以加上小括号调
用,也可以不加 .mine();}
//定义的时候声明形参和变量一个样子.center(@w,@h,@bg){ width: @w; height: @h;
background-color: @bg;}.outer{ //传参数 .center(500px,500px,red); }
模式匹配
在Less中尝试利用模式匹配替if/else,其执行原理类似switch/case。 因为一个混合可能有多种形式,所以Less提供了一种机制,允许根据参数的值来改变 mixin的行为。 其中当参数是@_开头的,是调用此混合必选的。
2 重载
相同的混合,不同的行为,可以根据调用的时候传入的实参个数选择匹配的混合内容
3 守卫
根据判断条件选中Mixin的行为 类似于JavaScript的if/else,使用when语法 Guards 允许我们使用>,>=,<,<=,=,关键字true(只匹配关键字true,非true不会匹配),支持逻辑and ,not () 同时我们可以使用“,”分割多个Guards,其表示只要其中任意一个满足就为true
59. 函数
逻辑函数如if()、Boolean() 数学函数如 ceil()、floor()、sqrt()等等
60. 文件导入
导入Less文件: @import “lib.less”; //等价于@import “lib”(可以不带后缀) 导入css文件: @import “lib.css”;
61. 转义
有时候,当需要引入无效的CSS语法或Less不能识别的字符,就需要使用转义字符。此时,就可以在字 符串前面加一个 ~,并将需要转义的字符串放在 "" 中。
62. 什么是SEO
- SEO 是“Search Engine Optimization”(搜索引擎优化)或“Search Engine Optimizer”(搜索引擎 优化服务商)的首字母缩写。
- 一个关键词对用多个网址,因此就出现了排序的问题,相应的当与关键词最吻合的网址就会排在前 面了。在“蜘蛛”抓取网页内容,提炼关键词的这个过程中,就存在一个问题:“蜘蛛”能否看懂。如 果网站内容是flash和js等,那么它是看不懂的,会犯迷糊,即使关键字再贴切也没用。相应的,如 果网站内容可以被搜索引擎能识别,那么搜索引擎就会提高该网站的权重,增加对该网站的友好 度。这样一个过程我们称之为SEO。
63. 为什么需要用SEO
提高网站的权重,增强搜索引擎友好度,以达到提高排名,增加流量,改善(潜在)用户体验,促 进销售的作用。
64. 如何简单的实现SEO的优化?
简单说就是围绕两点展开:网站结构布局优化 + 网页代码优化,见下面两题。
65. 网站结构布局优化
1.控制首页链接数量 2.扁平化的目录层次 3.导航优化 4.网站的结构布局 5.利用布局,把重要内容HTML代码放在最前 6.控制页面的大小,减少http请求,提高网站的加载速度。
66. 网页代码优化
- 突出重要内容---合理的设计title、description和keywords
- 语义化书写HTML代码,符合W3C标准
- 标签:页内链接,要加 “title” 属性加以说明,让访客和 “蜘蛛” 知道。而外部链接,链接到其他网站 的,则需要加上 el=“nofollow” 属性, 告诉 “蜘蛛” 不要爬,因为一旦“蜘蛛”爬了外部链接之后,就不 会再回来了
- 正文标题要用标签:h1标签自带权重“蜘蛛” 认为它最重要,一个页面有且最多只能有一个H1标 签,放在该页面最重要的标题上面,如首页的logo上可以加H1标签。副标题用标签, 而其它地方不 应该随便乱用 h 标题标签。
- 应使用 “alt” 属性加以说明
- 表格应该使用表格标题标签
- 标签:只用于文本内容的换行
- 标签:需要强调时使用。
- 文本缩进不要使用特殊符号应当使用CSS进行设置。版权符号不要使用特殊符号 © 可以直接使用 输入法打出版权符号©。
- 重要内容不要用JS输出,因为“蜘蛛”不会读取JS里的内容,所以重要内容必须放在HTML里。
- 尽量少使用iframe框架,因为“蜘蛛”一般不会读取其中的内容。
- 谨慎使用 display:none :对于不想显示的文字内容,应当设置z-index或缩进设置成足够大的负 数偏离出浏览器之外。因为搜索引擎会过滤掉display:none其中的内容。
67. 前端网站性能优化
- 减少http请求数量
- 控制资源文件加载优先级
- 尽量外链CSS和JS(结构、表现和行为的分离),保证网页代码的整洁,也有利于日后维护
- 利用浏览器缓存
- 减少重排(Reflow)
- 减少 DOM 操作
- 图标使用IconFont替换
- 不使用CSS表达式,会影响效率
- 使用CDN网络缓存,加快用户访问速度,减轻服务器压力
- 启用GZIP压缩,浏览速度变快,搜索引擎的蜘蛛抓取信息量也会增大
- 伪静态设置,如果是动态网页,可以开启伪静态功能,让蜘蛛“误以为”这是静态网页,因为静态网 页比较合蜘蛛的胃口,如果url中带有关键词效果更好。
68. uuid
UUID 是通用唯一识别码(Universally Unique Identifier)的缩写,是基于当前时间、计数器 (counter)和硬件标识(通常为无线网卡的MAC地址)等数据计算生成的 uuid优点:出现数据拆分、合并存储的时候,能达到全局的唯一性 uuid不足: UUID生成的结果串会比较长 uuid之间比较大小相对数字慢,影响查询速度 uuid占空间大,如果你建的索引越多,影响越严重 影响插入速度,并且造成硬盘使用率低 可以通过 npm install uuid 安装
69. nanoid
Nano ID是JavaScript的一个随机 ID 生成模块。 nanoid的特点 安全。它使用加密强大的随机API,并保证符号的正确分配。 小。只有258字节(缩小和gzipped)。没有依赖。 紧凑。它使用比UUID(A-Za-z0-9_~)更多的符号,并且只有22个符号而不是36个具有相同数量的 唯一选项。 可以通过 npx i nanoid 安装或者yarn可以使用:yarn add nanoid
nanoid库和uuid库一样都可以生成uuid,但是nanoid相比uuid要更轻量级
二.什么是GUID
GUID是全局唯一标识符(GUID,Globally Unique Identifier)是一种由算法生成的二进制长度为 128位的数字标识符。GUID主要用于在拥有多个节点、多台计算机的网络或系统中。 GUID一词也专指微软对UUID标准的实现。 在 Windows 平台上,GUID 广泛应用于微软的产品中,用于标识如注册表项、类及接口标识、数据库、 系统目录等对象。 特点: 1.需要GUID的时候,可以完全由算法自动生成,不需要一个权威机构来管理。 2.GUID理论上能产生全宇宙唯一的值,对于以后的数据导入很方便。
70. HTML5的新特性
HTML5 主要新增:语义化标签、音视频原生支持、Canvas、本地存储、增强表单、地理定位、Web Workers、离线应用,让 Web 更强大、语义更清晰、性能更好、体验接近原生 APP。
71. HTML4、HTML5、XML、XHTML它们之间有什么区别
XML:自定义标签、存数据、语法极严 XHTML:按 XML 规则写 HTML,太严现在不用 HTML4:旧版网页语言,功能少 HTML5:当前主流,功能强、语法友好、语义化
72. DOCTYPE(⽂档类型) 的作用
DOCTYPE(Document Type Declaration,文档类型声明)是 HTML 文档的 “身份标识”,其核心作用 是:
- 告知浏览器解析规则: 声明当前文档遵循的 HTML 或 XML 标准(如 HTML4、HTML5、XHTML),让浏览器以对应模式 渲染页面,避免因规则不明确导致的显示异常。
- 触发浏览器的渲染模式: 标准模式(Standard Mode):严格遵循 W3C 标准解析 CSS 和布局。 怪异模式(Quirks Mode):兼容旧浏览器的非标准解析方式(仅在 DOCTYPE 缺失或格式错误时 触发)
73. img标签的title属性与alt属性的区别是什么
title 是鼠标悬停时的提示文本;alt 是图片的替代文本,加载失败时显示,也是读屏器朗读、搜索引擎抓取的内容。alt 是 img 必备的语义属性,title 只是增强提示。
74. CSS3新特性
CSS3 主要新增:更强选择器、圆角阴影、渐变、transform、transition、animation、flex/grid 布局、 自定义字体、响应式媒体查询,让页面更美观、交互更流畅、布局更简单。
75. 解决父元素高度塌陷
父元素高度塌陷是因为子元素浮动,脱离文档流。 解决方法有四种:
- 父元素 overflow:hidden 触发 BFC;
- 末尾加空元素 clear:both;
- 使用伪元素 ::after 清除浮动(最优);
- 父元素浮动或设置 inline-block。
特性
块元素(block)
行内元素(inline)
独占一 行 ✅独占一行 ❌不独占,和其他行内元素同行 宽高设 置 ✅可设置 width、height ❌不能直接设置宽高 内外边 距 ✅上下左右 margin/padding 都生 效 ✅左右生效,上下不占空间 默认宽 度 父元素 100% 内容本身宽度 可包含 可包含块元素 & 行内元素 只能包含文本 / 行内元素,不能嵌套块元
素
常见标 签 div、p、h1~h6、ul、li、section span、a、img、input、button
76. 伪类和伪元素的区别
伪类是单冒号,用于选中元素的状态;伪元素是双冒号,用于创建不存在的虚拟元素。最常见的伪类 是:hover,最常见的伪元素是::before 和::after。 伪类:用于选中元素的某个状态 :hover :active :focus :first-child :nth-child 伪元素:用于创建不存在的虚拟元素 ::before ::after ::first-line ::first-letter
77. 什么是CSS盒模型
CSS 盒模型就是把元素看成矩形盒子,包含 content、padding、border、margin 四部分。 分为标准盒模型(content-box,width = 内容)和怪异盒模型(border-box,width = 内容 + 内边距 + 边框),实际开发中常用 border-box。
78. 封装过哪些组件?
我主要封装过后台管理系统最常用的:通用表格、查询表单、弹窗、权限按钮、上传等组件。目的是减 少重复代码、统一交互风格、提高开发效率,让业务页面只关注业务逻辑。
79. 块元素和行内元素有什么区别
块元素独占一行、可设宽高、默认父元素 100% 宽;行内元素不换行、不能直接设宽高、靠内容撑开。
80. CSS 预处理器 SASS/LESS 有何用途
Sass/Less 是 CSS 预处理器,通过变量、嵌套、混合、继承、运算等功能,CSS 预处理器就是给 CSS 加 了编程能力,让 CSS 更好维护、更高效、更易复用。 主要用途: 变量:把颜色、尺寸、字体等定义成变量,统一修改,方便换肤、统一风格。 嵌套写法:层级结构清晰,代码更直观,不用重复写选择器。 混合(Mixin):封装重复样式(如圆角、阴影、居中),直接调用,减少冗余。 继承(Extend):让多个选择器共用一套样式,减少 CSS 体积。 运算、函数、逻辑:支持加减乘除、颜色计算、循环、判断,实现动态样式。
81. rgba和opacity的透明效果有什么不同
opacity opacity是一个属性。opacity属性的值,可以被其子元素继承,给父级div设置opacity属性,那么 所有子元素都会继承这个属性,并且,该元素及其继承该属性的所有子元素的所有内容透明度都会 改变。 rgba(0,0,0,0.5) rgba是一个属性值。rgba设置的元素,只对该元素的背景色有改变,并且,该元素的后代不会继承 该属性。 补冲:rgba只是一个属性值,在background 里用改变背景色,在color里是改字体颜色,shadow 里是改阴影色,不止是能够改元素的背景色,要看具体是在哪个属性上用
82. display:none与visibility:hidden的区别
display:none 让元素彻底消失、不占空间、触发重排;visibility:hidden 只是隐藏视觉,元素仍占据布 局空间,只触发重绘。
$color: #ff0000;
.box {
.title { color: red; }
}
特性
display: none
visibility: hidden
是否可见 ❌完全看不见 ❌看不见 是否占据空间 ❌不占位置 ✅还占原来位置 是否重排重绘 触发重排 + 重绘 只触发重绘 子元素 子元素会一起消失
子元素设visibility:visible可以重新显示
事件触发 无法触发点击等事件 无法触发事件 性能 较差 较好
83. CSS3选择器及其优先级
对于选择器的优先级: 标签选择器、伪元素选择器:1 类选择器、伪类选择器、属性选择器:10 id 选择器:100 内联样式:1000 注意事项: !important声明的样式的优先级最高; 如果优先级相同,则最后出现的样式生效; 继承得到的样式的优先级最低; 通用选择器(*)、子选择器(>)和相邻同胞选择器(+)并不在这四个等级中,所以它们的权值 都为 0 ; 样式表的来源不同时,优先级顺序为:内联样式 > 内部样式 > 外部样式 > 浏览器用户自定义样式 > 浏览器默认样式
84. display的block、inline和inline-block的区别
① block:会独占一行,多个元素会另起一行,可以设置width、height、margin和padding属性; ② inline:元素不会独占一行,设置width、height属性无效。但可以设置水平方向的margin和 padding属性,不能设置垂直方向的padding和margin; ③ inline-block:将对象设置为inline对象,但对象的内容作为block对象呈现,之后的内联对象会被排 列在同一行内。
85. 标签语义化的意义
(授权,微信登录获取code,微信登录,获取 iv , encryptedData 传到服务器后台,如果没有注册,需要注 册。) (授权,微信登录获取code,微信登录,获取 iv , encryptedData 传到服务器后台,如果没有注册,需要注 册。) 小程序支付如何实现? 1、小程序注册,要以公司的以身份去注册一个小程序,才有微信支付权限; 2、绑定商户号。 3、在小程序填写合法域
4.调用wx.login()获取appid
5.调用
wx.requestPayment(
{
'timeStamp': '',//时间戳从1970年1月1日00:00:00至今的秒数,即当前的时间
'nonceStr': '',//随机字符串,长度为32个字符以下。
'package': '',//统一下单接口返回的 prepay_id 参数值,提交格式如:prepay_id=*
'signType': 'MD5',//签名类型,默认为MD5,支持HMAC-SHA256和MD5。注意此处需与统一下单的签名类型一
致 ‘paySign’: ”,//签名,具体签名方案参见微信公众号支付帮助文档;
'success':function(res){},//成功回调
'fail':function(res){},//失败
'complete':function(res){}//接口调用结束的回调函数(调用成功、失败都会执行)
})
小程序还有哪些功能? 客服功能,录音,视频,音频,地图,定位,拍照,动画,canvas 微信小程序与H5的区别? 第一条是运行环境的不同 传统的HTML5的运行环境是浏览器,包括webview,而微信小程序的运行环境并非完整的浏览器,是微信开发团队基 于浏览器内核完全重构的一个内置解析器,针对小程序专门做了优化,配合自己定义的开发语言标准,提升了小程序的 性能。 第二条是开发成本的不同 只在微信中运行,所以不用再去顾虑浏览器兼容性,不用担心生产环境中出现不可预料的奇妙BUG 第三条是获取系统级权限的不同 系统级权限都可以和微信小程序无缝衔接 第四条便是应用在生产环境的运行流畅度 长久以来,当HTML5应用面对复杂的业务逻辑或者丰富的页面交互时,它的体验总是不尽人意,需要不断的对项目优化 来提升用户体验。但是由于微信小程序运行环境独立 小程序怎么实现下拉刷新?
方式1:
通过在 app.json 中,将 "enablePullDownRefresh": true, 开启全局下拉刷新。
或者通过在组件 .json ,将 "enablePullDownRefresh": true, 单组件下拉刷新。
方式2:
scroll-view :使用该滚动组件自定义刷新,通过 bindscrolltoupper 属性,当滚动到顶部/左边,会触发
scrolltoupper事件,所以我们可以利用这个属性,来实现下拉刷新功能。
- 开发者更容易理解,减少差异化,方便团队开发和维护
- 机器更容易理解结果(搜索爬虫、方便其他设备解析(读屏幕软件、盲人设备、移动设备)
86. 写页面结构应该注意什么
- 尽可能少的使用没有语义的 div 和 span 元素
- 块级元素和内联元素的嵌套一定要符合 web 标准,比如内联元素就是不能嵌套块级元素
87. HTML5 新特性
- 新的语义化元素:article 、footer 、header 、nav 、section
- 表单增强,新的表单控件:calendar 、date 、time 、email 、url 、search
- 新的 API:音频(用于媒介回放的 video 和 audio 元素)、图形(绘图 canvas 元素)
- 新的 API:离线,通过创建 cache manifest 文件,创建应用程序缓存
- 新的 API:本地存储,localStorage-没有时间限制的数据存储,sessionStorage-session 数据存储 (关闭浏览器窗口数据删除)
- 新的 API:实时通讯,设备能力
88. CSS3 新特性
- CSS3实现圆角(border-radius),阴影(box-shadow),
- 对文字加特效(text-shadow),线性渐变(gradient),旋转(transform)
- transform:rotate(9deg) scale(0.85,0.90) translate(0px,-30px) skew(-9deg,0deg);//旋转,缩放,定位,倾斜
- 增加了更多的CSS选择器多背景 rgba
- 在CSS3中唯一引入的伪元素是::selection.
- 媒体查询,多栏布局
89. 盒子模型
页面渲染时,dom 元素所采用的布局模型。可通过box-sizing 进行设置。根据计算宽高的区域可分 为: content-box (W3C 标准盒模型) border-box (IE 盒模型)
padding-box
margin-box (浏览器未实现)
90. BFC
块级格式化上下文,是一个独立的渲染区域,让处于 BFC 内部的元素与外部的元素相互隔离,使内外元 素的定位不会相互影响。 IE 下为 Layout,可通过 zoom:1 触发 触发条件: 根元素
position: absolute/fixed
display: inline-block / table
float元素
overflow !== visible
规则: 属于同一个 BFC 的两个相邻 Box 垂直排列 属于同一个 BFC 的两个相邻 Box 的 margin 会发生重叠 BFC 中子元素的 margin box 的左边,与包含块 (BFC) border box 的左边相接触 (子元素 absolute 除外) BFC 的区域不会与 float 的元素区域重叠 计算 BFC 的高度时,浮动子元素也参与计算 - 文字层不会被浮动层覆盖,环绕于周围 应用:
阻止margin 重叠
可以包含浮动元素 —— 清除内部浮动(清除浮动的原理是两个div 都位于同一个 BFC 区域之中) 自适应两栏布局 可以阻止元素被浮动元素覆盖
91. 选择器优先级
!important > 行内样式 > #id > .class > tag > * > 继承 > 默认 选择器从右往左解析
92. 去除浮动影响,防止父级高度塌陷
通过增加尾元素清除浮动
:after / <br> : clear: both
创建父级 BFC 父级设置高度
93. link 与 @import 的区别
link 功能较多,可以定义 RSS,定义 Rel 等作用,而@import 只能用于加载 css 当解析到link 时,页面会同步加载所引的 css,而@import 所引用的 css 会等到页面加载完才被 加载 @import 需要 IE5 以上才能使用 link 可以使用 js 动态引入,@import 不行
94. CSS 预处理器(Sass/Less/Postcss)
CSS 预处理器的原理: 是将类 CSS 语言通过Webpack 编译转成浏览器可读的真正 CSS。在这层编译之 上,便可以赋予 CSS 更多更强大的功能,常用功能: 嵌套 变量 循环语句 条件语句 自动前缀 单位转换 mixin 复用
95. 单行文本溢出
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
注意元素需要是块级且有宽度。
96. 多行文本溢出
overflow: hidden;
display: -webkit-box;
-webkit-box-orient: vertical;
-webkit-line-clamp: 2; /* 行数 */
line-clamp 目前仍需 -webkit- 前缀。
97. flex布局
Flex是Flexible Box的缩写,意为”弹性布局”,用来为盒状模型提供最大的灵活性。 布局的传统解决方案,基于盒状模型,依赖display属性 + position属性 + float属性。它对于那 些特殊布局非常不方便,比如,垂直居中就不容易实现。 分清主轴和交叉轴 flex-direction 为 row 时,主轴是横向的,相反的为 column 时,主轴是纵向的。 简单的分为容器属性和元素属性 容器的属性: flex-direction:决定主轴的方向(即子item的排列方法) flex-wrap:决定换行规则 flex-flow:flex-direction 和flex-wrap 的简写形式,默认值为row nowrap justify-content:对其方式,水平主轴对齐方式 align-items:对齐方式,竖直轴线方向 项目的属性(元素的属性): flex:是flex-grow和flex-shrink、flex-basis的简写,默认值为0 1 auto。
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
overflow: hidden;
text-overflow: ellipsis;
display: -webkit-box;
-webkit-line-clamp: 2; /*2*/
-webkit-box-orient: vertical;
order属性:定义项目的排列顺序,顺序越小,排列越靠前,默认为0 flex-grow属性:定义项目的放大比例,即使存在空间,也不会放大 flex-shrink属性:定义了项目的缩小比例,当空间不足的情况下会等比例的缩小,如果定义个 item的flow-shrink为0,则为不缩小 flex-basis属性:定义了在分配多余的空间,项目占据的空间。
98. 圣杯布局
圣杯特点简单记为:有头、有尾、包三列,圣杯布局中间有container大容器包裹着左、中、右三列 区域 左、中、右是独立的三个区域,都处于一个层级
99. 双飞翼布局
左、中、右是独立的三个区域,中间区域属于最上面的层级
二、移动端
100. 基础知识
- 1英寸(inch) = 2.54厘米(cm)
- IPhone 6 的屏幕分辨率为 750 * 1334 设备独立像素为 375 * 667
- 物理像素:由屏幕制造商决定,屏幕生产后无法修改
- css像素:单位是px,它是为 Web 开发者创造的
- 设备独立像素的出现,使得即使在【高清屏】下,也可以让元素有正常的尺寸,让代码不受到设备的影响,它是设备厂商根据屏幕特性设置的,无法更改。
- 1个位图像素对应1个物理像素,图片才能得到完美清晰的展示
- pc端视口:默认宽度和浏览器窗口的宽度一致,也被称为初始包含块
document.documentElement.clientWidth - 移动端视口:
-
布局视口:一般是980px左右,布局视口经过压缩后,横向的宽度用css像素表达就不再是375px了,而是980px
-
视觉视口:用户可见的区域,它的绝对宽度永远和设备屏幕一样宽
-
理想视口:布局视口宽度 与 屏幕等宽(设备独立像素),靠meta标签实现
<meta name="viewport" content="width=device-width,initial-scale=1.0" />
-
101. 适配
1.viewport 适配
- 方法:拿到设计稿之后,设置布局视口宽度为设计稿宽度,然后直接按照设计稿给宽高进行布局即可。
- 一般适用于:计图稿宽度 < 375
2.rem适配
- 方案一:(百度)
- 设置完美视口
- 通过js设置根字体大小 = *( 当前设备横向独立像素值 100) / 设计稿宽度
- 编写样式时,直接以rem为单位,值为:设计值 / 100
- 增加 JS 代码进行实时适配
- 方法二:(淘宝、搜狐、唯品会)
- 设置完美视口
- 通过js设置根字体大小 = 当前设备横向独立像素值 / 10
- 编写样式时,直接以rem为单位,值为:设计值 / (设计稿宽度 / 10)
- 增加 JS 代码进行实时适配
3.vw适配
vw和vh是两个相对单位
- 1vw = 等于布局视口宽度的1%
- 1vh = 等于布局视口高度的1%
4.1px物理像素边框
高清屏幕下 1px 对应更多的物理像素,所以 1 像素边框看起来比较粗,解决方法如下
方法一
使用媒查询:
@media screen and (-webkit-min-device-pixel-ratio:2){
#demo{
border: 0.5px solid black;
}
}
或
@media screen and (-webkit-min-device-pixel-ratio:2){
#demo2::after{
transform:scaleY(0.5);
}
}
方法二
根据dpr扩大布局视口,例如dpr为n则布局视口改为原来的n倍,则元素尺寸均变为原来的n分之一,为了保证元素尺寸比例不变,扩大根字体为原来的n倍,但整个过程中边框一直用px作为单位,不用rem。
- rem 页面布局
- 元素的边框设置为 1px
- 通过 viewport 中的 initial-scale 将布局视口扩大n倍,这样页面元素就比原来缩小了n倍
var viewport = document.querySelector('meta[name=viewport]')
var scale = 1 / window.devicePixelRatio
viewport.setAttribute('content', 'width=device-width,initial-scale=' + scale);
- 重新设置根元素字体
var fontSize = parseInt(document.documentElement.style.fontSize);
document.documentElement.style.fontSize = fontSize * window.devicePixelRatio + 'px'
102. 移动端事件
- touchstart 元素上触摸开始时触发
- touchmove 元素上触摸移动时触发
- touchend 手指从元素上离开时触发
- touchcancel 触摸被打断时触发
103. 移动端中touchstart,touchend,click执行顺序
- touchstart
- touchend
- click,浏览器在 click 后会等待约300ms去判断用户是否有双击行为,如果300ms内没有再一次click,那么就判定这是一次单击行为
104. 点击穿透
-
touch 事件结束后会默认触发元素的 click 事件 方法一:阻止默认行为
方法二:使背后元素不具备click特性,用touchXxxx代替click
方法三:让背后的元素暂时失去click事件,300毫秒左右再复原,属性
pointer-events: none;方法四:让隐藏的元素延迟300毫秒左右再隐藏
105. 基础知识
1英寸(inch) = 2.54厘米(cm) IPhone 6 的屏幕分辨率为 750 * 1334 设备独立像素为 375 * 667 物理像素:由屏幕制造商决定,屏幕生产后无法修改 css像素:单位是px,它是为 Web 开发者创造的 设备独立像素的出现,使得即使在【高清屏】下,也可以让元素有正常的尺寸,让代码不受到设备 的影响,它是设备厂商根据屏幕特性设置的,无法更改。 1个位图像素对应1个物理像素,图片才能得到完美清晰的展示 pc端视口:默认宽度和浏览器窗口的宽度一致,也被称为初始包含块
document.documentElement.clientWidth
移动端视口: 布局视口:一般是980px左右,布局视口经过压缩后,横向的宽度用css像素表达就不再是 375px了,而是980px 视觉视口:用户可见的区域,它的绝对宽度永远和设备屏幕一样宽 理想视口:布局视口宽度与屏幕等宽(设备独立像素),靠meta标签实现
106. 适配
<metaname="viewport"content="width=device-width,initial-scale=1.0"/>
107. viewport 适配
方法:拿到设计稿之后,设置布局视口宽度为设计稿宽度,然后直接按照设计稿给宽高进行布局即 可。 一般适用于:计图稿宽度 < 375
108. rem适配
方案一:(百度)
- 设置完美视口
- 通过js设置根字体大小 = ( 当前设备横向独立像素值 *100) / 设计稿宽度
- 编写样式时,直接以rem为单位,值为:设计值 / 100
- 增加 JS 代码进行实时适配 方法二:(淘宝、搜狐、唯品会)
- 设置完美视口
- 通过js设置根字体大小 = 当前设备横向独立像素值 / 10
- 编写样式时,直接以rem为单位,值为:设计值 / (设计稿宽度 / 10)
- 增加 JS 代码进行实时适配
109. vw适配
vw和vh是两个相对单位 1vw = 等于布局视口宽度的1% 1vh = 等于布局视口高度的1%
1px物理像素边框
高清屏幕下 1px 对应更多的物理像素,所以 1 像素边框看起来比较粗,解决方法如下
110. 方法一
使用媒查询:
111. 方法二
根据dpr扩大布局视口,例如dpr为n则布局视口改为原来的n倍,则元素尺寸均变为原来的n分之一,为了 保证元素尺寸比例不变,扩大根字体为原来的n倍,但整个过程中边框一直用px作为单位,不用rem。
- rem 页面布局
- 元素的边框设置为 1px
- 通过 viewport 中的 initial-scale 将布局视口扩大n倍,这样页面元素就比原来缩小了n倍
@mediascreenand (-webkit-min-device-pixel-ratio:2){
#demo{
border: 0.5pxsolidblack;
}
}
或
@mediascreenand (-webkit-min-device-pixel-ratio:2){
#demo2::after{
transform:scaleY(0.5);
}
}
- 重新设置根元素字体
112. 移动端事件
touchstart 元素上触摸开始时触发 touchmove 元素上触摸移动时触发 touchend 手指从元素上离开时触发 touchcancel 触摸被打断时触发
113. 移动端中touchstart,touchend,click执行顺序
touchstart touchend click,浏览器在 click 后会等待约300ms去判断用户是否有双击行为,如果300ms内没有再一次 click,那么就判定这是一次单击行为
114. 点击穿透
touch 事件结束后会默认触发元素的 click 事件 方法一:阻止默认行为 方法二:使背后元素不具备click特性,用touchXxxx代替click 方法三:让背后的元素暂时失去click事件,300毫秒左右再复原,属性pointer-events: none; 方法四:让隐藏的元素延迟300毫秒左右再隐藏
varviewport=document.querySelector('meta[name=viewport]')
varscale=1/window.devicePixelRatio
viewport.setAttribute('content', 'width=device-width,initial-scale='+scale);
varfontSize=parseInt(document.documentElement.style.fontSize);
document.documentElement.style.fontSize=fontSize*window.devicePixelRatio+'px'
三、JavaScript 基础
115. var / let / const 的区别
- 作用域:
var函数作用域或全局;let/const块级作用域。 - 提升(hoisting):
var声明会被提升并初始化为undefined;let/const被提升但处于 暂时性死区(TDZ),在声明前访问会报 ReferenceError。 - 重声明/重赋值:
var支持同一作用域重复声明;let不允许重复声明;const声明必须初始化且不能重新赋值(引用类型可修改内部状态)。 - 绑定到全局对象:在浏览器的全局作用域中,
var会成为window属性,let/const不会。 - 面试点:TDZ、作用域链、
const与不可变性的误解(const是不可变绑定,不是不可变值)。
示例:
console.log(a); // undefined
var a = 1;
console.log(b); // ReferenceError (TDZ)
let b = 2;
const c = {x:1};
c.x = 2; // 合法,改变的是对象内容,不是绑定
116. 数据类型 与 typeof 的陷阱
- JS 基本类型(primitive):
undefined, null, boolean, number, bigint, string, symbol。 - 引用类型:
object(包括 Array, Function, Date, RegExp, Map, Set 等)。 typeof陷阱:typeof null === 'object'(历史遗留)。typeof [] === 'object'(数组不是单独的 typeof)。typeof function(){}==='function'(函数特殊)。typeof NaN === 'number'。typeof 10n === 'bigint',typeof Symbol() === 'symbol'。
- 更准确的类型判断:
- 数组:
Array.isArray(x)。 - 更一般:
Object.prototype.toString.call(x)(返回[object Type])。 Number.isNaN更可靠(isNaN会先强制转换)。
- 数组:
示例:
typeof null // "object"
Array.isArray([]) // true
Object.prototype.toString.call(/a/) // "[object RegExp]"
Number.isNaN(NaN) // true
isNaN('a') // true <-- 因为 'a' -> NaN,再判定
117. 值类型 vs 引用类型
- 值类型(primitive):赋值/传参时拷贝值,互不影响(string, number, boolean, null, undefined, symbol, bigint)。
- 引用类型(object):赋值/传参时拷贝的是引用(指针),多个引用指向同一对象,修改会反映到所有引用。
- 重要面试点:JS 始终是按值传递(但是引用的值是指向对象的指针),这常被误说为“按引用传递”。
示例:
let a = 1;
let b = a;
b = 2; // a 仍是 1
let o1 = {x:1};
let o2 = o1;
o2.x = 2; // o1.x 也变成 2
118. 深拷贝 vs 浅拷贝(本质与常见实现)
- 本质:浅拷贝只复制一层属性(引用仍指向原对象的子对象);深拷贝递归复制所有可复制的子结构(避免共享引用)。
- 常见实现:
- 浅拷贝:
Object.assign({}, obj)、{...obj}、Array.prototype.slice、arr.concat()。 - 深拷贝(简单):
JSON.parse(JSON.stringify(obj))(缺点:丢失函数、undefined、Symbol、BigInt、日期、正则、无法处理循环引用)。 - 浏览器/Node:
structuredClone(obj)(支持更多类型,自动处理循环,但并非所有环境都可用)。 - 手写深拷贝:递归 +
WeakMap处理循环引用,并专门处理Date、RegExp、Map、Set等类型。
- 浅拷贝:
- 面试点:什么时候用浅拷贝(性能) vs 深拷贝(避免共享引用);JSON 深拷贝的边界条件;循环引用处理。
示例(简化版深拷贝,支持循环引用、Date、RegExp、Map、Set):
function deepClone(obj, map = new WeakMap()) {
if (obj === null || typeof obj !== 'object') return obj;
if (map.has(obj)) return map.get(obj);
if (obj instanceof Date) return new Date(obj);
if (obj instanceof RegExp) return new RegExp(obj);
if (obj instanceof Map) {
const m = new Map();
map.set(obj, m);
for (const [k, v] of obj) m.set(deepClone(k, map), deepClone(v, map));
return m;
}
if (obj instanceof Set) {
const s = new Set();
map.set(obj, s);
for (const v of obj) s.add(deepClone(v, map));
return s;
}
const copy = Array.isArray(obj) ? [] : {};
map.set(obj, copy);
Reflect.ownKeys(obj).forEach(key => {
copy[key] = deepClone(obj[key], map);
});
return copy;
}
119. 数组常用方法背后的面试点
- 遍历/映射:
forEach:无返回值,无法中途跳出(除非抛异常)。map:返回新数组,不改变原数组。filter:返回满足条件的新数组。reduce:最通用,可实现 map/filter/sum/groupBy 等。
- 查找:
find,findIndex,indexOf,includes(includes使用 SameValueZero,能检测 NaN)。 - 判断:
some,every(短路)。 - 变更:
push/pop/shift/unshift(原地变更),slice(不变更),splice(变更)。 - 排序:
sort默认按字符串比较;传 compareFn;注意数值排序需a-b;稳定性依引擎/规范而变(现代引擎通常稳定)。 - 面试点:
- 用
reduce实现map/filter(考察对高阶函数理解)。
sort的副作用与 compare 函数实现。map中返回的数组长度/稀疏数组的问题。- 时间复杂度(map/filter O(n); sort O(n log n))。
- 用
- 示例(用
reduce实现map):
function mapByReduce(arr, fn) {
return arr.reduce((acc, cur, idx) => {
acc.push(fn(cur, idx, arr));
return acc;
}, []);
}
120. 对象遍历方式对比(for..in, Object.keys, Reflect 等)
for..in:遍历对象可枚举属性,包括原型链上的可枚举属性(会遍历继承来的属性);顺序不是严格保证(尽管现代引擎特定顺序)。Object.keys(obj):返回自身可枚举属性的数组(不包含原型)。Object.getOwnPropertyNames(obj):返回自身属性(包括不可枚举)但不包含 Symbol。Object.getOwnPropertySymbols(obj):获取自身 Symbol 属性。Reflect.ownKeys(obj):返回自身所有键(string + symbol)。for..of:用于可迭代对象(Array、Map、Set、字符串等)。- 面试点:遍历时是否需要过滤原型属性;Symbol 属性如何遍历;性能差异(
for循环 vsforEachvsfor..of)。
示例:
for (const k in obj) { /* 包含原型的可枚举属性 */ }
Object.keys(obj).forEach(k => { /* 只包含自身可枚举 */ });
Reflect.ownKeys(obj).forEach(k => { /* 包含 symbol 和不可枚举 */ });
121. 隐式类型转换的坑
- 规则:
+若一方是字符串则执行字符串拼接;否则数值化(ToNumber)。- 关系比较
<, >会先将两边转换为 primitive(可能是 number 或 string)。 ==会进行复杂的抽象相等比较(见第 8 条)。- 对象转原始值:会尝试
valueOf(),若返回原始值则用之;否则toString()。
- 典型陷阱:
'' + 1->'1',1 + '2'->'12',1 - '2'->-1。null == undefined->true,但null == 0->false(null 不与其它值强制转换)。[] + []->'',[] + {}->"[object Object]"(对象 toString)。0 == false-> true,'0' == false-> true('0'-> 0)。isNaN('')-> false(” -> 0),isNaN('a')-> true。推荐用Number.isNaN。
- 面试点:能用具体例子说明
==的行为;对象到原始值转换顺序;+的优先字符串拼接或数字转换问题。
示例:
'' + 1 // "1"
1 - '2' // -1
null == undefined // true
'0' == false // true
Number.isNaN('a') // false (不会强制转换)
isNaN('a') // true (会先转 NaN)
122. == 和 === 的核心考点
===:严格相等,不做类型转换(若类型不同,直接 false)。==:抽象相等,会在许多情况下进行类型转换:null == undefined-> true- 如果类型不同,按表规则转换:字符串与数字 -> 字符串转数字;布尔 -> 转数字;对象 -> 转原始值(调用 valueOf / toString)。
- 面试点:要能列出若干典型
==的例子并解释原因(尤其 null/undefined、布尔与字符串、对象与原始值比较),以及推荐在业务代码中尽量使用===。
123. 执行上下文(execution context)和作用域链(scope chain)
- 执行上下文 包括:变量环境(variable environment)、词法环境(lexical environment,环境记录 + 外部引用)、
this绑定和作用域链。 - 创建阶段(creation):
- 为函数/全局创建绑定(变量提升、函数提升、参数对象)。
- 执行阶段(execution):执行代码,变量赋值,函数引用分配。
- 作用域链:当访问一个标识符时,JS 从当前执行上下文的词法环境开始查找,找不到则向上查找直至全局(或 null)。
- 面试点:区别词法作用域与动态作用域、变量提升的细节、
let/const和 TDZ、如何解释闭包是如何访问外层变量的。
示例(展示作用域链):
function a() {
let x = 1;
function b() {
console.log(x); // 通过作用域链拿到 a 的 x
}
return b;
}
const f = a();
f(); // 1
124. JS 中的 this 究竟指向谁?
- 四条规则(优先级):
-
- new:构造调用(
new Fn())——this指向新创建的实例。 - 显式绑定:
call/apply/bind显式指定(bind可创建固化 this 的函数)。 - 隐式绑定:通过对象调用(
obj.fn())——this指向该对象(注意丢失绑定,比如const f = obj.fn; f())。 - 默认绑定:非严格模式下全局(浏览器为
window,严格模式为undefined)。
- new:构造调用(
- 箭头函数:没有自己的
this,this由定义位置的词法环境确定(即继承外部this)。 - 面试点:
bind与new的组合行为(若使用new调用 bind 后的函数,this以new创建的实例为准);箭头函数不能作为构造器。
示例:
function Foo() { this.x = 1; }
const o = {};
Foo.call(o);
console.log(o.x); // 1
const obj = { x: 1, f() { console.log(this.x); } };
obj.f(); // 1
const g = obj.f;
g(); // undefined (strict) 或 window.x
125. 闭包(closure)到底是什么?如何判断?
- 定义:闭包是函数与其创建时的词法环境(包含被捕获的变量)的组合。换言之,内部函数保留了对外层作用域变量的引用,即使外层函数已返回。
- 如何判断:若一个函数引用了在它外部定义的变量,并且该函数在外部函数执行完后仍被调用/保留,则构成闭包。
- 面试点:闭包引起的内存保留(小心大闭包导致内存),如何避免(避免在全局保存大的闭包状态,及时释放引用);闭包与模块化的关系(实现封装)。
示例:
function counter() {
let n = 0;
return function() {
n += 1;
return n;
};
}
const c = counter();
c(); // 1 —— 闭包持有 n
126. 高阶函数和柯里化(应用场景)
- 高阶函数(HOF):接收函数或返回函数的函数(如
map,filter,reduce,或compose)。 - 柯里化(currying):把多参数函数转换为一系列单参数函数。常用于部分应用、配置化函数、函数复用。
- 面试点:区别柯里化和部分应用(partial application);高阶函数在中间件、函数式编程、事件处理等场景的应用。
示例(柯里化):
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) return fn(...args);
return (...rest) => curried(...args, ...rest);
};
}
const add = (a,b,c) => a+b+c;
const cadd = curry(add);
cadd(1)(2)(3); // 6
127. 节流(throttle) vs 防抖(debounce)
- 防抖(debounce):若短时间内多次触发,只在最后一次触发后执行(适合输入搜索、窗口调整完成后再计算)。
- 节流(throttle):限定一定时间内只执行一次(适合滚动、resize 等持续事件)。
- 面试点:实现带
leading/trailing选项(首次是否立即执行、最后一次是否执行),以及使用requestAnimationFrame实现节流以更平滑的动画。 - 实现:
防抖:
function debounce(fn, wait) {
let timer = null;
return function(...args) {
clearTimeout(timer);
timer = setTimeout(() => fn.apply(this, args), wait);
};
}
节流(时间戳版):
function throttle(fn, wait) {
let last = 0;
return function(...args) {
const now = Date.now();
if (now - last >= wait) {
last = now;
fn.apply(this, args);
}
};
}
128. bind、call、apply 的底层原理
- 实现思路:把函数作为对象的临时属性,然后调用该属性(这样
this指向该对象),完成后删除该属性。apply接收数组参数,call接收参数列表,bind返回新的函数(闭包)并记录要绑定的this与前置参数。 - 面试点:
bind返回的函数可用于new(有特殊处理:若用new调用,this指向实例),需要保留原函数的 prototype 链以支持instanceof。
示例(简化实现):
Function.prototype.myCall = function(context, ...args) {
context = context || globalThis;
const fnSym = Symbol();
context[fnSym] = this;
const result = context[fnSym](...args);
delete context[fnSym];
return result;
};
Function.prototype.myBind = function(context, ...args) {
const self = this;
function bound(...rest) {
// 支持 new
const isNew = this instanceof bound;
return self.apply(isNew ? this : context, args.concat(rest));
}
bound.prototype = Object.create(self.prototype);
return bound;
};
129. 立即执行函数(IIFE)是怎么工作的?
- 目的:创建独立作用域,避免污染全局,常用于早期模块化或块级封装。
- 写法:
(function(){ /*...*/ })();(() => { /*...*/ })();!function(){ /*...*/ }();(有趣但不常用)
- 注意:前面可能需要分号(防止与前一个未结束的语句造成解析错误)。
130. 纯函数、副作用 与 函数式编程入门
- 纯函数:相同输入总返回相同输出、不会产生副作用(不修改外部变量、无 I/O 等)。
- 副作用:修改外部状态、网络请求、DOM 操作、控制台输出等。
- 函数式编程(FP) 初识:强调不可变数据、纯函数、组合(compose)、高阶函数、声明式处理。
- 面试点:如何把副作用隔离到边缘(side-effect free core),以及用 Immutable/structural sharing 优化。
131. 手写 bind 实现(更完整版)
Function.prototype.myBind = function(context, ...args) {
if (typeof this !== 'function') throw new TypeError('Bind must be called on function');
const self = this;
function bound(...rest) {
// 如果通过 new 调用,this 会是实例,忽略绑定的 context
const isNew = this instanceof bound;
return self.apply(isNew ? this : context, args.concat(rest));
}
// 保持原型链以支持 new
bound.prototype = Object.create(self.prototype);
return bound;
};
132. 手写柯里化函数
- 支持一次或多次传参,直到参数数量满足原函数长度:
function curry(fn, ...preset) {
return function curried(...args) {
const all = [...preset, ...args];
if (all.length >= fn.length) return fn(...all.slice(0, fn.length));
return curry(fn, ...all);
};
}
// 用法
const add = (a,b,c) => a+b+c;
const cAdd = curry(add);
cAdd(1)(2)(3); // 6
cAdd(1,2)(3); // 6
133. 函数组合、记忆化(memoization)
- 组合(compose/pipe):
const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);
const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x);
- 记忆化:利用
Map缓存计算结果(注意:参数是对象时需要特殊处理或使用 WeakMap):
function memoize(fn) {
const cache = new Map();
return function(...args) {
const key = JSON.stringify(args);
if (cache.has(key)) return cache.get(key);
const res = fn.apply(this, args);
cache.set(key, res);
return res;
};
}
- 面试点:记忆化适用于纯函数,注意缓存失效/内存泄漏问题以及参数可序列化性。
134. setTimeout 和 setInterval 的陷阱
setInterval可能导致任务重叠(任务执行时间超过间隔),建议用递归setTimeout来确保间隔是任务完成后的固定延迟。- 最小延迟限制(浏览器或 Node 在后台页或某些环境会限制最小延迟)。
- 清除需要
clearTimeout/clearInterval。 - 计时精度:不保证精确(受事件循环阻塞影响)。
- 示例(安全的间隔):
function safeInterval(fn, delay) {
let stopped = false;
function run() {
if (stopped) return;
const p = Promise.resolve().then(fn);
p.finally(() => setTimeout(run, delay));
}
setTimeout(run, delay);
return () => { stopped = true; };
}
135. 事件循环(Event Loop)完整解析
- 主要概念:
- 调用栈(call stack)
- 宏任务队列(macrotasks):
setTimeout,setInterval, I/O, UI rendering callbacks - 微任务队列(microtasks):
Promise.then/catch/finally,queueMicrotask, DOM MutationObserver - 执行顺序:执行当前 call stack -> 执行所有微任务直到空 -> 渲染(浏览器)-> 执行一个宏任务 -> 重复。
- Node vs 浏览器差异:
- Node 有
process.nextTick(比 microtask 更高优先级),也有宏任务队列细分。
- Node 有
- 面试点:用例子说明输出顺序(微任务优先于宏任务),并能说明在某个输出序列中为啥 Promise.then 先于 setTimeout。
经典示例:
console.log('script start');
setTimeout(() => console.log('timeout'), 0);
Promise.resolve().then(() => {
console.log('promise1');
}).then(() => {
console.log('promise2');
});
console.log('script end');
// 输出: script start, script end, promise1, promise2, timeout
136. Promise 基本语法 + 错误捕获
.then(onFulfilled, onRejected):推荐链式.then(...).catch(...);catch等于.then(null, onRejected)。- 错误传播:
.then内抛错会变成返回的 Promise 的 reject,可被后续的.catch捕获。 - finally:无论成功或失败都会执行;返回值会被忽视(但可用于清理)。
- 面试点:错误冒泡链、在
.then内返回 Promise 会等待它 resolve/reject。
示例:
Promise.resolve(1)
.then(x => x+1)
.then(x => { throw new Error('err') })
.catch(err => console.error('caught', err));
137. async / await 的底层运行机制
async函数总是返回Promise。await会暂停 async 函数的执行(在当前执行帧结束后,await后的代码会作为微任务恢复执行),等待表达式解析(若不是 Promise,会被Promise.resolve()包装)。- 底层等效:用 Generator + Promise 来实现(Babel 转译思路)。
- 面试点:
await只会暂停当前 async 函数,不会阻塞主线程;错误可被try/catch捕获。
伪转译(概念):
async function foo() {
const a = await p1();
const b = await p2();
return a + b;
}
// 大致像
function foo() {
return new Promise((resolve, reject) => {
p1().then(a => {
p2().then(b => resolve(a+b), reject);
}, reject);
});
}
138. Promise.all、allSettled、race、any 用法对比
Promise.all(iterable):全部成功 -> 返回结果数组;任意一个失败 -> 立刻 reject(返回第一个遇到的 reject)。Promise.allSettled(iterable):等待全部完成(不论成功失败),返回每项{status, value/reason}。Promise.race(iterable):返回第一个完成(resolve 或 reject)的 Promise 的结果。Promise.any(iterable)(ES2021):返回第一个 resolve 的值;若全部 reject,则 reject 一个AggregateError(包含所有错误)。- 面试点:选择哪个取决于业务需求(是“全成功”还是“先到先得”或“至少一个成功”)。
示例:
Promise.all([p1,p2]).then(results => {});
Promise.allSettled([p1,p2]).then(results => {});
Promise.race([p1,p2]).then(first => {});
Promise.any([p1,p2]).then(firstFulfilled => {});
139. 手写一个简化版 Promise(核心功能:then 链式)
下面实现为简化版,支持链式 .then,基本的 resolve/reject,Promise 值穿透与 thenable 兼容(简化版,未实现所有 edge case):
class SimplePromise {
constructor(executor) {
this.state = 'pending';
this.value = undefined;
this.handlers = [];
const resolve = (val) => {
setTimeout(() => this._resolve(val), 0);
};
const reject = (err) => {
setTimeout(() => this._reject(err), 0);
};
try {
executor(resolve, reject);
} catch (e) {
reject(e);
}
}
_resolve(val) {
if (this.state !== 'pending') return;
if (val && (typeof val === 'object' || typeof val === 'function')) {
// thenable 处理
try {
const then = val.then;
if (typeof then === 'function') {
return then.call(val, v => this._resolve(v), e => this._reject(e));
}
} catch (e) {
return this._reject(e);
}
}
this.state = 'fulfilled';
this.value = val;
this.handlers.forEach(h => h.onFulfilled(val));
}
_reject(err) {
if (this.state !== 'pending') return;
this.state = 'rejected';
this.value = err;
this.handlers.forEach(h => h.onRejected(err));
}
then(onFulfilled, onRejected) {
return new SimplePromise((resolve, reject) => {
const handle = () => {
try {
if (this.state === 'fulfilled') {
if (typeof onFulfilled === 'function') {
resolve(onFulfilled(this.value));
} else {
resolve(this.value);
}
} else if (this.state === 'rejected') {
if (typeof onRejected === 'function') {
resolve(onRejected(this.value)); // 注意:如果 onRejected 返回值,视为 resolve
} else {
reject(this.value);
}
} else {
this.handlers.push({
onFulfilled: (v) => {
try {
if (typeof onFulfilled === 'function') resolve(onFulfilled(v));
else resolve(v);
} catch (e) { reject(e); }
},
onRejected: (e) => {
try {
if (typeof onRejected === 'function') resolve(onRejected(e));
else reject(e);
} catch (err) { reject(err); }
}
});
}
} catch (e) { reject(e); }
};
// 如果已经 settled,异步执行处理
if (this.state !== 'pending') setTimeout(handle, 0);
else this.handlers.push({
onFulfilled: (v) => { try { if (typeof onFulfilled === 'function') resolve(onFulfilled(v)); else resolve(v); } catch (e) { reject(e); } },
onRejected: (e) => { try { if (typeof onRejected === 'function') resolve(onRejected(e)); else reject(e); } catch (err) { reject(err); } }
});
});
}
catch(fn) {
return this.then(null, fn);
}
static resolve(v) {
return new SimplePromise((res) => res(v));
}
static reject(e) {
return new SimplePromise((_, rej) => rej(e));
}
}
- 面试点:异步执行
.then回调(规范要求微任务队列),thenable 处理,链式返回一个新的 Promise。
140. 实战:用 Promise 重写 setTimeout 任务队列
- 需求:按顺序执行一组带延迟的任务(每个任务按指定延迟执行,前一个完成才开始下一个)。
- 实现思路:用 Promise 链或
async/await顺序调度。
示例(任务队列类):
class TimeoutQueue {
constructor() { this.chain = Promise.resolve(); }
// task: () => Promise|value, delay: ms
add(task, delay = 0) {
this.chain = this.chain.then(() => new Promise((resolve) => {
setTimeout(() => {
Promise.resolve().then(task).then(resolve, resolve); // 即使 task 抛错,也让队列继续(可根据需要改为 reject)
}, delay);
}));
return this.chain;
}
}
// 用法
const q = new TimeoutQueue();
q.add(() => console.log('task1'), 1000);
q.add(() => fetch('/api'), 500);
- 也可以把
setTimeout包装为 Promise:
const wait = ms => new Promise(res => setTimeout(res, ms));
await wait(1000);
141. 实战:Async / await 错误处理的 3 种方式
- try / catch(最直观):
try {
const res = await foo();
} catch (err) {
// 处理
}
- 对 Promise 使用
**.catch**(适用于并行):
const p = foo();
p.catch(err => { /* 处理 */ });
- 返回 [err, result] 的封装(避免 try/catch):
const to = (p) => p.then(data => [null, data]).catch(err => [err]);
const [err, data] = await to(foo());
if (err) { /* 处理 */ }
142. “异步题大汇总”:输出顺序、陷阱解析(几个常见面试题)
- 经典例子(解释输出):
console.log('start');
setTimeout(() => console.log('timeout'), 0);
Promise.resolve().then(() => console.log('promise'));
console.log('end');
// 输出: start, end, promise, timeout
- 更复杂(微任务链):
Promise.resolve().then(() => {
console.log('p1');
Promise.resolve().then(() => console.log('p2'));
});
console.log('sync');
// 输出: sync, p1, p2
setTimeout与Promise.then的优先级(Promise microtask 优先于宏任务)。- Node 特例:
process.nextTick比 Promise 微任务更早执行(面试可能考)。
面试点:能够解释任意给定代码片段的输出顺序、理解微任务与宏任务优先级、Promise 回调的异步性(即使 Promise 已经 resolved)等。
143. 什么是原型?什么是原型链?
- 原型(prototype):每个函数(构造函数)都有
prototype对象,实例对象通过__proto__(或Object.getPrototypeOf)指向构造函数的prototype。属性查找会沿着这条链向上查找,这就是原型链。 - 面试点:区分
prototype(函数的属性,用于实例的原型)与__proto__(实例的指针);Object.prototype的__proto__是null(链的终点)。
示例:
function A() {}
A.prototype.say = function(){ console.log('hi'); };
const a = new A();
a.say(); // 查找:a -> A.prototype -> Object.prototype
144. 构造函数与 new 的机制
new 的执行过程(面试常考)简述:
- 创建一个新对象:
obj = {}。 - 将新对象的
__proto__指向构造函数的prototype(obj.__proto__ = Fn.prototype)。 - 将构造函数内部
this绑定到新对象并执行构造函数:Fn.call(obj, ...args)。 - 若构造函数返回一个对象(非 null 且类型为 object 或 function),则返回该对象;否则返回
obj。
- 面试点:要写出
new的手写实现(见第 31 条)。
145. 手写 new 的实现逻辑
function myNew(fn, ...args) {
if (typeof fn !== 'function') throw new TypeError('myNew must be called with constructor');
const obj = Object.create(fn.prototype);
const res = fn.apply(obj, args);
return (res !== null && (typeof res === 'object' || typeof res === 'function')) ? res : obj;
}
// 用法
function Person(name) { this.name = name; }
const p = myNew(Person, 'Tom');
146. instanceof 背后的原理
- 原理:判断构造函数的
prototype是否出现在对象的原型链上。 - 手写实现:
function myInstanceOf(obj, constructor) {
let proto = Object.getPrototypeOf(obj);
const prototype = constructor.prototype;
while (proto !== null) {
if (proto === prototype) return true;
proto = Object.getPrototypeOf(proto);
}
return false;
}
- 面试点:
instanceof与跨 global 环境(iframe)对象的问题;Object.prototype.toString在类型检测上的作用。
147. Object.create 是怎么实现继承的?
Object.create(proto)本质上创建了一个新的对象并将它的内部[[Prototype]]指向proto。- 简单 polyfill:
function objectCreate(proto) {
function F() {}
F.prototype = proto;
return new F();
}
- ES6 中可直接用
Object.create(proto)。Object.create(null)创建无原型的纯字典对象。
148. class 是语法糖吗?背后发生了什么?
- 是的:ES6
class只是构造函数 + 原型链的语法糖,提供更清晰的语法(constructor、extends、静态方法、super等)。 - 背后:
class声明会创建一个构造函数(不可被提升),并把实例方法放在.prototype上,把静态方法放在构造函数上。extends会设置子类的prototype指向父类实例的prototype(通过Object.create),同时设置super调用链。 - 面试点:
class的方法是不可枚举的;class的 constructor 不可在非构造情境直接调用(class的toString、name等),以及extends null的特殊情况。
示例(等价思想):
class A {
constructor(x) { this.x = x; }
foo() { return this.x; }
}
// 转换为
function A(x) { this.x = x; }
A.prototype.foo = function() { return this.x; };
149. JS 中常见继承方式对比总结
- 原型链继承(
Child.prototype = new Parent()):共享引用属性问题。 - 构造函数继承(借用构造)(
Parent.call(this)):可以继承实例属性,无法继承方法(需用 prototype)。 - 组合继承(借用构造 + 原型链):常见且实用(constructor 调用 + prototype 链接)。
- 寄生组合继承(优化组合继承,避免调用两次父构造):使用
Object.create(Parent.prototype)并修复 constructor。 - ES6
**class extends**:语法糖,背后处理原型链与super。 - 面试点:每种方式的优缺点(比如共享引用带来的 bug、性能或重复调用父构造函数的问题),以及如何修复(使用
Object.create、修复 constructor 等)。
150. 说说JS如何判断数据类型
6种判断方式
- === undefined null
- typeof string number boolean undefined symbol bigint function object null 所有非函数对象
- instanceof A instanceof B: 判断A或者A原型链上的对象是否是B类型的实例 可以用于判断某个对象是否某个特定类型的 区别Object对象与数组对象
- obj.constructor 得到对象的构造函数 得到number/string/boolean值的包装类型 null/undefined没有constructor
- String.prototype.toString.call(obj) 得到构造函数的名称
- Array.isArray() 专门判断数组
151. 说说常见的数组方法
-
更新数组的7个 push / pop / unshift / shift splice sort / reverse
-
遍历元素 forEach map / filter / reduce find / findIndex every / some
-
其它 slice concat join includes indexOf
-
函数调用时, 是将实参变量的数据拷贝一份赋值给形参变量
-
只是实参变量数据可能是基本类型值 ==> 值传递
-
也可能是引用类型的值(也就是地址值) ==> 引用传递/值传递
-
注意下面的代码, 准确的说不是将a内存的地址赋值给b, 而是将a中保存的地址值赋值给b
var a = {} var b = a var a1 = 2 var a2 = {} function fn (x) { } fn(a1) // 值传递 fn(a2) // x = a2 拷贝a2内存中保存的值(地址值)传递给x
152. 说说你对作用域与作用域链的理解
- 作用域
- 一个变量可以合法使用的范围/区域
- 作用域起到了隔离变量, 避免了变量重名冲突的问题(也就是允许了不同作用域中可以有同名的变量)
- 分类:
- 全局作用域
- 函数作用域
- 块作用域 => ES6的let或const变量
- 作用域链
- 多个嵌套的作用域形成的由内向外的结构, 用于查找变量
- 本质: 包含由内向外的多个变量对象的数组 ==> 这个可以不用说
- 当查找一个变量, 在整个作用域链中都找不到时: 会报引用错误(RefrenceError), 错误信息(message)为这个变量没有定义
153. 说说变量提升与函数提升
- 变量提升(
变量声明提升)- 变量声明语句会提升到当前作用域的最前面执行
- 在变量声明语句之前, 就可以访问到这个变量(undefined)
- 函数提升(
函数声明提升)- 函数声明语句提升到当前作用域的最前面执行
- 在函数声明语句之前, 就可以执行该函数
- 原因: 简单来说就是在执行全局代码和函数前会进行
预解析/处理- 将var变量声明放在最前面执行
- 将function函数声明放在最前面执行
- 注意
- const / let / class 没有提升
- var 变量 / function 函数声明 才有提升
154. 区分执行函数定义与执行函数
- 执行函数定义: 创建函数对象, 如果指定了函数名, 同时会定义变量并指向这个函数对象
- 执行函数: 执行函数内部的语句
- 必须先执行函数定义, 再执行函数 ===> 注意: 函数定义有可能会提升到最上面执行
155. 原型链继承
原型链继承的核心:将父类的实例作为子类的原型 原型链式继承模式实现了子类对父类的原型的继承,但是,原型链式继承并没有实现代码的复用,且 如果原型中包含引用类型值,那么所有的实例会共享这个属性。
156. 构造函数
优点:构造函数模式继承实现了代码的复用;缺点:不能继承借用的构造函数的原型,只能借用构造 函数本身的属性和方法;每次构造函数都要多走一个函数
157. 组合继承
组合继承,既能达到对父类属性的继承,也能继承父类原型上的方法;父类属性继承也不会在所有子 类的实列上共享;唯一缺点,子类原型上有父类构造函数的属性,也就是多了一份属性
158. 寄生组合继承
寄生组合式继承是对组合继承的进一步优化如果所有继承该父类的子类对象的原型都指向同一个了 ,显然是错误的;不能直接继承,可以间接继承xxx.prototype ;我们让一个函数去指向 xxx.prototype,然后让xxx.prototype指向这个函数产生的对象 .
ES6中:
159. 类的constructor方法
constructor方法是类的默认方法,通过new命令生成对象实例时,自动调用该方法。一个类必须有 constructor方法,如果没有显式定义,一个空的constructor方法会被默认添加。
160. 类的继承
在子类的构造函数中,如果显示声明了constructor,则必须要显示的调用super函数,只有调用 super之后,才可以使用this关键字,否则会报错。
161. 类的 prototype 属性和 proto 属性
prototype 是函数独有的属性,指向它的原型对象,实例通过它共享方法;__proto__ 是每个对象都有的属性,指向构造它的构造函数的 prototype,是原型链上的链环。
162. ES5 有哪几种继承方式?
- 原型链继承:
Child.prototype = new Parent()。实例共享引用类型属性,且无法向父构造函数传参。 - 借用构造函数继承:在 Child 里
Parent.call(this)。能传参、不共享,但拿不到父原型上的方法。 - 组合继承:原型链 + 借用构造函数,最常用的完整方案;缺点是父构造函数被调用两次。
- 原型式继承:基于已有对象创建新对象(
Object.create(obj)),相当于对原型做浅拷贝。 - 寄生式继承:在原型式外面包一层函数做增强;方法难以复用。
- 寄生组合继承:借用构造函数 +
Object.create(父.prototype),只调用一次父构造函数,是最理想的继承方式,class 继承的底层就等价于它。 - 用 Object.create 实现类式继承:
Child.prototype = Object.create(Parent.prototype)再修正constructor,避免为了继承而实例化父类。
163. 分类输出
console.log() 输出普通信息 console.info() 输出提示信息 console.warn() 输出警告信息 console.error() 输出错误信息 注意:console.exception()是console.error()的别名,它们功能相同 console.debug 输出调试信息
164. 分组输出
console.group()和console.groupEnd() 包裹分组内容 console.group:开始一组输出信息 console.groupEnd:结束一组输出信息 console.group可嵌套使用 console.groupCollapsed() 生成折叠的分组
165. 表格输出
console.table() 可以将传入的对象,或数组以表格形式输出,适合排列整齐的元素
166. 查看对象
console.dir() 将DOM节点以树形结构形式进行输出,便于我们查看
167. 查看节点
console.dirxml() 显示一个XML表示的node节点
168. 条件输出
console.assert(expression,object) 当第一个参数或返回值为真时,不输出内容 当第一个参数或返回值为假时,输出后面的内容并抛出异常
169. 计次输出
console.count() 输出内容和被调用的次数 console.countReset() 重置计数器
170. 计时功能
console.time() 和Console.timeEnd() 包裹需要计时的代码片段,输出运行这段代码的事件 console.time()中的参数作为计时器的标识,具有唯一性 console.timeEnd()中的参数来结束此标识的计时器,并以毫秒为单位返回运行时间 最多同时运行10000个计时器
171. 控制台输出计时器的值
console.timeLog() 该计时器必须已经通过 console.time() 启动
172. 返回时间戳
console.timeStamp 事件属性可返回一个时间戳,指示发生事件的日期和时间(从 epoch 开始的毫秒 数)
173. 追踪调用堆栈
console.trace 追踪函数被调用的过程
174. 性能分析
console.profile() 开始记录性能描述信息 console.profileEnd 停止记录之前已经由Console.profile()开始记录的性能描述信息 console.memory 性能问题很难分析,可能还要考虑是否有内存泄露,可使用此方法来查看当前的 堆的使用情况
175. 记录一段时间轴
console.timeLine()和console.timeLineEnd()
176. 清空控制台
console.clear() 清除当前控制台的所有输出,将光标回置到第一行
177. 数组元素的添加和删除:
1)、push( )
向数组的最后面插入一个或多个元素,返回结果为新数组的长度
2)、pop( )
删除数组中的最后一个元素,返回结果为被删除的元素
3)、unshift( )
在数组最前面插入一个或多个元素,返回结果为新数组的长度
4)、shift( )
删除数组中的第一个元素,返回结果为被删除的元素
5)、slice( )
从数组中提取指定的一个或多个元素,返回结果为新的数组
6)、splice( )
从数组中删除指定的一个或多个元素,返回结果为被删除元素组成的新数组
7)、fill( )
填充数组:用固定的值填充数组,返回结果为新的数组
178. 数组元素的修改和查询:
1)、indexOf(value)
从前往后索引,检索一个数组中是否含有指定的元素
2)、lastIndexOf(value)
从后往前索引,检索一个数组中是否含有指定的元素
3)、includes(item)
数组中是否包含指定的内容
4)、find(function( ) )
找出第一个满足「指定条件返回 true」的元素
5)、findIndex(function( ) )
找出第一个满足「指定条件返回 true」的元素的 index
6)、every( )
确保数组中的每个元素都满足「指定条件返回 true」,则停止遍历,此方法才返回 true
7)、some( )
数组中只要有一个元素满足「指定条件返回 true」,则停止遍历,此方法就返回 true
179. 数组的合并和拆分
1)、concat( )
合并数组:连接两个或多个数组,返回结果为新的数组
2)、join( )
将数组转换为字符串,返回结果为转换后的字符串
3)、split( )
将字符串按照指定的分隔符,组装为数组
180. 数组排序
1)、reverse( )
反转数组,返回结果为反转后的数组
1)、sort( )
对数组的元素,默认按照Unicode 编码,从小到大进行排序
181. 遍历数组
for 循环
1)、forEach( )
和 for 循环类似,但需要兼容 IE8 以上
2)、map( )
对原数组中的每一项进行加工,将组成新的数组
3)、filter( )
过滤数组:返回结果是 true 的项,将组成新的数组,返回结果为新的数组
4)、reduce( )
接收一个函数作为累加器,返回值是回调函数累计处理的结果
182. 数组的转换和判断
1)、toString( )
数组转换为字符串
2)、isArray( )
判断是否为数组
3)、Array.from( )
将伪数组转换为真数组
4)、Array.of( )
创建数组
183. 错误类型有哪些?如何进行更好的调试错误?
主要分为:语法错误,编译错误,逻辑错误 ECMA-262规范了7种错误类型。其中Error是基类,其他6种错误类型是子类,都继承了基类。Error类 型的主要作用是自定义错误对象。 // 定义一些命令
varopenDoorCommand= {
execute: function () {
console.log("开门");
},
};
varopenPcCommand= {
execute: function () {
console.log("开电脑");
},
};
varopenLolCommand= {
execute: function () {
console.log("撸一局");
},
};
// 定义命令宏组合命令
varMarcoCommand= {
list: [],
add: function (command) {
this.list.push(command);
},
execute: function () {
this.list.forEach(function (command) {
command.execute();
});
},
};
MarcoCommand.add(openDoorCommand);
MarcoCommand.add(openPcCommand);
MarcoCommand.add(openLolCommand);
MarcoCommand.execute(); // 开门开电脑撸一局
1)、Error:
普通异常。与thorw语句和try/catch语句一起使用,属性name可以读写异常类型,message属性可以 读写详细的错误信息。
2)、EvalError:
不正确使用eval()方法时抛出
3)、SyntaxError:
出现语法错误时抛出
4)、RangeError:
数字超出合法范围之抛出
5)、ReferenceError:
读取不存在的变量时抛出 1、TypeError: 值的类型发生错误的时候抛出 1、URIError: URI编码和解码错误时抛出
184. 错误调试方式有哪些?
1)、console
对象直接把 JavaScript 消息写入控制台,这个对象包含如下方法。
2)、error(message)
在控制台中记录错误消息。
3)、info(message)
在控制台中记录信息性内容。
4)、log(message)
在控制台记录常消息。
5)、warn(message)
在控制台中记录警告消息。
6)、alert()
弹出警告窗口。
7)、debug
开发者调试工具
8)、debugger
断点调试
9)、try…catch
错误处理
10)、throw new Error(message)
抛出错误
185. 同源策略
1)、什么是同源策略?
同源策略 (Same-Origin Policy) 最早由 Netscape 公司提出,是浏览器的一种安全策略。
2)、什么是同源?
同源指的是协议、域名、端口号必须完全相同,任何一个不满足条件都会导致跨域问题。
3)、什么是跨域?
违背同源策略就是跨域。
4)、跨域解决方案有什么?
186. CORS
1)、 CORS是什么?
CORS(Cross-Origin Resource Sharing),跨域资源共享。CORS是官方的跨域解决方案,它的特点是 不需要在客户端做任何特殊的操作,完全在服务器中进行处理,支持get和post请求。
2)、CORS怎么工作的?
CORS是通过设置一个响应头Access-Control-Allow-Origin来告诉浏览器,该请求允许跨域,浏览器 收到该响应以后就会对响应放行。
3)、相关响应头介绍:
Access-Control-Allow-Origin :允许的域名,该字段是必须的,设置为* ,表示取消跨域限制。
Access-Control-Allow-Credentials :该字段可选。它的值是一个布尔值,表示是否允许发送
Cookie。默认情况下,Cookie不包括在CORS请求之中Access-Control-Expose-Headers :该字段可 选。CORS请求时,XMLHttpRequest 对象的 getResponseHeader()方法只能拿到6个基本字段: Cache-Control、Content-Language、Content-Type、Expires、Last-Modified、Pragma。如果想拿 到其他字段,就必须在Access-Control-Expose-Headers里面指定。
4)、不足之处
4.1 需要和后端工程师沟通协商,在服务端取消跨域限制 4.2 任意的请求协议、域名和端口都可以访问后端的接口数据,存在一定的安全风险
187. JSONP
1)、什么是JSONP ?
JSONP(JSON with Padding),是一个非官方的跨域解决方案,纯粹凭借程序员的聪明才智开发出来,只 支持get请求。 在网页有一些标签天生具有跨域能力,比如:img link iframe script,JSONP就是利用 script 标签的跨 域能力来发送请求的。
2)、JSONP 使用步骤
3)、不足之处
1它只支持GET请求而不支持POST等其它类型的HTTP请求 2它只支持跨域HTTP请求这种情况,不能解决不同域的两个页面之间如何进行JavaScript调用的问题。 3 jsonp在调用失败的时候不会返回各种HTTP状态码。 4安全性。万一提供jsonp的服务存在页面注入漏洞,即它返回的javascript的内容被人控制的,所有调用 这个 jsonp的网站都会存在漏洞。
4 代理服务(推荐)
1)、Nginx与Node
在工作上,由于工作平台和语言的原因,对于大部分前端开发人员来说,更倾向于用Nodejs来搭建服务 器,进而实现一些需求,对Nginx有天然的抗拒感。的确,Nginx中的绝大部分功能,如果单纯的使用 Node.js也可以满足和实现。但实际上,Nginx和Node.js并不冲突,都有自己擅长的领域:Nginx更擅长 于底层服务器端资源的处理(静态资源处理转发、反向代理,负载均衡等),Node.js更擅长于上层具体 业务逻辑的处理。两者可以实现完美组合,助力前端开发。
Access-Control-Allow-Origin: http://api.bob.com
Access-Control-Allow-Credentials: true
Access-Control-Expose-Headers: content-type,cache-control
// 1.动态的创建一个script标签
varscript=document.createElement("script");
// 2.设置script的 src
script.src="http://localhost:3000/testAJAX?callback=abc";
// 3. 定义回调函数
functionabc(data) {
alert(data.name);
};
// 4.将script添加到 body 中,会发送请求
document.body.appendChild(script);
2)、反向代理
正向代理:
翻墙工具其实就是一个正向代理工具。它会把们访问墙外服务器server的网页请求,代理到一个可 以访问该网站的代理服务器proxy,这个代理服务器proxy把墙外服务器server上的网页内容获取, 再转发给客户。
反向代理:
客户端发送的请求,想要访问server服务器上的内容。但将被发送到一个代理服务器proxy,这个 代理服务器将把请求代理到和自己属于同一个LAN下的内部服务器上,而用户真正想获得的内容就 储存在这些内部服务器上。 这里proxy服务器代理的并不是客户,而是服务器,即向外部客户端提供了一个统一的代理入口, 客户端的请求,都先经过这个proxy服务器,至于在内网真正访问哪台服务器内容,由这个proxy去 控制。
为什么要Nginx反向代理
使用反向代理最主要的两个原因: (1)安全及权限。 可以看出,使用反向代理后,用户端将无法直接通过请求访问真正的内容服务器,而必须首先通过 Nginx。可以通过在Nginx层上将危险或者没有权限的请求内容过滤掉,从而保证了服务器的安 全。 (2)负载均衡。 单个服务器解决不了,我们增加服务器的数量,然后将请求分发到各个服务器上,将原先请求集中 到单个服务器上的情况改为请求分发到多个服务器上,将负载分发到不同的服务器,也就是我们所 说的负载均衡。
3)、前后端分离项目
(1)vue项目中的配置
在vue.config.js 文件中,我们需要配置:(vue-cli 3.0)
在config/index.js 文件中,我们需要配置:(vue-cli 2.0)
配置多个代理地址: 情形:某个项目时,由于是多个后端配合(A写一般任务的接口,B写技术预研的接口),出现了多个端 口。因此,前端也需要配置多个代理。
devServer: {
//代理列表
proxy: {
'/api': {
target: 'http://172.31.46.4:8088', //要代理的域名
changeOrigin: true,//允许跨域
pathRewrite: {
'^/api': '' // 这个是定义要访问的路径,名字随便写
}
}
}
}
dev: {
proxyTable: {
'/api': {
target: 'http://172.31.46.4:8088', //要代理的域名
changeOrigin: true,//允许跨域
pathRewrite: {
'^/api': '' // 这个是定义要访问的路径,名字随便写
}
}
}
}
/api/getUserMsg` 相当于 `http://172.31.46.4:8088/getUserMsg
/api`相当于`http://172.31.46.4:8088
this.$http.get("/api/getUserMsg", {
}
.then(res=> {
})
.catch(function(error) {
});
devServer: {
//代理列表
proxy: {
'/mps-ss': {
target:'http://xxxxxx:7890',//线上1
changeOrigin: true,
pathRewrite: {
'^/mps-ss': '/mps-ss'
}
这个时候,我们可能会疑惑,为什么有的pathRewrite 这个对象,内容不同。 这因为,后端接口匹配的路由不同。 例如:(以nodejs 模拟的接口),针对情况一
},
'/mps-fileApi': {
target:'http://xxxxx:7777',//线上2
changeOrigin: true,
pathRewrite: {
'^/mps-fileApi': '/mps-fileApi'
}
},
'/mps-video': {
target:'http://xxxxxx:8090',//返回播放地址
changeOrigin: true,
pathRewrite: {
'^/mps-video': '/mps-video'
}
}
}
}
// 情况一:
'/api': {
target:'http://172.31.242.10:7890',
changeOrigin: true,
pathRewrite: {
'^/api': '/api'
}
}
//上下两个pathRewrite对比,会发现,匹配^/mps-ss会等于 '/mps-ss',另一个是匹配^/mps-ss会
等于 '/'
// 情况二:
'/api': {
target:'http://172.31.242.10:7890',
changeOrigin: true,
pathRewrite: {
'^/api': ''
}
}
(以nodejs 模拟的接口),针对情况二
(2)react配置跨域(两种)
(1)(在package.json 里配置proxy),单一代理 1,如代理到本地服务器5000端口, “proxy”:“http://localhost:5000”
2,本地服务器是由nodejs 启动的(express)。路由:app.get('/getStudentsMsg',
(req,res)=>{}) 。所以,在axios 做请求数据时,直接请求:‘http://localhost:3000/getStuden tsMsg’。(详情查看app.js 文件中的button点击事件) (2)(不在package.json 里配置proxy,而在项目目录src/ 下新建setupProxy.js 文件),多个 代理 如果在package.json 文件中配置:(报错:提示只支持string类型,不支持object.)
app.get('/cars',(req,res)=>{
letdata= [
{name:'宝马',price:'32万',sell:1230192},
{name:'奥迪',price:'23.4万',sell:21091},
{name:'奔驰',price:'46万',sell:721912}
]
res.send(data)
})
解决方法:
安装http-proxy-middleware 管理包,cnpm http-proxy-middleware --save (注意,在
create-react-app 脚手架已经下载好了依赖。此步骤可以省略) 在项目目录src/ 下新建setupProxy.js 文件,然后写入如下代码:
188. 什么是CDN?
CDN的全称是Content Delivery Network,即内容分发网络。 CDN是一个空间换时间的策略。 CDN使用户就近获取所需内容,降低网络拥塞,提高用户访问响应速度和命中率。 CDN依靠部署在各地的边缘服务器,包括中心平台的负载均衡、内容分发、调度等功能模块。
189. 什么时候使用CDN?
解决因分布、带宽、服务器性能带来的访问延迟问题,适用于站点加速、点播、直播等场景。使用户可 就近取得所需内容,解决 Internet网络拥挤的状况,提高用户访问网站的响应速度和成功率。 控制时延无疑是现代信息科技的重要指标,CDN的意图就是尽可能的减少资源在转发、传输、链路抖动 等情况下顺利保障信息的连贯性。
190. 为什么需要使用CDN?
1)为了加速网站的访问; 2)为了实现跨运营商、跨地域的全网覆盖 互联不互通、区域ISP地域局限、出口带宽受限制等种种因素都造成了网站的区域性无法访问。CDN加速 可以覆盖全球的线路,通过和运营商合作,部署IDC资源,在全国骨干节点商,合理部署CDN边缘分发 存储节点,充分利用带宽资源,平衡源站流量。 3)为了保障你的网站安全 CDN的负载均衡和分布式存储技术,可以加强网站的可靠性,相当无无形中给你的网站添加了一把保护 伞,应对绝大部分的互联网攻击事件。防攻击系统也能避免网站遭到恶意攻击。 4)为了异地备援 当某个服务器发生意外故障时,系统将会调用其他临近的健康服务器节点进行服务,进而提供接近100% 的可靠性,这就让你的网站可以做到永不宕机。 5)为了节约成本投入 使用CDN加速可以实现网站的全国铺设,你根据不用考虑购买服务器与后续的托管运维,服务器之间镜 像同步,也不用为了管理维护技术人员而烦恼,节省了人力、精力和财力。 6)为了让你更专注业务本身 CDN加速厂商一般都会提供一站式服务,业务不仅限于CDN,还有配套的云存储、大数据服务、视频云 服务等,而且一般会提供7x24运维监控支持,保证网络随时畅通,你可以放心使用。并且将更多的精力 投入到发展自身的核心业务之上。
191. 它的优势与不足是什么?
优势:
1)更快地传递内容 由于CDN最靠近用户放置,因此当内容需要移动的距离更短时,可以减少延迟。CDN可以使网站加载速 度更快。例如,如果网站位于英国并且从美国获得流量,则CDN提供商可能在美国拥有服务器并将该服 务器用于网站。 2)更多同步用户 CDN可以确保网络具有高数据阈值。因此,大量用户可以在没有延迟的情况下同时访问网络。通过实现 高流量,CDN允许来自世界各地的人们同时访问网站。 3)持续可用性 CDN中的服务器始终在运行,即使服务器已关闭,网站也可以访问。如果没有CDN,服务器有时可能会 关闭,这意味着必须等到主机解决问题。如果使用CDN,则不会发生这种情况。如果服务器崩溃,CDN 将使用缓存页面。 4)可靠的内容传递 如果使用CDN,则内容的传送更加一致。特别是,这涉及高分辨率内容,如视频和图像。CDN提供高质 量的内容交付,因此对网站的性能产生重大影响。由于54%的客户希望在的网站上看到视频,因此可以 以高分辨率提供这些视频对业务至关重要。 5)控制资产交付 当CDN监控资产交付时,运营商可以根据实时统计数据确定需要额外容量的位置。如果某个地区的服务 器出现过载,运营商可以提供额外的带宽,以确保一切顺利运行。 6、防止流量高峰 如果网站突然出现大量流量,可以从CDN服务中受益。大型服务器网络可确保这些资源在所有情况下都 可用且可扩展。许多企业的噩梦是他们将获得大幅增加的流量,但他们的网站无法处理它。 不足: 1)成本 这可能是使用CDN的最重要的缺点。开始使用CDN服务的成本很高,而且它们也有许多隐藏成本。其中 包括每次数据传输和千兆字节的成本。高成本来自第三方网络。启动新的CDN网络要求服务器公司从另 一家公司获得帮助以安装此类网络。请务必仔细阅读所有条款和条件。 鉴于此,CDN网络往往是能够负担这些成本的大公司的更好选择。在全球范围内维护无用的复制服务器 也是不切实际的。 2)服务地点 如果大多数受众群体位于CDN没有服务器的国家/地区,则网站上的数据可能需要比不使用任何CDN更进 一步。 3)限制 一些组织和国家已阻止流行CDN的域或IP地址。在这种情况下,来自这些组织或国家/地区的受众群体无 法访问网站,最终会失去部分流量。 4)支持可用性 当第三方供应商负责运行CDN时,会出现支持问题。如果出现技术问题,即使很少见,无法知道操作员 需要多长时间来解决问题并防止再次发生问题。 5)失去控制 是否愿意将网站文件移交给另一家公司?在决定是否使用CDN之前,必须考虑这一点。使用CDN意味着 第三方会收到有关网站和系统的信息。
192. 什么是深拷贝与浅拷贝
浅拷贝是创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型, 拷贝的就是基本类型的值,如果属性是引用类型,拷贝的就是内存地址,所以如果其中一个对象改 变了这个地址,就会影响到另一个对象。 深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修 改新对象不会影响原对象。
193. 深拷贝与浅拷贝的区别
浅拷贝:重新在堆中创建内存,拷贝前后对象的基本数据类型互不影响,但引用类型因共享同一块内存,会相互影响。 深拷贝:从堆内存中开辟一个新的区域存放新对象,对对象中的子对象进行递归拷贝,拷贝前后的两个对象互不影响。 浅拷贝只复制一层对象的属性,而深拷贝则递归复制了所有层级。
194. 深拷贝与浅拷贝的实现方式
- 浅拷贝:
Array.concat()、Array.slice()、Object.assign()、展开运算符...(见 202-205 各条)。 - 深拷贝:
JSON.parse(JSON.stringify())、jQuery.extend(true, ...)、structuredClone()、手写递归(见 207-208 各条)。
195. 浅拷贝的实现方式
Array.concat() / Array.slice()(数组)、Object.assign()(对象)、展开运算符 ...(数组与对象),都是只复制一层的浅拷贝。
196. Array.concat( )
let arr = ['a', 'b', 'c'];
let newArr = arr.concat();
newArr.push('d');
console.log(arr); // ["a", "b", "c"]
console.log(newArr); // ["a", "b", "c", "d"]
197. Array.slice( )
let arr = ['a', 'b', 'c'];
let newArr = arr.slice();
newArr.push('d');
console.log(arr); // ["a", "b", "c"]
console.log(newArr); // ["a", "b", "c", "d"]
198. Object.assign( )
Object.assign() 方法可以把任意多个的源对象自身的可枚举属性拷贝给目标对象,然后返回目标对象。
语法:Object.assign(target, source1, source2);只复制一层,源对象的引用类型属性仍与目标共享。
let obj1 = { person: { name: "张三", age: 18 }, sex: '男' };
let obj2 = Object.assign({}, obj1);
obj2.person.name = "李四";
obj2.sex = '女';
console.log(obj1); // person 仍被共享,name 已被改成 '李四'
199. 展开运算符
{...obj} / [...arr] 与 Object.assign 一样只做一层浅拷贝:
let obj1 = { name: '张三', address: { x: 100, y: 100 } };
let obj2 = { ...obj1 };
obj1.address.x = 200;
obj1.name = 'wade';
console.log(obj2); // name 是 '张三',但 address.x 已变成 200 —— address 仍被共享
200. 深拷贝的实现方式
JSON.parse(JSON.stringify())(简单场景)、jQuery.extend(true, ...)、原生 structuredClone()(不支持函数)、以及手写递归克隆(可以处理函数、循环引用等特殊情况)。
201. JSON.parse(JSON.stringify())
let arr = [1, 2, { name: '张三' }];
let newArr = JSON.parse(JSON.stringify(arr));
newArr[2].name = '李四';
console.log(arr); // [1, 2, {name: '张三'}]
console.log(newArr); // [1, 2, {name: '李四'}]
注意:无法处理 function、undefined、Symbol、循环引用,Date 会变成字符串、RegExp/Map/Set 会丢失。
202. jQuery.extend( )
语法:$.extend([deep], target, object1 [, objectN])。deep 为 true 时递归合并,实现深拷贝:
let obj1 = { a: 1, b: { f: { g: 4 } }, c: [1, 2, 3] };
const obj2 = $.extend(true, {}, obj1);
console.log(obj1.b.f.g === obj2.b.f.g); // false —— 深层互不影响
203. 深拷贝与浅拷贝的应用场景
无论是浅拷贝还是深拷贝,一般都用于操作Object 或 Array之类的复合类型。 对于一层结构的Array和Object想要拷贝一个副本时使用,使用浅拷贝 对于想对某个数组或对象的值进行修改,但是又要保留原来数组或对象的值不被修改,此时就可以 用深拷贝来创建一个新的数组或对象,从而达到操作(修改)新的数组或对象时,保留原来数组或对 象。
十一、event.target与event.currentTarget的差异
204. 什么是target?什么是currentTarget?
event.target 是发生事件的元素或触发事件的元素。 event.currentTarget 是我们在其上显式附加事件处理程序的元素。(是事件绑定的元素)
205. target和currentTarget的区别:
- target:触发事件的元素。
- currentTarget:事件绑定的元素。
- 两者在没有冒泡的情况下,是一样的值,但在用了事件委托的情况下event.target指向引起触发事 件的元素,而event.currentTarget则是事件绑定的元素。
- 小结:currentTarget始终是监听事件者,绑定谁就是谁,而target是事件的真正发出者,点谁就是 谁。
一、针对部分监听事件,例如onclick:
1、如果你点击的是添加事件元素的子元素,就用currentTarget来获取父元素的值,用target来获取 子元素的值; 2、如果没有子元素,就在本元素上添加事件,target和currentTarget效果一样。
二、针对部分监听事件,例如onmouseenter:
1、如果你点击的是添加事件元素的子元素。使用currentTarget或者target都是获取父元素的值; 2、如果没有子元素,就在本元素上添加事件,target和currentTarget效果都是获取到自身元素的 值。
三、针对部分监听事件(比如onclick):
- target指向的是事件触发事的元素。 target在事件流的目标阶段,没有事件流的捕获和冒泡。点击始终是指向被单击的对象
- currentTarget指向事件绑定的元素。 当事件流处在目标阶段的时候(就是点击当前事件绑定对象),指向被单击的对象 当处于捕获和冒泡阶段的时候,指向当前事件活动的对象(一般为父级)。
206. 什么时候使用target和currentTarget?
常用于:事件委托中通过 e.target 判断真正的事件源;模拟用户点击 <a>、<input type="file"> 等必须”真实点击”才生效的元素;label 关联表单控件后触发控件行为。
207. target在事件流的目标阶段
当事件流处在目标阶段的时候(就是点击当前事件绑定对象),指向被单击的对象 当需要获取不同子组件绑定的属性,比如点击某个组件拿到该组件上绑定的属性,可以使用 event.target
208. 2 . currentTarget在事件流的捕获,目标及冒泡阶段。
当事件流处在目标阶段的时候(就是点击当前事件绑定对象),指向被单击的对象 当处于捕获和冒泡阶段的时候,也是指向当前事件绑定的对象。 始终都可以找到当前绑定事件的对象,所以开发人员一般使用event.currentTarget属性,event.target 属性很少使用 一般情况下,建议只使用 currentTarget 对象,因为它能拿到我们想要的参数属性 如果我们需要获取不同子组件绑定的属性,比如点击某个组件拿到该组件上绑定的属性,才用 target 对 象
209. current的不足:
通过查询MDN了解到,currentTarget在Safari on iOS10.0以下的版本中兼容性较差。
210. 类型转换之String()
String方法是可以将其他类型转换成字符串类型 1.null类型的转换 String(null) 字符串的 ‘null’ 2.undefined转换 String(undefined) 字符串的’undefined 3.number类型的转换 转换规则:普通数字直接变成字符串其他进制先转换成10进制然后在转换成相应的字符串无穷大无穷 小NaN都直接变成字符串 String(123) ‘123’ String(-123) ‘-123’ String(010) ‘8’ String(0xff) ‘255’ String(4E-5) ‘0.00004’ String(Infinity) ‘Infinity’ String(-Infinity) ‘-Infinity’ String(12.3) ‘12.3’ String(NaN) ‘NaN’ 4.布尔值的转换 String(true) ‘true’ String(false) ‘false’ 5.对象的转换 String([]) 空字符串 ” String([1]) ‘1’ String([1,2,3]) ‘1,2,3’ String({}) [object object] String({name:“lily”}) [object object]
211. 类型转换之toString()
我们的代码中有+(加号)运算符等情况下,它在这种情况下(字符串 + 其它什么东西),会调用 toString()方法,将其它类型的东西转化为字符串,再和原始字符串拼接成一个字符串 除了null和undefined之外,其他的类型(数值、布尔、字符串、对象)都有toString()方法,它返回 相应值的字符串表现(并不修改原变量)。 每个对象都有一个toString()方法。 当该对象被表示为一个文本值时,或者一个对象以预期的字符串方式引用时自动调用。 (1).toString() “1” [1,2].toString() “1, 2” ({}).toString() [object Object] true.toString() “true” null.toString() Uncaught TypeError: Cannot read property ‘toString’ of null undefined.toString() Uncaught TypeError: Cannot read property ‘toString’ of null
212. 类型转换之Number()
Number()方法将其他类型转换成number类型 Number方法会返回一个转换后的值 1.Number() 数字转数字还是原来的值 2.字符串转数字 Number("") 空字符串—>0 (Number(” ”) 都是空格的字符串—>0 (Number(“123”) 纯数字的字符串—>相对应的数字 Number(“1a23”) 非纯数字的字符串—>NaN 3.布尔值转数字 Number(true) true—>1 Number(false) false—>0 4.undefined转数字 Number(undefined) undefined—>NaN 5.null转数字 Number(null) null--->0 6.object(数组和对象)转数字 Number([]) 空数组—>0 Number([1,2,3]) 一般非空数组—>NaN Number([1]) 数字只有一个值,并且是数字—>当前数字 Number([“1”]) 数字只有一个值,并且是数字值的字符串—>当前数字 Number([“a”]) 数字只有一个值,并且是非数字—>NaN Number({}) 空对象—>NaN Number({name:“lily”}) 非空对象—>NaNz
213. 类型转换之Boolean()
布尔类型仅包含两个固定的值:true 和false 。其中true 代表真,false 代表假 1.null Boolean(null) false 2.undefined Boolean(undefined) false 3.number 数字转布尔值非0为true 0为false NaN为false Boolean(123) true Boolean(-123) true Boolean(0) false Boolean(1.23) true Boolean(NaN) false Boolean(Infinity) true Boolean(010) true Boolean(0xa) true 4.string 空为false 非空为true Boolean(“123”) true Boolean("") false Boolean(” ”) true 5.object 对象类型都转换成true Boolean([]) true Boolean([1,2,3]) true Boolean([0]) true Boolean({}) true Boolean({name:“lily”}) true
214. 类型转换之parseInt()
parseInt是一个全局方法,它可以把值转换为整数 第1步,先解析位置0处的字符,如果不是有效数字,则直接返回 NaN。 第2步,如果位置0处的字符是数字,或者可以转换为有效数字,则继续解析位置1处的字符,如果不是有 效数字,则直接返回位置0处的有效数字。 第3步,以此类推,按从左到右的顺序,逐个分析每个字符,直到发现非数字字符为止。 第4步,parseInt()将把前面分析合法的数字字符全部转换为数值并返回。 注意:浮点数中的点号对于parseInt来说属于非法字符,因此不会转换小数部分值。如果是以0开 头的数字字符串,则parseInt()不会把它作为八进制数字处理如果是以0x 开头的数字字符串,则 parseInt()会把它作为十六进制数字处理:先把它转换为十六进制数值,然后再转换为十进制的数字 返回。 parseInt(123) 123 parseInt(“a123”) NaN parseInt(“1a123”) 1 parseInt(“10a23”) 10 parseInt(“100px”) 100 parseInt(12.3) 12 parseInt(“0xa”) 12 parseInt(null) NaN parseInt(true) NaN parseInt 支持基模式,把不同进制的数字字符串转换为整数 let a = “abc123”; parseInt(a,16) 11256099 把a当成16进制,转化为10进制输出 let b = “111”; parseInt(b,2) 7 parseInt(5,3) NaN 因为3进制没有5这个字符 特殊情况如下: parseInt(1,1) NaN parseInt(0,1) NaN parseInt(0,0) 0
215. 类型转换之parseFloat()
parseFloat()也是一个全局方法,它可以把值转换成浮点数,即它能够识别第一个出现的小数点, 而第二个小数点视为非法。解析过程和parseInt相同。 parseFloat()的参数必须是十进制的字符串,对十六进制和八进制前的0进行忽略或返回0。 parseFloat(123) 123 parseFloat(12.3) 12.3 parseFloat(“12.3.3”) 12.3 parseFloat(“a12.1”) NaN
二.自动转换
216. 类型转换之算数运算符
如果说变量进行运算就会被自动隐式转换为数字类型,如果无法转换成合法数值就变成NaN 1.一元运算+ let y = ‘5’; let x = +y; x为number类型的5 let y = ‘piggy’; let x = +y; x为NaN 2.乘法 let a = “1”; console.log(a * 1) number类型的 1 let b = “1a”; console.log(b * 1) NaN 3.加法(字符串的加法运算不在此列) let c = 1; console.log(c + true) number类型的 2 let d = 1; console.log(d + NaN) NaN(任何值和NaN做运算都得NaN) 4.除法 let e = “1”; console.log(e / 1) number类型的 1 let f = “1a”; console.log(f / 1) NaN 5.减法 let g = “1” console.log(g - 0) number类型的 1 let h = “1a”; console.log(h - 0) NaN
217. 类型转换之双重逻辑非
JavaScript 遇到预期为布尔值的地方(比如if语句的条件部分),就会将非布尔值的参数自动转换为布尔值。 系统内部会自动调用Boolean函数。 一个逻辑非运算符(!)可以把值转换为布尔值并取反,两个就是转换成正确的布尔值 console.log(!!0) false console.log(!!1) true
218. 事件冒泡以及相关
事件冒泡event bubble
当一个元素接收到事件的时候会把他接收到的事件传给自己的父级,一直到window 。 注意这里传递的仅仅是事件并不传递所绑定的事件函数。所以如果父级没有绑定事件函数,就算传递了 事件也不会有什么表现但事件确实传递了。
事件捕获event capturing
当鼠标点击或者触发dom事件时,浏览器会从根节点开始由外到内进行事件传播,即点击了子元素,如 果父元素通过事件捕获方式注册了对应的事件的话,会先触发父元素绑定的事件。
219. 事件委托以及相关
事件委托Event Delegation
事件委托也称之为事件代理,事件委派。是JavaScript中常用绑定事件的常用技巧。顾名思义,“事件代 理”即是把原本需要绑定在子元素的响应事件委托给父元素,让父元素担当事件监听的职务。事件代理的 原理是DOM元素的事件冒泡。
1.事件委托的优点
1)减少事件注册,节省内存,例如: 在table上代理所有td的click事件。 在ul上代理所有li的click事件。 2)简化了dom节点更新时,相应事件的更新。比如: 不用在新添加的li上绑定click事件。 当删除某个li时,不用移解绑上面的click事件。
2.事件委托的不足
1)事件委托基于冒泡,对于不冒泡的事件不支持。 2)层级过多,冒泡过程中,可能会被某层阻止掉。 3)理论上委托会导致浏览器频繁调用处理函数,虽然很可能不需要处理。所以建议就近委托,比如在 table上代理td,而不是在document上代理td。
if ('abc') { console.log('hello')
} // "hello"
4)把所有事件都用代理就可能会出现事件误判。比如,在document中代理了所有button的click事件, 另外的人在引用改js时,可能不知道,造成单击button触发了两个click事件。
220. 阻止事件冒泡与默认事件的方法
event.stopPropagation()方法
这是阻止事件的冒泡方法,不让事件向documen上蔓延,但是默认事件任然会执行,当你调用这个方法 的时候,如果点击一个连接,这个连接仍然会被打开。
event.preventDefault()方法
这是阻止默认事件的方法,调用此方法是,连接不会被打开,但是会发生冒泡,冒泡会传递到上一层的 父元素。
return false方法
这个方法比较暴力,他会同事阻止事件冒泡也会阻止默认事件;写上此代码,连接不会被打开,事件也 不会传递到上一层的父元素;可以理解为return false就等于同时调用了event.stopPropagation()和 event.preventDefault().
221. application/x-www-form-urlencoded
该值是 Form 默认的编码方式,使用该值时,提交表单时内容必须经过如下规则编码:
- 空格转换为 “+” 号;非字母数字的其它字符转换为类似于“%E0”的两位 16 进制表示的 ASCII 码;换 行符被转换为“CR LF”;
- 数据项名称和数据值以“=”号分割,数据项与数据项之间以“&”分割;
222. multipart/form-data
对于二进制文件或者非 ASCII 字符的传输,application/x-www-form-urlencoded是低效的。对于包
含文件、二进制数据、非 ASCII 字符的内容,应该使用multipart/form-data 。multipart/form-
data的请求体包含多个部分,需要通过 boundary 字符分割。
223. application/json
application/json以序列化的 JSON 字符串形式传输,更易于解析和使用,可读性更高。常用于传输 各类以对象或数组形式组织的数据
224. application/octet-stream
用于传输二进制数据。可用于上传文件的场景。在 Postman 中,还可以看到 “binary” 这一类型,指的 就是一些二进制文件类型。如application/pdf ,指定了特定二进制文件的 MIME 类型。就像对于 text文件类型若没有特定的子类型(subtype),就使用text/plain 。类似的,二进制文件没有特定 或已知的 subtype,就使用application/octet-stream ,这是应用程序文件的默认值,一般很少直接 使用。
225. application/javascript application/x-javascript text/javascript
传统的js程序对应的MIME类型为text/javascript,在学习JSONP时使用过这种形式,除此之外还 有”application/x-javascript”(x前缀表示这是实验性类型)等其他形式,因为text/javascript是最常见 的类型,所以RFC4329定义了“text/javascript”。
其它常见值
文本:text/plain、text/html、text/css、application/javascript、text/xml 图片:image/gif、image/png、image/jpeg 视频:video/webm、video/ogg 音频:audio/midi、audio/mpeg、audio/webm、audio/ogg、audio/wav 二进制:application/octet-stream、application/pdf、application/json
数据库
MongoDB
MySQL
数据库类 型 非关系型 关系型 存储方式 以类JSON的文档的格式存储 不同的引擎有不同的存储方 式 查询语句 MongoDB查询方式(类似JavaScript函数) SQL语句 数据处理 方式 基于内存,将热数据存放在物理内存中,从而达到 高速读写 不同的引擎有自己的特点 成熟度 新型数据库,成熟度较低 成熟度高 广泛度 NoSQL数据库中,比较完善且开源,使用人数不断 增加 开源数据库,市场份额不断 增长 事务性 仅支持单文档事务操作,弱一致性 支持事务操作 占用空间 占用空间大 占用空间小 join操作 MongoDB没有join MySQL支持join
226. HTTP的常用方法
1)、GET方法
GET方法用于使用给定的URI从给定服务器中检索信息,即从指定资源中请求数据。使用GET方法的请求 应该只是检索数据,并且不应对数据产生其他影响。 在GET请求的URL中发送查询字符串(名称/值对),需要这样写: 说明: GET请求是可以缓存的,我们可以从浏览器历史记录中查找到GET请求,还可以把它收藏到书签中;且 GET请求有长度限制,仅用于请求数据(不修改)。 注:因GET请求的不安全性,在处理敏感数据时,绝不可以使用GET请求。
`/test/demo_form.php?name1=value1&name2=value2`
2)、POST方法
POST方法用于将数据发送到服务器以创建或更新资源,它要求服务器确认请求中包含的内容作为由URI 区分的Web资源的另一个下属。 POST请求永远不会被缓存,且对数据长度没有限制;我们无法从浏览器历史记录中查找到POST请求。
3)、HEAD方法
HEAD方法与GET方法相同,但没有响应体,仅传输状态行和标题部分。这对于恢复相应头部编写的元数 据非常有用,而无需传输整个内容。
4)、PUT方法
PUT方法用于将数据发送到服务器以创建或更新资源,它可以用上传的内容替换目标资源中的所有当前 内容。 它会将包含的元素放在所提供的URI下,如果URI指示的是当前资源,则会被改变。如果URI未指示当前 资源,则服务器可以使用该URI创建资源。
5)、DELETE方法
DELETE方法用来删除指定的资源,它会删除URI给出的目标资源的所有当前内容。
6)、CONNECT方法
CONNECT方法用来建立到给定URI标识的服务器的隧道;它通过简单的TCP / IP隧道更改请求连接,通 常实使用解码的HTTP代理来进行SSL编码的通信(HTTPS)。
7)、OPTIONS方法
OPTIONS方法用来描述了目标资源的通信选项,会返回服务器支持预定义URL的HTTP策略。
8)、TRACE方法
TRACE方法用于沿着目标资源的路径执行消息环回测试;它回应收到的请求,以便客户可以看到中间服 务器进行了哪些(假设任何)进度或增量。
227. 哪一种情况下使用post,哪一种情况下使用get
两者差异
- get是从服务器上获取数据,post是向服务器传送数据。
- get是把参数数据队列加到提交表单的ACTION属性所指的URL中,值和表单内各个字段一一对应, 在URL中可以看到。post是通过HTTP post机制,将表单内各个字段与其内容放置在HTML HEADER内一起传送到ACTION属性所指的URL地址。用户看不到这个过程。
- 对于get方式,服务器端用Request.QueryString获取变量的值,对于post方式,服务器端用 Request.Form获取提交的数据。
- get传送的数据量较小,不能大于2KB。post传送的数据量较大,一般被默认为不受限制。但理论 上,IIS4中最大量为80KB,IIS5中为100KB。
- get安全性非常低,post安全性较高。但是执行效率却比Post方法好。
228. 若符合下列任一情况,则用POST方法:
请求的结果有持续性的副作用,例如,数据库内添加新的数据行。 若使用GET方法,则表单上收集的数据可能让URL过长。 要传送的数据不是采用7位的ASCII编码。
229. 若符合下列任一情况,则用GET方法:
请求是为了查找资源,HTML表单数据仅用来帮助搜索。 请求结果无持续性的副作用。 收集的数据及HTML表单内的输入字段名称的总长不超过1024个字符
230. RBAC的概念:RBAC 是基于角色的访问控制(Role-Based Access Control)。
要有角色?请问角色是谁?用户—角色 接收控制?什么需要控制? 用户:想要操纵资源的对象 角色:某一些用户归纳为一类角色 资源:对应到系统中,所谓资源就是我们需要开发的不同的功能板块 1)所有菜单板块的内容,菜单级资源 2)添加、修改、删除资源的时候,每一个资源都有相应的控制按钮内容,按钮级资源
231. 权限控制有三大类:
1.菜单级控制(99%) 2.按钮级控制(60%) 3.数据级控制(10%)
232. 操作步骤:
1)预设资源,菜单资源有没有预设,按钮资源有没有预设(按钮资源应该是在每一项菜单资源中做相应 的限制) 2)管理用户(除了普通的增、删、改、查,还必须多出一个操作功能,是授权,这个授权是授角色) a.用户对于角色授权的操作应该是一对多 b.一个用户可以拥有多个角色的权限(从代码层需要考虑的问题会很多) c.一个角色也会拥有多个用户(也是一对多) d.因为上述的两个一对多,最终形成N对N多对多的关系 举个例子: 对产品模块需要进行管理 1.超管:所有产品管理的权限(添加、修改、删除、查询、多个删除、审核发布..) 2.网管:有修改、删除、查询的权限 3.一般管理:只有添加权限、查询权限,没有修改和删除权限 3)角色管理 a.普通角色在进行增、删、改的时候很简单 b.但是角色应该有一个功能是角色授权,也就是给这个角色分配(1.菜单资源;2.对应的菜单资源项里 的按钮权限)
233. 面试的时候如何说权限模块
1.我们之前的项目有比较完善的权限管理模块,采用模式是RBAC基于角色的授权控制 2.项目模块的权限管理有三大核心板块,包括用户管理、角色管理以及资源管理 3.这三个板块基础是资源管理,事实上资源管理是相对固定,资源的增、删是会影响整个项目的版本的 4.资源事实上就是菜单级权限,但它又与按钮级权限控制相关联,所以在给资源进行处理的时候就需要 赋予相应的菜单资源的按钮权限 5.想要将用户与资源之间建立起关系可以通过角色来进行桥接,所以只需要给用户进行一个识别,确定 用户拥有多少个角色身份即可 6.用户与角色之间的关联是多对多之间的关联,所以在整个RBAC权限管理模块,就是角色的权限分配是 最复杂 7.角色的权限分配事实上是角色的菜单资源以及按钮资源的分配操作 用户一登录,就知道是谁,并且清楚他有什么角色身份,就能够算清楚他有什么菜单资源(能够显示左 侧菜单导航) 菜单资源是与routes路由模块相挂钩 想要确认这一个模块它有什么样的按钮权限,前提需要知道你操作的是什么资源菜单(按钮的权限是数 组)checkPermission RBAC权限管理虽然它的工作内容与难点主要集中在后端,但是我对于这个权限管理操作流程以及业务模 式还是比较熟悉与了解的,这也便于我与后台开发工程师之间的沟通与衔接。
234. 一个项目里的核心板块有哪些:
1.权限管理模块 2.用户管理模块 3.分类管理模块
235. JSONP原理
JSONP 的原理是利用
对比项
cookie
sessionStorage
localStorage
存储大小
4KB 左右
5MB 左右
5MB 左右
生命周期 可设置过期时间,默认会 话关闭失效 仅当前会话,关闭标签 / 窗口即销毁 永久存储,手动清除 才失效 与服务端 通信
每次请求自动携带在请求
头
仅在浏览器,不自动发送 仅在浏览器,不自动
发送
作用域 同源窗口共享 同源但不同标签页不共享 同源窗口共享 API 易用 性 原生难用,需自己封装 简单易用:setItem /getItem 简单易用:setItem /getItem 主要用途 登录状态、会话标识、跟 踪 临时页面数据、表单暂存 长期本地缓存、配置 信息
236. cookie、sessionStorage、localStorage的区别
| 维度 | cookie | sessionStorage | localStorage |
|---|---|---|---|
| 大小 | 约 4KB | 约 5MB | 约 5MB |
| 生命周期 | 可设置过期时间 | 关闭标签页即清空 | 永久保存 |
| 随 HTTP 请求携带 | 是 | 否 | 否 |
| 作用域 | 同源 + 路径 | 当前标签页 | 同源 |
| API | document.cookie,较繁琐 | getItem/setItem,简洁 | getItem/setItem,简洁 |
237. 什么是事件传播?
事件传播是事件在 DOM 节点间传递的过程,分为捕获、目标、冒泡三个阶段。浏览器默认使用冒泡机 制,即从子元素向父元素传递,可通过 stopPropagation 阻止传播。
238. 解释 JavaScript 中“this”的工作原理
new→新对象 call/apply/bind→指定对象 对象.方法 ()→该对象 直接调用→ window/undefined 箭头函数→继承外层 this
239. 解释原型继承如何工作
JS 每个对象都有原型对象,通过 proto 指向它。访问属性时,自身没有就沿着原型链往上找,这就是原
型继承。方法定义在 prototype 上可被所有实例共享,最终所有对象都继承自 Object.prototype。
- 当你访问对象的一个属性 / 方法时: 先在对象自身找 找不到→去它的__proto__ (原型对象)找 还找不到→继续往原型的原型找 直到null (最顶层)
- 这条链就是原型链。
3. 所有对象最终都继承自Object.prototype 。
240. null、未定义或未声明的变量之间有什么区别?
null 是主动赋值的空对象;undefined 是已声明未赋值的默认值;未声明变量是从未定义过,直接使用 会报错。null == undefined 为 true,全等为 false,typeof 未声明变量不会报错而是返回 undefined。
241. 什么是闭包,以及如何/为什么使用闭包?
闭包就是内部函数引用外部函数变量,使变量不被回收。
作用是私有化变量、缓存状态、保存上下文。
优点是能持久化状态,缺点是可能造成内存泄漏。
作用:让外部函数的变量不会被垃圾回收,长期保存在内存中。
242. call和apply有什么区别
call 和 apply 都能改变函数的 this 指向并立即执行,区别仅在于参数形式:call 接收参数列表,apply 接收数组参数。 call:参数一个个传 apply:参数放在数组里
243. CORS 代表什么以及它解决什么问题
CORS(Cross-Origin Resource Sharing)是跨域资源共享,是解决浏览器跨域请求限制的官方标准方 案。通过后端设置响应头,允许指定域名访问接口,支持所有请求方式和 Cookie,比 JSONP 更安全强 大。
工作原理:
浏览器发送跨域请求时,自动在请求头带上Origin (当前域名)。
functionouter(){
let count=0; // 被闭包“包住”的变量
returnfunctioninner(){
count++;
console.log(count);
};
}
const fn =outer();
fn(); // 1
fn(); // 2
func.call(thisArg, arg1, arg2, arg3...)
func.apply(thisArg, [arg1, arg2, arg3...])
特性
var
let
const
作用域
函数级作用域
块级作用域
块级作用域
变量提升 有,值为 undefined 有,但暂时性死区 同 let 重复声明 允许 不允许 不允许 重新赋值 可以 可以
不可以
声明可不赋值 可以 可以
必须赋值
对比项
数组 Array
集合 Set
是否允许重复
允许重复
自动去重
是否有序
有序,按插入顺序排列 有序(ES6+),但无索引
访问方式
通过下标arr[i]
不能通过下标访问
查找元素
includes / indexOf慢 O (n)
has()极快O(1)
占用内存
相对较低 相对较高
常用方法
push、pop、splice、map、filter
add、delete、has、clear
后端在响应头里配置允许的域、方法、请求头。 浏览器检查响应头,允许则正常返回数据,否则拦截报错。
后端配置:
Access-Control-Allow-Origin :允许哪些域名(最重要)
Access-Control-Allow-Methods :允许的请求方法(GET、POST、PUT 等)
Access-Control-Allow-Headers :允许的请求头
Access-Control-Allow-Credentials :是否允许携带 Cookie
244. 解释let、var和const之间的区别
var:函数作用域、可重复声明、无块级、有变量提升。 let:块级作用域、不可重复声明、有暂时性死区、可修改。 const:块级作用域、声明必须赋值、不可重新赋值,适合常量。
245. 集合与数组有什么区别
数组有序、可重复、支持下标访问;集合无重复、无下标、查找更快。Set 常用于去重和快速判断存 在,Array 用于需要顺序和下标的场景。
246. 你能举一个解构对象或数组的例子吗
解构就是快速从数组或对象中取出值,赋值给变量,代码更简洁。 数组解构 对象结构 函数参数解构(面试高频)
247. ES2015 和 ES6 有什么区别
ES6 和 ES2015 是同一个标准的两种叫法,ES6 是版本号,ES2015 是官方年份名称,之后的版本都改用 年份命名,比如 ES2016、ES2017。
248. “use strict”有什么作用?
use strict 是开启 JS 严格模式,让语法检查更严格 ①禁止意外创建全局变量 不声明直接赋值会报错。 ②禁止删除变量、函数
delete obj不允许。
// 普通写法
letarr= [10, 20, 30];
leta=arr[0];
letb=arr[1];
// 解构写法
let [a, b, c] = [10, 20, 30];
console.log(a); // 10
console.log(b); // 20
letuser= { name: "张三", age: 20 };
// 普通写法
letname=user.name;
letage=user.age;
// 解构写法
let { name, age } =user;
console.log(name); // 张三
console.log(age); // 20
functionprint({ name, age }){
console.log(name, age);
}
print({ name: "李四", age: 25});
对比项
GET
POST
参数位置
在URL里 在请求体 body里
数据大小
小,受 URL 长度限制 大,理论无限制
安全性
低,参数可见 相对高,参数不可见
缓存
会被浏览器缓存 默认不缓存
书签 / 历史
可收藏、保留历史 不可以
编码类型
只支持 URL 编码 支持多种(form-data、json 等)
后退 / 刷新
无害 数据会重新提交
语义
获取数据
提交 / 修改数据
③禁止重复参数名
function(a,a){}报错。
④禁止八进制前缀 0
let num = 0123;报错。
⑤禁止this指向 window
普通函数中this = undefined 。
⑥不允许使用with 、callee 、caller等废弃语法。
249. HTTP GET 和 POST 请求有什么区别
- 参数位置:GET 拼在 URL 上(长度受浏览器限制),POST 放在请求体里(大小基本不受限)。
- 缓存与幂等:GET 会被浏览器缓存、语义上幂等,适合查询;POST 不缓存,适合写操作。
- 编码:GET 只支持 URL 编码,POST 支持多种 Content-Type(表单、JSON、文件上传)。
- 安全:两者都是明文传输,敏感数据都必须走 HTTPS。
250. 使用回调、promise、await 和 async 处理异步调用。使用每种方法来处理异步调用有何优缺点
回调:最原始,简单但易陷入回调地狱,错误处理混乱。 Promise:解决回调地狱,支持链式调用和并发,但仍有 then 链。 async/await:基于 Promise,写法像同步,最优雅、最易维护,是目前最佳方案。
251. “Object.create”和“new”有什么区别?
Object.create和new之间的区别在于它们如何创建和初始化对象。Object.create(proto)使用
指定的原型对象创建一个新对象,而不调用构造函数。 另一方面,“new Constructor()”创建一个新对象,调用构造函数,将新创建的对象设置为构造函数中 “this”的值,并返回新创建的对象。
特性
浅拷贝
深拷贝
拷贝层级 仅第一层 所有层级(递归) 深层对象 共享引用 完全独立 修改深层 互相影响 互不影响 性能 快 较慢 适用 扁平数据 嵌套深、复杂对象
对比项
普通函数
箭头函数
this 指向
由调用方式决定,动态可变 继承外层作用域的 this,无法修改
构造函数
可以用new
不能 new,会报错
arguments
有
没有
prototype
有
没有
yield
可作为 Generator 函数
不能使用 yield
写法
完整繁琐 简洁,单行可省略{}和return
252. 深拷贝与浅拷贝
浅拷贝只复制一层,引用类型共享同一块内存会互相影响;深拷贝递归复制所有层级,两个对象完全独立(详见「深拷贝与浅拷贝的实现方式」一组题)。
253. JS基础类型和复杂类型
JS数据基础类型有: String、Number、Boolean、Null、undefined五种基本数据类型,加上新增的两种ES6的类型 Symbol、BigInt JS有三种复杂类型(引用数据类型): Object(对象)、Array(数组)、function(函数)
254. 箭头函数与普通函数的区别
箭头函数没有自己的 this(取定义处外层的 this)、没有 arguments、不能用作构造函数(new 报错)、没有 prototype,call/apply/bind 也改变不了它的 this。适合回调和纯计算,不适合对象方法与需要动态 this 的场景。
255. JS垃圾回收机制
JS 通过垃圾回收自动管理内存,主流用标记清除法:标记可达对象,清除不可达对象;需避免意外全局 变量、未清理定时器、闭包滥用等造成内存泄漏。
256. js列举和数组操作相关的方法(常用)
添加元素
push(): 在数组的末尾添加一个或多个元素,并返回新的长度。 unshift(): 在数组的开头添加一个或多个元素,并返回新的长度。
删除元素
pop(): 删除数组的最后一个元素,并返回那个元素。 shift(): 删除数组的第一个元素,并返回那个元素。 splice(): 通过删除、替换或添加新元素来改变数组的内容。
查找元素
indexOf(): 查找元素在数组中的索引。 lastIndexOf(): 从数组的末尾开始查找元素。 find(): 查找第一个满足测试函数的元素。 findIndex(): 查找第一个满足测试函数的元素的索引。
排序和翻转
sort(): 对数组元素进行排序。 reverse(): 颠倒反转数组中元素的顺序。
遍历和过滤
forEach(): 对数组的每个元素执行一次提供的函数。 map(): 创建一个新数组,其结果是该数组中的每个元素都调用一次提供的函数后的返回值。 filter(): 创建一个新数组,包含通过所提供函数实现的测试的所有元素。 reduce(): 对数组中的每个元素执行一个由您提供的reducer函数(升序执行),将其结果汇总为单个返 回值。 reduceRight(): 类似reduce(),但是从数组的末尾开始累加。
归并数组
concat(): 合并两个或多个数组。 slice(): 提取原数组的一部分,返回一个新数组。
其它方法
join(): 将数组的所有元素连接成一个字符串并返回这个字符串。 toString(): 返回一个表示数组内容的字符串。 split(): 把字符串转换成数组。 toLocaleString(): 返回一个表示数组内容的本地化字符串。
257. JS中 “==“和“===“的区别详解
===:三个等号我们称为等同符,当等号两边的值为相同类型的时候,直接比较等号两边的值,值相同 则返回 true,若等号两边的值类型不同时直接返回 false。也就是说三个等号既要判断值也要判断类型 是否相等。 ==:两个等号我们称为等值符,当等号两边的值为相同类型时比较值是否相同,类型不同时会发生类型 的自动转换,转换为相同的类型后再作比较。也就是说两个等号只要值相等就可以。
258. 如何用原生 JS给一个按钮绑定两个 onclick 事件
addEventListener 可以给同一元素重复绑定同名事件,多个监听器依次触发;onclick 属性赋值则会覆盖。
const btn = document.querySelector('button');
btn.addEventListener('click', () => console.log('第一次'));
btn.addEventListener('click', () => console.log('第二次'));
259. 谈谈你对Webpack的理解
Webpack 是前端工程化的核心构建工具,负责把项目里的 JS、CSS、图片、字体等各种资源,模块化解 析、编译转换、压缩优化,最终打包成浏览器能运行的静态资源。
核心概念
①Entry:打包入口 ②Output:打包出口 ③Loader:编译转换非 JS 资源 ④Plugin:扩展打包功能
核心能力
①支持 ES6、TypeScript、Sass 等编译 ②代码分割、懒加载、Tree Shaking ③压缩、混淆、缓存优化 ④开发热更新(HMR)
260. javascript获取元素的值
<buttonid="btn">点击</button>
<script>
//通过事件监听绑定多个事件
letbtn=document.getElementById('btn')
btn.addEventListener('click', one)
btn.addEventListener('click', two)
functionone() {
alert('第一个')
},
functiontwo() {
alert('第二个')
},
</script>
<inputtype="text"id="inp1"/>
<divid="box">
内容部分
</div>
<script>
constval=document.querySelector('#inp1').value
constval2=document.querySelector('#box').innerHTML
constval3=document.querySelector('#box').innerText
</script>
261. jquery的ajax请求属性
常用属性:url(请求地址)、type(请求方式)、data(请求参数)、dataType(预期返回类型 json/text/jsonp…)、async(是否异步,默认 true)、timeout(超时毫秒数)、headers(自定义请求头)、beforeSend(发送前拦截,如显示 loading)、success / error(成功/失败回调)、complete(无论成败都执行)。
262. v-show 与 v-if 的区别
v-show 指令是通过修改元素的display 的CSS 属性让其显示或者隐藏; v-if 指令是直接销毁和重建DOM 达到让元素显示和隐藏的效果; 使用v-show 会更加节省性能上的开销;当只需要一次显示或隐藏时,使用v-if 更加合理。
263. keep-alive 的作用是什么
keep-alive 用于缓存 Vue 组件,避免组件反复创建与销毁,保留组件状态,提升页面切换性能。 核心作用
- 缓存组件实例,组件切换时不被销毁
- 避免重复创建、销毁,大幅提升性能
- 保留组件状态、数据、滚动位置 生命周期(独有的两个)
activated :组件激活时触发
deactivated :组件失活时触发
常用属性 include :只缓存哪些组件 exclude :不缓存哪些组件 max :最大缓存实例数
varformData=newFormData();
formData.append("param1", "value1");
formData.append("param2", "value2");
// 例如添加文件
// formData.append("file", fileInput.files[0]);
$.ajax({
url: "yourserver.com/api/data",
type: "POST",
data: formData,
processData: false, // 告诉jQuery不要处理发送的数据
contentType: false, // 告诉jQuery不要设置Content-Type请求头
success: function(response) {
console.log(response);
}
});
264. Vue2.0和Vue3.0的区别
我给你整理成最常考、最清晰的要点,逻辑非常顺:
265. 响应式原理不同
Vue2:Object.defineProperty ,劫持对象属性
Vue3:Proxy代理整个对象 支持监听新增 / 删除属性 支持数组索引、length 性能更好
266. 生命周期变化
Vue3 支持Composition API(setup) 生命周期改名:
beforeCreate / created→用setup替代
beforeMount→onBeforeMount mounted→onMounted beforeUpdate→onBeforeUpdate updated→onUpdated beforeUnmount→onBeforeUnmount unmounted→onUnmounted
267. 编写方式(最大区别)
Vue2:Options API(data、methods、computed 分开) Vue3:Composition API(setup 组合式,按逻辑聚合) 代码更好维护、复用、类型推导友好
268. 支持 TypeScript
Vue2:对 TS 支持弱 Vue3:TS 从头开发,类型提示极好
269. 虚拟 DOM & 性能
Vue3 对 diff 算法优化:编译时标记静态节点 打包体积更小,Tree-shaking 友好
270. 新组件 / 新功能
<Teleport>传送门
<Suspense>异步组件加载
多根节点:Fragment
271. 指令与插槽
v-model语法统一
函数式组件、自定义指令写法简化
272. Vue3带来了什么改变
性能的提升:
①打包大小减少41% ②初次渲染快55%, 更新渲染快133% ③内存减少54%
源码的升级:
①使用Proxy代替defineProperty实现响应式 ②重写虚拟DOM的实现和Tree-Shaking ③拥抱TypeScript ④ Vue3可以更好的支持TypeScript
新的特性:
① setup配置 ② ref与reactive ③ watch与watchEffect ④ provide与inject
新的内置组件:
① Fragment ② Teleport ③ Suspense
其他改变:
①新的生命周期钩子 ② data 选项应始终被声明为一个函数 ③移除keyCode支持作为 v-on 的修饰符
273. MVVM
MVVM 是 Model-View-ViewModel 的架构模式,通过 ViewModel 实现数据与视图的双向绑定,让数据 变化自动更新视图、视图变化自动同步数据,无需手动操作 DOM,使代码更易维护。
- Model(数据层) 后端接口、本地数据、业务数据。
- View(视图层) 页面、DOM、用户看到的界面。
- ViewModel(视图模型) Vue 实例本身,桥梁: 数据变→视图自动更新 视图变→数据自动更新
双向数据绑定 + 关注点分离
View 和 Model 不直接通信 不用手动操作 DOM 代码更清晰、好维护、好测试
274. Vue实现双向数据绑定的4个方法
v-model 本质是 :value + @input 的语法糖:数据变 → 输入框值更新,输入框输入 → 数据更新。自定义组件上是 modelValue + update:modelValue(Vue3 写法)。底层依赖数据劫持 + 发布订阅驱动视图更新。
275. 使用 v-model 指令实现双向数据绑定
使用 v-model 指令可以很方便地实现双向数据绑定。以下是使用 v-model 指令实现双向数据绑定的步 骤: 在 Vue 实例中定义一个数据属性。 在表单元素上使用 v-model 指令来绑定数据。
276. 使用 .sync 修饰符:
.sync 是 Vue 提供的修饰符,用于实现父子组件之间的双向数据绑定。它可以简化父组件向子组件传递 数据并接收子组件修改后的数据的过程。 父组件传递数据到子组件: 子组件内部修改数据并通知父组件: 在子组件中,使用.sync修饰符将父组件传递的值绑定到子组件的属性上,并通过$emit方法触发 update:前缀的事件来更新父组件的数据。
<template>
<inputv-model="message"type="text">
<p>{{ message }}</p>
</template>
<script>
exportdefault {
data() {
return {
message: ''// 定义一个数据属性
};
}
};
</script>
<inputv-model="message"type="text">
<template>
<child-component:value.sync="data"></child-component>
</template>
<template>
<inputtype="text":value="value"@input="$emit('update:value',
$event.target.value)">
</template>
277. 使用自定义事件
可以通过自定义事件在组件之间实现双向数据绑定。父组件通过 props 传递数据给子组件,子组件在修 改数据时,通过自定义事件将修改后的数据传递给父组件。 父组件传递数据到子组件: 子组件内部修改数据并通知父组件: 在子组件中,通过$emit方法触发input事件,并将修改后的数据传递给父组件。
278. 使用全局状态管理(如 Vuex)
Vuex 是 Vue 的官方状态管理库,它提供了一个集中式的数据存储,用于管理共享的状态。通过在 Vuex 中定义状态和 mutations,可以实现全局的双向数据绑定。 状态定义和修改: 组件中使用和修改状态:
<template>
<child-component:value="data"@input="data = $event"></child-component>
</template>
<template>
<inputtype="text":value="value"@input="$emit('input',
$event.target.value)">
</template>
// 在 Vuex 的 state 中定义数据
state: {
value: ''
},
// 在 mutations 中修改数据
mutations: {
updateValue(state, newValue) {
state.value=newValue;
}
}
<template>
<inputtype="text":value="value"@input="updateValue">
</template>
<script>
import { mapState, mapMutations } from'vuex';
exportdefault {
computed: {
...mapState(['value'])
},
methods: {
...mapMutations(['updateValue'])
}
在组件中使用mapState将状态映射到组件的计算属性中,使用mapMutations将 mutations 映射到 组件的方法中,从而实现对共享状态的双向数据绑定。
279. Vue组件传参的八种方式
常用八种:Props(父→子)、$emit(子→父)、v-model(双向语法糖)、Provide/Inject(跨层级注入)、$attrs/$listeners(属性透传)、$parent/$children(直接访问实例)、Vuex(全局状态)、插槽与事件总线(内容分发/全局事件)。分别见下面各题。
280. Props
Props是Vue中组件之间传递数据的一种常见方式。父组件可以通过props将数据传递给子组件,子组件 通过props选项来接收这些数据。 使用方式: 父组件中定义要传递的数据,并在使用子组件时以属性的形式传递。 子组件中通过props选项来声明要接收的数据。 示例:
}
</script>
<!-- 父组件 -->
<template>
<div>
<child-component:message="parentMessage"></child-component>
</div>
</template>
<script>
importChildComponentfrom'./ChildComponent.vue';
exportdefault {
components: {
ChildComponent
},
data() {
return {
parentMessage: '这是来自父组件的消息'
};
}
};
</script>
<!-- 子组件 -->
<template>
<div>{{ message }}</div>
</template>
<script>
exportdefault {
props: ['message']
};
</script>
281. $emit
emit是Vue中组件之间通过事件进行数据传递的一种方式。子组件可以通过emit方法触发一个自定义事 件,并将数据传递给父组件。父组件可以通过在子组件标签上监听这个自定义事件来接收数据。 使用方式: 子组件中定义要触发的事件,并通过$emit方法传递数据。 父组件中在子组件标签上监听该事件,并定义处理函数来接收数据。 示例:
282. Provide/Inject
Provide/Inject是Vue中组件之间通过依赖注入进行数据传递的一种方式。父组件可以通过provide选项 提供数据,子组件(包括跨层级的子孙组件)可以通过inject选项注入这些数据。 使用方式: 父组件中通过provide选项提供数据。
<!-- 子组件 -->
<template>
<button@click="sendMessage">发送消息给父组件</button>
</template>
<script>
exportdefault {
methods: {
sendMessage() {
this.$emit('childMessage', '这是来自子组件的消息');
}
}
};
</script>
<!-- 父组件 -->
<template>
<div>
<child-component@childMessage="handleChildMessage"></child-component>
</div>
</template>
<script>
importChildComponentfrom'./ChildComponent.vue';
exportdefault {
components: {
ChildComponent
},
methods: {
handleChildMessage(message) {
console.log(message);
}
}
};
</script>
子组件中通过inject选项注入所需的数据。 示例:
283. $attrs 和 $listeners
$attrs:
概述:$attrs 是一个对象,它包含了父作用域中没有被prop接收的所有属性(不包含class和 style属性)。可以通过v-bind=“$attrs” 直接将这些属性传入内部组件,实现父组件隔代向孙组 件传值。 示例:父组件将name 和age 属性传递给子组件,子组件通过v-bind=“$attrs” 将这些属性(以及 可能的其他未声明的属性)传递给孙组件。孙组件通过props 接收这些属性。
<!-- 父组件 -->
<template>
<div>
<child-component></child-component>
</div>
</template>
<script>
importChildComponentfrom'./ChildComponent.vue';
exportdefault {
components: {
ChildComponent
},
provide() {
return {
message: '这是通过provide/inject传递的消息'
};
}
};
</script>
<!-- 子组件 -->
<template>
<div>{{ message }}</div>
</template>
<script>
exportdefault {
inject: ['message']
};
</script>
<!-- 父组件(Parent.vue) -->
<template>
<div>
<h1>父组件</h1>
<ChildComponent:name="parentName":age="parentAge"/>
</div>
</template>
$listeners:
概述:$listeners 是一个对象,它包含了父组件中所有的v-on事件监听器(不包含.native修饰器 的)。可以通过v-on=“$listeners” 将这些事件监听器传入内部组件,实现孙组件隔代向父组件 传值。 举例: 在上述例子中,如果孙组件需要向父组件发送事件,可以通过$emit 触发事件,并在子组件中使 用v-on=“$listeners” 将这些事件传递给父组件。然而,需要注意的是,$listeners 通常用于 孙组件向隔代的父组件发送事件,而不是直接用于父子组件间的通信。在实际应用中,父子组件间 的通信更多地使用$emit 和v-on 。
<script>
importChildComponentfrom'./ChildComponent.vue';
exportdefault {
components: { ChildComponent },
data() {
return {
parentName: 'Tom',
parentAge: 30
};
}
};
</script>
<!-- 子组件(ChildComponent.vue) -->
<template>
<div>
<h2>子组件</h2>
<GrandChildComponentv-bind="$attrs"/>
</div>
</template>
<script>
importGrandChildComponentfrom'./GrandChildComponent.vue';
exportdefault {
components: { GrandChildComponent }
};
</script>
<!-- 孙组件(GrandChildComponent.vue) -->
<template>
<div>
<h3>孙组件</h3>
<p>父组件传递的名字:{{ name }}</p>
<p>父组件传递的年龄:{{ age }}</p>
</div>
</template>
<script>
exportdefault {
props: ['name', 'age']
};
</script>
284. parent和children
parent和children是Vue中组件之间通过访问父组件和子组件实例进行数据传递的一种方式。子组件可以 通过parent属性访问父组件实例,父组件可以通过children属性访问子组件实例(注意:$children是一 个数组,包含了所有子组件的实例,但不保证顺序)。 使用方式: 通过parent或children访问相应的组件实例。 直接在组件实例上访问或修改数据。
示例
注意:通常不建议直接使用$children 进行组件间的通信,因为它可能导致代码难以维护和理 解。如果需要访问子组件的数据或方法,更推荐使用ref 或provide/inject 等机制。
<!--父组件(Parent.vue)-->
<template>
<div>
<h1>父组件</h1>
<ChildComponent />
</div>
</template>
<script>
import ChildComponent from'./ChildComponent.vue';
export default{
components: { ChildComponent },
data(){
return{
parentMessage: 'Hello from Parent'
};
},
methods: {
parentMethod(){
console.log('Parent method called');
}
}
};
</script>
<!--子组件(ChildComponent.vue)-->
<template>
<div>
<h2>子组件</h2>
<button @click="callParentMethod">调用父组件方法</button>
</div>
</template>
<script>
export default{
methods: {
callParentMethod(){
this.$parent.parentMethod();
}
}
285. Vuex
Vuex是Vue中一种专门用于状态管理的插件。通过在Vuex中定义全局的状态,并在组件中使用getter和 mutation来访问和修改状态,可以实现组件之间的数据传递和共享。 使用方式: 安装Vuex并创建store。 在store中定义状态、mutation、action等。 在组件中通过this.$store访问store,并使用getter获取状态,使用mutation或action修改状态。
示例
};
</script>
<!-- 父组件(Parent.vue) -->
<template>
<div>
<h1>父组件</h1>
<ChildComponent/>
</div>
</template>
<script>
import { mapState, mapMutations } from'vuex';
importChildComponentfrom'./ChildComponent.vue';
exportdefault {
components: { ChildComponent },
computed: {
...mapState(['counter'])
},
methods: {
...mapMutations(['increment'])
}
};
</script>
<!-- 子组件(ChildComponent.vue) -->
<template>
<div>
<h2>子组件</h2>
<p>计数器:{{ counter }}</p>
<button@click="increment">增加</button>
</div>
</template>
<script>
import { mapState, mapMutations } from'vuex';
exportdefault {
computed: {
...mapState(['counter'])
},
methods: {
...mapMutations(['increment'])
286. 插槽(Slot)
插槽是一种让父组件能够向子组件指定内容插入点的机制。通过插槽,父组件可以将自己的模板内容 传递给子组件,并在子组件的指定位置渲染出来。 插槽分为默认插槽、具名插槽和作用域插槽三种类型。 使用方式: 在子组件中定义插槽。 在父组件中使用子组件时,通过插槽向子组件传递内容。
示例
默认插槽
默认插槽是最基本的插槽类型,用于在组件内传递和显示任意内容。如果没有给插槽命名, Vue会将内容传递到默认插槽中。
}
};
</script>
<!-- Vuex Store(store.js) -->
import Vue from 'vue';
import Vuex from 'vuex';
Vue.use(Vuex);
export default new Vuex.Store({
state: {
counter: 0
},
mutations: {
increment(state) {
state.counter++;
}
}
});
//子组件
<template>
<divclass="my-component">
<slot></slot><!-- 默认插槽 -->
</div>
</template>
//父组件
<template>
<MyComponent>
<p>This is some default slot content!</p>
</MyComponent>
</template>
具名插槽
具名插槽允许我们在组件中定义多个插槽,每个插槽都有一个唯一的名称。这样可以在组件中 更精确地控制内容的显示位置。
在这个例子中,<h1>Header Content</h1> 将会显示在<slot name="header"></slot> 位置,
<p>Footer Content</p> 将会显示在<slot name="footer"></slot> 位置,而默认插槽中的内
容仍会显示在<slot></slot> 位置。
作用域插槽
作用域插槽是一种特殊类型的插槽,允许我们在父组件中访问子组件的数据。这在需要动态渲 染内容时特别有用。
//子组件(MyComponent.vue)
<template>
<divclass="my-component">
<header>
<slotname="header"></slot>
</header>
<main>
<slot></slot><!-- 默认插槽 -->
</main>
<footer>
<slotname="footer"></slot><!--具名插槽-->
</footer>
</div>
</template>
//父组件
<template>
<MyComponent>
<templatev-slot:header>
<h1>Header Content</h1>
</template>
<p>This is some default slot content!</p>
<templatev-slot:footer>
<p>Footer Content</p>
</template>
</MyComponent>
</template>
//子组件(MyComponent.vue)
<template>
<divclass="my-component">
<slot:data="someData"></slot>
</div>
</template>
<script>
exportdefault {
data() {
return {
someData: 'Hello from MyComponent!'
};
}
287. 事件总线(Event Bus)
事件总线是一个设计模式,它充当一个中间人,负责监听各个组件发布的事件,并分发给订阅这些事件 的其他组件。在Vue中,事件总线通常是一个新的Vue实例,它提供了$emit 、$on 和$off 方法,分别 用于触发事件、监听事件和移除事件监听。 $emit:用于触发事件,并传递相关数据。 $on:用于监听事件,并定义事件触发时的回调函数。 $off:用于移除事件监听,防止内存泄漏。 使用方式: 创建一个空的Vue实例作为事件总线。 组件通过事件总线监听和触发事件来传递数据。
事件总线的实现步骤
- 创建事件总线: 你可以在一个单独的.js 文件中创建一个新的Vue实例,并将其导出为事件总线。 或者,你也可以在Vue项目的入口文件(如main.js )中,将事件总线挂载到Vue的原型上, 使其成为全局可用的。
- 在组件中引入事件总线: 使用import 语句将事件总线引入到你需要使用它的组件中。
- 触发和监听事件: 使用$emit 方法在组件中触发事件,并传递相关数据。 使用$on 方法在另一个组件中监听这个事件,并定义回调函数来处理接收到的数据。
- 移除事件监听: 在组件销毁之前,使用$off 方法移除所有不再需要的事件监听,以防止内存泄漏。
事件总线的例子
- 创建事件总线(event-bus.js):
- 在组件中引入事件总线并使用: ComponentA:
};
</script>
//父组件
<template>
<MyComponentv-slot:default="slotProps">
<p>{{ slotProps.data }}</p>
</MyComponent>
</template>
importVuefrom'vue';
exportconstEventBus=newVue();
<template>
<button@click="sendMessage">Send Message to ComponentB</button>
</template>
ComponentB: 在这个例子中,当ComponentA 中的按钮被点击时,它会通过事件总线触发一个名为message-from-a 的 事件,并传递一条消息。然后,ComponentB 会监听这个事件,并在接收到消息时更新其数据。最后, 在ComponentB 销毁之前,它会移除对message-from-a 事件的监听,以防止内存泄漏。
说说JS的数据类型
- 基本类型 number/string/boolean undefined/null symbol/bigint
- 引用/对象类型 Object/Array/Function 其它内置或自定义类型 注意 number/string/boolean对就的包装类型Number/String/Boolean, 在读取属性或调用方法时会自 动转换 undefined/null 没有对应的包装类型, 不能读取属性或调用方法 symbol/bigint也有对应的包装类型, 但不能我们new调用 ==> 说出它的一些特点就行, 开发中 很少
288. 说说JS如何判断数据类型
6种判断方式
- === undefined null
- typeof string number boolean undefined symbol bigint function object null 所有非函数对象
- instanceof A instanceof B: 判断A或者A原型链上的对象是否是B类型的实例 可以用于判断某个对象是否某个特定类型的 区别Object对象与数组对象
- obj.constructor 得到对象的构造函数 得到number/string/boolean值的包装类型 null/undefined没有constructor
- String.prototype.toString.call(obj) 得到构造函数的名称
- Array.isArray() 专门判断数组
289. 说说常见的数组方法
- 更新数组的7个 push / pop / unshift / shift splice sort / reverse
- 遍历元素 forEach map / filter / reduce find / findIndex every / some
- 其它 slice concat join includes indexOf
290. 函数传参是值传递, 还是引用传递?
函数调用时, 是将实参变量的数据拷贝一份赋值给形参变量 只是实参变量数据可能是基本类型值 ==> 值传递 也可能是引用类型的值(也就是地址值) ==> 引用传递/值传递 注意下面的代码, 准确的说不是将a内存的地址赋值给b, 而是将a中保存的地址值赋值给b
vara= {}
varb=a
vara1=2
vara2= {}
functionfn (x) {
}
fn(a1) // 值传递
fn(a2) // x = a2 拷贝a2内存中保存的值(地址值)传递给x
291. 说说你对作用域与作用域链的理解
作用域 一个变量可以合法使用的范围/区域 作用域起到了隔离变量, 避免了变量重名冲突的问题(也就是允许了不同作用域中可以有同名的 变量) 分类: 全局作用域 函数作用域 块作用域 => ES6的let或const变量 作用域链 多个嵌套的作用域形成的由内向外的结构, 用于查找变量 本质: 包含由内向外的多个变量对象的数组 ==> 这个可以不用说 当查找一个变量, 在整个作用域链中都找不到时: 会报引用错误(RefrenceError), 错误信息 (message)为这个变量没有定义
292. 说说变量提升与函数提升
变量提升( 变量声明提升) 变量声明语句会提升到当前作用域的最前面执行 在变量声明语句之前, 就可以访问到这个变量(undefined) 函数提升( 函数声明提升) 函数声明语句提升到当前作用域的最前面执行 在函数声明语句之前, 就可以执行该函数 原因: 简单来说就是在执行全局代码和函数前会进行预解析/处理 将var变量声明放在最前面执行 将function函数声明放在最前面执行 注意 const / let / class 没有提升 var 变量 / function 函数声明才有提升
293. 区分执行函数定义与执行函数
执行函数定义: 创建函数对象, 如果指定了函数名, 同时会定义变量并指向这个函数对象 执行函数: 执行函数内部的语句 必须先执行函数定义, 再执行函数 ===> 注意: 函数定义有可能会提升到最上面执行
294. 说说你对闭包的理解
是什么? 通过chrome的debugger调试工具得知: 闭包本质是内部函数中的一个容器(非js对象), 这个容器 中包含了引用的变量 如何产生? 嵌套的内部函数引用了外部函数的变量, 当调用外部时就会产生闭包 闭包不是在调用内部函数时产生, 而是在创建内部函数对象时产生 作用? 延长局部变量的生命周期 让函数外部能间接操作内部的局部变量 区别产生闭包与使用闭包及释放闭包? 产生闭包: 内部函数对象创建时产生, 包含那个被引用的变量的容器(不是js对象) 使用闭包: 执行内部函数 释放闭包: 让内部函数对象成为垃圾对象, 断开指向它的所有引用 应用? 举删除删除列表中的的某个商品的例子(带确定框) IIFE 模块编译之后的运行代码 写一个简单的闭包程序
295. 如何判断函数中的this?
常规情况下, 函数中的this取决于执行函数的方式(四种绑定规则) 默认绑定: 直接调用 fn() => 严格模式下是undefined, 非严格模式下是window 隐式绑定: 通过对象调用 obj.fn()=> 对象 显式绑定: 通过call/apply/bind调用 fn.call/apply/bind()=> 第一个参数对象 构造函数绑定: 通过new调用 new fn() => new出来的对象 特殊情况: 箭头函数 ==> this是?外部作用域的this==》沿着作用域链去外部找this bind(obj)返回的函数 ==> this是? obj 回调函数它不是我们调用的 定时器/ajax/promise/数组遍历相关方法回调 ==> this是? window DOM事件监听回调 ==> 发生事件的DOM元素 vue控制的回调函数(生命周期/methods/watch/computed) ==> this是?组件的实例 React控制的生命周期回调, 事件监听回调 ==> this是?组件对象 / undefined
function fn1() {
var a = 2;
var b = 3;
function fn2() {
a++;
console.log(a);
}
return fn2;
}
var f = fn1();
f();
f();
f = null;
296. 如何改变(指定)函数中的this?
情况一: 将任意对象指定为当前函数中的this 函数立即调用: call() / apply() 函数后面某个时候调用: bind() 情况二: 将外部的this指定为当前函数中的this ES6之前: 将外部this保存为其它名称变量, 当前函数中不使用this, 而使用这个变量 ES6之后: 箭头函数
297. 说说原型与原型链
原型 每个函数都有一个显式原型属性: prototype 每个实例都有一个隐式原型属性: proto
实例的__proto__ 与对应函数的prototype 都指向原型对象
函数的默认的原型对象是Object的实例,也就是一个{} 原型对象上有一个constructor 属性指向对应的构造函数 原型链 从对象的__proto__ 开始, 连接的所有对象。也可称为“隐式原型链” 原型链的作用: 在查找对象属性或调用对象方法时,会先在对象自身上查找,找不到就会沿着原型链查 找 利用原型链可以实现继承
298. instanceof的内部原理和自定义实现
作用: 判断一个任意类型对象的具体类型 instanceof内部如何判断? 对于 A instanceof B A是实例对象, B是构造函数 如果B的prototype属性所指向的原型对象是A实例对象的原型链接上的某个对象, 返回true, 否则 返回false 原型链详图 自定义instanceof功能函数
/*
自定义instanceof工具函数:
语法: myInstanceOf(obj, Type)
功能: 判断obj是否是Type类型的实例 实现: Type的原型对象是否是obj的原型链上的某个对象, 如果是返回true, 否则返回false
*/
functionmyInstanceOf(obj, Type) {
// 得到原型对象
letprotoObj=obj.__proto__
// 只要原型对象存在
while(protoObj) {
// 如果原型对象是Type的原型对象, 返回true
if (protoObj===Type.prototype) {
returntrue
}
// 指定原型对象的原型对象
protoObj=protoObj.__proto__
}
returnfalse
}
299. 编码实现继承
基于构造函数的继承 原型链 + 借用构造函数的组合式继承 让子类的原型为父类的实例: Student.prototype = new Person() 让子类型原型的构造器为子类型: Student.prototype.constructor = Student 借用父类型构造函数: Person.call(this, name, age) 基于ES6的类的继承 子类 extends 父类: class Teacher extends Person2 子类构造器中调用父类的构造: super(name, age)
// 父类型
functionPerson(name, age) {
this.name=name
this.age=age
}
Person.prototype.fn=function () {}
Person.prototype.sayHello=function () {
console.log(`我叫${this.name}, 年方${this.age}`)
}
// 子类型
functionStudent(name, age, price) {
// this.name = name
// this.age = age
// 借用父类型的构造函数
Person.call(this, name, age) // 相当于执行this.Person(name, age)
this.price=price
}
// 让子类的原型为父类的实例
Student.prototype=newPerson()
// 让原型对象的构造器为子类型
Student.prototype.constructor=Student
// 重写方法
Student.prototype.sayHello=function () {
console.log(`我叫${this.name}, 年方${this.age}, 身价: ${this.price}`)
}
consts=newStudent('tom', 23, 14000)
s.sayHello()
s.fn()
// 父类
classPerson2 {
constructor (name, age) {
this.name=name
this.age=age
}
fn () {}
sayHello () {
300. 说说面向对象的三大特征
封装: 将可复用的代码用一个结构包装起来, 后面可以反复使用 js的哪些语法体现了封装性: 函数 ==> 对象 ==> 模块 ==> 组件 ==> 库 封装都要有个特点: 不需要外部看到的必须隐藏起来, 只向外部暴露想让外部使用的功能或数据 继承 为什么要有继承? 复用代码, 从而减少编码 js中的继承都是基于原型的继承: ES6的类本质也是 编码实现: 原型链+借用构造函数的组合 / ES6的类继承 多态: 多种形态 理解 声明时指定一个类型对象, 并调用其方法, 实际使用时可以指定任意子类型对象, 运行的方法就是当前子类型对象的方法 JS中有多态: 由于JS是弱类型语言, 在声明时都不用指定类型 在使用时可以指定任意类型的数据 ==> 这已经就是多态的体现了
301. 说说JS的垃圾回收机制
在JS中对象的释放(回收)是靠浏览器中的垃圾回收器来回收处理的 垃圾回调器 浏览器中有个专门的线程,它每隔很短的时间就会运行一次 主要工作:判断一个对象是否是垃圾对象,如果是,清除其内存数据,并标记内存是空闲状 态 如何判断对象是垃圾对象呢?
console.log(`我叫${this.name}, 年方${this.age}`)
}
}
// 子类
classTeacherextendsPerson2 {
constructor (name, age, course) {
super(name, age)
this.course=course
}
// 重写父类的方法
sayHello () {
console.log(`我叫${this.name}, 年方${this.age}, 课程:${this.course}`)
}
}
constt=newTeacher('bb', 34, 'CC')
t.sayHello()
t.fn()
机制1:引用计数法 机制2:标记清除法 V8垃圾回调机制: 分代回收 垃圾回收机制1:引用计数法 最初级的垃圾收集算法: 判断一个对象的引用数,引用数为0 就垃圾对象,引用数大于0 就不 是垃圾对象 问题: 有循环引用问题 如果2个对象内部存在相互引用,断开对象的引用后,它们还不是垃圾对象 垃圾回收机制2:标记-清除法 现代垃圾回收算法的基础: 将可达的对象标记起来,不可达的对象当成垃圾回收 从根对象(也就是window)开始递归深度查找所有引用的对象,并标记为‘活动’,没有标记为 活动的对象就是垃圾对象 没有循环引用问题 问题: 反复对所有可达的对象进行遍历标记, 但有的对象存话时间是较长的,这样效率太低了 V8垃圾回收机制: 分代回收 将堆分为两个空间,一个叫新生代区,一个叫老生代区
302. 区别一下内存溢出与内存泄漏
内存溢出 运行程序需要分配的内存超过了系统能给你分配的最大剩余内存 抛出内存溢出的错误,程序中断运行 演示代码 内存泄漏 理解: 当程序中的某个内存数据不再需要使用,而由于某种原因,没有被释放 常见情况: 意外的全局变量 没有及时清除的定时器 没有及时解绑的监听
const arr = []
for (let index = 0; index < 100000000; index++) {
arr[index] = new Array(1000)
}
function fn () {a = new Array(100000)}
fn()
this.intervalId = setInterval(() => {}, 1000)
// clearInterval(this.intervalId)
this.$bus.$on('xxx', this.handle)
// this.$bus.$off('xxx')
没有及时释放的闭包
303. 区别一下同步与异步
同步: 从上往下按顺序依次执行 只有将一个任务完全执行完后, 才执行后面的 会阻塞后面的代码执行 异步 启动任务后, 立即向下继续执行, 等同步代码执行完后才执行回调函数 不会阻塞后面的代码执行 异步回调函数会即使触发了, 也是要先放入队列中待执行, 只有当同步任务或前面的异步任务执 行完才执行
304. 说一下JS的事件循环机制
JS内部是通过事件循环机制来实现单线程异步执行执行的 分析事件循环机制 所有任务(同步/异步)都在主线程上执行,形成一个执行栈 执行栈之外有用于存储待执行异步回调的任务队列(task queue) ==> 准备的说是2个(宏列队与 微队列) 浏览器中有在其它分线程执行相关管理模块 定时器管理模块 ajax请求管理模块 DOM事件管理模块 JS引擎执行代码的顺序为 在执行栈中执行初始化同步代码 执行过程中如果有启动异步任务, 交给对应的管理模块处理, 管理模块会在后面特定时间 将回调函数放入任务队列中待执行 在执行栈中所有代码都执行完后, 依次取出任务队列中的回调到执行栈中依次执行 宏任务与微任务 script(整体代码) setTimeout / setInterval, Ajax DOM事件监听 postMessage (H5, 向其它窗口分发异步消息) setImmediate(Node.js 环境) 宏队列与微队列 Promise async & await mutationobserver(H5, 监视DOM元素变化) 整体的执行顺序
- script(整体代码)
- 所有微队列中的微任务
- 宏队列中的第一个宏任务
- 所有微队列中的微任务 后面3-4循环处理
305. 说说ES6的promise
ES6推出的更好的异步编程解决方案(相对于纯回调的方式) 解决嵌套回调的回调地狱问题 ==> 通过promise.then的链式调用 指定读取结果数据的回调函数时机更灵活 ==> 请求后/请求前/请求完成后都可以 promise对象有3种状态 pending resolved/fulfilled rejected promise状态的2种变化 pending —> resolved pending —> rejected 如何改变promise的状态 调用resolve() 调用reject() throw error
306. 说说ES6中Promise的then方法
then指定成功和失败的回调, 用于得到成功/失败的结果数据 then()总是返回一个新的promise 新promise的结果状态由then指定的回调函数执行的结果决定 抛出错误 => 失败且reason就是抛出的错误 返回失败的promise => 失败且reason是返回的promise的reason 返回成功的promise => 成功且value是返回的promise的value 返回其它任何值 => 成功且value是返回的值 返回pending的promise => pending的promise
307. 区别Promise的all与race方法
Promise.all([p1, p2, p3]) 接收包含多个promise的数组, 返回一个新的promise 只有当所有接收的promise都成功了, 返回的promise才成功, 且成功的value为所有成功promise 的value组成的数组 一旦有一个失败了, 返回的promise就失败了, 且失败的reason就是失败promise的reason Promise.race([p1, p2, p3]) 接收包含多个promise的数组, 返回一个新的promise 返回的promise的结果由第一个完成的promise决定
308. 说说async与await的理解和使用
async与await是异步编程的终极解决方案 => 消灭回调函数 作用: 简化promise对象的使用, 不用再使用then/catch来指定回调函数 使用 await一般在结果为promise的表达式左侧 async在await所在函数定义的左侧 注意: 调用async函数得到是一个promise, 其结果状态由async函数体执行的结果决定 await的右侧也可以不是promise, 如果不是, 直接返回表达式的值
309. var、let、const之间的区别
const定义常量, let和var定义变量 let相对于var 有块作用域 没有变量提升 不会添加到window上 不能重复声明
310. 箭头函数的特点
编码简洁 没有自己的this, 使用外部作用域中的this, 不能通过bind来绑定this 不能通过new来创建实例对象 内部没有arguments, 可以通过rest参数来代替
311. ES6的模块化语法
导出语法: 整个模块总是一个对象, 所有导出语法都是向模块对象中添加属性或方法 分别导出: export const a = 2 默认导出: export default 3 统一导出: export {b, c} 导入 静态导入 import {a} from ’./test’ import value from ’./test’ import {default as xxx} from ’./test’ import * as test from ’./test’ 静态导入的模块打包到一起 动态导入 import(’./test’).then(module => {}) 动态导入的模块会被单独打包
312. 说出几个ES6常用新语法
const与let 箭头函数 解构赋值 形参默认值 rest/剩余参数 类语法: class / extends / constructor / static /super 扩展运算符: … 模板字符串 异步语法: promise / async & await 对象的属性与方法简写 模块化语法: export / default / import / import() set / map
313. 说说事件冒泡与事件委托
事件冒泡 事件在传递给目标元素后, 会由内向外传递给外层的元素处理 事件委托 不直接给多个子元素绑定多个事件监听, 而是给它们共同的父元素绑定一个监听 当操作任意子元素时, 事件会冒泡到父元素上处理 在事件回调中通过event.target得到发生事件的目标元素, 并进行相关处理
314. HTTP请求的常用响应状态码
2XX: 表示成功处理请求, 如200(成功), 201(添加数据成功) 3XX: 需要重定向, 浏览器直接跳转, 如302(重定向) 4XX: 客户端请求错误, 如: 401(token失效), 404 (不存在) 5XX: 服务器端错误, 如: 500
315. 对原生ajax进行简单的封装
/*
xhr + promise 封装一个异步ajax请求的通用函数简洁版
ajax ('xxx.json')
*/
functionajax(url) {
returnnewPromise((resolve, reject) => {
// 创建一个XHR对象
constxhr=newXMLHttpRequest()
// 初始化一个异步请求(还没发请求)
xhr.open('GET', url, true)
// 绑定状态改变的监听
xhr.onreadystatechange=function () {
/*
ajax引擎得到响应数据后
将xhr的readyState属性指定为4
将响应数据保存在response / responseText属性上
调用此回调函数
*/
// 如果状态值不为4, 直接结束(请求还没有结束)
if (xhr.readyState!==4) {
return
}
// 如果响应码在200~~299之间, 说明请求都是成功的
if (xhr.status>=200&&xhr.status<300) {
// 指定promise成功及结果值
resolve(JSON.parse(xhr.responseText))
} else { // 请求失败了
// 指定promise失败及结果值
reject(newError('request error staus '+request.status))
}
316. 说说你对跨域问题的理解和解决办法
同源: 协议, 域名, 端口, 三者都相同 同源策略 ajax请求时, 浏览器要求当前网页和Server必须同源(安全), 否则会抛出跨域的错误 加载image/link/script不受同源策略限制 解决ajax跨域问题的办法 JSONP CORS Proxy
317. 说说你知道的ajax跨域解决方案
JSONP: 利用script发跨域请求目标接口, 得到响应数据 CORS: 浏览器直接请求跨域的目标接口, 服务器返回响应头告诉浏览器允许跨域 Proxy: 浏览器发同源请求代理服务器, 代理服务器转发请求跨域的目标接口
318. 说说你项目中的axios的二次封装
- 配置通用的基础路径和超时
- 显示请求进度条
- 显示进度条: 请求拦截器回调
- 结束进度条: 响应拦截器回调
- 成功返回的数据不再是response, 而直接是响应体数据response.data
- 统一处理请求错误, 具体请求也可以选择处理或不处理
- 每个请求自动携带userTempId的请求头: 在请求拦截器中实现
- 如果当前有token, 自动携带token的请求头
- 对token过期的错误进行处理
319. 说说axios的整体执行流程
基本执行顺序 请求拦截器的回调函数 xhr发请求 响应拦截器成功/失败的回调 具体请求成功/失败的回调 内部原理: 通过promise.then的链式调用将这4个任务串连越来, 依次执行并进行数据传递
}
xhr.send()
})
}
320. 从输入url到渲染出页面的整个过程
- 得到服务器对应的IP地址 ==> DNS解析
- 通过IP连接上服务器: 3次握手
- 向服务器发请求,接收服务器返回的响应
- 解析响应数据(html/css/js)显示页面 解析html => dom树 解析css => cssom树 解析js => 更新dom树/cssom树 生成渲染树 = dom树 + cssom树 布局 渲染
- 断开连接:4次挥手
321. 说说前台数据存储
Promise.resolve(config)
.then((config) => { // 请求拦截器
// 显示进度/携带token/userTempId
return config
})
.then((config) => { // 使用xhr发ajax请求
return new Promise((resolve, reject) => {
// 根据config创建xhr对象发送异步ajax
// 如果请求成功(响应状态码200--299之间)
const response = {
data: JSON.parse(xhr.responseText),
status: xhr.statusCode
}
resolve(response)
// 如果请求失败
reject(new Error('请求失败 code ' + xhr.statusCode))
})
})
.then( // 响应拦截器
response => {
return response.data
},
error => {
throw error
}
)
.then(result => { // 特定请求的回调
}).catch(error => {
})
322. 自定义call和bind
存储方式:
cookie: 会话/持久化两种
sessionStorage
localStorage
数据库(很少用) 区别:
---------------------sessionStorage VS localStorage
刷新在/ 关闭不在 关闭还在
---------------------cookie VS sessionStorage与localStorage
- 容量 小
- 请求时是否自动携带 会
- API易用性 不好用
- 浏览器是否可禁用 可
/*
自定义函数对象的call方法
*/
functioncall (fn, obj, ...args) {
// 如果传入的是null/undefined, this指定为window
if (obj===null||obj===undefined) {
// obj = window
returnfn(...args)
}
// 给obj添加一个方法: 属性名任意, 属性值必须当前调用call的函数对象
obj.tempFn=fn
// 通过obj调用这个方法
constresult=obj.tempFn(...args)
// 删除新添加的方法
deleteobj.tempFn
// 返回函数调用的结果
returnresult
}
/*
自定义函数对象的bind方法 重要技术:
闭包
call()
三点运算符
*/
functionbind (fn, obj, ...args) {
returnfunction (...args2) {
returncall(fn, obj, ...args, ...args2)
}
}
323. 区别函数节流与防抖
防抖(debounce):事件停止触发 n 秒后才执行一次,期间再触发就重新计时——适合搜索输入、resize 结束处理。节流(throttle):固定时间窗口内最多执行一次——适合滚动加载、鼠标移动。手写实现见下一题。
324. 自定义函数节流与防抖
- 事件高频触发处理的问题 如果更新界面 => 界面更新卡顿 如果发送ajax请求 => 发送了很多没必要的请求
- 解决办法 函数节流 函数防抖
3. 区别:
当事件高频发生很多次时, 防抖只执行最后一次, 而节流执行少量几次 4. 应用场景
节流: 窗口调整(resize)/ 页面滚动(scroll)/ OM元素的拖拽功能实现(mousemove)
防抖: 输入搜索联想功能
/*
用于产生节流函数的工具函数
*/
functionthrottle (callback, delay) {
// 用于保存处理事件的时间, 初始值为0, 保证第一次会执行
letstart=0
// 返回事件监听函数 ==> 每次事件发生都会执行
returnfunction (event) {
console.log('---throttle')
// 发生事件的当前时间
constcurrent=Date.now()
// 与上一次处理事件的时差大于delay的时间
if (current-start>delay) {
// 执行处理事件的函数
callback.call(event.target, event)
// 保证当前时间
start=current
}
}
}
/*
用于产生防抖函数的工具函数
*/
functiondebounce (callback, delay) {
// 返回事件监听函数 ==> 每次事件发生都会执行
returnfunction (event) {
console.log('---debounce')
// 如果还有未执行的定时器, 清除它
if (callback.timeoutId) {
clearTimeout(callback.timeoutId)
}
// 启动延时delay的定时器, 并保证定时器id
callback.timeoutId=setTimeout(() => {
// 执行处理事件的函数
325. 自定义数组扁平化
function flatten(arr) {
return arr.reduce((acc, cur) =>
acc.concat(Array.isArray(cur) ? flatten(cur) : cur), []);
}
flatten([1, [2, [3, [4]]]]); // [1, 2, 3, 4]
326. 自定义new
callback.call(event.target, event)
// 删除保存的定时器id
callback.timeoutId=null
}, delay);
}
}
/*
数组扁平化: 取出嵌套数组(多维)中的所有元素放到一个新数组(一维)中
如: [1, [3, [2, 4]]] ==> [1, 3, 2, 4]
*/
/*
方法一: 递归 + reduce() + concat() + some()
*/
functionflatten1 (array) {
returnarray.reduce((pre, item) => {
if (Array.isArray(item) &&item.some((cItem=>Array.isArray(cItem)))) {
returnpre.concat(flatten1(item))
} else {
returnpre.concat(item)
}
}, [])
}
/*
方法二: ... + some() + concat()
*/
functionflatten2 (arr) {
// 只要arr是一个多维数组(有元素是数组)
while (arr.some(item=>Array.isArray(item))) {
// 对arr进行降维
arr= [].concat(...arr)
}
returnarr
}
/*
自定义new工具函数
语法: newInstance(Fn, ...args)
功能: 创建Fn构造函数的实例对象
实现: 创建空对象obj, 调用Fn指定this为obj, 返回obj
*/
functionnewInstance(Fn, ...args) {
327. 自定义深拷贝
// 创建一个新的对象
constobj= {}
// 执行构造函数
constresult=Fn.apply(obj, args) // 相当于: obj.Fn()
// 如果构造函数执行的结果是对象, 返回这个对象
if (resultinstanceofObject) {
returnresult
}
// 给obj指定__proto__为Fn的prototype
obj.__proto__=Fn.prototype
// 如果不是, 返回新创建的对象
returnobj
}
/*
1). 大众乞丐版 问题1: 函数属性会丢失 问题2: 循环引用会出错
*/
exportfunctiondeepClone1(target) { // 从后台获取的数据都可以用
returnJSON.parse(JSON.stringify(target))
}
/*
获取数据的类型字符串名
*/
functiongetType(data) {
returnObject.prototype.toString.call(data).slice(8, -1) // -1代表最后一位
}
/*
2). 面试基础版本 解决问题1: 函数属性还没丢失
*/
functiondeepClone2(target) {
consttype=getType(target)
if (type==='Object'||type==='Array') {
constcloneTarget=type==='Array'? [] : {}
for (constkeyintarget) {
if (target.hasOwnProperty(key)) {
cloneTarget[key] =deepClone2(target[key])
}
}
returncloneTarget
} else { // 基本类型 / function
returntarget
}
}
/*
3). 面试加强版本 解决问题2: 循环引用正常
*/
functiondeepClone3(target, map=newMap()) {
consttype=getType(target)
if (type==='Object'||type==='Array') {
// 从map容器取对应的clone对象
letcloneTarget=map.get(target)
// 如果有, 直接返回这个clone对象
if (cloneTarget) {
returncloneTarget
}
cloneTarget=type==='Array'? [] : {}
// 将clone产生的对象保存到map容器
map.set(target, cloneTarget)
for (constkeyintarget) {
if (target.hasOwnProperty(key)) {
cloneTarget[key] =deepClone3(target[key], map)
}
}
returncloneTarget
} else {
returntarget
}
}
deepClone3(obj)
/*
4). 面试加强版本2(优化遍历性能)
数组: while | for | forEach() 优于 for-in | keys()&forEach()
对象: for-in 与 keys()&forEach() 差不多
*/
functiondeepClone4(target, map=newMap()) {
consttype=getType(target)
if (type==='Object'||type==='Array') {
letcloneTarget=map.get(target)
if (cloneTarget) {
returncloneTarget
}
if (type==='Array') {
cloneTarget= []
map.set(target, cloneTarget)
target.forEach((item, index) => {
cloneTarget[index] =deepClone4(item, map)
})
} else {
cloneTarget= {}
map.set(target, cloneTarget)
Object.keys(target).forEach(key=> {
cloneTarget[key] =deepClone4(target[key], map)
})
}
returncloneTarget
328. 实现数组的冒泡排序和sort排序
function bubbleSort(arr) {
for (let i = 0; i < arr.length - 1; i++)
for (let j = 0; j < arr.length - 1 - i; j++)
if (arr[j] > arr[j + 1]) [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
return arr;
}
329. 说说重排(回流)与重绘
页面显示过程 解析HTML生成DOM树 解析CSS生成CSSOM树 解析JS更新DOM树和CSSOM树 DOM树 + CSSOM树生成渲染树 布局(也称回流, 确定个节点显示的位置) 渲染绘制
} else {
returntarget
}
}
/*
冒泡排序的方法
*/
functionbubbleSort (array) {
// 1.获取数组的长度
varlength=array.length;
// 2.反向循环, 因此次数越来越少
for (vari=length-1; i>=0; i--) {
// 3.根据i的次数, 比较循环到i位置
for (varj=0; j<i; j++) {
// 4.如果j位置比j+1位置的数据大, 那么就交换
if (array[j] >array[j+1]) {
// 交换
// const temp = array[j+1]
// array[j+1] = array[j]
// array[j] = temp
[array[j+1], array[j]] = [array[j], array[j+1]];
}
}
}
returnarr;
}
constproducts= [{price: 23, sales: 103}, {price: 22, sales: 101}]
/*
根据销量升序
*/
products.sort((p1, p2) => { // 比较函数 ==> 返回数值 如果大于o, p2放在左边
returnp1.sales-p2.sales
})
更新DOM或Style 可能会导致局部重排(也称回流, 重新布局) 可能会导致局部重绘 注意: 重排肯定会重绘, 但重绘不一定有重排 重排比重绘开销更大, 更消耗性能 哪些操作会导致重排 浏览器窗口尺寸改变 元素位置和尺寸发生改变的时候 新增和删除可见元素 内容发生改变(文字数量或图片大小等等) 元素字体大小变化。 激活CSS伪类(例如::hover)。 设置style属性 查询某些属性。比如说: offsetTop、offsetLeft、 offsetWidth、offsetHeight、scrollTop、scrollLeft、scrollWidth、 scrollHeight、clientTop、clientLeft、clientWidth、clientHeight 哪些操作会导致重绘 更新元素的部分属性(影响元素的外观,风格,而不会影响布局),比如 visibility、outline、背景色等属性的改变。 例子代码 如何减少重排次数 更新节点的样式,尽量通过类名而不是通过style来更新 分离样式的读定操作,不要将读写操作混合调用 将DOM操作离线处理,比如使用DocumentFragment
四、Vue
330. 什么是 Vue 中的 slot?它有什么作用?
要点:slot 是组件内容分发机制(内容投影/插槽),用于父组件向子组件传入任意结构的 DOM/模板片段,使组件更具复用性和可配置性。
常见类型:
- 默认插槽(unnamed slot)
- 具名插槽(named slot)
- 作用域插槽 / 作用域插槽(scoped slot)——子组件向插槽提供数据,父组件接收并渲染
示例(Vue 3 / Vue 2 语法一致):
子组件 BaseCard.vue:
<template>
<div class="card">
<header class="card-header">
<slot name="header">默认头部</slot>
</header>
<main class="card-body">
<slot>默认内容</slot>
</main>
<footer class="card-footer">
<slot name="footer">默认底部</slot>
</footer>
</div>
</template>
<script>
export default {
name: 'BaseCard'
}
</script>
<style scoped>
.card{border:1px solid #eee;padding:12px;border-radius:6px}
</style>
父组件使用:
<template>
<BaseCard>
<template #header>
<h3>我是头部</h3>
</template>
主体内容在这里
<template #footer>
<button>确定</button>
</template>
</BaseCard>
</template>
作用域插槽示例(子提供数据,父使用):
子组件 ListProvider.vue:
<template>
<ul>
<slot v-for="item in items" :item="item" :index="indexOf(item)"></slot>
</ul>
</template>
<script>
export default {
props: { items: Array },
methods: { indexOf(i){ return this.items.indexOf(i) } }
}
</script>
父组件:
<ListProvider :items="users">
<template #default="{ item, index }">
<li>{{ index }} - {{ item.name }}</li>
</template>
</ListProvider>
331. 在 Vue 渲染模板时,如何保留模板中的 HTML 注释?
要点:Vue 默认会移除模板中的 HTML 注释(<!-- -->)。如果需要保留注释,一般是调试或特定场景。
- 在 Vue 2 中可以使用
v-pre来跳过编译(会保留注释?需谨慎 — v-pre 主要是跳过模板编译并保留原样内容)。 - 在编译阶段保留注释通常不推荐,Vue 的虚拟 DOM 不把注释视为常规节点。
实操建议:如果只是用于调试,直接在渲染前查看源模板或使用开发者工具。若确实需要在 DOM 中保留注释,可在 mounted 时手动插入注释节点。
代码示例(手动插入注释):
<template>
<div ref="container"></div>
</template>
<script>
export default {
mounted(){
const comment = document.createComment('这是保留的注释');
this.$refs.container.appendChild(comment);
}
}
</script>
332. Vue 计算属性的函数名和 data 中的属性可以同名吗?为什么?
要点:不可以(或不应)同名。若同名,会产生冲突,后定义的会覆盖先定义的(Options API 下 Vue 会把 data、props、computed 等合并到实例上,命名冲突会警告或覆盖)。
原理:Vue 将 data、methods、computed 等代理到组件实例(this)上,命名冲突会导致不确定行为。computed 返回的是 getter (和可选 setter),而 data 是响应式数据,混淆会导致难以调试。
示例(错误写法):
data() { return { count: 1 } },
computed: {
count() { return this.count + 1 } // 会造成递归/覆盖问题
}
正确做法:使用不同命名或改为 computedCount。
333. Vue 的 v-show 和 v-if 有什么区别?使用场景分别是什么?
要点:
v-if:真正的条件渲染,会在条件为false时移除/销毁 DOM 节点与组件实例;开销较大(创建/销毁)但在条件很少变更时更合适。v-show:通过 CSSdisplay控制显示/隐藏,始终保留 DOM 节点与组件实例;切换开销小但初始渲染始终会创建元素。适合频繁切换的场景。
选用建议:
- 条件很少改变(如登录后显示某个模块)使用
v-if。 - 频繁切换显示/隐藏(如标签页切换、弹窗显示)使用
v-show。
示例:
<!-- v-if -->
<div v-if="showModal">
<ModalComponent />
</div>
<!-- v-show -->
<div v-show="visible">
<HeavyButFrequentlyToggledComponent />
</div>
334. 如何在 Vue 中使用 defineAsyncComponent 实现异步组件加载?
要点:defineAsyncComponent 是 Vue 3 提供的 API(Vue 2 可使用异步组件工厂函数)。支持加载占位组件、超时、错误处理、延迟展示等。
Vue 3 示例:
import { defineAsyncComponent } from 'vue'
const AsyncComp = defineAsyncComponent({
loader: () => import('./MyHeavyComponent.vue'),
loadingComponent: LoadingSpinner,
errorComponent: ErrorDisplay,
delay: 200, // 延迟显示 loading(ms)
timeout: 10000, // 超时(ms)
onError(error, retry, fail, attempts) {
if (attempts <= 3) {
retry()
} else {
fail()
}
}
})
模板中:
<template>
<AsyncComp />
</template>
Vue 2 示例(异步工厂):
const AsyncComp = () => ({
component: import('./MyHeavyComponent.vue'),
loading: LoadingSpinner,
error: ErrorDisplay,
delay: 200,
timeout: 10000
})
335. 请简单介绍一下你对 Vue 的理解,包括它的特点和优势
要点(面试回答要点):
- 响应式数据驱动视图(Declarative Rendering)
- 组件化(Component-based),易组合与复用
- 渐进式框架:可以逐步引入(只用于视图层或全栈)
- 生态完善:Vue Router、Vuex/Pinia、CLI、Vite 支持
- 性能:虚拟 DOM + 优化策略(Vue 3 使用 Proxy,性能更好)
- 开发体验:单文件组件(SFC)、良好文档、社区活跃
面试包装句: “Vue 是一个以数据驱动视图的渐进式前端框架,强调组件化与简洁的 API,适合快速构建 SPA,同时在大型应用中也能通过组合式架构与成熟的生态(路由、状态管理、工具链)满足复杂需求。”
336. 在 Vue 项目中,你通常如何组织和管理组件?请描述一下你的组件化开发思路
原则:
- 按功能/域(feature)划分目录(Domain-driven folder),而不是按类型(components/services/styles)
- 公共组件库(
/components/ui)与业务组件(/views或/modules/**)分离 - 组件粒度:先抽象小且重复的 UI 组件(Button、Input、Modal),业务组件保持较高层次
- 组件命名:
PascalCase或kebab-case一致性 - 侧重可测试性与文档(Storybook)
- 使用
props+emits明确数据流,尽量避免父子深层传递(使用 provide/inject 或状态管理)
示例目录结构:
src/
components/ # 通用 UI 组件
modules/ # 按业务模块划分
user/
components/
views/
store/
layouts/
router/
store/
组件开发流程(面试回答的流程化思路):
- 识别复用点 -> 抽取组件边界
- 定义
props/slots/emits合约 - 写文档和示例(Story)
- 编写单元测试
- 优化样式与交互(无副作用)
337. Vue 的生命周期钩子有哪些?它们在什么阶段被调用?
Vue 2(Options API)主要钩子:
beforeCreate:实例初始化(响应式未建立)created:实例已创建(可以访问 data、methods、computed,但 DOM 未挂载)beforeMount:模板编译并挂载之前mounted:DOM 已挂载(可以访问$el)beforeUpdate:响应式数据改变但 DOM 还未更新updated:DOM 已更新beforeDestroy:实例销毁前(清理定时器、事件监听)destroyed:实例已销毁
Vue 3(名字略有变化,destroy -> unmount):
beforeUnmount/unmounted(替代 beforeDestroy/destroyed)- 对 Composition API 使用
onMounted,onUnmounted等等
示例(Options API):
export default {
created() { console.log('created') },
mounted() { console.log('mounted') },
beforeUnmount() { console.log('beforeUnmount') }
}
示例(Composition API):
import { onMounted, onUpdated, onUnmounted } from 'vue'
setup(){
onMounted(()=>console.log('mounted'))
onUpdated(()=>console.log('updated'))
onUnmounted(()=>console.log('unmounted'))
}
338. 谈谈你对 Vue 的响应式系统的理解,以及它是如何实现数据的双向绑定的
要点:
- Vue 2:使用
Object.defineProperty的 getter/setter 检测属性访问与修改,不能直接检测新增/删除;通过数组方法重写(push/pop/splice)来拦截变动。 - Vue 3:采用
Proxy,对对象、数组等更全面地拦截(包括新增属性、删除等),性能与实现更简洁。 - 双向绑定(
v-model):在底层是 prop + 事件(modelValue+update:modelValue在 Vue 3),组件监听事件并更新 prop 对应的外部数据,从而形成“类似双向”的交互。
工作原理简述:
- 将数据变为响应式(Vue 2:
defineReactive->Object.defineProperty;Vue 3:reactive使用 Proxy) - 渲染函数/模板收集依赖(在 getter 时收集当前副作用 watcher)
- 当 setter 被触发时,通知相关 watcher 重新渲染或调用 computed/watch
示例(Vue 3 reactive):
import { reactive } from 'vue'
const state = reactive({ count: 0 })
v-model 在父子组件传值上的示例(Vue 3):
父组件:
<Child v-model="name" />
子组件:
<script>
export default {
props: ['modelValue'],
emits: ['update:modelValue'],
methods: {
onInput(e){ this.$emit('update:modelValue', e.target.value) }
}
}
</script>
339. 在 Vue 中,如何进行路由管理?你是否使用过 Vue Router?
要点:
- Vue Router 是官方路由解决方案,支持 SPA 的路由、嵌套路由、路由守卫、动态路由、懒加载等。
- 常见用法:在
router/index.js定义路由表,通过createRouter(Vue 3)或new VueRouter(Vue 2)创建实例,挂载到 App。
Vue 3 + Vue Router 4 示例:
// router/index.js
import { createRouter, createWebHistory } from 'vue-router'
import Home from '@/views/Home.vue'
const routes = [
{ path: '/', name:'Home', component: Home },
{ path: '/users/:id', name:'User', component: () => import('@/views/User.vue'), props: true },
]
const router = createRouter({
history: createWebHistory(),
routes
})
export default router
挂载:
// main.js
import { createApp } from 'vue'
import App from './App.vue'
import router from './router'
createApp(App).use(router).mount('#app')
路由守卫示例(全局):
router.beforeEach((to, from, next) => {
if (to.meta.requiresAuth && !isLoggedIn()) next('/login')
else next()
})
340. 对于 Vue 的状态管理,你有什么经验?是否使用过 Vuex 或其他类似的状态管理库
要点(面试回答):
- 大型应用推荐集中式状态管理(Vuex 或 Pinia),用于跨组件共享、时间旅行、插件生态(持久化、日志、调试)。
- 小型或局部状态可以使用组件组合、
provide/inject、或通过组合式 API 的reactive在模块间共享。 - 我在项目中既使用过 Vuex(V2/V3 时代),也在 Vue 3 项目中使用过 Pinia(更简洁、更 TS 友好)。
经验/实践:
- 使用模块化(namespaced modules)划分业务状态
- 把副作用(API 请求)放在 actions(Vuex)或 stores(Pinia)的 actions 中
- 使用持久化(localStorage)只保存必要状态(token、user),避免过度持久化
- 在 SSR 场景注意状态注水/反序列化
341. 请你说说 Pinia 和 Vuex 的不同
要点:
- API 风格:Pinia 更轻量、基于函数(类似组合式 API),Vuex 更偏配置式(mutations / actions / getters)。
- 写法:Pinia 使用
defineStore,没有 mutations 的强制分层(可直接修改 state 或通过 action 修改);Vuex 需要通过 mutation 修改 state(更明确但冗长)。 - TypeScript 支持:Pinia 原生更友好,类型推断更自然。
- 调试:两者都支持 devtools,但 Pinia 的插件系统更简单。
- 体量与学习成本:Pinia 更小、更易上手,Vuex 适合已有大量 Vuex 代码库的中大型项目迁移成本较高。
Pinia 示例:
// stores/user.js
import { defineStore } from 'pinia'
export const useUserStore = defineStore('user', {
state: () => ({ name: '', token: '' }),
actions: {
setName(n){ this.name = n },
async login(payload){ this.token = await api.login(payload) }
}
})
342. 对于 Vue 的单文件组件(.vue),你对它的结构和用法有什么了解?
要点:SFC(Single File Component)包含三个主要块:
<template>:模板,可写 HTML + 指令<script>:逻辑(Options API / Composition API / setup)<style>:样式(支持 scoped、module、lang=less/scss)
增强功能:
<script setup>(Vue 3)更简洁、自动类型推断<style scoped>:作用域样式- SFC 支持
<script setup lang="ts">、多个<style>等
示例(Vue 3 + script setup):
<template>
<button @click="inc">{{ count }}</button>
</template>
<script setup>
import { ref } from 'vue'
const count = ref(0)
function inc(){ count.value++ }
</script>
<style scoped>
button { padding:8px 12px }
</style>
343. 请分享一些你在 Vue 项目中进行性能优化的经验和技巧
要点与技巧:
- 路由懒加载(按需加载页面组件)
- 组件懒渲染 / keep-alive 控制(避免不必要重复渲染)
- 使用
v-once渲染静态节点 - 减少响应式对象范围:只对必要数据做 reactive/ref
- 避免在模板中做复杂计算;把逻辑放到 computed
- 使用虚拟列表(virtual-scroller)处理长列表
- 使用
watch代替deep大量遍历 - 服务端压缩/HTTP2、CDN、资源预加载、Cache-Control
- 图片懒加载、SVG 优化、合并小资源、代码分割
- 对第三方库进行按需引入(lodash 按需或只引入特定函数)
- 对频繁更新的 DOM 使用
v-show而非v-if(见第 4 点) - 使用性能分析工具(Chrome DevTools、Lighthouse、Vue Devtools)
示例:路由懒加载:
const routes = [
{ path: '/home', component: () => import('@/views/Home.vue') }
]
344. 如果要在 Vue 项目中集成第三方库或插件,你通常会采取哪些步骤?
流程:
- 确认兼容性(Vue 版本、SSR/CSR)
- 查看是否有官方或社区插件(优先)
- 按需引入并做 Tree-shaking(避免整个包引入)
- 在主入口
main.js使用.use()或通过 provide/inject 注入 - 封装适配层(在项目中标准化使用接口)
- 在组件中注入/导入,写测试
- 做性能评估与样式隔离(若会污染全局 CSS)
- 编写使用文档与示例
示例(注册插件):
// main.js
import { createApp } from 'vue'
import App from './App.vue'
import MyLib from 'my-lib'
createApp(App).use(MyLib, { option: true }).mount('#app')
345. 请描述一次你在 Vue 项目中遇到的挑战,并说明你是如何解决它的
示例回答(面试型):
挑战:某项目首屏加载慢(首屏时间 > 3s),业务页面包含多个第三方图表、地图 SDK 与大量初始数据。 分析:通过 Lighthouse 与 Chrome Profile 定位到 JS 大包和阻塞渲染(同域 synchronous 请求、CSSOM 阻塞),以及首次渲染加载大量静态数据。 解决措施:
- 路由层面做懒加载,拆分 chunk。
- 将大型非必要 SDK(地图、图表)按需加载或延迟加载(IntersectionObserver + import())。
- 对接口做分页/延迟加载,首屏仅请求必要数据,次屏请求异步加载。
- 打包优化:使用 Vite + rollup 动态拆包,并开启 gzip/ brotli;移除未用到的 polyfills。
- 使用 SSR/预渲染(如果适合)或 HTML 预渲染部分静态内容。 结果:首屏时间从 3s 降到 1.2s,用户感知显著提升。
346. 请说说 Vue 项目中一般把数据请求这个操作放在那个位置
要点:
- 页面级(视图组件
mounted/setup)通常负责请求页面所需数据。 - 将通用或共享数据放到统一 store(Vuex/Pinia)的 action 中;组件触发 action 获取数据。
- 可把 API 请求封装到
services/api.js层,便于复用与测试。 - SSR 场景会在服务端做数据预取(如
asyncData风格)。
示例(Composition API):
// services/api.js
export async function fetchUser(id){ return await fetch(`/api/user/${id}`).then(r=>r.json()) }
// 页面组件
import { onMounted, ref } from 'vue'
import { fetchUser } from '@/services/api'
setup(){
const user = ref(null)
onMounted(async ()=> { user.value = await fetchUser(1) })
return { user }
}
347. Vue 组件之间的通信方式有哪些?
列表:
- 父子组件:
props/emit - 兄弟组件:通过父组件中转 props 或使用事件总线(不推荐),或使用状态管理(Pinia/Vuex)
- 跨层级:
provide/inject - 全局状态管理:Vuex / Pinia
- 自定义事件总线(EventEmitter)——小型场景可用,但易混乱
- $attrs / $listeners(透传属性/事件)
- 插槽(slot)与作用域插槽(child->parent 数据流)
- DOM 自定义事件(极少使用)
示例(父子):
<!-- Parent -->
<Child :value="count" @update="val => count = val" />
348. 动态给 Vue 的 data 添加一个新的属性时会发生什么?怎样解决?
问题:在 Vue 2 中,直接 this.someNewProp = value 不会使新属性成为响应式(因为 Object.defineProperty 在初始化时未拦截新增属性)。
解决办法:
- Vue 2:使用
Vue.set(this.obj, 'newKey', value)或this.$set(this.obj, 'newKey', value)。 - Vue 3(Proxy):新增属性是响应式的,直接赋值生效。
- 另外的设计建议:尽量在
data中先声明所有预期字段,或使用reactive包装对象并初始化默认值。
示例(Vue 2):
this.$set(this.user, 'age', 25) // 响应式
349. 说说你对 Vue 的 mixin 的理解,有什么应用场景?
要点:Mixin 是一种复用组件逻辑的方式,将一组选项(data、methods、created 等)混入目标组件。但 mixin 会引入命名冲突和隐式依赖,难以追踪数据来源。
应用场景:
- 旧项目中快速复用通用逻辑(如日志、通用方法)
- 当逻辑很小且重复,且不适合状态管理时可短期使用
替代方案(更推荐):
- Composition API(
useXxxhooks)更明确、可组合、类型安全
示例 mixin:
// mixins/logger.js
export default {
created(){ console.log('组件创建', this.$options.name) },
methods: {
$log(msg){ console.log(msg) }
}
}
使用:
import logger from '@/mixins/logger'
export default { mixins: [logger] }
350. Vue 常用的修饰符有哪些,有什么应用场景?
事件修饰符(常用):
.stop:@click.stop阻止事件冒泡.prevent:@submit.prevent阻止默认事件.capture:使用事件捕获.self:只有事件目标是元素本身才触发(常用于遮罩层).once:只触发一次
按键修饰符:
.enter、.esc、.space等或自定义键码.keyCode
表单修饰符:
.lazy:失去焦点或 change 时更新(默认 input 实时).number:把输入转为 Number.trim:去掉首尾空格
指令修饰符:
v-bind的.prop,.camel(用于属性名转换)
示例:
<input v-model.lazy="name" @keyup.enter="onEnter" />
<button @click.stop="onClick">点我</button>
351. Vue 的 computed 和 watch 有什么区别?
要点:
computed:基于依赖缓存的计算属性,适合用于模板绑定或衍生数据;只有相关依赖变化时才重新计算。watch:观察数据变化并执行副作用(异步或开销较大操作),适合数据变化触发异步请求或手动执行逻辑。
使用建议:
- 需要返回值并用于模板/其他计算用
computed - 需要执行副作用(API 调用、手动 DOM 操作)用
watch
示例:
computed: {
fullName(){ return `${this.first} ${this.last}` }
},
watch: {
query: {
handler: _.debounce(function(val){ this.fetch(val) }, 300),
immediate: true
}
}
352. 有写过自定义指令吗?自定义指令的应用场景有哪些?
常见场景:
- 直接操作 DOM:如自动聚焦
v-focus、节流滚动监听、拖拽、权限指令控制元素显示 - 第三方库 DOM 集成(如直接在元素上挂载某 SDK)
Vue 3 自定义指令示例(**v-focus**):
// directives/focus.js
export default {
mounted(el){ el.focus() },
updated(el){ /* 可选逻辑 */ }
}
// main.js
app.directive('focus', FocusDirective)
模板使用:
<input v-focus />
353. SPA 首屏加载速度慢的怎么解决?
策略汇总:
- 路由懒加载 & 代码分割(减少首包体积)
- 延迟/按需加载第三方 SDK(地图、图表)
- 减少初始请求:分页、首屏只请求必要数据
- 使用
prefetch/preload或 HTTP/2、CDN、压缩(gzip/brotli) - SSR 或预渲染以减少白屏(若适用)
- 使用
resource hints(<link rel="preload">) - 优化图片:缩放、WebP、懒加载
- 去掉/延迟执行阻塞 JS(critical JS inlined only)
- 使用浏览器缓存、长缓存策略
- 使用性能指标追踪(Lighthouse, RUM)持续监控
354. Vue 3 有了解过吗?能说说跟 Vue 2 的区别吗?
核心差异:
- 响应式实现:
Proxy(Vue3) vsObject.defineProperty(Vue2) - Composition API:更好的逻辑复用与 TypeScript 支持
- 性能提升:更小 runtime、更快的虚拟 DOM
- Tree-shaking 更友好,生态重写以支持按需引入
- 新的生命周期钩子命名(beforeUnmount/unmounted)
- 更好的 TypeScript 支持与
<script setup>
355. Vue 3 为什么使用 Proxy 拦截数据?
要点:
- Proxy 能拦截更多操作(属性读取、写入、删除、枚举、原型操作等),解决 Vue 2 在新增/删除属性和数组索引上的限制。
- Proxy 性能更优,允许更简洁的实现,且代码更平台友好(更少 polyfill)。
356. Vue 3 新增特性
主要新增(面试摘要):
- Composition API(
setup、ref、reactive、computed) <script setup>语法糖Teleport、Suspense组件- 更快的虚拟 DOM、Proxy 响应式系统
- 更好的 TypeScript 支持
- 新的生命周期钩子和 API(
onMounted等)
357. 如何看待 Composition API 和 Options API
对比与看法:
- Options API:结构化清晰,适合小团队或上手快的场景,代码可读性对初学者友好。
- Composition API:更适合复杂逻辑、逻辑复用(hooks 风格)、TypeScript 支持好。将相关逻辑放在一起,便于维护。
- 实践建议:在团队中可混合使用(Vue 3 支持),对新项目推荐 Composition API(长远收益),对老项目可逐步迁移。
358. Vue 3.0 编译做了哪些优化?
要点:
- 静态提升(static hoisting):把静态节点抽离,减少渲染开销
- 编译时静态树标记:优化 patch 流程
- 更细粒度的依赖跟踪与副作用收集
- 编译器输出更轻量(支持 tree-shaking)
359. watch 和 watchEffect 的区别?
要点(Vue 3):
watch:显式依赖,传入要观察的响应式源(ref、reactive、getter),更适合观察特定变量并执行副作用;可以设置flush(sync/pre/post)等。watchEffect:自动收集依赖(在回调中引用的响应式值),适合立即执行并响应依赖变化的场景;不是用于对比前后值(watch能获得 old/new)。
示例:
// watch
watch(()=>state.count, (newVal, oldVal) => console.log(newVal, oldVal))
// watchEffect
watchEffect(()=> { console.log(state.count) })
360. 如何理解 reactive、ref、toRef 和 toRefs?
要点:
ref(value):创建一个响应式的引用对象,包含.value。用于基本类型或需要单独引用的值。reactive(obj):将对象变为响应式代理(Proxy),直接使用对象属性,不需要.value。toRef(obj, key):把obj[key]转为一个ref,用于把 reactive 对象中的某个属性以 ref 的方式传递或解构而不丢失响应性。toRefs(obj):把 reactive 对象的每个属性都转换成 ref(常用于解构 reactive 对象而不丢失响应性)。
示例:
import { reactive, ref, toRef, toRefs } from 'vue'
const state = reactive({ count: 0, name: 'Alice' })
const countRef = toRef(state, 'count') // countRef.value == state.count
const { count, name } = toRefs(state) // 解构后仍然响应式,count.value 对应原 state.count
const n = ref(3) // 基本类型 ref
361. Vue 的设计哲学 & 核心理念
答案要点(面试话术)
- 简单与渐进式:从 CDN 引入到完整框架,学习曲线平滑。
- 以声明式渲染为中心:模板 -> 数据驱动视图。
- 组件化:把 UI 拆成可复用、隔离的组件。
- 响应式系统为核心:自动追踪依赖、最小更新单元。
- 开发者体验优先:直观 API、良好错误提示、丰富生态(CLI、Router、Pinia)。
可补充谈点
- Vue 把可维护性、性能、开发体验做了折中(例如模板语法更直观)。
- Vue 3 的设计目标:更小的体积、更快的性能、易于树摇(tree-shakeable)。
示例(谈话示例)
“我会把 Vue 的核心归结为:声明式 + 组件化 + 响应式。开发上,我优先把复杂逻辑拆组件、用 Composition API 管理逻辑复用,借助 Pinia 做状态明确化。”
362. Composition-API 与响应式系统整体介绍
答案要点
- Composition API(
setup())提供按功能/业务组织逻辑的能力,便于复用(hook 风格)。 - 响应式系统包含
reactive,ref,computed,watch等,底层基于Proxy做属性拦截与依赖收集。 setup()在组件实例创建阶段执行,返回的数据会暴露给模板。
面试话术
“Composition API 解决了 Options API 在大型组件中逻辑散落的问题,使关注点按功能聚合,便于测试和复用。”
Demo
<!-- Composition API 基本示例 -->
<template>
<div>
<p>count: {{ count }}</p>
<p>double: {{ double }}</p>
<button @click="increment">+1</button>
</div>
</template>
<script>
import { ref, computed } from 'vue';
export default {
setup() {
const count = ref(0);
const double = computed(() => count.value * 2);
function increment() { count.value++; }
return { count, double, increment };
}
};
</script>
363. Composition-API 基础语法讲解
重点 API
setup(props, ctx):初始化逻辑,返回对象暴露给模板。ref(value):创建基本类型响应式引用。reactive(obj):创建深层响应式对象。computed(fn):计算属性,带缓存。watch(source, cb, options):监听副作用。onMounted,onUnmounted等生命周期钩子(在 setup 内使用)。
示例(组合使用)
<template>
<div>
<input v-model="form.name" placeholder="name" />
<p>Hello, {{ greeting }}</p>
<button @click="submit">Submit</button>
</div>
</template>
<script>
import { reactive, computed } from 'vue';
export default {
setup() {
const form = reactive({ name: '' });
const greeting = computed(() => form.name ? `Hi ${form.name}` : 'Please input name');
function submit() { alert(greeting.value); }
return { form, greeting, submit };
}
};
</script>
364. Vue 的响应式陷阱
常见陷阱(面试应答点)
- 直接解构
reactive对象会失去响应性:const { a } = reactiveObj会脱离响应系统。 ref包装对象时,访问嵌套属性可能需要.value或用toRefs/reactive。- 在模板内直接操作
v-for的索引或 key 使用不当导致重用/渲染问题。 - 对数组直接更改索引(例如
arr[3] = x)在 Vue 2 有问题,Vue 3 的 Proxy 已修复大部分,但需注意赋值与变更触发场景。 - 深度监听对象时容易造成性能问题。
修复示例
import { reactive, toRefs } from 'vue';
const state = reactive({ count: 0, nested: { val: 1 } });
// 错误做法(会失去响应)
const { nested } = state; // nested 不再是响应式的 proxy 引用
// 正确做法
const { nested: nestedRef } = toRefs(state); // nestedRef 是 ref,保持响应
365. Vue 响应式底层原理 — Proxy(简述)
核心要点
- Vue3 使用
Proxy为对象创建代理,拦截get/set等操作。 get时收集依赖(在依赖收集阶段记录当前 activeEffect -> key)。set时触发已订阅的 effect 执行(调度更新)。Proxy支持对数组、Map/Set、动态添加属性等更好支持(相较于 Vue2 的defineProperty)。
示例(手写极简版本,面试中可以白板/口述)
// 极简依赖收集示意(非完整实现)
const bucket = new WeakMap();
let activeEffect = null;
function effect(fn) {
activeEffect = fn; fn(); activeEffect = null;
}
function reactive(obj) {
return new Proxy(obj, {
get(target, key) {
if (!activeEffect) return Reflect.get(target, key);
let depsMap = bucket.get(target);
if (!depsMap) bucket.set(target, (depsMap = new Map()));
let deps = depsMap.get(key);
if (!deps) depsMap.set(key, (deps = new Set()));
deps.add(activeEffect);
return Reflect.get(target, key);
},
set(target, key, value) {
const res = Reflect.set(target, key, value);
const depsMap = bucket.get(target);
if (depsMap) {
const deps = depsMap.get(key);
if (deps) deps.forEach(fn => fn());
}
return res;
}
});
}
366. Vue 响应式底层原理 — 依赖追踪机制
要点
- 依赖收集阶段:当执行
effect(即组件渲染或 computed/watcher)时,全局记录当前 activeEffect,在get中把 activeEffect 存到对应 key 的依赖集合。 - 触发阶段:
set时查找对应 key 的依赖,依次执行/调度(队列化、去重、异步刷新)。 - 调度策略:Vue 会把更新放入微任务或 nextTick 队列(批量更新,避免重复渲染)。
- computed 是懒求值:只有被读取时才计算,并在依赖变化时标记为 dirty。
代码示例:computed 实现核心(伪代码)
function computed(getter) {
let value;
let dirty = true;
const runner = () => {
if (dirty) { value = getter(); dirty = false; }
return value;
};
effect(() => {
getter(); // 触发依赖收集
dirty = true; // 当依赖变化时,effect 会把 dirty 置 true
});
return { get value() { return runner(); } };
}
367. Vue 响应式更新 vs React 状态更新
对比要点(面试回答结构化)
- Vue:基于依赖追踪,细粒度更新(只更新受影响的组件/模板片段);响应式对象追踪属性级别。
- React:基于不可变状态(setState / useState)触发组件重新渲染,组件内所有依赖都会重新执行(整体函数组件重新运行),需借助 memo/pureComponent 做局部优化。
- 优点/缺点:
- Vue 的优点:更高效的局部更新、模板更直观。缺点:当大量副作用和复杂依赖时,调试依赖链可能复杂。
- React 的优点:模型简单(全量重新渲染)、易于推理与测试。缺点:可能造成不必要的重复计算,需要额外优化。
面试话术
“面试可以举例:修改对象的某个属性,在 Vue 中只会触发使用该属性的 watcher 或组件片段重新渲染;在 React 中默认会导致整个组件函数运行一次,除非用 memo/selector 等做优化。”
示例对比(伪示意)
- Vue:
<p>{{ user.name }}</p> <!-- 只有 name 被依赖,修改 age 不会重新渲染该绑定 -->
- React:
function Profile({ user }) {
return <p>{user.name}</p>; // 只要父组件 setState 导致 user reference 变化,Profile 会重新渲染
}
368. Vue 常用的生命周期函数
列表(setup 环境下)
beforeCreate/created(Options API,setup 前后)setup()(执行点)onBeforeMount、onMountedonBeforeUpdate、onUpdatedonBeforeUnmount、onUnmountedonActivated/onDeactivated(keep-alive)onErrorCaptured
示例
import { onMounted, onUnmounted } from 'vue';
export default {
setup() {
onMounted(() => console.log('mounted'));
onUnmounted(() => console.log('unmounted'));
return {};
}
};
面试话术
“常见问题:mounted 里访问 DOM 合理,created/ setup 更适合做数据初始化。onBeforeUnmount 可用于清理定时器或取消订阅。”
369. Vue 的副作用清理逻辑
要点
watch返回一个停止函数:const stop = watch(...); stop();onUnmounted用于组件销毁时清理副作用(事件监听、定时器、订阅)。watchEffect的回调接收onInvalidate,用于清理上一次副作用(例如取消请求)。effect/computed内也有调度与清理机制(computed 的缓存、watch 的 lazy/flush 选项)。
示例:watchEffect 清理
import { watchEffect } from 'vue';
setup() {
const stop = watchEffect((onInvalidate) => {
const ctrl = new AbortController();
fetch('/api/data', { signal: ctrl.signal }).then(...);
onInvalidate(() => { ctrl.abort(); }); // 清理上一次的 fetch
});
return { stop };
}
370. 模板语法 — v-if``v-for``v-bind``v-model
要点与注意
v-if与v-for:尽量不要把 v-if 放在 v-for 上的同一元素,否则会在每次迭代执行条件判断。优先在父层做过滤。v-bind缩写:。可以绑定对象:class、:style、v-bind="props"(属性展开)。v-model在 Vue3 支持多个参数和自定义 prop/event 名(v-model:foo),modelValue与update:modelValue约定。key在v-for中很重要,避免复用错误 DOM。尽量使用稳定唯一的 id。
示例
<!-- 不推荐 -->
<li v-for="item in list" :key="item.id" v-if="item.show">{{ item.text }}</li>
<!-- 推荐 -->
<li v-for="item in filteredList" :key="item.id">{{ item.text }}</li>
v-model 自定义组件
<!-- Parent -->
<CustomInput v-model="value" />
<!-- Child -->
<script>
export default {
props: { modelValue: String },
emits: ['update:modelValue'],
setup(props, { emit }) {
const onInput = e => emit('update:modelValue', e.target.value);
return () => h('input', { value: props.modelValue, onInput });
}
};
</script>
371. Vue 的通信基础
方式
- 父子:props + events(emit)。
- 兄弟/跨层级:全局状态管理(Pinia)、provide/inject、event bus(不推荐)。
- 插槽:父向子传渲染内容(可配 scoped slot 实现数据回传)。
- Router params / query 用于页面级通信。
面试话术
“首选 props + event;复杂跨多层共享状态优先 Pinia 或 provide/inject(只作依赖注入,不做全局状态替代)。”
代码示例(父子通信)
<!-- Parent.vue -->
<Child :count="count" @inc="count++" />
<!-- Child.vue -->
<script>
export default {
props: ['count'],
emits: ['inc'],
template: `<div>{{ count }} <button @click="$emit('inc')">+1</button></div>`
};
</script>
372. Provide-Inject 的用法
要点
provide在上层组件提供值,inject在子组件任意深度获取。- 常用于插件、主题、依赖注入(但不用于频繁变更的共享状态,因不是响应式,除非提供
ref/reactive)。 - 可以传默认值。
示例
// Provider.vue
import { provide, ref } from 'vue';
setup() {
const theme = ref('dark');
provide('theme', theme); // 提供 ref 保持响应
return {};
}
// Consumer.vue
import { inject } from 'vue';
setup() {
const theme = inject('theme', ref('light'));
return { theme };
}
373. 插槽 slot 与具名插槽
要点
- 默认插槽(
<slot/>)用于未命名的内容。 - 具名插槽:
<slot name="header"/>与父组件<template #header>...</template>。 - 插槽由父提供,子决定渲染位置,适合高阶组件或容器组件布局。
示例
<!-- MyCard.vue -->
<template>
<div class="card">
<header><slot name="header"></slot></header>
<section><slot></slot></section>
<footer><slot name="footer"></slot></footer>
</div>
</template>
<!-- 使用 -->
<MyCard>
<template #header>Title</template>
Main content
<template #footer>Footer</template>
</MyCard>
374. 插槽作用域(Scoped Slots)
要点
- 子组件通过
<slot :data="x">向父传数据,父用<template #default="{ data }">解构接收。 - 用于渲染高可配置性内容(像表格、列表项自定义渲染)。
示例
<!-- List.vue -->
<template>
<ul>
<li v-for="item in items" :key="item.id">
<slot :item="item">{{ item.text }}</slot>
</li>
</ul>
</template>
<!-- Parent.vue -->
<List :items="things">
<template #default="{ item }">
<strong>{{ item.name }}</strong> - {{ item.desc }}
</template>
</List>
375. Vue-Router 的基本配置与使用
要点
- 创建 router:
createRouter({ history: createWebHistory(), routes })。 - 路由文件化建议:按页/模块组织
views/。 - 在组件内可用
useRouter()(编程式导航)和useRoute()(读取当前 route)。
示例
// router/index.js
import { createRouter, createWebHistory } from 'vue-router';
import Home from '@/views/Home.vue';
import About from '@/views/About.vue';
const routes = [
{ path: '/', component: Home, name: 'home' },
{ path: '/about', component: About, name: 'about' },
];
export const router = createRouter({ history: createWebHistory(), routes });
// main.js
import { createApp } from 'vue';
import App from './App.vue';
import { router } from './router';
createApp(App).use(router).mount('#app');
376. Vue-Router 的路由参数与传参方式
方式
- 动态路由 params:
/user/:id->route.params.id - query:
/search?q=vue->route.query.q - props 传参(组件接收 props):
{ path: '/user/:id', component: User, props: true } - 编程式导航传参:
router.push({ name: 'user', params: { id: 1 }, query: { q: 'x' } })(注意 params 与 name 搭配更稳)
示例
// route config
{ path: '/user/:id', name: 'user', component: User, props: true }
// User.vue
export default {
props: ['id'],
setup(props) {
// props.id 可用,无需从 route 里取
}
};
377. Vue-Router 的路由守卫
类型
- 全局前置守卫
router.beforeEach - 全局解析守卫
router.beforeResolve - 全局后置守卫
router.afterEach - 单路由守卫
beforeEnter - 组件内守卫
beforeRouteEnter,beforeRouteUpdate,beforeRouteLeave
示例:全局守卫做鉴权
router.beforeEach((to, from, next) => {
const requiresAuth = to.meta.requiresAuth;
const loggedIn = Boolean(localStorage.getItem('token'));
if (requiresAuth && !loggedIn) next({ name: 'login', query: { redirect: to.fullPath } });
else next();
});
378. Vue-Router 的路由元信息
要点
- 在路由配置里使用
meta字段(如meta: { requiresAuth: true, title: '首页' })。 - 常用于权限校验、动态标题、面包屑或布局选择。
- 可在
beforeEach或afterEach使用to.meta。
示例
{ path: '/dashboard', component: Dashboard, meta: { requiresAuth: true, layout: 'admin' } }
379. Vue 何时需要全局状态
判断点(面试回答)
- 多个组件或页面需要共享同一份数据(用户信息、权限、主题、购物车)。
- 需要跨层级或跨页面的可预测状态管理(不会频繁变化的小配置信息可用 provide/inject)。
- 要实现时间旅行 / 可追踪变更或复杂缓存策略时(更倾向使用状态管理库如 Pinia)。
面试话术
“若仅父子传递则不用全局;若是多页面、多组件共享并且需要统一操作(登录态、购物车),就上 Pinia。”
380. Pinia 基本用法 — store
示例:简单 store
// stores/counter.js
import { defineStore } from 'pinia';
export const useCounterStore = defineStore('counter', {
state: () => ({ count: 0 }),
getters: {
double: (state) => state.count * 2
},
actions: {
increment() { this.count++; }
}
});
// main.js
import { createApp } from 'vue';
import { createPinia } from 'pinia';
const pinia = createPinia();
createApp(App).use(pinia).mount('#app');
// 组件中使用
import { useCounterStore } from '@/stores/counter';
export default {
setup() {
const counter = useCounterStore();
return { counter };
}
};
381. Pinia 三大核心概念
三大要点
- State:可响应的数据源(
state())。 - Getters:基于 state 的计算(类似 computed)。
- Actions:改变 state 的方法(可以是异步),内部
this指向 store 实例。
面试话术
“Pinia API 简洁,支持模块化、TypeScript 友好,且 store 实例可直接在组件中使用,便于聚合与测试。”
382. Pinia — Store 的响应式解构(常见问题)
问题
- 直接解构 store(如
const { count } = useStore())会脱离响应(变成普通值)。
正确做法
- 使用
storeToRefs把 store 的 state -> refs,或直接在模板中使用store.count。
import { storeToRefs } from 'pinia';
const store = useCounterStore();
const { count } = storeToRefs(store); // count 是 ref,保持响应性
383. Pinia 最小可变点原则
要点
- 把可变状态集中到最小范围(store),其余尽量使用纯计算与组合函数,减少副作用。
- 设计时思考:哪些是源状态(single source of truth),哪些是派生状态(computed)。
- 有利于调试(time-travel、快照)与可测试性。
面试话术
“实际项目中把真实的可变数据放 store,把 UI 局部状态留在组件,能减少冲突与不必要重渲染。”
384. Vue 的自定义指令
用途
- 操作 DOM(聚焦、悬浮提示、长按等),需要直接 DOM 操作时用指令。
API
beforeMount,mounted,beforeUpdate,updated,beforeUnmount,unmounted。
示例(v-focus)
// directives/focus.js
export default {
mounted(el) { el.focus(); }
};
// main.js
app.directive('focus', import('./directives/focus.js'));
// 使用
<input v-focus />
385. Vue 模板编译流程(概述)
步骤
- 模板解析(parse):将模板字符串解析为 AST(抽象语法树)。
- 转换(transform):对 AST 做静态提升、v-for/v-if 转换、slot 编译等优化。
- 代码生成(codegen):生成渲染函数(
render),包含createVNode的调用。 - 运行时(runtime):执行 render,触发响应式依赖收集与 DOM patch。
面试话术
“重要优化点:静态提升(static hoist)减少渲染成本;编译时把模板转换为高效 JS 代码以便 runtime 复用。”
386. Vue 的 diff 算法
要点
- Vue 的 patch 算法参考了 Snabbdom:先对比同层节点(同 key/tag),处理 DOM 复用、props 更新、children diff。
- 对 children 使用双端指针优化(头尾对比)并对中间区使用 key -> index map 进行最少移动(最长递增子序列 LIS)以最少 DOM 操作实现移动最小更新。
- Vue3 在编译阶段生成更高效的 VNode shape & 静态标记,减少 runtime diff 工作。
面试话术
“简述时突出:双端比较 + key map + LIS 最小移动策略,是面试中的高分点。”
387. nextTick 的作用是什么?
要点
nextTick用于在 DOM 更新完成、视图刷新后执行回调(在当前事件循环的微任务/宏任务之后)。- 场景:在修改响应式数据后需要读取更新后的 DOM(例如获取元素尺寸、聚焦、滚动)。
- Vue 内部的 DOM 更新是异步批量的,
nextTick保证在 DOM 更新并渲染完成后执行。
示例
<template>
<div ref="box">{{ text }}</div>
<button @click="change">Change</button>
</template>
<script>
import { ref, nextTick } from 'vue';
export default {
setup() {
const text = ref('a');
const box = ref(null);
async function change() {
text.value = 'longer text';
await nextTick(); // 等待 DOM 更新完成
console.log(box.value.getBoundingClientRect()); // 获取最新尺寸
}
return { text, box, change };
}
};
</script>
388. 区别MVVM与MVC
- MVVM: 前台的技术
- M: Model模型, 也就是包含数据的js对象 ==> data对象
- V: View视图,动态显示模型对象中的数据的页面(前台渲染) ==> 模板页面
- VM: ViewModel视图模型, 通过vm读取model中的数据显示到view上, 同时view输入数据改变, vm也可以将输入数据保存到model中 ==> Vue/组件的实例
- MVC: 后台的技术
- M: Model(模型)包含从数据库中查询得到的数据的对象
- V: View(视图)动态显示模型对象中的数据的页面(后台渲染)
- C: Controller(控制器)接收用户提交的请求参数, 操作数据库生成动态数据并产生模型对象
389. Vue.use()做了什么
- 对象插件: 调用插件对象install方法(传入Vue)来安装插件(执行定义新语法的代码)
- 函数插件: 直接将其作为install来调用(传入Vue)来安装插件(执行定义新语法的代码)
390. 简述一下你对 Vue 的理解
Vue 的作者是尤雨溪,一位华裔前 Google 工程师(Who) Vue 项目于 2014 年正式发布,至今已经有 6 年历史,而在 2020 年 9 月 18 日发布了 3.0.0 版本One Piece。(When) Vue 是一个渐进式 JavaScript 框架,它只负责视图层数据渲染功能,所以就需要很多第三方 库来完善更多的扩展功能,以便完成动态构建用户界面的目标。(What) Vue 技术体系应用的场景非常的多,包括 PC 端 SPA 网站项目、后台管理系统、移动端 Webapp 的 M 站开发、微信小程序的实现以及 App 应用程序的处理等,应该说包含了多端 多设备的不同应用面。(Where) 这是因为 Vue 有其编码简洁、体积小、运行效率高、遵循 MVVM 模式、轻松引入第三方插 件与类库使用,能够快速实现应用程序的开发。(Why) Vue 在国内不同类型公司都广受欢迎,包括大型厂家,美团、饿了吗、阿里等,而中小型企 业发展更追求速度与效率,所以对于 Vue 的需求也更为的明确。
391. 声明式和命令式编程概念的理解
声明式编程 Declarative Programing,主要关注“我想要什么”,而不关注具体该怎么实现, 当你告诉“机器”你想要的是什么(what),让机器想出如何去做(how)。声明式编程的计算在运 行时构建完成。 命令式编程 Imperative Programming,命令“机器”如何去做事情(how),这样不管你想要的 是什么(what),它都会按照你的命令实现,计算机会严格遵循你的指令,而不理会最后的结 果是不是你所想要的。命令式编程的计算在编译时构建完成。JavaScript 并非完全是命令式 编程,例如:数组的 map 方法,即为声明式编程。
392. Vue 有哪些基本特征
声明式编程(没有 DOM 操作) 响应式数据 双向数据绑定
393. vue 之防止页面加载时看到花括号解决方案有哪几种?
v-cloak 用于大段内容,这个指令保持在元素上直到关联实例结束编译。和 CSS 规则如 [v- cloak] { display: none } 一起用时,这个指令可以隐藏未编译的标签直到实例准备完毕
<style>
[v-cloak]{display:none}
</style>
利用 v-text、v-html 代替插值表达式,v-text 用于单个标签、v-html 用于带有标签的处理 {{}}插值表达式是 v-text 的缩写,最终还是会解析成 v-text 的模式
394. Vue 中 v-for 与 v-if 能否一起使用?
不能 这需要考虑到 v-for 与 v-if 的优先级顺序问题,当它们处于同一节点,v-for 的优先级比 v-if 更高,这意味着 v-if 将分别重复运行于每个 v-for 循环中 如果对于整体循环内容的控制,建议将条件判断编写至 v-for 循环的外部 如果需要对每个循环内容进行条件判断的话,建议编写 computed 属性计算进行对应内容的 控制
395. vue 中 v-if 与 v-show 的区别以及使用场景
区别 手段:v-if 是通过控制 dom 节点的存在与否来控制元素的显隐;v-show 是通过设置 DOM 元素的 display 样式,block 为显示,none 为隐藏; 编译过程:v-if 切换有一个局部编译/卸载的过程,切换过程中合适地销毁和重建内部的事件 监听和子组件;v-show 只是简单的基于 css 切换; 编译条件:v-if 也是惰性的,如果初始条件为假,则什么也不做;只有在条件第一次变为真时 才开始局部编译; v-show 是惰性的,在任何条件下都被编译,然后被缓存,而且 DOM 元 素保留; 性能消耗:v-if 有更高的切换消耗;v-show 有更高的初始渲染消耗; 总结: v-if 判断是否加载,可以减轻服务器的压力,在需要时加载,但有更高的切换开销;v-show 调整 DOM 元素的 CSS 的 dispaly 属性,可以使客户端操作更加流畅,但有更高的初始渲染开销。如果 需要非常频繁地切换,则使用 v-show 较好;如果在运行时条件很少改变,则使用 v-if 较好。
396. v-on 可以监听多个方法吗
可以,利用对象设置的方式设置多个监听事件
397. v-on 绑定的修饰符有哪些?v-model 绑定的修饰符有哪些?
v-on 绑定的修饰符主要包括:事件的修饰符:stop、prevent、capture、self、once 等,按 键修饰符:enter、tab、delete、esc、space 等,系统修饰键:ctrl、alt、shift 等。 v-model 绑定的修饰符主要包括:lazy、trim、number
398. Vue 中动态样式绑定的方式有哪些?
不管是 class 类样式还是 style 行内样式,要进行动态样式绑定都需要进行表达式的返回操 作,而 class 绑定时表达式返回的结果可以是:字符串、对象、数组,并且数组中可以包含 的内容包括字符串与对象类型。 而 style 绑定时表达式返回的结果是:对象、数组,数组中包含的是对象。
<inputtype="text"v-on="{ input:onInput, focus:onFocus, blur:onBlur}">
399. Vue 能否通过下标的方式进行数组的响应式数据的修改?Vue 能否通过路径的方式进行对象的响应式数据的修改?为什么?
不能 响应式数据需要在 data 中进行设置,而 data 中设置的响应式数据内容都会被转绑给 vm 实 例对象,如果直接通过 this.xxx 设置的属性能够被挂载到 Vue 实例当中,但它们并不是响应 式数据。 对于数组 Vue 内部对数组提供了一系列变异的方法操作,是对原来的 Javascript 数组操作进 行了内部的重写,只不过 Vue 所提供的数组函数名称与 Javascript 所提供的名称保持一致而 已,而这些数组的方法主要包括:push、pop、shift、unshift、splice、sort、reverse 等 Vue 同样不能检测对象属性的添加或删除,但利用 Vue.set(object, key, value) / Vue.delete(Object,key) 方法可以向嵌套对象添加响应式属性,你还可以使用 vm.$set / vm.$delete 实例方法,它只是全局 Vue.set / Vue.delete 的别名 ::: danger 列表中的 key 设置 为什么 Key 一定需要使用唯一值,如果没有唯一值则需要生成,不建议使用 index 下标进行 key 的设 置?(详见:列表中的 key 设置.html 示例) :::
400. 如果后台接口返回的循环数据没有唯一值,在 v-for 循环中如何设置 key?
key 值在列表渲染的时候,能够提升列表渲染性能,为什么呢?首先得想想 Vue 的页面是如何渲 染的,主要分为以下几步: 将页面结构的文档构建成一个 vdom 虚拟数 页面有新的交互,产生新的 vdom 数,然后与旧数进行比较,看哪里有变化了,做对应的修 改(删除、移动、更新值)等操作(对比 react、小程序) 最后再将 vdom 渲染成真实的页面结构 key 值的作用就在第二步,当数据改变触发渲染层重新渲染的时候,会校正带有 key 的组件,框架 会确保他们被重新排序,而不是重新创建,以确保使组件保持自身的状态,并且提高列表渲染时的 效率。key 值如果不指明,默认会按数组的索引来处理,因而会导致一些类似 input 等输入框组件 的值出现混乱的问题。 不加 key,在数组末尾追加元素,之前已渲染的元素不会重新渲染。但如果是在头部或者中 间插入元素,整个 list 被删除重新渲染,且 input 组件的值还出现了混乱,值没有正常被更 新 添加 key,在数组末尾、中间、或者头部插入元素,其它已存在的元素都不会被重新渲染, 值也能正常被更新 因而,在做 list 渲染时,如果 list 的顺序发生变化时,最好增加 key,且不要简单的使用数组索引 当做 key,需要用唯一值当成 key。 如果后台接口返回的循环数据没有唯一值,那么可以在客户端利用 map 循环对原数组内容进行遍 历,然后返回经处理过带有唯一值的数组列表,那么在 v-for 循环的时候依旧设置的是唯一值数 据。
401. 为什么在-HTML-中监听事件?
扫一眼 HTML 模板便能轻松定位在 JavaScript 代码里对应的方法。 因为你无须在 JavaScript 里手动绑定事件,你的 ViewModel 代码可以是非常纯粹的逻辑,和 DOM 完全解耦,更易于测试。 当一个 ViewModel 被销毁时,所有的事件处理器都会自动被删除。你无须担心如何清理它 们。
402. vue 中 methods、watch、computed 之间的差别对比以及适用场景
methods,watch 和 computed 都是以函数为基础的,但各自却都不同 computed:计算属性是基于其它的响应式依赖进行缓存的,只在相关响应式依赖发生改变 时它们才会重新求值。就算在 data 中没有直接声明出要计算的变量,也可以直接在 computed 中写入。计算属性默认只有 getter,可以在需要的时候自己设定 setter。数据量 大,并需要进行依赖计算的时候使用 computed,因为它会进行缓存处理,提升执行的性 能。computed 应用的场景:一个数据受多个数据的影响。 methods:首先 compunted 属性计算需要实现的目标利用 methods 方法都能够实现,但 是 compunted 基于缓存处理,而 methods 每当触发重新渲染时,调用方法将总会再次执行 函数,从目标性能上来看,如果两者都可以实现目标的话一般建议使用 compunted 而不是 methods。 watch:watch 和 computed 很相似,watch 用于观察和监听页面上的 vue 实例,大部分情 况下我们建议使用 computed,但如果要在数据变化的同时进行异步操作或者是比较大的开 销,那么 watch 为最佳选择。watch 为一个对象,键是需要观察的表达式,值是对应回调函 数。值也可以是方法名,或者包含选项的对象。如果在 data 中没有相应的属性的话,是不能 watch 的,这点和 computed 不一样。watch 应用的场景:一个数据影响多个数据。watch 监控除了编写 watch 对象,还可以利用 vm.$watch 进行 API 模式的监控操作。 immediate:组件加载立即触发回调函数执行 deep: 深度监听:为了发现对象内部值的变化,复杂类型的数据时使用,例如数组中的对象 内容的改变 总结:在 computed、methods、watch 方面,一个是计算,一个是调用、一个是观察,在语义 上是有区别的。计算是通过变量计算来得出数据,调用是方法的重复执行,而观察是观察一个特定 的值。
403. computed 属性计算函数能否传递参数?
可以 compunted 中定义属性计算函数,一般如果没有参数传递,可以直接 return 返回属性计算 的结果 但如果需要传递参数,则计算函数中需要进行 return fn(arg…),而这个返回的函数中可以设 置参数内容,最终属性计算的函数调用将会调用到 return 返回的这个函数内容。
404. Vue 实例中最为重要的三大部分是什么?
{{ compuntedFn(arg) }}
computed: {
compuntedFn: function () {
returnfunction (arg) {
return"compuntedResult"
};
},
},
不管是 Vue 也好或者其它的框架也罢,基本上面向对象以及组件化开发中实例对象都包含三个主 要部分内容: 属性:设置属性,给实例对象内容进行属性的设值操作。 事件:触发事件,由对象提供事件,触发事件以后进行对应功能的处理。 方法:调用方法,方法的调用一般由第三方触发并调用对应的方法内容。 属性、事件是对象本身的操作,而方法一般交由第三方去操作对象本身内容,比如点击按钮去修改 对象的属性操作。
405. 组件在定义与使用的时候一般需要注意哪些细节?
组件中 data 的定义必须是一个函数:每个组件需要拥有自己的数据内容,并且不希望干扰到 其它的组件内容,如果定义成 Object 对象的话,那么将会作用于所有的组件内容,在一个组 件中进行 data 数据修改将会影响到其它组件。所以我们需要将它定义成函数的形式,函数返 回的对象才是真正意义上数据的存储仓库(data),这样设计的目的是为了让每个组件间的数据 都是独立的,互不影响。 当组件的嵌套与 Html5 的规范产生冲突时我们可以使用 is 属性来解决冲突,比如: 组件上的所有事件都是 vue 自定义事件 props 特性属性与 vue 指令在组件中都不会继承,而非 props 特性属性则会进行继承处理
406. Vue 中如何实现块状内容的输出?
块状内容在页面中将不会进行块状标签的输出 Vue:template React:fragment,<> 小程序:block
407. 简述一下组件的生命周期
在进行组件化项目开发的时候都会存在一个组件的生命周期概念,像 Vue、React、小程序等等, 无一例外,而通常情况组件的生命周期主要分成三个阶段,包括:创建、更新以及销毁阶段。 Vue 的生命周期钩子函数主要包括:
- beforeCreate(): 在实例初始化之后调用, data 和 methods 都还没有初始化完成, 通过 this 不 能访问
- created(): 此时 data 和 methods 都已初始化完成, 可以通过 this 去操作, 可以在此发 ajax 请 求
- beforeMount(): 模板已经在内存中编译, 但还没有挂载到页面上, 不能通过 ref 找到对应的标 签对象
- mounted(): 页面已经初始显示, 可以通过 ref 找到对应的标签, 也可以选择此时发 ajax 请求
- beforeUpdate(): 在数据更新之后, 界面更新前调用, 只能访问到原有的界面
- updated(): 在界面更新之后调用, 此时可以访问最新的界面
- beforeDestroy(): 实例销毁之前调用, 此时实例仍然可以正常工作
- destroyed(): Vue 实例销毁后调用, 实例已经无法正常工作了
- deactivated():组件失活, 但没有死亡
- activated(): 组件激活, 被复用
- errorCaptured(): 用于捕获子组件的错误,return false 可以阻止错误向上冒泡(传递)
我们通常在 created()/mounted()进行发送 ajax 请求,启动定时器等异步任务,而在
beforeDestory()做收尾工作,如: 清除定时器操作。
不过需要注意的是 mounted 生命周期钩子中并不代表界面已经渲染成功,因为 mounted 不会
保证所有的子组件也都一起被挂载。如果你希望等到整个视图都渲染完毕,可以在 mounted 内
部使用 vm.$nextTick。
Vue 的生命周期钩子函数又分为了:单个组件生命周期、父子组件的生命周期、带缓存的路由组 件生命周期等不同的状态,在不同的状态下所拥有的生命周期内容是不相同的。 单个组件生命周期 初始化: beforeCreate created beforeMount - mounted 更新: beforeUpdate - updated 销毁: beforeDestroy destroyed 父子组件的生命周期 初始化: beforeCreate created beforeMount —child beforeCreate —child created —child beforeMount —child mounted mounted 更新: beforeUpdate —child beforeUpdate —child updated updated 销毁: beforeDestroy — child beforeDestroy — child destroyed destroyed 带缓存的路由组件生命周期 初始化: … mounted —Child activated activated 路由离开 —Child deactivated
阶段
Vue
React
小程序应
用
小程序页
面
创建 beforeCreate constructor() onLaunch onLoad created static getDerivedStateFromProps() onShow beforeMount render() onReady mounted componentDidMount() 更新 beforeUpdate static getDerivedStateFromProps() onShow onShow updated shouldComponentUpdate() onHide onHide deactivated render() activated getSnapshotBeforeUpdate() componentDidUpdate() 销毁 beforeDestroy componentWillUnmount() onUnload destroyed 捕获错 误 errorCaptured static getDerivedStateFromError() onError componentDidCatch() deactivated 路由回来 —Child activated activated 捕获子组件错误的勾子 子组件执行抛出错误 errorCaptured
408. 生命周期函数能否写成箭头函数?为什么?
不能。 在 src 引入 Vue 的操作模式中,如果生命周期函数写成箭头函数形式,函数体中的 this 指向 将指向于 Window,那将无法获取到 Vue 的实例对象,也就无法操作 Vue 的特性内容。而生 命周期里面的函数(比如 setTimeout)如果写成普通函数,那么将会改变 this 指向,所以 需要写成箭头函数,以确保函数体内的 this 指向不被修改,指向于上层 Vue 实例对象内容。 在 Vue 脚手架项目的.vue 组件文件中,生命周期钩子函数如果书写成箭头函数,this 对象返 回的是 undefined,同样也无法进行 Vue 组件对象的获取。
409. 哪一个生命周期钩子函数开始可以找到 this 对象内容?哪个钩子函数开始可以找到 ref 对象?哪个钩子函数开始可以找到 DOM 对象?
所有生命周期钩子函数都可以找到 this 对象内容,但却并不一定能够访问到想要的 this 对象 属性,在 beforeCreate 实例初始化之后调用, data 和 methods 都还没有初始化完成,通过 this 不能访问响应式数据与对应的方法内容,但因为 store、router 等对象内容是在入口文 件中进行挂载的,那么在组件的 beforeCreate 钩子函数中是通过获取到对应的对象内容的, 所以可以在 beforeCreate 钩子函数中进行类似 route 当前路由对象的参数内容获取操作。 ref 与 Dom 对象需要在 mounted 钩子函数中才能找到,而在 mounted 钩子函数中并不能 确保页面都已经被渲染成功,所以还需要利用 nextTick 来进行 DOM 对象是否最终存在,而 在 destroyed 钩子函数中因为组件的销毁,ref 以及 dom 对象内容将不再能够获取。
410. 组件间的关系类型有哪几种?有哪些方式可以实现组件之间的数据传递操作?
组件间的关系主要分成:父与子、子与父、祖与孙以及非父子之间的关系,正是因为存在组件之间 的不同关系也就意味着它们之间会存在一定的数据传递操作,而组件之间的数据传递方式主要可以 归纳为如下 10 多种实现: 父子 props:父向子、子向父 vue 自定义事件:子向父 v-model:父子之间 .sync:在父向子的基础上添加子向父 $ref,$children 与$parent $ref,$children:父向子 $parent:子向父 插槽 默认插槽/具名插槽:父组件向子组件传递标签内容 作用域插件:子向父传递数据后,父组件根据接收到的数据来决定向子组件传递不 同的标签内容 祖孙 provide 与 inject $attrs 与$listeners 非父子 全局事件总线 Vuex
411. 如何访问及修改根级组件的属性?
不同于$parent、$children、$refs,$root 获取的并不是 VueComponent 组件实例,而是 Vue 实例对象,所以我们不能够直接获取到 this.$root 的 data 数据内容以及调用 this.$root 的方法 如果想要访问根级组件的数据可以利用 this.$root.$children[0].xxx的方式进行获取,利用 this.$root.$children[0]的方式可以获取根级 App 组件,因为根级组件只有一个,所以取 children 的第 1 个元素。只要组件对象获取到了,那么它的数据获取、修改以及组件方法的 调用都可以随心操作。
412. 属性接收的约束以及注意事项有什么?
子组件在进行 props 属性接收的时候可以利用数组及对象的方式进行处理,但数组方式只能 进行简单的属性接收,而对像的方式则可以进行属性条件的约束操作。 利用 Object 对象进行属性条件约束时需要注意 default 默认值的设置,default 默认值在设 置时必须从一个工厂函数获取,其原因与 Vue 组件的 data 设置是一个 Function 概念是一致 的,因为需要确保数据的私有性问题。
413. Ref 的作用与指向是什么?
作用:ref 被用来给元素或子组件注册引用信息,引用信息将会注册在父组件的 $refs 对象 上。 指向:如果在普通的 DOM 元素上使用,引用指向的就是 DOM 元素。如果用在子组件上, 引用就指向组件实例。
414. Vue 的动画方式有几种?需要注意的问题有哪些?
Vue 的动画方式主要分成两大类,一类是 CSS 动画,一类是 JS 动画 CSS 动画中包含 transition 以及 animation,但在 Vue 中只需要通过 transition 封装组件实 现。 CSS 动画的类名主要包括:v-enter、v-enter-active、v-enter-to、v-leave、v-leave- active、v-leave-to transition 只允许有一个元素内容,appear、type、duration、mode 等属性可以进行 动画操作的设置 mode 属性设置以后需要给动画元素设置唯一 key 值 in-out: 新元素先进行过渡,完成之后当前元素过渡离开。 out-in: 当前元素先进行过渡,完成之后新元素过渡进入。 一般情况下可以利用 animate.css 动画库内容进行 CSS 动画功能的实现 JS 动画仍旧操作的是 transition 组件 设置的是属性钩子,内容包括 before-enter、enter、after-enter、enter-cancelled、 before-leave、leave、after-leave、leave-cancelled 等 在 enter 和 leave 中必须使用 done 进行回调。否则,它们将被同步调用,过渡会立即 完成 可以设置 css 属性为 false,以免受 css 影响 js 动画同样可以利用 js 动画类库实现动画操作,比如 Velocity.js 列表动画可以利用 transition-group 进行实现
415. 组件、过滤器、自定义指令的注册方式有哪几种?
组件、过滤器、自定义指令的注册方式都包含全局与局部注册两种 Vue.component、Vue.filter、Vue.directive 进行的是全局注册,需要在入口文件中进行注 册操作,所有组件可以进行使用。单词都是单数形式,需要单个内容的注册操作。 components、filters、directives 则是在当前组件中进行局部注册,只能当前组件中进行对 应功能的使用。单词形式都是复数形式,代表在组件中可以引入多个组件、过滤器与自定义 指令内容。
416. Filter 过滤器多个参数的传递以及多个过滤器的联合使用
定义 filter 过滤器的函数第一个参数是需要过滤的对象内容,但假若在使用 filter 过滤器方法 的时候想要传递参数,那么定义的 filter 过滤器的函数参数将从第一个参数内容开始获取。 过滤器可以进行多个拼接使用,利用|管道符进行拼接,需要注意的是后面的过滤器操作的主 体是前一个过滤器操作的结果值,特别需要注意前一个过滤结果的数据类型内容,以免引起 类型操作错误。
417. Directive 自定义指令的钩子函数以及函数参数是什么?
个指令定义对象可以提供如下几个钩子函数(均为可选):bind、inserted、update、 componentUpdated、unbind 对应钩子函数的参数主要包括:el、binding(属性:name、value、oldValue、expression、 arg、modifiers)、vnode、oldVnode
418. 封装自定义插件的操作步骤主要有哪些?
Vue.js 的插件应该暴露一个 install 方法,这个方法的第一个参数是 Vue 构造器,第二个参数 是一个可选的选项对象,在这个方法中可以 添加全局方法或属性 添加全局资源 注入组件选项 添加实例方法 使用插件的时候需要 install 安装以及 use 使用操作 插件的类型主要包括: 对象插件: 调用插件对象 install 方法(传入 Vue)来安装插件(执行定义新语法的代码) 函数插件: 直接将其作为 install 来调用(传入 Vue)来安装插件(执行定义新语法的代码)
419. assets 与 static 的共性与区别是什么?
static 和 assets 的区别,原理就在于webpack 是如何处理静态资源的
static
static 目录下的文件并不会被 webpack 处理,它们会直接复制到最终目录(dist/static)
下。
必须使用绝对路径引用这些文件,这是通过在 config.js 的 build.assetsPublicPath 和
nuild.assetsSubDirectory 连接确定的。
任何放在 static/的文件需要以绝对路径形式引用:/static/[name]。
如果更改 assetsSubDirectory 的值为 assets,那么路径需更改为:/assets/[filename]。
assets
在 vue 组件中,所有模板和 css 都会被 vue-html-loader 和 css-loader 解析,并查找
资源 url。
例:
或者 background: url(”./logo.png”)
因为./logo.png 是相对的资源路径,将会由 webpack 解析为模块依赖;
由于 logo.png 不是 js,当被视作模块依赖时,需要使用 url-loader 和 file-loader 处理
它,vue-cli 已经配好了这些 loader(webpack)因此可以使用相对/模块路径。
由于这些资源可能在构建过程中被内联、复制、重命名,所以它们基本是代码的一部
分,即 webpack 处理的静态资源放在/src 目录中,和其它资源文件放在一起。
总结:assets 里面的资源会被 webpack 打包进代码,static 里面的资源就直接引用了,一般在
static 里放一些类库的文件,assets 放属于项目的资源文件。
420. Vue 中如何实现表单数据的重置?
Vue 中的表单重置不像 HTML 的表单重置,只需要对 form 表单进行 reset 即可,因为 Vue 中的表单重置可能需要显示初始化的表单数据内容。 可以通过 this.$data 获取当前状态下的 data,通过 this.$options.data()获取该组件初始状 态下的 data。然后使用 Object.assign(this.$data, this.$options.data())就可以将当前状态的 data 重置为初始状态。 如果需要需要重置某个 data 的节点属性,那么可以指明对应的节点内容 Object.assign(this.$data.formSelectObj, this. $options.data())
421. 本地存储的方式有哪些?各自的优势与不足是什么?
实现本地存储的方式有很多,主要包括有 localStorage、sessionStorage、indexedDb、 webSql、Cookie,它们各有优势与不足 Cookie 是最为常用的一种本地存储方式,可以设置有效期限等条件限制,但有每个域名可以 设置 50 个 Cookie,每个不超过 4K 的文件大小,不便存储敏感信息 localStorage 是一种持久化存储,没有过期时间限制,但有尺寸大小限制,它有 5M 的存储 空间 与 localStorage 相似的是 sessionStorage,不过它是会话级存储,浏览器关闭则会清除相应 的存储内容 indexedDB 是本地类似于 mongodb 一般的对象型存储方式,但对浏览器版本要求比较高, 可以进行类似 mongodb 一般的数据增、删、改、查操作,属于无限量空间存储。 webSql 也是本地数据库存储模式,同样对浏览器版本要求比较高,但它则与 mysql 关系型 数据库操作非常相似,也可以进行数据的 sql 语法操作,进行增、删、改、查,非常的方 便,也属于无限空间存储模式。
422. 什么是插槽,有哪些类型?
插槽是一种组件间 html 传递的策略,实现父组件向子组件传递标签内容。插槽的类型主要包括: 普通插槽、具名插槽以及作用域插槽 对于作用域插槽是在父组件需要向子组件传递标签结构内容,但决定父组件传递怎样标签结构的数 据是在子组件中。在 Vue2.6 版本以后,新版本插槽的语法比起老版本区别略有区别,主要可以利 用#slotName={property}的方式进行简化缩写。
423. 组件的类型及特点有哪些?
如果想要对组件进行类型划分,从实现的功能以及所具备的特点来划分,大致可以归纳为:动态组 件、缓存组件、异步组件、函数式组件 + JSX、递归组件等 动态组件:通过动态确定要显示的组件, is 指定要显示组件的组件名 问题: 当从 A 组件切换到 B 组件时, A 组件就会销毁 缓存组件:即可以利用 component,也可以使用 router-view 使用缓存动态组件, 可以通过 include 或 exclude 指定只缓存特定组件
slot="插槽的名字" + slot-scope="{要收集的数据-1,要收集的数据-2}"
=
v-slot:插槽名字="{要收集的数据-1,要收集的数据-2}"
=
#插槽名字=“{要收集的数据-1,要收集的数据-2}”
<component :is="currentComp"/>
使用也可以缓存路由组件 路由组件对象什么时候创建? 默认: 每次跳转/访问对应的路由路径时 有缓存: 第一次访问时 路由组件对象什么时候死亡? 默认: 离开时 有缓存: 离开时不死亡, 只有当 destroy/父组件死亡/刷新页面 异步组件 好处:能更快的看到当前需要展现的组件界面(异步组件的代码开始没有加载) 无论是路由组件还是非路由组件都可以实现异步组件效果 拆分单独打包 需要时才请求加载组件对应的打包文件 配置组件: component: () => import(modulePath) import(modulePath): 被引入的模块会被单独打包(code split) —ES8 的新语法 () => import(modulePath): 函数开始不调用, 当第一次需要显示对应的界面时才会 执行, 请求加载打包文件 细节 import()返回 promise, promise 成功的结果就是整体模块对象 本质上: 可以利用 import()实现对任意模块的懒加载 函数式组件 + JSX,与 Vue 的 Component 概念有明显不同,更雷同于 React 中的函数式组 件 只能针对无状态(data)的组件 不用创建实例对象, 运行更快 可以没有根标签 递归组件,组件内部有自己的子组件标签,简单的说就是组件自已调用自身 应用场景: 用于显示树状态结构的界面 注意: 递归组件必须有 name
424. 简述一下对 Vue-Router 的理解?
<keep-alive :exclude="['Home']">
<component :is="currentComp"/>
</keep-alive>
<keep-aliveinclude='Life1'>
<router-view></router-view>
</keep-alive>
exportdefault {
functional: true, // 当前是函数组件
render(createElement, context) {
return要显示界面的虚拟DOM;
},
};
功能
React-router
Vue-Router
静态路由 表及分配 地址 HashRouter/BrowserRouter as Router Route/Switch 设置数组,path 和 component 对象 内容的确认 首页的渲 染 Route 的 path 为/,但是需要加上 exact router-view 链接形式 1 a 链接,但是要加# a 链接,但是要加# 链接形式 2 Link/NavLink 链接,to,不需要加# router-link,to,不需要加# 高亮显示 NavLink 下的 activeClassName/activeStyle active-class 路由嵌套 是通过不同的组件中设置 Route 来 进行路由的嵌套,嵌套操作被拆分了 children 嵌套 路由嵌套 的显示 Route 既是路由,也是占位渲染显示 router-view 参数传递 设参在路由 :xxx 传参在地址 Link/NavLink to 的设置接参在组件 this.props.match.params.xxx 设参在路由 :xxx 传参在地址 router- link 的 to 的设置接参在组件 this.$route.params.xxx/watch 首页的高 亮显示 exact exact 多层嵌套 是通过不同的组件中设置 Route 来 进行路由的嵌套,嵌套操作被拆分了 children 的多层嵌套+router-view 程序式导 航 this.props.history.push(pathUrl) this.$router.push(pathUrl) Miss 与 NoMatch NoMatch 不需要写 path,直接写 NoMatch redirect 与*号通配符 在以往的项目开发中,包括使用不同技术栈的项目内容,例如 nodejs 的 express、Vue 项目、 React 项目、小程序项目等都涉及到了路由的概念与操作。虽然这些项目归属于不同的技术体系, 但路由的核心概念都是一致的,我也做了相应的归纳,总结出 5 个词进行了概括:静态路由表、 分配地址、统一入口、寻址渲染,过滤判断。当然,对于不同的技术体系,路由的表现与配置方式 会有所差异与不同。 路由的具体操作又表现在:操作模式、跳转方式、参数的传递、嵌套处理、守卫管理、懒加载及动 态路由等方面。
425. 路由守卫的类型有哪些,一共有几个路由守卫,不同类型包含哪些路由守卫的钩子函数
导航守卫是什么? 导航守卫是 vue-router 提供的下面 2 个方面的功能 监视路由跳转 —>回调函数 控制路由跳转 —> 放行/不放行/强制跳转到指定位置 next() 应用 在跳转到界面前, 进行用户权限检查限制(如是否已登陆/是否有访问路由权限) 在跳转到登陆界面前, 判断用户没有登陆才显示 导航守卫分类主要包括: 全局守卫:beforeEach、beforeResolve、afterEach 路由独享的守卫:beforeEnter 组件内的守卫:beforeRouteEnter、beforeRouteUpdate、beforeRouteLeave 当点击切换路由时:beforeRouterLeave—>beforeEach—>beforeEnter—>beforeRouteEnter—
beforeResolve—>afterEach—>beforeCreate—>created—>beforeMount—>mounted— beforeRouteEnter 的 next 的回调 当路由更新时:beforeRouteUpdate
426. 最为常用的路由守卫类型是哪个,主要应用在什么功能操作?
最为常用的路由守卫应当是全局守卫中的 beforeEach,因为在用户权限认证操作过程中都会需要 该守卫操作的处理,而用户权限又是每个项目中不可缺少的一部分。 关键技术: 全局前置守卫 beforEach + 动态添加路由 判断是否有 token 没有 token, 判断请求是否是白名单路由: 是: 直接放行 不是: 强制跳转到 login 页面 有 token, 判断请求的是否是 login 页面 是: 强制跳转到根路由 不是, 判断是否已经登陆? 已登陆: 放行 没有登陆: 请求获取用户相关信息数据: name/avatar/路由的权限数据和按钮的权 限数据 请求成功了: 将用户相关数据保存到 vuex 中 根据路由权限数据动态生成权限路由的数组 将所有的权限路由和匹配任意路由的路由动态添加到 router 中 请求失败了: 删除 cookie 中和 token 删除 vuex 中用户相关信息 强制跳转到登陆页面
427. router 与 route 的差异与区别是什么?
我们可以根据这两个单词的长度来进行判断,一个是 router,这个单词长一些,代表的是整 个路由对象,里面是整个静态路由表的配置信息。如果需要实现路由的跳转,则需要从整个 静态路由表对象中进行匹配,所以使用的是 router。 而 route 这个单词短一些,代表的是当前的路由页面内容,如果需要获取当前路由对象的参 数信息,则可以对 route 内容进行处理。
428. Vue 的双向数据绑定原理是什么?
答:vue.js 是采用数据劫持结合发布者-订阅者模式的方式,通过 Object.defineProperty()来劫持 各个属性的 setter,getter,在数据变动时发布消息给订阅者,触发相应的监听回调。 具体步骤: 第一步:需要 observe 的数据对象进行递归遍历,包括子属性对象的属性,都加上 setter 和 getter 这样的话,给这个对象的某个值赋值,就会触发 setter,那么就能监听到了数据变化 第二步:compile 解析模板指令,将模板中的变量替换成数据,然后初始化渲染页面视图,并将每 个指令对应的节点绑定更新函数,添加监听数据的订阅者,一旦数据有变动,收到通知,更新视图 第三步:Watcher 订阅者是 Observer 和 Compile 之间通信的桥梁,主要做的事情是: 1、在自身实例化时往属性订阅器(dep)里面添加自己 2、自身必须有一个 update()方法 3、待属性变动 dep.notice()通知时,能调用自身的 update()方法,并触发 Compile 中绑定的回 调,则功成身退。 第四步:MVVM 作为数据绑定的入口,整合 Observer、Compile 和 Watcher 三者,通过 Observer 来监听自己的 model 数据变化,通过 Compile 来解析编译模板指令,最终利用 Watcher 搭起 Observer 和 Compile 之间的通信桥梁,达到数据变化 -> 视图更新;视图交互变化 (input) -> 数据 model 变更的双向绑定效果。
429. 对 keep-alive 的了解
keep-alive是 Vue 内置的一个组件,可以使被包含的组件保留状态,或避免重新渲染。它有两个 属性: include(包含的组件缓存) 与 exclude(排除的组件不缓存,优先级大于 include) 。 使用方法 参数解释 include - 字符串或正则表达式,只有名称匹配的组件会被缓存 exclude - 字符串或正则表达式,任何名称匹配的组件都不会被缓存 include 和 exclude 的属性允许组件有条件地缓存。二者都可以用“,”分隔字符串、正则表达式、 数组。当使用正则或者是数组时,要记得使用 v-bind 。 使用示例
<keep-aliveinclude="include_components"exclude="exclude_components">
<component>
<!-- 该组件是否缓存取决于include和exclude属性 -->
</component>
</keep-alive>
<keep-aliveinclude="a,b">
<component></component>
</keep-alive>
<keep-alive:include="/a|b/">
<component></component>
</keep-alive>
<!-- Array (需要使用 v-bind,被包含的都会被缓存) -->
内容
作用
映射
位置
调用
其它
state 设置状 态 mapState computed getters 获取内 容 mapGetters computed 计算数据后返回 mutations 修改数 据 mapMutations methods commit 可以异步但不建 议,不利调试 actions 异步操 作 mapActions methods dispatch modules 模块拆 分 namespaced plugins 插件辅 助
430. 路由切换以后需要进行页面中某一锚点的定位需要如何实现?
需要利用 router 的 scrollBehavior 来进行指定位置的跳转操作
431. 你如何理解 vuex?
vuex 的 6 大属性:
432. vuex 中的 namespaces 是什么?它的主要作用是什么?
在 Vuex 模块中开启 namespaced 以后,确定该模块为带命名空间的模块。当模块被注册后,它 的所有 state、getter、action 及 mutation 都会自动根据模块注册的路径调整命名。
433. 如何解决 vuex 数据丢失问题?
刷新页面 Vuex 的 state 会丢失,可以利用 vuex-persist、vuex-persistedstate 状态持久化插件将 state 数据存储于本地存储对象当中,比如 localStorage。
434. vuex 和 redux 的区别?
<keep-alive:include="['a', 'b']">
<component></component>
</keep-alive>
scrollBehavior: function (to) {
if (to.hash) {
return {
selector: to.hash
}
}
},
vuex: 我们直接在 mutation 中直接更新状态数据 直接可以在 action 中执行异步操作 redux: 只能通过 reducer 返回一个新的状态数据, 由 redux 内部自己更新 本身不支持异步, 必须引入 react-redux 之类的插件才支持异步 ::: danger 虚拟滚动列表 虚拟滚动列表的实现原理是什么?(详见:虚拟滚动列表.html 示例) :::
435. 如果不使用分页处理,在一个页面中想显示 10 万条数据,如何实现高效的 DOM 渲染处理?
利用虚拟滚动的方式,控制在指定区域内容只渲染可显示范围的数据内容,不增加 DOM 节 点 vue-virtual-scroller/vue-virtual-scroll-list 第三方插件的应用
436. 前端开发人员在不借助后端人员协助的情况下,如果换作是你,如何最快速的实现跨域问题的解决?跨域问题的解决一般有哪些方式,如何实现?
直接安装 Chorme 插件,CORS unblock 开启插件即可 利用 vue.config.js 配置 devServer 的 proxy 反向代理 通过建立本地 nginx 服务器,配置代理地址
437. 一般情况,你会对程序的错误分成几大类型?你是如何进行程序的调试的处理的?
语法错误:利用编辑器进行提示,包括 eslint 等辅助工具的配置使用 运行错误:利用报错提示查看出错的行列,分析错误情况进行排错 逻辑错误:梳理业务流程,利用 debug 调试工具,包括断点测试实现纠错
438. 你如何快速了解、学习与掌握脚手架项目或者其他公司新接收的项目?
项目的发解、学习与掌握也是有一定的顺序与方法的,主要的流程包括如下几个步骤: 有 Readme 说明文档一定先看 Readme 说明文档,最为主要解决的是项目运行环境的搭建 与启动 项目目录结构的分析 项目文件结构的分析 项目代码结构的分析:需要找到入口文件以及主组件,从入口文件着手,主组件触发,从上 到下,剥洋葱一般的进行代码层次结构的剥离与分析
439. 对于 Vue 项目,你所常用的性能优化方式主要包含哪些方面?
项目性能优化的方面包含很多,针对 Vue 项目的优化可以介绍几种类型的内容,主要包括:Vue 代码层面的优化、webpack 配置层面的优化、基础的 Web 技术层面的优化、用户体验优化等 代码层面的优化: v-if 和 v-show computed 和 watch 不要将所有的数据放在 data 中,固定数据或者定时器等可设置于实例对象当中 keep-alive 缓存组件 v-for 遍历 key 设置,且避免同时使用 v-if 长列表利用 Object.freeze 冻结数据 监听对象的销毁 图片资源懒加载 路由懒加载,异步组件 第三方插件的按需引入 无限列表利用虚拟滚动列表实现 服务端渲染或预渲染 函数式组件应用 高频触发使用防抖、节流 事件委托 图片编码优化,尽量使用 svg 和字体图标 避免重定向以及 404 页面 动态注册组件 使用编程式导航代替声明式导航 前端表单验证,减少请求处理 Webpack 层面的优化 文件压缩,包括图片、css、js、html 等 减少 ES6 转为 ES5 的冗余代码 提取公共代码 模板预编译 模块文件的提取,包括 css、第三方 js 库等 优化 SourceMap 构建结果输出分析 基础的 Web 技术层面的优化 开启 gzip 压缩 浏览器缓存 CDN 的使用 使用 Chrome Performance 查找性能瓶颈 https://www.jianshu.com/p/ef44aaa41fe8
440. 路由跳转指定 params 参数时可不可以用 path 和params 配置的组合?
不可以,只能用 name 和 params 配置的组合,query 配置可以与 path 或 name 进行组合使用
441. 如何指定 params 参数可传可不传?
path: ‘/search/:keyword?’,利用?号设定
442. 如果指定 name 与 params 配置, 但 params 中数据是一个"", 无法跳转
不指定 params 或者指定 params 参数值为 undefined
443. 路由组件能不能传递 props 数据?
可以:可以将 query 或 params 参数映射成 props 传递给路由组件对象
444. 编程式路由跳转到当前路由(参数不变), 会抛出NavigationDuplicated 的警告错误
面试问题::在做项目时有没有遇到比较难的问题?(可做回答) 回答步骤:
- 我的问题: 我在上一个项目时没有问题,后面再做一个新的项目时就有了问题
- 原因分析: vue-router3.1.0 之后,引入了 push()的 promise 的语法,如果没有通过参数指定 回调函数就返回一个 promise 来指定成功/失败的回调,且内部会判断如果要跳转的路径和 参数都没有变化,会抛出一个失败的 promise
- 解决办法:解决 1: 在跳转时指定成功或失败的回调函数, 通过 catch 处理错误 解决 2: 修正 Vue 原型上的 push 和 replace 方法 (优秀) 56.是否有对 axios 进行二次封装?主要的封装功能包括哪些?
- 配置通用的基础路径和超时: axios.create({baseURL, timeout})
- 显示请求进度条 显示: 准备发请求前显示, 在请求拦截器中执行 NProgress.start() 隐藏: 请求结束隐藏, 在响应拦截器成功/失败回调中 NProgress.done()
- 携带 token 数据 在请求拦截器中, 将 token 添加到请求头中
- 成功返回的数据不再是 response, 而直接是响应体数据 response.data
//在routes中配置
props: (route) => ({ keyword1: route.params.keyword, keyword2:
route.query.keyword });
// 缓存原型上的push方法
constoriginPush=VueRouter.prototype.push;
VueRouter.prototype.push=function(location, onComplete, onAbort) {
console.log('push()', location, onComplete, onAbort);
// this是路由器对象 $router
// 如果调用push, 传递了成功或者失败的回调函数
if (onComplete||onAbort) {
// 让原来的push方法进行处理
originPush.call(this, location, onComplete, onAbort); // 不用返
回, 因为执行的结果返回是undfined
} else {
// 如果调用push, 没传递了成功或者失败的回调函数, 可能会抛出失败的promise,
需要catch一下
returnoriginPush.call(this, location).catch(() => {
console.log('catch error');
}); // 必须返回产生的promise对象
}
};
响应拦截器成功的回调中: return response.data 5. 统一处理请求错误, 具体请求也可以选择处理或不处理 在响应拦截器失败的回调中: alert 提示错误信息, return Promise.reject(error)
445. 为什么要使用编程式导航代替声明式导航,典型应用场景是什么?
在重复使用声明式导航时需用编程式导航替换,以便提升性能。在电商项目商品分类跳转时可以进 行编程式导航的应用。
446. 如何配置使用 swiper?
必须在列表显示显示之后创建 , 在 mounted()中创建 异步动态获取数据并且在 mounted 中创建 Swiper 对象也会导致没有轮播效果,需要 nextTick 确定 DOM 已经渲染完毕
447. 如何解决多个 swiper 效果冲突的问题
问题: 针对某个 swiper 界面创建一个 swiper 对象, 它会影响了其它界面的 swiper 界面 原因: new Swiper (‘.swiper-container’), 类名选择器匹配了页面中所有的 swiper 界面, 都产 生了效果 解决: 使用 ref 技术: 通过 ref 标识 swiper 的根 div, new Swiper (this.$refs.swiper)
448. 什么情况下需要深度作用选择器修改第三方 UI 组件的内部样式,如何实现
场景:当我们需要覆盖 element-ui 等 UI 框架中组件的样式时可以通过深度作用选择器
style 为 css 时的写法如下
style 使用 css 的预处理器(less, sass, scss)的写法如下
449. 利用深拷贝解决修改不能取消的问题
在对某数据进行修改时考虑还需要进行“确认”、“取消”操作,那么在取消时就需要返回保留的数据 内容,那么如何将原有数据保留一份则是关键性问题。 显然修改值不能直接进行原值的赋值操作,因为这样无法取消回退
.a >>> .b {
...;
}
/deep/ .a {
...;
}
/* /deep/在某些时候会报错,::v-deep更保险并且编译速度更快 */
::v-deep.a {
...;
}
如果采用浅拷贝,那么浅拷贝只复制指向某个对象的指针,而不复制对象本身,新旧对象还 是共享同一块内存,那么数据还是会出现问题 需要采用深拷贝的形式进行数据的复制 JSON.parse(JSON.stringify(obj))实现深拷贝其实会存在很多的问题 如果 obj 里面有时间对象,则 JSON.stringify 后再 JSON.parse 的结果,时间将只 是字符串的形式,而不是时间对象 如果 obj 里有 RegExp、Error 对象,则序列化的结果将只得到空对象 如果 obj 里有函数,undefined,则序列化的结果会把函数或 undefined 丢失 如果 obj 里有 NaN、Infinity 和-Infinity,则序列化的结果会变成 null JSON.stringify()只能序列化对象的可枚举的自有属性,例如如果 obj 中的对象是 有构造函数生成的,则使用 JSON.parse(JSON.stringify(obj))深拷贝后,会丢弃对 象的 constructor 如果对象中存在循环引用的情况也无法正确实现深拷贝 使用 lodash 的 cloneDeep 进行数据的深拷贝
450. vue 变量名如果以_、$开头的属性会发生什么问题?怎么访问到它们的值?
以_或者$开头的属性不会被 vue 实例代理,因为它们可能会和 vue 内置属性、api 方法冲突 可以使用 vm.$data._property 的方式访问这些属性。
451. Vue 组件中写 name 选项有什么作用
使用 keep-alive 时,可以搭配组件 name 进行缓存过滤 DOM 做递归组件时需要调用自身 name。 vue-devtools 调式工具里显示的组件名称是有 vue 中 name 决定的
452. Vue 渲染模板时怎么保留模板中的 HTML 注释呢?
Vue 默认会丢弃模板里的 HTML 注释,要保留它们需要给组件模板启用 comments 配置:
// 模板标签添加 comments 属性
<template comments>
...
</template>
453. 如何更优雅的进行监听对象的清除处理?
可以通过$once 这个事件侦听器在定义完定时器之后的位置来清除定时器
mounted(){
consttimer=setInterval(()=>{
console.log(1)
},1000)
this.$once('hook:beforeDestroy',()=>{ // 监听beforeDestroy这个钩子函数
clearInterval(timer)
})
}
454. 请说一下 computed 中的 getter 和 setter
computed 中可以分成 getter(读取)和 setter(设值),一般情况下是没有 setter 的, computed 预设只有 getter,也就是只能读取,不能改变设值。
默认只有 getter 的写法 注意:不是说我们更改了 getter 里使用的变量,就会触发 computed 的更新,前提是 computed 里的值必须要在模板里使用才行。如果将{{fullName}}去掉,get()方法是不会 触发的。 setter 的写法,可以设值
<divid="demo">{{ fullName }}</div>
varvm=newVue({
el: '#demo',
data: {
firstName: 'Foo',
lastName: 'Bar'
},
computed: {
fullName: function () {
returnthis.firstName+' '+this.lastName
}
}
})
//其实fullName的完整写法应该是如下:
fullName: {
get(){
returnthis.firstName+' '+this.lastName
}
}
<template>
<divid="demo">
<p> {{ fullName }} </p>
<inputtype="text"v-model="fullName">
<inputtype="text"v-model="firstName">
<inputtype="text"v-model="lastName">
</div>
</template>
varvm=newVue({
el: '#demo',
data: {
firstName: 'zhang',
lastName: 'san'
},
computed: {
fullName: {
//getter 方法
get(){
console.log('computed getter...')
returnthis.firstName+' '+this.lastName
},
//setter 方法
set(newValue){
console.log('computed setter...')
varnames=newValue.split(' ')
this.firstName=names[0]
this.lastName=names[names.length-1]
returnthis.firstName+' '+this.lastName
在这里,我们修改 fullName 的值,就会触发 setter,同时也会触发 getter。 注意:并不是触发了 setter 也就会触发 getter,他们两个是相互独立的。我们这里修改了 fullName 会触发 getter 是因为 setter 函数里有改变 firstName 和 lastName 值的代码,这 两个值改变了,fullName 依赖于这两个值,所以便会自动改变。
455. 如果 elementUI,iview 等 UI 框架的 Table 表格组件功能达不到业务复杂度需求,比如需要实现树形结构的深度查询、分组汇总以及合计、行列单元格的可编辑操作等,会如何操作?
elementUI,iview 是比较符合大众业务需求的 UI 框架,而表格组件在业务需求的使用中极为的频 繁,elementUI,iview 对于 Table 表格组件的功能并没有做极大的强化,所以可以考虑选择更为 专业的 vxe-table 插件,https://xuliangzhan_admin.gitee.io/vxe-table/#/table/start/install
456. 利用 Vue 技术体系是否能够进行小程序项目的开发?
可以 wepay、mpx、mpvue(停更)、uniApp 都是类 Vue 或者是 Vue 体系的技术框架,利用它 们可以进行小程序项目的开发。
457. 利用 Vue 技术体系是否能够进行 App 项目的开发?
可以 阿里的 weex,dclould 的 uniApp,还有 NativeScript 的 Vue 体系都可以进行移动端 App 项目的开发。
458. 如何实现路由参数的响应式处理?
可以利用监控或者组件的路由守卫功能实现 监控模式: 路由守卫模式:
}
}
}
})
constUser= {
template: '<div>User {{ $route.params.name }} </div>',
watch: {
$route(to, from) {
// react to route changes...
},
},
};
459. 在同一组件中能否既定义全局样式,又定义组件局部样式?
可以,定义两个 style,一个没有 scoped,一个有 scoped
460. Vue 中多国语言支持需要利用什么方式实现?
可以利用 Vue-i18n 插件实现:http://kazupon.github.io/vue-i18n/
461. 能否将 vue-router 当前的 $route 同步为 vuex 状态的一部分?
可以,利用 vuex-router-sync 可以将 vuex 与 router 对象进行同步,将当前的$route 同步为 vuex 状态的一部分,我们甚至可以利用修改 vuex 的路由状态来进行路由地址的跳转与参数传递
462. 如何对 lodash 库实现按需引入
按需引入:import { debounce } from 'lodash-es' 配合 tree-shaking(ESM 包最佳);CJS 版 lodash 用 import debounce from 'lodash/debounce' 按模块路径引入,或用 babel-plugin-lodash 自动转换。
463. 如何实现跨域配置
在 vue.config.js 中对 devServer 进行属性配置
464. 理解 Vue.use
自定义 Vue 插件需要向外暴露对象或者是函数 如果向外暴露对象的话,对象中必须有 install 方法 如果向外暴露的是函数的话,那么该函数本身就是 install 方法 当 Vue.use()的时候,会自动调用 install 方法,并且将 Vue 对象作为实参传入到 install 方法 中
constUser= {
template: '<div>User {{ $route.params.name }} </div>',
beforeRouteUpdate(to, from, next) {
// react to route changes and then call next()
},
};
commit('route/ROUTE_CHANGED', { to: { path: '/b' } });
import_from'lodash'; // 引入整体lodash ==> 打包了没用的工具函数, 打包文件变大
importthrottlefrom'lodash/throttle'; // 只引入我需要的工具函数 打包文件减少
1.4M
proxy: {
'/dev-api': { // 匹配所有以 '/dev-api'开头的请求路径
target: 'http://182.92.128.115', // 代理目标的基础路径
changeOrigin: true, // 支持跨域
pathRewrite: { // 重写路径: 去掉路径中开头的'/dev-api'
'^/dev-api': ''
}
},
}
465. history 模式刷新 404 问题解决方法
通过配置 webpack 来解决:在 devServer 中加 historyApiFallback: true index.html 需要将 href=”./bootstrap.css” 等内容改成 href=“/bootstrap.css” webpack.config.js 需要 output 上增加 publicPath: ’/‘
466. v-model 都做了哪些事情
将指定变量的数据赋值给 input 的 value 给当前的表单相自动绑定一个 input 事件,监听 View 层表单项数据发生改变获取最新 value 的同时更新 Model 的数据
467. 路由设置中的 meta 属性通常设置什么内容?
一般我们会设置 title 标题以及 isAuth 是否授权操作等自定义的路由属性内容
468. 如何动态修改 Vue 单页面应用的标题
通过设置路由的 meta 属性,添加路由 title 标题 利用路由全局守卫可以进行拦截并修改标题设置
469. 什么是 Props 传递数据防脏
所有的 props 都使得其父子组件形成一个单向下行绑定,父级 props 的更新会流动到子组件中, 但反过来不行。这种设计办法是为了防止子组件意外改变父组件的状态,从而导致你的应用的数据 流向难以理解。另外,如果该数据还被其他子组件使用,也将受影响,产生洪水式灾难。因此不应 该在子组件中设计修改 props 数据的操作。
470. 如何实现数据防脏操作?
利用 update:myPropName 的方式进行数据防脏处理 子组件赋值操作 父组件事件绑定处理 缩写模式,利用 sync
471. 你所熟悉与应用的 VueUI 框架有哪些?
PC 端主要有 iview、elementUI、Ant-Design-Vue
router.beforeEach= ((to,from,next)) => {
window.document.title=to.meta.title;
next();
});
this.$emit('update:title', newTitle);
<text-documentv-bind:title="doc.title"v-on:update:title="doc.title =
$event"></text-document>
<text-documentv-bind:title.sync="doc.title"></text-document>
移动端:MintUI、Vant、Vux
472. 如果实现 css 的模块化?
使用 CSS Modules 实现样式的模块化
473. 如何实现事件委托操作?
利用事件冒泡将事件操作委托于父元素的事件对象内容
474. 如何实现模块自动化加载操作?
require.context()函数获取一个特定的上下文,主要用来实现自动化导入模块,在前端工程中,如 果遇到从一个文件夹引入很多模块的情况,可以使用这个 api,它会遍历文件夹中的指定文件,然后自 动导入,使得不需要每次显式的调用 import 导入模块
<!-- 使用CSSModules-->
<stylemodule>
.button {
border: none;
border-radius: 2px;
}
.buttonClose {
background-color: red;
}
</style>
<!-- 不将事件绑定于button,而是绑定在table上 -->
<table@click="edit">
<trv-for="item in list":key="item.id">
<td>{{ item.name }}</td>
<td>
<button:data-id="item.id"title="edit">编辑</button>
</td>
</tr>
</table>
// 通过获取绑定的标识参数来确认事件目标对象
edit(event) {
if (event.target.title=="edit") {
//如果点击到了edit
letid=event.target.dataset.id;
}
},
475. addRoutes 的作用与应用场景
addRoutes 可以实现动态路由的添加操作 应用场景:根据用户权限判断展示不同路由菜单项 前台公共路由的获取 后台通过用户权限判断返回具体用户拥有的路由 前台利用 addRoutes 将公共路由与后台返回的动态路由进行组合成新的用户功能路由
476. 不同路由同一组件的重用
如果设置不同的路由,但指向的是同一组件,那么因为组件性能考虑及缓存策略,组件并不会刷 新,那么如何实现组件的刷新重用呢?
477. 如何实现组件属性的验证处理?
可以利用 validator 进行自定义验证方法的定义处理
478. 如何实现组件的刷新?
一般情况组件的 state 状态或者是 props 发生改变时就会进行刷新渲染,但有时需要进行用户控 制,那么有哪些方法呢: 最差的方式:刷新页面 常见的方法:v-if 控制组件的显示 利用 forceUpdate 强制更新,将触发 updated 钩子函数
/*
动态加载vuex中所有的modules模块
不再需要通过import手动一个一个引入
*/
constcontext=require.context('./modules', false, /\.js$/);
constmodules=context.keys().reduce((modules, modulePath) => {
// './app.js' => 'app'
constmoduleName=modulePath.replace(/^\.\/(.*)\.\w+$/, '$1');
modules[moduleName] =context(modulePath).default;
returnmodules;
}, {});
router.addRoutes([...asyncRoutes, lastRoute]);
<template>
<router-view:key="$route.fullPath"></router-view>
</template>
alertType: {
validator: (value) => ['signup', 'login', 'logout'].includes(value);
}
<template>
<divid="app">
<h1>{{ Math.random() }}</h1>
<button@click="update">Force Update</button>
利用 mount 进行重新挂载,将触发 beforeMount 与 updated 钩子函数
479. 重载刷新页面
this.$router.go(0) 相当于 F5 刷新,这种方法虽然代码很少,只有一行,但是体验很差。页 面会一瞬间的白屏,体验不是很好 location.reload() 这种也是一样,画面一闪,体验不是很好,相当于页面刷新 推荐解决方法:用 provide / inject 组合 在 App.vue,声明 reload 方法,控制 router-view 的显示或隐藏,从而控制页面的再次加载。
</div>
</template>
<script>
exportdefault {
methods: {
update() {
this.$forceUpdate();
},
},
};
</script>
<divid="app">
<h1>{{Math.random()}}</h1>
<button@click="update">Force Update</button>
</div>
</template>
<script>
exportdefault {
methods:{
update(){
this.$mount();
}
}
};
</script>
<template>
<divid="app">
<router-viewv-if="isRouterAlive"></router-view>
</div>
</template>
<script>
exportdefault {
name: 'App',
provide() {
return {
reload: this.reload,
};
},
data() {
return {
在需要用到刷新的页面。在页面注入 App.vue 组件提供(provide)的 reload 依赖,在逻辑完成 之后(删除或添加…),直接 this.reload()调用,即可刷新当前页面。 注入 reload 方法 在需要重载的地方直接调用
480. 表单提交时如何阻止页面刷新?
表单提交时为了防止页面刷新需要进行默认事件的阻止处理,可以利用 submit.prevent 进行实 现。
481. 是否有集成过在线编辑器?使用的是哪些?
百度 ueditor 的 Vue 版本,vue-ueditor-wrap,功能强大,配置略麻烦:https://github.com/Ha oChuan9421/vue-ueditor-wrap quill-editor 的 Vue 版本,vue-quill-editor,功能一般,配置简单:https://github.com/surmon- china/vue-quill-editor
482. 是否有了解过动态表单生成概念?
所谓的动态表单就是根据数据库动态获取的字段配置信息生成表单模块,这一操作在产品的 SKU 管理,还有 OA,ERP 系统中应用广泛。 vue-form-generator:https://github.com/vue-generators/vue-form-generator vue-dynamic-form-component:https://vue-dynamic-form.quincychen.cn/
483. 父组件可以监听到子组件的生命周期吗
比如有父组件 Parent 和子组件 Child,如果父组件监听到子组件挂载 mounted 就做一些逻辑处 理,可以通过以下写法实现:
isRouterAlive: true,
};
},
methods: {
reload() {
this.isRouterAlive=false;
this.$nextTick(function() {
this.isRouterAlive=true;
});
},
},
};
</script>
exportdefault {
inject: ['reload'],
};
this.reload();
以上需要手动通过 $emit 触发父组件的事件,更简单的方式可以在父组件引用子组件时通过 @hook 来监听即可,如下所示: 当然 @hook 方法不仅仅是可以监听 mounted,其它的生命周期事件,例如:created,updated 等都可以监听。
484. 首屏加载性能优化中为了解决 js 阻塞需要实现库文件的抽离,如何实现?
修改 vue.config.js 配置,configureWebpack 属性中加入 externals,将对应的类库抽离,需要在 index.html 中加入对应的 cdn 文件。
485. 首屏性能优化一般有哪些方案?
异步路由加载 不打包库文件 关闭 sourcemap 开启 gzip 压缩 单独 SSR 页面生成
486. 什么是 XSRF 攻击,Vue 中如何做好相应的安全策略?
Cross-site request forgery 跨站请求伪造,也被称为“One Click Attack”或者 Session Riding,通 常缩写为 CSRF 或者 XSRF,是一种对网站的恶意利用。CSRF 定义的主语是”请求“,是一种跨站的 伪造的请求,指的是跨站伪造用户的请求,模拟用户的操作。
// Parent.vue
<Child@mounted="doSomething"/>
// Child.vue mounted() { this.$emit("mounted"); } 复制代码
// Parent.vue
<Child@hook:mounted="doSomething"></Child>
doSomething() { console.log('父组件监听到 mounted 钩子函数 ...'); }, //
Child.vue mounted(){ console.log('子组件触发
mounted 钩子函数 ...'); }, // 以上输出顺序为: // 子组件触发 mounted 钩子函数 ...
// 父组件监听到 mounted 钩子函数 ...
复制代码
module.exports ={
publicPath:'./',
configureWebpack:{
// 此处可以配置 cdn 配置
// 需要在index.html 中引入 cdn 文件
externals:{
vue:'Vue',
'vue-router':'VueRouter',
vuex:'vue',
'element-ui':'ELEMENT'
}
}
}
在 Vue 中进行 vue-csrf 插件的使用:https://github.com/nicita13/vue-csrf
487. 电商平台购物车流程的处理方式有哪几种,操作流程与优势不足各有哪些
购物车数据本地缓存存储模式,单设备存储与应用,切换设备将无法同步,但性能优良 以 id 为参数模式的操作方式 用户查看产品详情,将产品添加到购物车,而购物车中生成的是一个单一数组,类 似[1,2,1,1,3,4,4] 1,2,3,4 为产品 id,出现的次数为购买的数量 在购物车清单页面需要进行再次的数据请求与查询 选中购物车产品等操作则增加程序复杂层度 以对象为参数模式的操作方式 用户查看产品详情,将产品添加到购物车,而购物车中生成的是一个对象数组,将 会把产品整体对象传递并存储于数组当中 可以给数组对象添加 count(购买数量),selected(是否选中)等属性值 在购物车清单页面不再需要进行数据请求与查询操作,减少性能开销 选中购物车产品等操作简化程序复杂层度 购物车数据远程序服务器存储模式,与本地设备无关,切换设备也可以同步数据,请求次数 多,服务器压力大,性能略低下 将用户信息、产品 id 以及购买数量等信息作为参数进行订单接口的请求操作 由服务器端进行订单内容的查询、新增、更新与删除的操作 订单列表页则需要进行订单列表接口的请求获取与显示操作 每个商品信息任何一次变化都需要与后台接口进行交互,http 请求次数巨大
488. 什么是 SPU、什么是 SKU?
SPU = Standard Product Unit (标准化产品单元) SPU 是商品信息聚合的最小单位,是一组可复用、易检索的标准化信息的集合,该集合描述了一 个产品的特性。通俗点讲,属性值、特性相同的商品就可以称为一个 SPU。 SKU=stock keeping unit(库存量单位) SKU 即库存进出计量的单位,可以是以件、盒、托盘等为单位。 SKU 是物理上不可分割的最小存货单元。在使用时要根据不同业态,不同管理模式来处理。在服 装、鞋类商品中使用最多最普遍。
489. Vue 中项目中,你有了解哪些 SKU 的表单生成插件?
vue-sku:基于 element-ui 实现 zent sku 商品规格组件。https://github.com/easeava/vue-sku vue-sku-form:基于 Vue & ElementUI 的电商 SKU 表单配置组件。https://hooray.github.io/vu e-sku-form/
490. Vuex 中命名空间使用后组件调用带命名空间的action 方法里有几种方式?
直接利用 store 进行单个调用:this.$store.dispatch(‘moduleName/run’, command); 利用 mapActions 映射,空间模块直接映射方式
mapActions(['some/nested/module/foo', 'some/nested/module/bar']);
空间模块调用方式: 利用 mapActions 映射,空间模块名称+方法数组方式 空间模块调用方式:
附加知识点面试题
491. 区别v-if与v-show
隐藏: v-if干掉标签, v-show通过样式来隐藏 重新显示: v-if需要重新创建标签对象, v-show只需要修改样式显示出来就可以 v-show重新显示更快, 但隐藏时还占用着内存空间: 以空间换时间 v-show更适合切换频繁/需要隐藏的DOM结构比较大 使用v-if解决模板中初始解析undefined的bug 比如: {{a.b.c}} a初始为一个空对象
492. 为什么v-for与v-if不适合一起使用
对遍历的item数据进行限制判断 问题: 如果使用v-if, 每个数组元素都会解析指令来判断 ==> 效率低 解决: 不使用v-if, 使用计算属性, 过滤产生一个子数组 ==> 效率高 根据外部的数据判断 问题: 如果在当前标签上用v-if, 执行n次 ==> 效率低 解决: 添加一个/在父标签, 使用v-if, 执行1次 ==> 效率高
493. computed与watcher以及method的区别
computed与watch的区别 计算属性必须同步返回计算结果, 而watch中可以在异步操作后更新数据显示 watch可以深度监视, 计算属性只是监视了使用到的数据 选择: 如果是根据现在的数据同步计算就可以确定要显示的另一个数据 ==> computed 如果涉及到异步操作/深度监视 ==> watch 一旦一个数据变化, 我们需要做一系列操作 ===> watch computed与method的区别 计算属性有缓存, 多次读取显示只计算一次 method, 多处显示计算多次
494. 说说Vue的常用指令
v-text v-html v-show v-if / v-else / v-else-if v-for v-on v-once: 只初始渲染一次, 用于优化更新性能 v-bind v-model v-slot: 插槽
495. Vue组件的生命周期
单个组件生命周期 初始化: beforeCreate: 不能通过this读取data数据和调用methods中的方法 执行了一些初始化的准备工作 created: 可以通过this读取data数据和调用methods中的方法 编译模板 beforeMount: 不能通过ref读取到页面中内容 挂载编译好的模板, 显示页面 mounted: 能通过ref读取到页面中内容 更新: this.msg += ’—’ beforeUpdate (在数据更新后, 界面更新前调用): 读取的数据是最新的, 但页面是老的 更新页面 updated: 读取的数据和页面都是新的 死亡: $destroy() beforeDestroy: 做一些收尾的工作, 比如: 清除定时器/解绑监听/… destroyed
496. Vue父子组件的生命周期顺序
初始化: beforeCreate created beforeMount —child beforeCreate —child created —child beforeMount —child mounted mounted 更新: beforeUpdate —child beforeUpdate —child updated updated 死亡: beforeDestroy — child beforeDestroy — child destroyed destroyed
497. 区别组件的钩子函数 actived与mounted
mounted:初始化执行一次 activated: 初始化mounted之后 / 每次再回到当前路由
498. 说说对动态组件、缓存组件与异步组件的理解
动态组件 通过的is属性动态加载一个组件 is属性初始为A组件名, 加载A组件, 切换为B组件名, 加载B组件 缓存组件 默认路由组件离开或动态组件被切换, 组件都会立即死亡 能让原本要死亡的组件不死亡, 在背后缓存起来, 后面需要时, 直接使用缓存的 可以通过include与exclude属性来控制哪些组件要缓存或不缓存 异步组件 在引入组件时使用import动态引入: const Home = () => import(’./Home.vue’) 组件会被单独打包, 且只有在第一次访问时才会请求加载对应的打包文件 ==> 减小首屏打包文 件打小 除了组件, 其它模块也可以异步懒加载
499. 说说对递归组件的理解
递归组件: 组件内部有自己的子组件标签 应用场景: 用于显示树状态结构的界面 注意: 递归组件必须有name 编码: 实现一个简单的可开关的树状结构界面的 Tree 组件
<template>
<ul>
<liv-for="(item, index) in data":key="index"
@click.stop="handleClick(item)">
{{item.text}}
<Tree2v-if="item.expend":data="item.children"/>
</li>
</ul>
</template>
<script>
exportdefault { //
name: 'Tree2', // 作为内部的标签名
props: ['data'],
methods: {
handleClick (item) {
if (item.hasOwnProperty('expend')) {
item.expend=!item.expend
} else {
this.$set(item, 'expend', true)
}
}
}
}
500. Vue组件间有哪些通信方式
根据组件间关系分类
- 父向子 props(非函数) v-model $refs, $children 插槽
- 子向父 props(函数) vue自定义事件 v-model .sync $parent 作用域插槽
- 祖孙间 $attrs与$listeners 与v-bind/v-on配合使用 provide与inject
- 兄弟或其它/任意 全局事件总线 Vuex 另一种分类方式
- 属性相关 props v-model $attrs与$listeners 作用域插槽(子向父传递)
- 自定义事件相关 自定义事件 全局事件总线 v-model .sync
- 其它 $refs, $children, $parent provide与inject 插槽 vuex
</script>
501. 子向父通信有哪些方式
props(函数) vue自定义事件 v-model .sync $parent 作用域插槽
502. 说说Vue的自定义事件与全局事件总线
vue自定义事件 实现子组件向父组件通信 相关语法: 父组件中绑定自定义事件监听: <Child @eventName=“callback($event)”> child.$on(‘eventName’, callback) 子组件中分发事件 this.$emit(‘eventName’, 2) 应用: elment-ui的组件的事件监听语法都用的是自定义事件 <el-button @click=“test”> 我们项目中的组件也用了不少自定义事件 全局事件总线 实现任意组件间通信 编码 将入口js中的vm作为全局事件总线对象: beforeCreate() { Vue.prototype.$bus = this } 传递数据的组件分发事件: this.$bus.$emit(‘eventName’, data) 接收数据的组件处理监听: this.$bus.$on(‘eventName’, (data) => {}) 应用: 前台项目中使用全局事件总线 理解: 为什么将vm放到Vue的原型对象上, 所有组件都可见呢? VueComponent.prototype = Object.create(Vue.prototype); VC的原型对象的原型对象就是Vue的原型对象
503. Vue响应式数据原理
简洁表达 对象: 通过Object.defineProperty()添加setter方法来监视属性数据的改变 + 订阅-发布 数组: 重写更新数组元素的一系列方法 + 订阅-发布 调用原生的对应对数组元素进行相应的操作 更新界面去 详细表达(主要说对象的) 初始化 实现数据代理 通过defineproperty给vm定义与data中属性对应的带getter/setter的属性 在getter中, 读取data中对应的属性值返回 => 读取this.msg => 读取的是data中msg 属性值 在setter中, 将最新值保存到data对应的属性上 => this.msg = ‘abc’ => ‘abc’会保存到 data的msg上 创建observer 目标: 对data中所有层次的属性进行监视/劫持 通过defineproperty给data中所有层次属性, 都重新定义, 加上getter与setter getter: 用来建立dep与watcher的关系 setter: 用来当data数据发生改变去更新界面 为data中所有层次的属性创建一个对应的dep ==> 用来将来更新界面的 创建compile 目标1: 实现界面的初始化显示 / 目标2: 为将更新做准备 为模板中每个包含表达式(事件表达式除外)的节点创建一个对应的watcher 给watcher绑定用于更新对应节点的回调函数 将watcher添加到n个对应的dep中 更新 this.msg = ‘abc’ 由于有数据代理 ==> data的msg更新为了’abc’ 由于有数据劫持 ==> data中msg的setter调用了 在setter中, 通过对应的dep去通知所对应的watcher去更新对应的节点 ==> 使用了订阅发 布模式 Vue数据响应式原理结构图
504. Vue双向数据绑定原理
通过v-model来实现双向数据绑定 v-model的本质 将动态的data数据通过value属性传给input显示 ==> data到view的绑定 给input标签绑定input监听, 一旦输入改变读取最新的值保存到data对应的属性上 ==> view到 data的绑定 双向数据绑定是在单向数据绑定(data—>view)的基础, 加入input事件监听(view ==> data)
505. $set和$nextTick的使用场景
项目功能: 列表项点击动态显示输入框, 并自动获取焦点 编码实现: 动态给列表项数据对象添加edit属性为true ==> 标识显示输入框 获取当前input对象, 调用focus() ==> 获取焦点 问题 向响应式对象上直接点添加属性不是响应式 ==> 输入框不会显示 ==> 使用$set添加edit属性 得不到input, 调用focus会报错 ==> 因为界面还没有更新, 还没有input ==> 使用$nextTick指定在 DOM更新后才去执行回调, 在回调中获取input
506. 区别MVVM与MVC
MVVM: 前台的技术 M: Model模型, 也就是包含数据的js对象 ==> data对象 V: View视图,动态显示模型对象中的数据的页面(前台渲染) ==> 模板页面 VM: ViewModel视图模型, 通过vm读取model中的数据显示到view上, 同时view输入数据改变, vm也可以将输入数据保存到model中 ==> Vue/组件的实例 MVC: 后台的技术 M: Model(模型)包含从数据库中查询得到的数据的对象 V: View(视图)动态显示模型对象中的数据的页面(后台渲染) C: Controller(控制器)接收用户提交的请求参数, 操作数据库生成动态数据并产生模型对象
507. Vue.use()做了什么
对象插件: 调用插件对象install方法(传入Vue)来安装插件(执行定义新语法的代码) 函数插件: 直接将其作为install来调用(传入Vue)来安装插件(执行定义新语法的代码)
508. 说说Vue的mixin技术
用来复用多个组件中相关的js代码的技术 将多个组件相同的js代码提取出来, 定义在一个mixin中配置对象 在多个组件中通过mixins配置引入mixin中的代码, 会自动合并到当前组件的配置中
509. Vue的组件data为什么必须是一个函数
同一个组件的多个组件实例的data必须是不同的对象(内容初始数据可以相同) 如果是data是对象, 组件的多个实例共用一个data对象 如果是函数, 组件对象通过调用函数得到的一个新的data对象
510. vuex的5大属性
state mutations actions getters modules namespaced: true
511. vuex的数据流结构图
单向数据流:组件 dispatch → Action(可异步)→ commit → Mutation(同步修改 state)→ state 变更 → 视图/Getter 更新。Mutation 必须同步、异步放 Action,数据只能沿这条链流动,便于追踪变更。
512. vuex中的mutation可以执行异步操作吗?
功能可以 ==> 异步更新数据后界面确实会自动更新 问题 ==> vuex的调试工具监视不到mutation中的异步更新, 工具记录还是更新前的数据(不对) 扩展: 工具如何记录数据变化? ==> 每次mutation函数执行完后, 立即记录当前的数据 ==> 在mutation 中同步更新state, 才能被记录到
513. vuex中的状态数据的响应式的原理?
- 创建了一个vm对象
- state中的数据都是vm的data数据(是响应式的)
- 组件中读取的state数据本质读取的就是data中的数据
- 一旦更新了state中的数据, 所有用到这个数据的组件就会自动更新
514. vuex数据刷新丢失的问题
绑定事件监听: 在卸载前保存当前数据 在初始时读取保存数据作为状态的初始值
515. 路由组件间通信方式
query参数 params参数 props(需要配置, 而不是标签属性) true ==> 将路由的params参数映射成props ==> 只能传递param参数 对象 ==> 将对象中的属性映射成props ==> 只能传递自定义的参数 route => {} ==> 将函数返回的对象中的属性映射成props ==> 能会传递params和query参数和自 定义的 meta(也是配置) meta vuex
516. 跳转携带的参数, 刷新就丢失了
如果注册没有指定/:xxx的点位, 而跳转时通过params配置携带的参数数据, 刷新时就会丢失 因为url中没有携带的参数数据路径
new Vue({
data: {
home: {
categoryList: [],
xxx: {}
},
user: {
userInfo: {}
}
}
})
window.addEventListener('beforeunload', () => { // 当页面刷新时, 页面卸载前的事件回调
sessionStorage.setItem('CART_LIST_KEY',
JSON.stringify(this.$store.state.shopCart.cartList))
})
window.removeEventListener('beforeunload')
cartList: JSON.parse(sessionStorage.getItem('CART_LIST_KEY')) || [],
517. 编程式路由跳转到当前路由, 参数不变, 会报出错误?
前一个项目没这个问题, 后一个项目有问题 3.1.0版本(2019.8)没这个问题, 3.1.0这后才有这个问题 3.1.0之前: 返回值为undefined push(location) push(location, () => {}, () => {}) 3.1.0之后: 如果没有指定回调函数返回promise对象 push(location).then(() => {}).catch(() => {}) vue-router在3.1.0版本(2019.8)引入了push()的promise的语法, 如果没有通过参数指定回调函数 就返回一个promise来指定成功/失败的回调, 且内部会判断如果要跳转的路径和参数都没有变 化, 会抛出一个失败的promise 说明文档: https://github.com/vuejs/vue-router/releases?after=v3.3.1 解决: 办法1: 在每次push时指定回调函数或catch错误 办法2: 重写VueRouter原型上的push方法 (比较好) 1). 如果没有指定回调函数, 需要调用原本的push()后catch()来处理错误的promise 2). 如果传入了回调函数, 本身就没问题, 直接调用原本的push()就可以 扩展问题 声明式路由跳转之所有没有问题, 是因为默认传入了成功的空回调函数
518. history与hash路由的区别和原理
区别: history: 路由路径不#, 刷新会携带路由路径, 默认会出404问题, 需要配置返回首页 404: history有: 刷新请求时会携带前台路由路径, 没有对应的资源返回 hash没有: 刷新请求时不会携带#路由路径 解决: 开发环境: 如果是脚手架项目本身就配置好
push('/xxx', () => {}) ===>
push('/xxx').catch(() => {})
constoriginPush=VueRouter.prototype.push
VueRouter.prototype.push=function (location, onComplete, onAbort) {
console.log('push()', onComplete, onAbort)
// 判断如果没有指定回调函数, 通过call调用源函数并使用catch来处理错误
if (onComplete===undefined&&onAbort===undefined) { // 使用的新语法
returnoriginPush.call(this, location).catch(() => {})
} else { // 如果有指定任意回调函数, 通过call调用源push函数处理
returnoriginPush.call(this, location, onComplete, onAbort)
}
}
==> webpack ==> devServer: { historyApiFallback : true} 当使用HTML5 History API时, 所有的404请求都会响应index.html的内容 生产环境打包运行: 配置nginx hash: 路由路径带#, 刷新不会携带路由路径, 请求的总是根路径, 返回首页, 没有404问题 原理: history: 内部利用的是history对象的pushState()和replaceState() (H5新语法) hash: 内部利用的是location对象的hash语法 写hash路径 location.hash = ’#/xxx’ 读hash路径: location.hash 监视hash路径的变化: window.onhashchange = () => {}
519. 如何实现登陆后, 自动跳转到前面要访问的路由界面
在全局前置守卫中, 强制跳转到登陆页面时携带目标路径的redirect参数 在登陆成功后, 跳转到redirect参数的路由路径上
520. 路由导航守卫的理解和使用
导航守卫是什么? 导航守卫是vue-router提供的下面2个方面的功能 监视路由跳转 —>回调函数 控制路由跳转 —> 放行/不放行/强制跳转到指定位置 next(path) 应用 在跳转到界面前, 进行用户权限检查限制(如是否已登陆/是否有访问路由权限) 在跳转到登陆界面前, 判断用户没有登陆才显示
location / {
try_files$uri $uri/ /index.html; # 所有404的请求都返回index页面
}
if (userInfo.name) {
next()
} else {
// 如果还没有登陆, 强制跳转到login
next('/login?redirect='+to.path) // 携带目标路径的参数数据
}
awaitthis.$store.dispatch('login', {mobile, password})
// 成功了, 跳转到redirect路由或首页
constredirect=this.$route.query.redirect
this.$router.replace(redirect||'/')
导航守卫分类 全局守卫: 针对任意路由跳转 全局前置守卫 全局后置守卫 router.afterEach((to, from) => {}) 路由独享守卫 前置守卫 组件守卫: 只针对当前组件的路由跳转 进入 更新: beforeRouteUpdate (to, from, next) {} 离开 beforeRouteLeave (to, from, next) {}
521. 请说明key的作用和原理
router.beforeEach((to, from, next) => {
// ...
})
{
path: '/foo',
component: Foo,
beforeEnter: (to, from, next) => {}
},
{
path: '/ff',
component: Foo,
},
beforeRouteEnter (to, from, next) {
// 不能使用this, this是undefined
next((comp) => { // 延迟到组件对象创建后才执行
// comp就是组件对象
})
},
1. 虚拟DOM的key的作用?
1). 简单的说: key是虚拟DOM对象的标识, 在更新显示时key起着极其重要的作用 2). 详细的说: 当列表数组中的数据发生变化生成新的虚拟DOM后, 进行新旧虚拟DOM的diff比较
a. 有一个对应的key
item数据没变, 直接使用原来的真实DOM
item数据变了, 对原来的真实DOM进行数据更新
522. 理解Vue的虚拟DOM
虚拟 DOM 是用 JS 对象描述真实 DOM 树的轻量副本(tag、props、children)。数据变化时先生成新的虚拟 DOM,与旧树 diff 找出最小变更,再 patch 到真实 DOM,避免整棵重渲染;同时让 Vue 具备跨平台渲染能力(SSR、Weex)。
523. 说说Vue的 Diff算法
b. 没有一个对应的key
根据item数据创建新的真实DOM显示
2. key为index的问题
1). 添加/删除/排序 => 产生没有必要的真实DOM更新 ==> 界面效果没问题, 但效率低 2). 如果item界面还有输入框 => 产生错误的真实DOM复用 ==> 不仅效率低, 界面效果也有问题 注意: 如果不存在添加/删除/排序操作, 用index没有问题
3. 解决:
使用item数据的标识数据作为key, 比如id属性值 一个较轻的普通JS对象 ==> 真实DOM是一个较重的对象 => 轻重看对象内部属性多少 虚拟DOM对象有时也称为虚拟节点对象(vNode), 它包含了用于生成一个真实DOM/Node的必要信息, 比如: 标签结构:
<ul id="list">
<li key="1">abc1</li>
<li key="2">abc2</li>
</ul>
虚拟DOM/节点
{
tagName: 'ul',
props: {
id: 'list',
},
children: [
{tagName: 'li', props: {}, children: ['abc1'], key: '1'},
{tagName: 'li', props: {}, children: ['abc2'], key: "2"},
]
}
目标:
比较的结果是要确定: 哪些原来真实DOM可以复用(但内部内容可能要更新), 要创建哪些真实DOM 处理流程 只做同层比较 => 虚拟DOM也是一个倒立树状态结构, 只进行同层比较, 这样比较次数少,效率高 确定要比较的新旧虚拟节点
没有key: 依次比较 ==> 多出的虚拟DOM, 直接创建新的真实DOM
有key: 找同名的key比较 ==> 没有找到, 直接创建新的真实DOM
先比较标签名
如果不同, 直接创建新的真实DOM
如果相同, 复用原来对应的真实DOM => 如果数据内容有变化, 更新真实DOM内部内容
简单流程: 同层比较 => 比较key => 比较标签名 => 复用
524. nextTick的理解
Vue 的 DOM 更新是异步批量的:改完数据立刻读 DOM 拿到的还是旧值。nextTick 把回调推迟到本轮 DOM 更新之后执行(微任务实现),用于”改完数据马上操作 DOM”的场景。
525. Vue代码层面优化
v-for 遍历列表 指定非下标的唯一key, 尽量不用index, 如果只用于展示就没关系 不同时使用 v-if 图片资源懒加载 使用vue-lazyload element-ui/vant-ui Image组件本身就有懒加载的功能 路由组件懒加载 ==> 预加载 第三方插件的按需引入打包 element-ui / vant /lodash 对高频事件进行节流或防抖处理 是什么? 官方描述: 在下次 DOM 更新循环结束之后执行延迟回调。在修改数据之后立即使用这个方法,获取更新后的
DOM
在数据更新后, 调用nextTick(callback),在callback中才可以读取到更新后的DOM
使用场景? 更新数据后, 想操作更新后的DOM 项目功能1: 使用swiper实现动态轮播 项目功能2: 动态显示input输入框后, 需要自动获取焦点 原理? 更新数据后, DOM不会立即更新, 而是在所有数据都变化完后, 将DOM更新作为一个异步任务统一执行 理解Tick: 取出队列中的一个回调任务到调用栈中执行就是一个tick, 有时也指定队列中的一个回调任务
nextTick(callback): 将callback指定为下一个异步回调任务执行
为什么要先更新数据再调用nextTick()呢?
第一个数据更新才触发将DOM更新放入任务队列
这样nextTick指定的callback就是放在DOM更新任务之后
这样callback中才能读取到更新后的DOM
nextTick中用的是哪个异步技术呢?
简单说: 优先使用微任务, 如果不支持才选择宏任务
详细说: promise => MutationObserver => setImmediate => setTimeout
及时销毁事件监听 大数组优化 冻结响应式数据 虚拟列表
526. webpack配置层面优化
浏览器兼容处理 JS: @babel/polyfill => core-js配置useBuiltIns: ‘usage’ CSS: 给C3样式自动添加浏览器厂商前缀 => autoprefixer => postcss-loader 拆分打包与压缩 资源预加载(prefetch) 生产环境时不生成 SourceMap 文件名hash化=>利用浏览器缓存 代码Tree Shaking
527. 基础的Web技术层面的优化
对打包文件开启 Gzip压缩 静态资源(css/js/img)使用CDN引入
528. TS + Vue3
defineComponent让 props/emit 拥有完整类型推断。- Composition API 的 setup 天然利于类型推导(Options API 的 this 类型复杂)。
- Volar 提供模板级类型检查,支持泛型组件。
- API 层可以用 axios 泛型约束返回结构。新项目直接用 create-vue 的 TS 模板起步。
五、React
529. 如何理解 UI = f(state) 这个公式?
解释(核心思想):UI 是应用状态(state)在某个时刻的纯函数映射。给定相同的 state 输入,渲染结果应该一致;渲染逻辑不要产生副作用。把 UI 理解为“状态的视图”有助于构建可预测、可测试的界面——当 state 改变时,框架负责把 UI 从旧状态更新到新状态(差分/重渲染)。
面试要点:强调纯函数、可重现性、单向数据流、不可变性带来的简单比较(引用 shallow compare 优势)。
代码 demo:
function Counter({ count }) {
// Counter 是 UI = f(state) 的直接例子
return <div>Count: {count}</div>;
}
// 使用
function App() {
const [count, setCount] = React.useState(0);
return (
<>
<Counter count={count} />
<button onClick={() => setCount(c => c + 1)}>+1</button>
</>
);
}
530. 虚拟 DOM(Virtual DOM)是什么?它解决了哪些实际问题?
解释:虚拟 DOM 是 JS 对实际 DOM 的轻量内存表示(通常是树形对象)。当 state 改变时,框架先基于新的状态生成一棵新的虚拟 DOM,然后对新旧虚拟 DOM 做差分(reconciliation),只把必要的最小修改(patch)应用到真实 DOM。它解决了:频繁操作真实 DOM 的性能开销、手工高复杂度 DOM 更新逻辑以及跨平台渲染抽象(如服务端渲染、原生渲染)。
面试要点:区别“直接操作 DOM”与“构建树->差分->最小更新”的优势;并说明虚拟 DOM 并非万能(正确的性能策略还需避免过度重渲染、使用键 key 等)。
代码 demo(手写简化版本的虚拟 DOM diff):
// 极简:虚拟节点表示
function h(type, props, ...children) {
return { type, props: props || {}, children };
}
// 简单 render -> DOM(递归)
function render(vnode, container) {
if (typeof vnode === 'string' || typeof vnode === 'number') {
container.appendChild(document.createTextNode(String(vnode)));
return;
}
const el = document.createElement(vnode.type);
for (const [k, v] of Object.entries(vnode.props || {})) {
el.setAttribute(k, v);
}
vnode.children.forEach(child => render(child, el));
container.appendChild(el);
}
// 用法:
const vnode = h('div', {id: 'app'}, 'hello', h('span', null, 'world'));
render(vnode, document.getElementById('root'));
531. 说说你对 JSX 的理解
解释:JSX 是 JavaScript 的语法扩展,编写起来像 HTML,但本质是 React.createElement(type, props, ...children) 的语法糖。JSX 提高可读性、把组件结构表达为声明式树,并且允许在模板中直接使用 JS 表达式。编译工具(Babel/TypeScript)把 JSX 转成普通 JS 对象(React 元素)。
面试要点:解释 JSX 并不是模板引擎,强调表达式能力(花括号)、条件渲染、列表渲染与 key、以及与类型系统(TSX)的协作。
代码 demo:
// JSX 写法
function Greeting({ name }) {
return <h1>Hello, {name ?? 'stranger'}!</h1>;
}
// 编译后大致等价于:
function GreetingCompiled(props) {
return React.createElement('h1', null, 'Hello, ', props.name ?? 'stranger', '!');
}
532. 函数组件和类组件的本质区别是什么?
解释:本质上两者都是将 props 映射到 UI 的函数式抽象,但区别在于实现与生命周期模型:
- 类组件:通过
class Component extends React.Component,生命周期方法为实例方法(constructor、componentDidMount 等),内部使用this.state,this语义。 - 函数组件:本质上是函数(无实例),通过 Hooks(如
useState、useEffect)管理状态与副作用。Hooks 提供更灵活的组合能力、避免this相关陷阱,并鼓励小粒度复用。
React 团队的方向(从 React 16.8 后)是以函数组件 + Hooks 为主流,类组件仍被支持但不推荐新写。
代码 demo(同功能对比):
// 类组件
class TimerClass extends React.Component {
state = { t: 0 };
componentDidMount() { this.id = setInterval(() => this.setState(s => ({t: s.t + 1})), 1000); }
componentWillUnmount() { clearInterval(this.id); }
render() { return <div>{this.state.t}</div>; }
}
// 函数组件 + Hooks
function TimerFunc() {
const [t, setT] = React.useState(0);
React.useEffect(() => {
const id = setInterval(() => setT(v => v + 1), 1000);
return () => clearInterval(id);
}, []);
return <div>{t}</div>;
}
533. 为什么 React 中 props 不可变(immutable)?
解释:props 是父组件下发给子组件的只读输入参数。不可变性保证了组件之间的边界清晰——子组件不会悄然改变父组件的数据源。此外,不可变数据便于进行浅比较(reference compare)从而优化渲染(shouldComponentUpdate / PureComponent / memo),减少不必要的重渲染。若需要改变父数据,应通过回调把意图通知父组件由父修改状态。
代码示例(错误示范 + 正确做法):
// 错误(不要直接修改 props 对象内部)
function Child({ obj }) {
// BAD: mutating props
obj.count = obj.count + 1; // 切勿这样做
return <div>{obj.count}</div>;
}
// 正确(通过回调向上通知)
function Parent() {
const [obj, setObj] = React.useState({count: 0});
return <Child obj={obj} onInc={() => setObj(o => ({...o, count: o.count + 1}))} />;
}
function Child({ obj, onInc }) {
return <button onClick={onInc}>{obj.count}</button>;
}
参见:不可变数据便于引用比较与性能优化(可理解参考 React 文档)。bennadel.com+1
534. React 的 Fiber 架构主要是为了解决什么问题?
解释:Fiber 是对 React 内部 reconciler 的重写,目标是支持增量渲染与可中断/优先级调度。在早期版本 React 在执行大量同步渲染时会阻塞主线程,影响动画与交互体验。Fiber 将渲染拆分为可中断的“工作单元”,允许 React 在渲染中插入优先级判断与让步(yield),从而改善动画、手势响应以及并发特性(concurrent rendering)的实现基础。
面试要点:说明两个阶段(reconciliation 与 commit),Fiber 如何让中断与恢复成为可能,以及它对 useTransition/并发渲染等特性的支撑作用。LogRocket Blog+1
简化示意代码(伪代码展示任务分片):
// 伪:把大任务拆成小任务,模拟 Fiber 调度
function workLoop(workQueue) {
while (workQueue.length > 0 && !shouldYield()) {
const unit = workQueue.shift();
performUnitOfWork(unit);
}
if (workQueue.length > 0) {
requestIdleCallback(() => workLoop(workQueue));
} else {
commitAll();
}
}
535. React 中的 key 属性有什么作用?
解释:key 用于在列表渲染时帮助 React 辨认元素的身份,从而在做 diff 时能正确地保留/复用 DOM 节点并最小化变更。合适的 key(稳定且唯一,如数据库 id)避免了错误的节点复用(例如输入框光标跳动、组件内部 state 错位)。不推荐使用索引作为 key(在列表会发生插入/删除/排序时会破坏复用)。
代码 demo:
function TodoList({ items }) {
return (
<ul>
{items.map(item => (
<li key={item.id}>
<input defaultValue={item.text} />
</li>
))}
</ul>
);
}
536. React 的事件机制和合成事件是如何工作的?
解释:React 使用“合成事件”(SyntheticEvent)作为跨浏览器的事件封装层。React 在根节点上绑定少量真实 DOM 事件(事件委托),当事件发生时,React 会构建合成事件对象并按组件树执行回调。合成事件的好处:统一跨浏览器行为、事件池(老版本)以复用对象、以及更简单的生命周期一致性(在某些场景下 React 能更好地控制事件顺序)。注意:事件处理器中的 event.persist() 可阻止事件被复用(旧机制),React 现在已改进事件对象生命周期但概念仍然一致。
代码 demo:
function MyButton() {
function handleClick(e) {
console.log('target', e.target);
// e is a SyntheticEvent
}
return <button onClick={handleClick}>Click</button>;
}
537. 受控组件(controlled)和非受控组件(uncontrolled)有什么区别?
解释:
- 受控组件:表单元素的值由 React state 完全控制(
value+onChange)。好处:单一真相、便于验证、条件禁用、联动等。 - 非受控组件:表单元素自己管理内部 state,通过 ref 在需要时读取值(类似传统 DOM 表单)。适用于简单场景或需要与第三方库集成且不想每次输入都触发渲染。
代码 demo(对比):
// 受控
function Controlled() {
const [v, setV] = React.useState('');
return <input value={v} onChange={e => setV(e.target.value)} />;
}
// 非受控
function Uncontrolled() {
const ref = React.useRef();
function submit() {
alert(ref.current.value);
}
return <>
<input ref={ref} defaultValue="init" />
<button onClick={submit}>Submit</button>
</>;
}
538. 为什么在 React 中“组合优于继承”?
解释:组合(composition)更灵活、可组合、符合函数式思想;通过把小组件组合起来可以构建复杂功能,而继承往往造成紧耦合、难以复用、难以理解的类层级。React 的 props / children / render-props / hooks 都是组合的体现。官方建议使用组合来复用组件逻辑(而不是继承)。
代码 demo(组合示例):
function Modal({children}) {
return <div className="modal">{children}</div>;
}
function App() {
return (
<Modal>
<h1>Title</h1>
<p>Content</p>
</Modal>
);
}
539. React 的严格模式(StrictMode)有什么作用?
解释:<StrictMode> 在开发模式下启用额外检查与警告(并不影响生产构建),如:
- 检查过时的生命周期方法;
- 在开发环境对组件 mount/unmount 进行双重调用以暴露副作用中的不纯代码(例如不正确的清理);
- 启用对某些未来改动的警告(如对 refs 的变化等)。
面试要点:说明 StrictMode 通过“在开发环境下执行额外运行”帮你发现副作用和不安全的生命周期。
代码 demo:
ReactDOM.createRoot(root).render(
<React.StrictMode>
<App />
</React.StrictMode>
);
540. useState 的更新是异步的吗?
解释:在 React 中调用 setState(或 setX)不会立即更新当前渲染中的变量——它会安排一次重新渲染,更新会在随后渲染周期反映出来。并且 React 会对同一事件循环中的多个更新进行批处理(React 18+ 的自动批处理扩展了批处理的情形)。因此从调用 setState 到 DOM 更新是异步的(对当前渲染而言);但如果你在同一个渲染里多次调用 setState,React 可能会合并这些更新(尤其在使用函数式更新时行为确定)。
代码 demo(说明):
function Demo() {
const [n, setN] = React.useState(0);
function onClick() {
setN(n + 1);
console.log(n); // 仍然是旧值(在当前渲染里)
setN(n + 2);
}
return <button onClick={onClick}>{n}</button>;
}
关于自动批处理(React 18)的工作方式可参考官方发布说明。react.dev
541. 使用 useState 的函数式更新方式能带来哪些好处?
解释:函数式更新(setState(prev => newVal))的优势:
- 保证在多次更新(尤其依赖旧值)时的正确性,避免闭包捕获旧 state 导致竞态;
- 在批处理或异步回调中能安全地基于最新值做计算;
- 更容易避免依赖数组问题。
代码 demo:
function Counter() {
const [count, setCount] = React.useState(0);
function incTwice() {
// 正确:每次都基于最新值
setCount(c => c + 1);
setCount(c => c + 1);
}
return <button onClick={incTwice}>{count}</button>;
}
542. “状态提升”这种模式有哪些优缺点?
解释:
- 优点:把共享 state 放到最近的共同祖先,能保证单一数据源、易于同步与逻辑集中,便于验证与持久化。
- 缺点:会导致“祖先”组件变大(prop drilling),频繁更新可能导致更多子组件重渲染,降低局部封装性。需要配合
memo、context、或拆分组件来缓解。
代码 demo(状态提升):
function Parent() {
const [value, setValue] = React.useState('');
return (
<>
<Input value={value} onChange={v => setValue(v)} />
<Preview value={value} />
</>
);
}
缓解方案:用 context、或者把不变部分 memo 化,或使用局部状态与事件回传。
543. useReducer 相比 useState 优势体现在哪?
解释:
- 更适合描述复杂状态逻辑(多子值,基于操作类型的更新),便于把更新逻辑集中到 reducer 函数;
- 便于在多个组件之间共享或抽离状态逻辑(将 reducer 提取为纯函数);
- 与中间件 / 日志 / 时间旅行(像 Redux)思想契合。
代码 demo(计数器):
function reducer(state, action) {
switch (action.type) {
case 'inc': return {count: state.count + 1};
case 'dec': return {count: state.count - 1};
default: return state;
}
}
function Counter() {
const [state, dispatch] = React.useReducer(reducer, {count: 0});
return (
<>
<button onClick={() => dispatch({type: 'dec'})}>-</button>
{state.count}
<button onClick={() => dispatch({type: 'inc'})}>+</button>
</>
);
}
544. 如何优化因 useContext 引起的性能问题?
解释:Context 更新会触发所有消费该 context 的组件重新渲染(即使它们读取的值未改变)。优化策略:
- 将 context 值拆分为更粒度的 context(避免频繁更新的大对象);
- 在提供方使用
useMemo或稳定引用(避免每次 render 提供新对象); - 消费方用
memo并把 context 中仅必要字段传入子组件,或使用选择器/订阅模式(像 Zustand 的订阅); - 把高频更新(如动画、光标位置)移出 React state,使用 ref 或外部 store。
代码 demo(useMemo 防止不必要重渲染):
function Provider({children}) {
const [count, setCount] = React.useState(0);
const value = React.useMemo(() => ({count, increment: () => setCount(c => c + 1)}), [count]);
return <MyContext.Provider value={value}>{children}</MyContext.Provider>;
}
545. 说一下 Redux 的核心思想
解释:Redux 的核心思想:
- 单一源(single source of truth):整个应用的 state 存在一个 store;
- 状态只读:不能直接修改 state,只能派发 action;
- 使用纯函数 reducer 描述 state 如何更新:reducer 接收旧 state 与 action,返回新 state(纯函数)。
Redux 强调可预测性、时间旅行(devtools)、中间件链(处理异步/副作用)与易于测试。
代码 demo(基本 Redux 概览,使用 **@reduxjs/toolkit** 推荐):
// 使用 Redux Toolkit 简化
import { configureStore, createSlice } from '@reduxjs/toolkit';
const counter = createSlice({
name: 'counter',
initialState: {value: 0},
reducers: {
inc: s => { s.value += 1; },
dec: s => { s.value -= 1; }
}
});
const store = configureStore({ reducer: { counter: counter.reducer } });
store.dispatch(counter.actions.inc());
console.log(store.getState());
546. 为什么说 Immer.js 在现代 Redux 生态中扮演重要角色?
解释:Immer 允许用“可变风格”的代码写 reducer(直接修改 draft),在内部会生成不可变的新 state(通过 structural sharing)。这样兼顾了编程便利性(直观的赋值语句)与不可变数据带来的性能/可预测性优势。Redux Toolkit 将 Immer 集成到 createSlice,简化 reducers 的编写。
代码 demo(使用 Immer 的写法 vs 等价不可变写法):
// Immer 风格(Redux Toolkit 已内置)
function reducer(state = {a: 0}, action) {
if (action.type === 'inc') {
state.a += 1; // 看起来是可变,但 Immer 会转成不可变更新
}
return state;
}
// 等价手写不可变写法
function reducerPure(state = {a: 0}, action) {
if (action.type === 'inc') {
return {...state, a: state.a + 1};
}
return state;
}
547. Redux 的中间件(Middleware)机制是如何工作的?
解释:中间件是 Redux dispatch 流程中的拦截器。它接收 store(getState/dispatch)并返回一个接收 next 的函数,然后返回接收 action 的函数。中间件可以在 action 到达 reducer 之前拦截、修改、延迟或触发其他副作用(例如 thunk、saga、logger)。中间件以链式方式组合,最终调用 reducer。
代码 demo(自定义 logger 中间件):
const logger = store => next => action => {
console.log('dispatching', action);
const result = next(action);
console.log('next state', store.getState());
return result;
};
const store = Redux.createStore(rootReducer, Redux.applyMiddleware(logger));
548. 你是否了解像 Zustand、Jotai 这类新兴的状态管理库?它们各自有什么特点?
解释 & 要点:
- Zustand:轻量、基于订阅的全局 store(没有 Provider 必要),使用简单的 API(
create),组件可以选择性订阅切片状态,性能友好(按订阅字段更新)。适合替代 Redux 的简单场景。 - Jotai:基于原子(atom)概念的小粒度可组合状态,易于分片和复用,支持异步/派生状态。它把状态拆成原子,组件订阅原子,减少不必要渲染。 两者都追求更简单更小的 API 曲线,并利用现代 React 特性来减少样板。
代码 demo(Zustand 简单示例):
import create from 'zustand';
const useStore = create(set => ({
count: 0,
inc: () => set(s => ({count: s.count + 1}))
}));
function Counter() {
const {count, inc} = useStore(s => ({count: s.count, inc: s.inc}));
return <button onClick={inc}>{count}</button>;
}
549. 像 SWR 或 React Query 这样的库,它们主要解决了什么问题?
解释:这些库专注于客户端数据获取(fetching)与缓存,解决了常见问题:
- 请求缓存与去重(避免重复请求);
- 后台刷新(stale-while-revalidate)策略;
- 请求失败重试、分页/无限滚动、请求状态(isLoading/isError)管理;
- 与 React 渲染整合(避免竞态、自动重试/刷新);
- 方便的缓存失效(invalidations)与查询依赖管理。
它们把数据获取变成可声明的资源,简化了从服务器数据到 UI 的管线。
代码 demo(React Query):
import { useQuery } from '@tanstack/react-query';
function Todos() {
const { data, isLoading } = useQuery(['todos'], () => fetch('/api/todos').then(r => r.json()));
if (isLoading) return 'loading';
return <ul>{data.map(t => <li key={t.id}>{t.text}</li>)}</ul>;
}
550. 你是如何理解 Signals 的?它与 React 现有的状态管理方式有何不同?
解释:Signals(常见于 Solid、Angular signals、或 React 围绕 signal 的提议)是对可观察值的轻量封装,读取时会建立依赖,值变化会同步触发对应读取位置的更新。与 React 的 Hooks(基于组件重新渲染)不同,signals 更像细粒度的可变引用:改变 signal 只会更新真正依赖它的地方,而不需要整个组件重新渲染。优点:更小的更新粒度、潜在更少的重渲染、并且更接近响应式编程模型。React 社区对此也在探索(例如部分库/提案),但 React 的核心目前仍以 hooks & rerender 为主流。
代码 demo(Signal 风格伪代码):
// 伪示意(非官方 API)
const count = signal(0);
effect(() => {
console.log('count changed', count.value);
});
count.value = 1; // 只触发依赖该 signal 的 effect
551. 你能详细解释一下 React Hooks 的执行顺序和依赖规则吗?
解释(关键规则):
- Hooks 必须在 React 函数组件或自定义 Hook 的顶层调用,不能在条件、循环或嵌套函数中调用(保证每次渲染 Hook 调用顺序一致)。
- React 根据调用顺序(索引)把 Hook 调用与内部状态槽(hook slots)一一对应,因此不能更改调用顺序。
- 依赖规则(针对
useEffect/useMemo/useCallback):传入的依赖数组应列出所有在回调中使用到的外部变量(除非这些变量是稳定的,如ref.current、常量或经useRef/useReducer管理的值),否则可能导致过时的数据或副作用问题。
面试要点:讲清楚“为什么”不能在条件中调用(因为索引错位会把 state/副作用错配),说明如何处理函数依赖(useCallback)、避免无限循环(不要把 setState 作为依赖,或使用函数式更新)。
代码 demo(错误示范与修正):
// 错误:Hook 在条件里
function Bad({ flag }) {
if (flag) {
React.useEffect(() => { /* ... */ }, []); // 不可行
}
}
// 正确
function Good({ flag }) {
React.useEffect(() => {
if (!flag) return;
// safe
}, [flag]);
}
552. useEffect 的执行时机具体是什么时候?它和 useLayoutEffect 有什么核心区别?
解释:
useEffect:在浏览器完成布局与绘制之后异步执行(commit 后、paint 后),不会阻塞渲染,因此适合网络请求、订阅、日志等副作用。useLayoutEffect:在 DOM 变更提交但在浏览器绘制之前同步执行(在 commit 阶段),会阻塞浏览器绘制,适合需要同步读取/修改 DOM(例如测量元素尺寸并同步设置样式)以避免视觉闪烁。
面试要点:尽量用 useEffect;仅当你必须在绘制前同步读写 DOM 时才用 useLayoutEffect。
代码 demo:
function Measure() {
const ref = React.useRef();
React.useLayoutEffect(() => {
const rect = ref.current.getBoundingClientRect();
// 这里同步读布局并可同步修改 DOM
}, []);
return <div ref={ref}>box</div>;
}
553. useEffect 依赖项有什么用?
解释:依赖数组让 React 决定何时重新运行 effect:当数组中的任一引用(===)变化时,effect 会在下次 commit 后运行。它用于控制副作用的触发频率与条件,避免不必要的重复执行或遗漏必要更新。
面试要点:说明依赖应该包含 effect 中用到的所有外部变量;可以用 useCallback/useMemo 稳定引用;必要时明确说明 // eslint-disable 仅在确认安全的情况下使用。
代码 demo:
React.useEffect(() => {
// fetch whenever userId changes
fetch(`/api/user/${userId}`).then(...);
}, [userId]);
554. 在 useEffect 中,如何正确地处理异步请求并避免竞态条件(race condition)?
解释 & 实践:
- 在 effect 内使用一个**标记(isMounted / abort controller)**来忽略过时的响应;
- 使用
AbortController取消 fetch 请求; - 在有多个请求并发时,为每次请求生成唯一标识并只处理最新一次的结果;
- 如果 state 更新必须基于最新请求结果,使用
useRef保存最新标识并在回调里比对。
代码 demo(使用 AbortController):
function User({ userId }) {
const [data, setData] = React.useState(null);
React.useEffect(() => {
const ac = new AbortController();
fetch(`/api/user/${userId}`, { signal: ac.signal })
.then(r => r.json())
.then(d => setData(d))
.catch(err => {
if (err.name === 'AbortError') return;
throw err;
});
return () => ac.abort(); // cleanup cancels previous request
}, [userId]);
return <div>{JSON.stringify(data)}</div>;
}
555. 什么时候应该使用 useCallback 和 useMemo?如果滥用它们会带来什么后果?
解释:
- 使用场景:当你需要稳定的引用(函数或计算结果)以避免子组件不必要重渲或避免重新创建昂贵计算时使用(例如传给依赖数组或作为 prop 给
memo组件)。 - 滥用后果:增加复杂性与内存开销(缓存本身也有成本),且在很多情况下
useMemo/useCallback的维护成本比它带来的性能提升要高(小组件/快速计算下反而更慢)。
面试要点:先测(profile),只在确实存在性能问题或避免不必要重新渲染时使用。
代码 demo:
const memoizedFn = React.useCallback(() => {
doSomething(expensiveParam);
}, [expensiveParam]);
const memoizedValue = React.useMemo(() => heavyCompute(x), [x]);
556. useRef 有哪些常见的应用场景?
解释 & 场景:
- 访问 DOM 节点(
ref指向元素); - 存放跨渲染周期的可变值(例如计时器 id、上一次 props 值),且更新不会触发重渲染;
- 在回调中获取最新的值(避免闭包捕获旧值);
- 实现非受控组件或与第三方库集成。
代码 demo(保存上一次值):
function Component({ value }) {
const prevRef = React.useRef();
React.useEffect(() => { prevRef.current = value; }, [value]);
const prev = prevRef.current;
return <div>prev: {String(prev)}</div>;
}
557. forwardRef 和 useImperativeHandle 怎么用?
解释:
forwardRef用来把父组件传下来的 ref 转发到子组件的内部 DOM 或值上;useImperativeHandle在使用forwardRef时允许子组件暴露自定义的实例值(而不是默认的 DOM 节点),通过第二个参数返回要暴露的对象。注意:这种方式破坏封装性,应谨慎使用,仅在需要 imperative API(例如 focus)时使用。
代码 demo(暴露 focus API):
const Input = React.forwardRef((props, ref) => {
const inputRef = React.useRef();
React.useImperativeHandle(ref, () => ({
focus: () => inputRef.current.focus()
}));
return <input ref={inputRef} {...props} />;
});
function Parent() {
const ref = React.useRef();
return <button onClick={() => ref.current.focus()}><Input ref={ref} /></button>;
}
558. useId 如何解决 SSR 场景下的 ID 冲突和可访问性问题?
解释:useId 生成稳定且在服务器/客户端一致的 id(避免 SSR 首次渲染时 id 不一致导致 hydration mismatch)。它用于生成与组件实例相关的唯一 id(例如 label 与 input 的 id/htmlFor 关系),改善可访问性和避免手写 id 的冲突。
代码 demo:
function TextField({ label }) {
const id = React.useId();
return (
<div>
<label htmlFor={id}>{label}</label>
<input id={id} />
</div>
);
}
559. useTransition 和 useDeferredValue 的使用和区别?
解释:
useTransition:用于把某些更新标记为低优先级“transition”,提供startTransition来包裹更新并返回isPending标志。适合将“非关键”渲染放到后台(例如列表过滤后的渲染)。useDeferredValue:用于延迟某个值的更新,使 UI 在输入时保持响应(例如输入框即时反馈,但大列表过滤延迟更新)。它更适合在你不能轻易把更新包装到startTransition中时使用。
代码 demo(对比):
// useTransition
function Search() {
const [q, setQ] = React.useState('');
const [isPending, startTransition] = React.useTransition();
const [results, setResults] = React.useState([]);
function onChange(e) {
const v = e.target.value;
setQ(v);
startTransition(() => {
setResults(expensiveFilter(v));
});
}
return <>
<input value={q} onChange={onChange} />
{isPending ? 'loading...' : <List items={results} />}
</>;
}
// useDeferredValue
function Search2() {
const [q, setQ] = React.useState('');
const deferredQ = React.useDeferredValue(q);
const results = React.useMemo(() => expensiveFilter(deferredQ), [deferredQ]);
return <>
<input value={q} onChange={e => setQ(e.target.value)} />
<List items={results} />
</>;
}
参见官方 useTransition 与 useDeferredValue 文档。react.dev+1
560. React18 中的自动批处理(Automatic Batching)如何工作?
解释:React 18 引入了更广泛的自动批处理:若使用 createRoot,React 会把同一事件循环中的多个 setState 调用自动合并为一次重渲染(不仅限于 React 事件处理器,还包括 timeout、promise 回调等)。这能显著减少不必要渲染次数,提高性能。若需要立即刷新某个更新,可以用 flushSync(但应慎用)。
代码 demo(示例):
function Example() {
const [a, setA] = React.useState(0);
const [b, setB] = React.useState(0);
function handleClick() {
setA(v => v + 1);
setB(v => v + 1);
// 在 React 18+ 自动批处理下这会只触发一次渲染
}
return <button onClick={handleClick}>Click</button>;
}
官方说明关于 React 18 的自动批处理可以参考 React 官方发布说明。react.dev
561. React19 中的 Activity 组件与 Suspense 有什么区别?
解释(基于 React 19 官方描述):<Suspense> 关注“数据/代码尚未就绪时显示 fallback”,它是基于“某个子树 suspend(抛出 promise)”的通用边界。<Activity> 是 React 19 里新增的用于“隐藏 UI 但保留组件状态”的工具(把部分 UI 暂时‘冻结’/‘睡眠’而不卸载状态),与 Suspense 的目的不同:Suspense 是等待数据就绪,Activity 更多是关于界面活动/状态保留与按需唤醒。官方文档对 Activity 的用途与示例有说明。react.dev+1
代码 demo(伪示意):
function Tabs() {
const [active, setActive] = React.useState('home');
return (
<>
<nav>
<button onClick={() => setActive('home')}>Home</button>
<button onClick={() => setActive('settings')}>Settings</button>
</nav>
<Activity isActive={active === 'home'}>
<HomePanel />
</Activity>
<Activity isActive={active === 'settings'}>
<SettingsPanel />
</Activity>
</>
);
}
// 注:上例为示意,具体 API 以官方文档为准。
562. React19 中的 use Hook 如何简化异步数据处理?
解释:React 19 引入/标准化了 use()(或类似)用于直接在组件中读取 promise/异步资源:在服务端渲染或与 Suspense 结合时,use() 可以直接接受 Promise,并在渲染期处理等待逻辑,从而减少显式的 useEffect/loading state 管理。它使得组件可以更直接地“同步”读取异步数据(在并发渲染模型与 Suspense 配合下),简化代码结构。
示意代码:
// 伪示例(以官方 use() 为准)
function Profile({ userId }) {
const user = use(fetchUser(userId)); // 如果未就绪,组件会 suspend 到 Suspense
return <div>{user.name}</div>;
}
参见对 use() 的文章与示例(社区/官方解读)。Medium
563. 说一下 React19 对表单处理的改进:useActionState 和 useFormState
解释:React 19 在表单与 actions 上引入了一系列 API(如 useActionState)来更好地描述服务器 action 的状态与表单交互:useActionState 帮助追踪 action 的当前状态、返回 action 可作为 <form> 的 action prop,以及提供 pending 标志以显示加载状态。这使得表单的提交状态管理与 UI 更加协同、也更易与 transitions 集成。官方参考文档对这些 Hook 有说明与示例。react.dev+1
代码 demo(示意):
function MyForm() {
const [state, action, isPending] = useActionState(async data => {
// action: 可以在服务端或路由处理器中执行
const res = await fetch('/submit', { method: 'POST', body: JSON.stringify(data) });
return res.json();
}, {initialState: null});
return (
<form action={action}>
<input name="name" />
<button type="submit">{isPending ? 'Submitting...' : 'Submit'}</button>
</form>
);
}
564. React19 中如何直接在组件中渲染 meta 标签和样式表?
解释:React 19 引入了对文档级 metadata 与 stylesheet 的更简单内联支持,允许在组件树中声明 <title>/<meta>/<link rel="stylesheet"> 等并由 React 在 render 时把它们“提升”到 <head> 中(hoist)。这简化了 SSR/组件化页面对 meta 信息和样式加载的管理。社区与官方教程给出具体示例。egghead.io+1
代码 demo(示意):
function Page() {
return (
<>
<title>My Page</title>
<meta name="description" content="..." />
<link rel="stylesheet" href="/page.css" />
<main>content</main>
</>
);
}
565. React19 的 ref 作为 prop 传递有什么优势?
解释:React 19 开始允许在函数组件中直接使用 ref 作为 prop(不再必须 forwardRef),简化了常见场景下的 ref 转发,减少模板样板代码并提高可读性。未来版本会逐步淘汰强制 forwardRef 的样式(官方会提供 codemod 帮助迁移)。优点:更少的 boilerplate、更直接的 API、更易读的代码。react.dev+1
代码 demo(React 19 风格):
// React 19 允许直接接收 ref prop(示例
function MyInput({ placeholder, ref }) {
return <input placeholder={placeholder} ref={ref} />;
}
function Parent() {
const r = React.useRef();
return <MyInput ref={r} />;
}
// 说明:在老版本仍需 forwardRef;在 React 19 中该用法被支持。
566. React 是什么?
React是一个由 Facebook 开发和维护的开源 JavaScript 库,用于构建用户界面,特别是单页面应用程序(SPA)。以下是 React 的主要特点和概念:
- 虚拟 DOM:React 使用一个叫做虚拟 DOM 的内存中数据结构来跟踪实际 DOM 的变化。当组件的状态改变时,React 会创建一个新的虚拟 DOM 树并与之前的树进行比较,然后决定如何以最有效的方式更新实际的 DOM。
- 声明式编程:在 React 中,你只需描述 UI 应该如何根据不同的状态显示,而不是描述如何进行变化。这使得代码更容易理解和预测。
- JSX:React 引入了 JSX(JavaScript XML)语法,允许开发者在 JavaScript 代码中写入类似 HTML 的标记。这种结合使得 UI 逻辑更加直观。
- 组件化:React 以组件为中心,让开发者能够构建复杂的 UI 从小到大,通过组合不同的可重用组件。
- 单向数据流:React 组件通过 props 接收数据并显示它们,当数据发生变化时,组件会重新渲染。这种单向数据流使得状态管理更为清晰和可预测。
- 可与各种工具和库集成:尽管 React 专注于 UI,但它可以与各种状态管理工具(如 Redux 或 MobX)、路由库(如 React Router)以及其他前端工具和库一起使用。
- 跨平台:除了 Web 开发,Facebook 还推出了 React Native,它允许开发者使用相同的 React 概念来构建原生移动应用程序。
567. 虚拟 DOM 的工作原理是什么?
虚拟 DOM(Virtual DOM)是 React 中的核心概念之一。为了理解它,首先需要知道直接操作真实的 DOM 是代价高昂的,因为这可能引起浏览器的重排和重绘,导致性能瓶颈。虚拟 DOM 旨在最小化与真实 DOM 的交互次数,从而提高性能。 以下是关于 React 中的虚拟 DOM 的详细解释:
- 定义:虚拟 DOM 是对真实 DOM 的轻量级表示。它是一个 JavaScript 对象,映射了真实 DOM 的结构和属性。
- 工作机制:
- 当 UI 的某个部分发生变化时(例如,因为用户输入或新数据),React 会创建一个新的虚拟 DOM 树。
- 接着,React 会将新的虚拟 DOM 树与上一个版本的虚拟 DOM 树进行比较,这一步被称为“差异化”(diffing)。
- 通过这一比较过程,React 能够确定真实 DOM 需要进行哪些最小的修改以反映新的 UI 状态。
- 最后,React 将这些变化批量应用到真实的 DOM,这一步被称为“重新渲染”(reconciliation)。
- 优势:
- 性能提高:通过批量更新真实 DOM,并只修改必要的部分,React 可以避免昂贵的 DOM 操作和不必要的重排/重绘。
- 编程简化:开发者不必关心如何高效地更新 DOM。他们只需声明 UI 在各种状态下的外观,而 React 负责如何实现这一过程。
- 跨平台:由于虚拟 DOM 只是 JavaScript 对象,因此 React 可以在不同环境中重复使用相同的逻辑,例如在 React Native 中。
- 局限性:
- 虽然虚拟 DOM 提高了性能,但它并不是解决所有问题的银弹。在某些情况下,对真实 DOM 的直接操作可能更快。
- 差异化和重新渲染仍然需要计算资源。对于大型应用或频繁的更新,开发者可能需要使用一些性能优化技巧。 总之,虚拟 DOM 是 React 如何快速和高效地更新 UI 的核心机制。通过将复杂的 DOM 更新逻辑抽象为简单的 JavaScript 运算,React 提供了一个强大且高性能的方法来构建动态 web 应用。
568. 为什么React要使用 JSX?
React 使用 JSX 为了提供一种更加直观、声明式的方式来描述 UI,并且在编写 UI 代码时能够保持 JavaScript 的所有功能。
核心概念:
- 声明式语法: JSX 提供了一种看起来很像 HTML 的语法,让我们能够直观地描述 UI 的外观和结构。这使得代码更加可读和易于维护。
- 组件化: 通过 JSX, 我们可以直接在 JavaScript 中定义组件,这使得 UI 的复用、测试和关注点分离变得简单。
- 整合能力: 由于 JSX 本质上是 JavaScript,我们可以在其中插入任何有效的 JavaScript 表达式。这为 UI 的创建提供了巨大的灵活性。
方案对比:
- 纯 JavaScript: 在没有 JSX 的情况下,UI 可以使用纯 JavaScript 来构建。但这样会使代码变得冗长和难以阅读,尤其是对于复杂的 UI 结构。与此相反,JSX 提供了一种简洁、易读的方式来定义 UI。
- 模板语言: 传统的前端框架经常使用特定的模板语言来描述 UI。虽然这些模板可以是声明式的,但它们通常限制了你可以使用的逻辑。与之相反,JSX 允许你在描述 UI 时使用完整的 JavaScript 功能。
- 字符串拼接: 直接使用字符串拼接 HTML 是不安全的,因为它容易受到跨站脚本攻击(XSS)。而 JSX 在编译时会自动进行安全转义,从而防止这种攻击。 结论: React 采用 JSX 是为了结合 HTML 的直观性和 JavaScript 的强大功能,提供一种更加有效、安全和声明式的方式来构建用户界面。
569. 类组件与函数组件有什么区别?
什么是 React 组件?
React 组件是独立、可重用的代码片段,用于描述 UI 的一部分。组件可以是简单的 UI 元素(如一个按钮)或包含其他组件的复杂容器。
共同点:
- 渲染 UI: 无论是类组件还是函数组件,它们的主要目标都是渲染 UI。
- 接收 props: 两者都可以接收
props,并依据props渲染 UI。 - 组件生命周期: 在引入 Hooks 之前,只有类组件能使用完整的生命周期方法。但现在,通过使用
useEffectHook,函数组件也可以模拟大多数生命周期行为。
不同点:
- 编程思想:
- 类组件: 面向对象编程 基于 ES6 的类语法,需要理解 JavaScript 的
this绑定。 - 函数组件: 函数式编程 基于函数,更简洁,并且更易于理解。
- 类组件: 面向对象编程 基于 ES6 的类语法,需要理解 JavaScript 的
- 使用场景:
- 类组件: 当需要使用
state或生命周期方法时。 - 函数组件: 对于简单的组件或当你想利用 Hooks。
- 类组件: 当需要使用
- 特有功能:
- 类组件: 具有完整的生命周期方法和错误边界处理。
- 函数组件: 可以使用 Hooks。
- 逻辑复用:
- 类组件: 需要使用高阶组件 (HOCs) 或 render props。
- 函数组件: 可以使用自定义 Hooks。
- 性能优化:
- 类组件: 使用
PureComponent或shouldComponentUpdate进行细粒度控制。 - 函数组件: 可以利用
React.memo和useMemo。
- 类组件: 使用
- 未来发展趋势:
- 类组件: 虽然 React 团队仍然支持,但鼓励新的开发使用函数组件和 Hooks。
- 函数组件: 是 React 的未来方向,尤其是随着 Hooks 的引入。 结论: 类组件和函数组件都是 React 的核心部分,它们在渲染和传递
props方面有很多相似之处。但随着 Hooks 的引入,函数组件变得更加强大和灵活,它们更简洁,易于读写,逻辑复用更直观,并且更符合 React 的未来发展方向。
570. setState 是同步的还是异步的?
在React中,状态更新(通过setState调用)可以是同步的也可以是异步的,这取决于被调用的上下文。 当setState被直接调用,例如作为事件处理器的一部分,例如绑定到按钮点击事件的函数中,React会将这些更新批处理(或“批量更新”),因为isBatchingUpdates标志被设置为true。这意味着React会积累所有的setState调用,并在事件处理结束后统一处理,以避免不必要的重渲染和性能问题。
但是,如果setState在一个异步函数中被调用,如在setTimeout、setInterval或者addEventListener的回调中,React就不会批处理这些更新,因为在这些情况下isBatchingUpdates标志通常是false。这意味着每次setState调用都会立即导致组件的重新渲染。
因此,当回答面试题时,您可以说明:setState通常在React事件处理器中是异步批处理的,以提高性能和减少不必要的渲染。但是,在诸如setTimeout、setInterval或DOM事件监听器中,setState可能会表现为同步的,除非使用了特定的技巧或者使用了React 18及以上版本的新特性。这个细微的差别是非常重要的,因为它影响到组件的渲染和性能优化。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script src="lib/react.development.17.js"></script>
<script src="lib/react-dom.development.17.js"></script>
<script src="lib/babel.min.js"></script>
</head>
<body>
<div id="root"></div>
</body>
<script type="text/babel">
class App extends React.Component{
state = {
count:100
}
render(){
return (
<div>
<button onClick={()=>{
// this.setState({
// count:this.state.count+100
// });
// console.log(this.state.count);// 100
setTimeout(()=>{
this.setState({
count:this.state.count+100
});
console.log(this.state.count);// 200
})
}}>{this.state.count}</button>
<h3>标题</h3>
</div>
)
}
componentDidMount(){
document.querySelector("h3").addEventListener("click",()=>{
this.setState({
count:9000
});
console.log(this.state.count);
})
}
}
// 第一个参数是渲染的内容,第二个参数是指定的根容器
ReactDOM.render(<App/>,document.querySelector("#root"));
</script>
</html>
571. React 中的 ref 是什么?
在 React 中,ref是一个重要的属性,它允许我们直接访问 DOM 元素或组件实例。虽然 React 鼓励使用 props 和 state 来控制渲染和组件交互,但有时我们仍然需要直接操作 DOM,或者访问 React 组件实例上的某些方法。这时,ref就显得特别有用。
572. React 中的生命周期?
React 的组件生命周期可以被大致分为三个主要阶段:Mounting(挂载),Updating(更新)和 Unmounting(卸载)。
-
Mounting(挂载)
: 这些方法会在组件创建并插入到 DOM 中时被调用。
- constructor: 组件的构造函数,最先被调用,用于初始化本地状态和绑定事件处理函数。
- static getDerivedStateFromProps: 当 props 发生变化时,在 render 方法之前被调用。它应返回一个对象来更新状态或返回 null 表示不更新任何内容。
- render: 唯一必需的方法。读取
this.props和this.state并返回以下类型之一:React 元素,字符串和数字,fragments,Portals,布尔值或 null。 - componentDidMount: 在组件输出被渲染到 DOM 之后立即调用。这是一个很好的地方去发起网络请求或设置订阅。
-
Updating(更新)
: 当组件的 props 或 state 改变时,会进入更新生命周期。
- static getDerivedStateFromProps: 同上。
- shouldComponentUpdate: 根据组件的 props 和 state 的变化,返回一个布尔值来决定 React 是否应继续渲染。默认返回
true。这是一个优化性能的点,可以避免不必要的渲染。 - render: 同上。
- getSnapshotBeforeUpdate: 在最近的渲染输出提交到 DOM 之前被调用。它使组件能在可能的 DOM 改变之前从 DOM 捕获一些信息。
- componentDidUpdate: 在更新发生后立即被调用。可以在此处进行 DOM 查询并触发网络请求。
-
Unmounting(卸载): 当组件从 DOM 中移除时会调用。
- componentWillUnmount: 在组件卸载及销毁之前直接调用。在此方法中执行必要的清理操作,如无效的定时器,或取消网络请求,或清理任何在
componentDidMount中创建的订阅。 此外,React 还引入了 Error Boundaries,用于捕获子组件树的 JS 错误,渲染备用 UI,而不是使整个组件树崩溃:
- componentWillUnmount: 在组件卸载及销毁之前直接调用。在此方法中执行必要的清理操作,如无效的定时器,或取消网络请求,或清理任何在
-
static getDerivedStateFromError: 此生命周期被调用后,你可以渲染一个备用 UI。
-
componentDidCatch: 此生命周期在报告错误日志时非常有用。 注意:
-
React 16.3 开始引入了新的生命周期方法,并且弃用了
componentWillMount,componentWillReceiveProps和componentWillUpdate。推荐使用新的生命周期方法。 -
React 中新的生命周期:
-
getDerivedStateFromProps
getDerivedStateFromProps是 React 的生命周期方法,专为 class 组件设计。它的主要目的是让组件在接收新的 props(属性)时有机会产生新的 state(状态)。这是一个静态方法,这意味着它不能访问组件实例(即不能使用this关键字)。以下是
getDerivedStateFromProps的一些关键特点:- 调用时机:该方法在组件实例化后和每次组件接收新的 props 时都会被调用。
- 参数:它接受两个参数:
nextProps和prevState。nextProps:组件将要接收的新属性。prevState:组件当前的状态。
- 返回值:它应该返回一个对象来更新状态,或者返回
null来表示不需要更新任何状态。 - 无副作用:此方法只应用于返回一个 state 更新的对象或
null,而不应该有任何副作用(如发送 HTTP 请求或调用 setTimeout 等)。 - 静态方法:由于它是一个静态方法,所以不能访问
this。 - 使用场景:当组件的状态依赖于 props 的更改时,可以考虑使用此方法。但是,大多数情况下,最好使用其他方法,如
componentDidUpdate,或者完全避免将 props 映射到 state。
-
getSnapshotBeforeUpdate
getSnapshotBeforeUpdate是一个生命周期方法,它允许您在 DOM 的实际更改之前捕获一些信息(例如滚动位置)。然后,该信息可以传递给componentDidUpdate方法,这样您就可以在更新之后使用这些信息。一般用途:当您的组件渲染的内容可能会改变滚动位置(例如,一个正在增长的列表),并且您想在 React 更新 DOM 后保持当前的滚动位置时,这个生命周期方法非常有用。
-
573. 什么是副作用(Side Effect)?
在 React 中,“副作用” 指的是组件渲染过程之外的操作—— 这些操作不直接参与 UI 渲染,但会影响组件或应用的状态。常见的副作用包括:
- 数据请求(Ajax / fetch / axios)
- DOM 操作(手动修改元素属性,如自动聚焦输入框)
- 订阅/取消订阅(WebSocket、事件监听器)
- 定时器(setInterval、setTimeout)
组件的主要任务是 “渲染 UI”(正作用),而副作用需要在渲染完成后执行,否则会阻塞渲染,影响页面性能。
574. 为什么 useState 返回的是数组而不是对象?
因为解构赋值的原因:
- 返回数组,可以对数组中的变量命名,代码看起来也比较干净。
- 返回对象,那就必须和返回的值同名,不能重复使用了。
575. React 与 Vue 比较有什么不同?
- 组件化方式不同
- React 组件包含状态和行为,所有组件共享一个状态树
- Vue 每个组件都有自己的状态和行为,并且可以很容易将数据和行为绑定在一起
- 数据驱动方式不同
- React 单项数据流
- Vue 双向数据绑定
-
模板语法不同
- React 模板语法是 JSX,all in js
- Vue 模板语法是 Template、js、css,支持指令
- 状态管理方式不同
- React 状态管理:Redux、Mobx、zustand
- Vue 状态管理:Vuex、Pinia
- 性能优化方式不同
- React 性能优化:React.memo、shouldComponentUpdate
- Vue 性能优化:keep-alive、v-if
576. 什么是错误边界(Error boundary)
- 部分 UI 的 JavaScript 错误不应该导致整个应用崩溃,为了解决这个问题,React 16 引入了一个新的概念 —— 错误边界。
- 当 React 检测到一个组件的渲染过程中抛出了错误,React 会通过错误边界机制捕获该错误。如果没有错误边界捕获该错误,React 将显示默认的错误页面并终止应用。 错误边界的关键是它们实现了两个生命周期方法:static getDerivedStateFromError 和 componentDidCatch,这使得组件能够在出现错误时恢复正常。
- 简单理解:用来捕获后代组件错误,渲染出备用页面。
- 错误边界只能捕获渲染过程中、生命周期方法中的错误,不会捕获事件处理程序中的错误。要处理事件中的错误,可以使用 try…catch 语句。
- 错误边界不会捕获异步代码中的错误。例如,setTimeout 或异步请求中的错误不会被错误边界捕获。为此,可以在异步操作中使用 try…catch 语句。
577. 说一下 React 中的 Context?
React 的Context是一种传递数据的方法,允许数据能够被传递到组件树中的任何层级,而不必通过每一个层级的组件明确地传递。它被设计为解决当有许多层嵌套时,只是为了把数据传递给较低层级的组件而手动传递props的问题。
使用Context的步骤:
- 使用
React.createContext创建一个新的上下文。 - 使用
Context.Provider组件为子组件提供上下文值。 - 使用
Context.Consumer组件或useContexthook 在任何子组件中访问上下文值。
578. 介绍一下useRef
useRef 是 React 提供的一个 Hook,它返回一个可变的 ref 对象,这个对象的 .current 属性可以被修改,并且它不会导致组件重新渲染。
下面是 useRef 的一些核心点:
- 创建 Ref: 当你调用
useRef(),它会返回一个像这样的对象:{ current: initialValue }。你可以为它提供一个初始值,例如useRef(0),但这并不是必需的。 - 持久性: 不像
useState,每次组件重新渲染时都会返回一个新的 state,useRef会在整个组件生命周期中保持其对象不变。 - 使用场景:
- 访问 DOM 元素: 可以使用
useRef创建一个 ref,然后将它附加到 JSX 元素上,从而在组件内部访问该 DOM 元素。 - 保留不触发渲染的可变数据: 如果你有一个值,你不希望它的变化导致组件重新渲染,可以将它存储在 ref 中。
- 跟踪上一次的 props 或 state: 你可以使用
useRef来跟踪前一个渲染周期中的值。
- 访问 DOM 元素: 可以使用
579. React Hooks的引入主要解决了哪些问题?
- 逻辑复用难度:类组件中的逻辑难以复用。虽然高阶组件(HOCs)和渲染道具(Render Props)提供了一定程度的复用,但它们往往导致代码结构复杂,产生所谓的”回调地狱”,难以理解和维护。
- 组件复杂性:在类组件中,复杂的业务逻辑通常散落在不同的生命周期方法中,这使得理解和维护变得困难。一个生命周期方法可能包含多个不相关的逻辑,这缺乏专注性且增加了混乱。
- this关键字的混淆:类组件中的
this关键字经常导致混淆,特别是在事件处理和异步操作中。此外,类组件的方法需要正确绑定this,这增加了代码的复杂性。
580. 为什么hooks 需要遵循两条主要规则?
规则一:不要在循环语句、条件语句或嵌套函数内调用 hooks
规则二:只在 React 函数组或自定义hooks函数中调用 hooks
- 不要在循环、条件语句或嵌套函数中调用 Hooks:这是为了保证 Hooks 每次渲染时都以相同的顺序调用,这对于 React 内部追踪 Hooks 状态非常重要。如果在条件语句或循环中使用 Hooks,可能导致每次组件渲染时 Hooks 调用的数量和顺序不一致,进而导致状态管理混乱。
- 只在 React 函数组件或自定义Hooks函数中调用 Hooks:保证了 Hooks 只在 React 组件的上下文中被使用,这有助于 React 管理组件的生命周期和状态。在组件外部调用 Hooks 可能导致不可预测的行为,因为那些地方没有与 React 组件的生命周期和状态管理机制相结合。
581. useEffect和useLayoutEffect的相同点和不同点有哪些?
useEffect 和 useLayoutEffect 在 React Hooks 中都用于处理副作用,但它们有以下相同点和不同点:
相同点
- 功能:两者都用于在组件渲染后执行副作用操作。
- API:它们具有相同的 API 结构,即可以接收一个函数(副作用函数)和一个依赖数组。
- 清理机制:两者都允许返回一个清理函数,用于组件卸载时执行清理操作。
不同点
- 执行时机:
useEffect在整个页面渲染和绘制完成后异步执行,不会阻塞浏览器的绘制过程。useLayoutEffect与 DOM 更新同步执行,会在浏览器绘制之前执行。因此,如果在useLayoutEffect中执行大量操作,可能会导致页面渲染的性能问题。
- 使用场景:
useEffect适用于大多数副作用场景,如数据获取、订阅、以及在渲染后需要执行的操作。useLayoutEffect通常用于需要同步读取或更新 DOM 的场景,或者在 DOM 更新后立即需要执行的操作,例如测量布局。
简而言之,尽管两者在功能上相似,但 useLayoutEffect 的使用应更加谨慎,以避免因同步执行而引起的性能问题。大多数情况下,使用 useEffect 就足够了。
582. React.memo和React.useMemo有什么区别?
React.useMemo 和 React.memo 虽然都用于优化性能,但它们服务于不同的场景和目的,所以不能直接比较谁更好。它们的有效性取决于你正在处理的具体问题和使用场景。
React.useMemo
- 目的:用于缓存复杂计算的结果。
- 适用场景:当组件内部有昂贵的计算操作,这些操作仅依赖于特定的props或state,并且这些值不经常改变时,使用
useMemo可以避免在每次渲染时重新计算。 - 限制:它仅对组件内部的值或计算有效,不能防止组件本身的重新渲染。
React.memo
- 目的:用于避免组件不必要的重新渲染。
- 适用场景:当组件经常因父组件的更新而重新渲染,但其props实际上并没有发生变化时,使用
React.memo可以防止这种不必要的渲染。 - 限制:它适用于整个组件,而不是特定的值或计算。
583. 说一下 React 中的 Context?
React 的Context是一种传递数据的方法,允许数据能够被传递到组件树中的任何层级,而不必通过每一个层级的组件明确地传递。它被设计为解决当有许多层嵌套时,只是为了把数据传递给较低层级的组件而手动传递props的问题。
使用Context的步骤:
- 使用
React.createContext创建一个新的上下文。 - 使用
Context.Provider组件为子组件提供上下文值。 - 使用
Context.Consumer组件或useContexthook 在任何子组件中访问上下文值。
584. 说一下 React 如何避免不必要的渲染?
- 类组件通过 React.PureComponent
PureComponent 是 React 提供的一个组件基类,它的核心特性是只有当它的 props 或 state 发生浅层变化时,它才会重新渲染。浅层比较会检查对象顶层的属性,而不是深度检查。如果对象的顶层属性没有变化,那么 PureComponent 就不会重新渲染,这可以提高性能。
使用 PureComponent 最适合于那些组件的 props 和 state 结构较简单,或者可以确保结构不会经常发生深度变化的场景。
- 函数组件通过React.memo
React.memo是一个高阶组件,它可以用于优化那些仅仅依赖于其 props 变化的组件的重新渲染行为。换句话说,如果组件的 props 在连续的渲染之间没有发生变化,那么使用React.memo可以避免组件的不必要的重新渲染。
如果你有一个功能组件并且你想避免该组件因父组件的重新渲染而不必要地重新渲染,你可以通过React.memo包裹该组件:
工作原理
- 当一个组件被
React.memo包裹时,React 会记住该组件上一次渲染的结果。 - 当这个组件的父组件再次渲染时,React 会使用浅比较(shallow comparison)来比较当前的 props 和上一次的 props。
- 如果 props 没有发生变化,React 会重用上一次的渲染结果,而不是重新渲染组件。
- 如果 props 发生了变化,组件将会被重新渲染。
585. React函数组件和类组件有什么相同点和不同点?
相同点
- 渲染 UI: 无论是函数组件还是类组件,都用于渲染 UI,并且可以接受 props 来定制显示内容。
- 使用方式和表达效果 函数组件和类组件的使用方式和表达效果是一样的
不同点
- 设计思想 类组件是面向对象编程,可以实现继承,函数组件是函数式编程
- 语法和结构: 类组件使用 ES6 类语法定义,拥有多个生命周期方法,而函数组件是普通的 JavaScript 函数,通常更简洁。
- Hooks使用: 只有函数组件可以使用 React Hooks(如
useState,useEffect),类组件不能使用这些钩子。 - 状态管理: 类组件通过
this.state和this.setState管理状态,而函数组件可以通过useState钩子管理状态。 this关键字: 类组件中经常需要使用this来访问 props、状态和类方法。而函数组件中没有this,一切都通过函数参数或钩子访问。- 生命周期方法: 类组件有完整的生命周期方法(如
componentDidMount,componentDidUpdate,componentWillUnmount),而函数组件则使用钩子如useEffect来模拟这些生命周期。 - 组件重用和组合: 函数组件倾向于促进重用和组合的小型、专注的组件。而类组件更适合于需要复杂状态逻辑和生命周期管理的场景。
- Context 使用: 类组件通过
static contextTypes使用Context,函数组件使用Consumer和useContext - 性能优化: 函数组件使用React.memo、useMemo、useCallback进行性能优化,而类组件使用PureComponent和重写shouldComponentUpdate
- 逻辑复用: 函数组件使用自定义Hooks、高阶组件、组合、Render Props等方式进行性能优化,而类组件使用高阶组件(HOCs)、继承(Inheritance)、Mixins等方式进行逻辑复用
- 趋势 随着 React 的发展,函数组件因其简洁性和对钩子的支持而变得越来越流行,但类组件在某些复杂场景中仍有其独特的优势。
586. React中函数组件如何进行逻辑复用?
- 自定义Hooks
React 的自定义 Hooks 是 React 功能的一个扩展,允许你在函数组件中重用状态逻辑,而无需改变组件结构。自定义 Hooks 本质上是 JavaScript 函数,但它们遵循一些特定的规则并利用 React 的基础 Hooks(如 useState, useEffect, useContext 等)。
以下是自定义 Hooks 的一些关键点:
- 重用状态逻辑:自定义 Hooks 允许你将组件逻辑提取到可重用的函数中。这意味着相同的状态管理和副作用逻辑可以在多个组件中共享,而无需重复代码。
- 命名约定:自定义 Hooks 应以
use开头,这不仅是一种命名约定,也是 React 自动应用 Hooks 规则的一部分。 - 封装和组织:通过自定义 Hooks,你可以将相关逻辑组织在一起,使代码更易于理解和维护。例如,你可以创建一个
useFormHook 来处理表单输入和验证。 - 使用基础 Hooks:自定义 Hooks 可以调用其他 Hooks,这意味着你可以在自定义 Hook 中使用
useState,useEffect,useContext等基础 Hooks。
- 高阶组件
高阶组件(HOCs)是 React 中用于重用组件逻辑的一种高级技术。简单来说,它们是参数为组件、返回值为新组件的函数。HOCs 让你可以把组件当作参数传入,然后返回一个新的“增强”组件,这个新组件拥有额外的属性或行为。
这里有几个关键点来理解高阶组件:
- 函数式编程概念:HOC 是一种基于函数式编程的模式。在函数式编程中,函数可以接受函数作为参数,并返回一个函数。
- 组件重用:HOC 允许你抽象出共通的逻辑,避免代码重复。例如,你可能有几个组件都需要进行数据获取,通过使用 HOC,你可以只编写一次数据获取逻辑,并将其应用于所有需要它的组件。
- 不修改原组件:HOC 不应该修改传入的组件,而是返回一个新的组件。这有助于保持原始组件的纯净性和可重用性。
- 组合:HOC 可以相互组合。你可以将一个组件通过多个 HOC 传递,每个都添加自己的功能。
- Render Props
使用一个值为函数的prop(属性),这个函数返回要渲染的React元素。通过这种方式,可以在多个组件间共享逻辑。
587. 如何在ReactHooks中获取上一轮的值?
import React, { useState, useEffect, useRef } from "react";
import ReactDOM from "react-dom/client";
function usePrevious(value) {
const ref = useRef();
useEffect(() => {
ref.current = value;
}, [value]);
return ref.current;
}
function App() {
const [value, setValue] = useState('初始值');
const prevValue = usePrevious(value);
return <div>
<p>当前值: {value}</p>
<p>上一轮的值: {prevValue}</p>
<button onClick={() => setValue('新值')}>更新值</button>
</div>;
}
ReactDOM.createRoot(document.getElementById("root")).render(<App />);
588. React Router如何在 React 应用中工作?
在 React 应用中,React Router 通过以下方式工作:
- 安装和设置:
- 首先,通过 npm 或 yarn 安装 React Router 库。然后,在 React 应用的顶层组件中,使用
<BrowserRouter>(或其他路由器类型)包裹应用的内容。
- 首先,通过 npm 或 yarn 安装 React Router 库。然后,在 React 应用的顶层组件中,使用
- 配置路由:
- 使用
<Routes>组件来定义应用的路由结构。在<Routes>内部,使用<Route>组件来定义每个路由的路径和对应的组件。
- 使用
- 导航和链接:
- 使用
<Link>组件来创建导航链接,允许用户在应用中的不同页面间导航。 - 使用
useNavigate钩子在组件中编程式地导航。
- 使用
- 参数和查询处理:
- 使用
useParams钩子来访问动态路由参数。 - 使用
useSearchParams钩子来处理 URL 查询参数。
- 使用
- 嵌套路由:
- 在 v6 中,可以更容易地创建嵌套路由。在父路由组件内部定义子路由,使得路由结构更加清晰和模块化。
- 重定向和守卫:
- 使用
<Navigate>组件来实现重定向。 - 通过条件渲染和钩子来实现路由守卫,如保护私有路由。
- 使用
React Router v6 的这些特性和工作方式使得在 React 应用中实现复杂的路由需求变得更加简单和高效。
589. 请解释 React Router 中BrowserRouter和HashRouter的区别?
在 React Router 中,<BrowserRouter>和<HashRouter>是两种不同的路由器组件,它们提供了不同的方式来处理 URL 和导航。理解这两者的区别对于选择适合特定应用的路由策略非常重要。
<BrowserRouter>
- 使用 HTML5 历史 API:
<BrowserRouter>使用 HTML5 的历史 API(特别是pushState、replaceState和popstate事件)来保持 UI 和 URL 的同步。
- 干净的 URL:
- 这种方式产生的 URL 看起来很干净,没有额外的字符。例如:
http://example.com/about。
- 这种方式产生的 URL 看起来很干净,没有额外的字符。例如:
- 服务器配置:
- 使用
<BrowserRouter>时,服务器必须正确配置,以便对所有可能的 URL 路径返回同一个 HTML 文件(通常是index.html)。这是因为应用的路由是前端控制的,服务器不会对每个路由有实际的页面。
- 使用
- 适用场景:
<BrowserRouter>适用于大多数单页应用(SPA),特别是在你可以控制服务器行为时。
<HashRouter>
- 使用 URL 的哈希部分:
<HashRouter>使用 URL 的哈希部分(即#后面的部分)来保持 UI 和 URL 的同步。它不依赖于 HTML5 历史 API。
- 带哈希的 URL:
- 这种方式产生的 URL 包含
#,例如:http://example.com/#/about。哈希后面的部分表示应用的前端路由。
- 这种方式产生的 URL 包含
- 无需特殊服务器配置:
- 由于 URL 的路径部分(
#之前的部分)不变,服务器只需对根 URL 返回应用即可。这意味着不需要特殊配置,因为服务器不会看到哈希后的路径。
- 由于 URL 的路径部分(
- 适用场景:
<HashRouter>适用于那些不能或不想在服务器上进行特殊配置的场景。它也是在文件系统(如file://)或无服务器环境中运行 React 应用的好选择。
总结
- 选择
<BrowserRouter>:如果你有权配置服务器,并且希望 URL 看起来干净、标准。 - 选择
<HashRouter>:如果你无法或不想配置服务器,或者在不支持 HTML5 历史 API 的环境中运行应用。
在实际应用中,选择哪种路由器通常取决于你对项目的部署环境和 URL 外观的需求。
590. 如何在 React Router 中配置路由?
在 React Router 中配置路由涉及几个关键步骤,包括设置路由器(如<BrowserRouter>或<HashRouter>),定义路由路径和关联的组件,以及在应用中使用链接进行导航。以下是配置路由的基本步骤:
1. 安装 React Router
首先,确保你已经安装了 React Router v6。如果没有,你可以通过 npm 或 yarn 来安装它:
npm install react-router-dom@6
或者
yarn add react-router-dom@6
从react-router-v7开始,将使用如下方式安装:
npm i react-router # 或 yarn add react-router
2. 设置路由器
在 React 应用的顶层组件中,使用<BrowserRouter>(或<HashRouter>,取决于你的需求)包裹应用的内容。这通常在index.js或App.js文件中完成:
import { BrowserRouter } from "react-router-dom";
function App() {
return <BrowserRouter>{/* 应用的其余部分 */}</BrowserRouter>;
}
export default App;
3. 定义路由
使用<Routes>组件来定义应用的路由结构,并在其中使用<Route>组件来指定每个路由的路径和对应的组件。这通常在你的应用的主组件或专门的路由配置文件中完成:
import { Routes, Route } from "react-router-dom";
import Home from "./Home";
import About from "./About";
import NotFound from "./NotFound";
function AppRoutes() {
return (
<Routes>
<Route path="/" element={<Home />} />
<Route path="about" element={<About />} />
<Route path="*" element={<NotFound />} />
</Routes>
);
}
在这个例子中,Home组件将在访问根路径/时渲染,About组件将在访问/about时渲染,而NotFound组件将用于处理所有未匹配的路由(通常用于显示 404 页面)。
4. 使用链接进行导航
在应用的其他部分,使用<Link>组件来创建导航链接,允许用户在不同页面间进行导航:
import { Link } from "react-router-dom";
function Navbar() {
return (
<nav>
<Link to="/">Home</Link>
<Link to="/about">About</Link>
</nav>
);
}
5. 嵌套路由(可选)
如果你的应用需要嵌套路由,你可以在<Route>组件内部再定义<Route>组件:
<Route path="dashboard" element={<Dashboard />}>
<Route path="profile" element={<Profile />} />
<Route path="settings" element={<Settings />} />
</Route>
在这个例子中,Dashboard组件可以包含用于渲染Profile和Settings组件的<Outlet>组件,这些子路由将在访问/dashboard/profile和/dashboard/settings时渲染。
591. 请解释 React Router 中Link组件与普通a标签的区别
在 React Router 中,<Link>组件和传统的 HTML <a>标签都用于创建导航链接,但它们在处理页面导航时有重要的区别:
<Link>组件
- 单页应用(SPA)导航:
<Link>组件用于在 React 的单页应用中创建内部导航链接。当用户点击这些链接时,<Link>会告诉 React Router 更新 URL,但不会导致页面重新加载。
- 不触发全页刷新:
- 使用
<Link>进行导航时,页面不会重新加载。这意味着应用不会丢失当前状态,并且页面切换更快,因为只有必要的组件会被重新渲染。
- 使用
- 与 React Router 集成:
<Link>组件是 React Router 的一部分,它知道如何与 React Router 的路由系统协同工作。它使用to属性来指定目标路由,例如<Link to="/about">About</Link>。
- 自定义行为:
- 你可以轻松地向
<Link>添加自定义行为或样式,例如,根据当前路由路径改变链接的样式。
- 你可以轻松地向
- 传统的 HTML 链接:
<a>标签是 HTML 中的标准元素,用于创建指向不同页面的链接。在 React 应用中,它们通常用于指向应用外部的页面。
- 触发页面刷新:
- 当使用
<a>标签进行导航时,浏览器会进行全页刷新,加载新页面。这意味着应用的当前状态会丢失,且页面加载可能更慢。
- 当使用
- 不了解 React Router:
<a>标签不了解 React Router 的存在。它们只是简单地根据href属性的值改变浏览器的 URL,并加载新页面。
- 适用于外部链接:
- 在 React 应用中,你通常会使用
<a>标签来创建指向外部网站或页面的链接,例如<a href="https://example.com">Visit Example.com</a>。
- 在 React 应用中,你通常会使用
总结
- 使用
<Link>:当你需要在 React 的单页应用内部进行路由导航时,不希望页面重新加载。 - 使用
<a>:当你需要链接到应用外部的页面,或者需要页面完全重新加载时。
通过使用<Link>,React Router 能够优化导航体验,保持应用状态,并提供更快的页面切换,这对于提升用户体验至关重要。
592. 如何在 React Router 中传递和接收参数?
在 React Router v6 中传递和接收参数主要涉及使用 useParams 钩子和定义路由参数。下面是基本步骤:
定义带参数的路由
首先,在你的路由定义中,你需要指定参数。例如,如果你有一个用户详情页面,你可能会这样定义路由:
import { BrowserRouter as Router, Routes, Route } from "react-router-dom";
import UserDetails from "./UserDetails";
function App() {
return (
<Router>
<Routes>
<Route path="/user/:userId" element={<UserDetails />} />
{/* 其他路由 */}
</Routes>
</Router>
);
}
在这个例子中,:userId 是一个路由参数。
在组件中接收参数
在 UserDetails 组件中,你可以使用 useParams 钩子来访问这个参数:
import { useParams } from "react-router-dom";
function UserDetails() {
let { userId } = useParams();
// 使用 userId 来获取用户详情
// ...
return <div>{/* 渲染用户详情 */}</div>;
}
传递参数
当你想导航到这个路由并传递参数时,你可以使用 Link 组件或编程式导航:
import { Link } from "react-router-dom";
function UserList() {
return (
<div>
{/* 假设 users 是一个用户数组 */}
{users.map((user) => (
<Link to={`/user/${user.id}`} key={user.id}>
{user.name}
</Link>
))}
</div>
);
}
或者使用编程式导航:
import { useNavigate } from "react-router-dom";
function SomeComponent() {
let navigate = useNavigate();
function goToUser(userId) {
navigate(`/user/${userId}`);
}
}
在 React Router 中传递查询参数(也称为搜索参数)也是一个重要的功能。这些参数通常用于在 URL 中传递非结构化数据,例如搜索词或分页信息。下面是如何传递和接收查询参数的步骤:
传递查询参数
查询参数可以通过 Link 组件或编程式导航添加到 URL 中。例如,假设你想根据搜索词过滤用户列表:
使用 Link 组件:
import { Link } from "react-router-dom";
// encodeURIComponent 是JavaScript中用于对URI组件进行编码的核心函数,会将特殊字符转换为十六进制转义序列,常用于URL参数编码以确保传输安全。
function SearchLink({ query }) {
return <Link to={`/search?query=${encodeURIComponent(query)}`}>搜索</Link>;
}
使用编程式导航:
import { useNavigate } from "react-router-dom";
function SearchButton({ query }) {
let navigate = useNavigate();
function handleSearch() {
navigate(`/search?query=${encodeURIComponent(query)}`);
}
return <button onClick={handleSearch}>搜索</button>;
}
在这些示例中,encodeURIComponent 函数用于确保查询字符串是正确编码的。
接收查询参数
在目标组件中,你可以使用 useSearchParams 钩子来访问查询参数。例如,如果你有一个用于显示搜索结果的组件:
import { useSearchParams } from "react-router-dom";
function SearchResults() {
let [searchParams] = useSearchParams();
let query = searchParams.get("query");
// 使用 query 来获取和显示搜索结果
// ...
return <div>{/* 渲染搜索结果 */}</div>;
}
在这个例子中,useSearchParams 提供了一个接口来读取和修改当前位置的搜索参数。你可以使用 get 方法来检索特定的查询参数。
593. 如何在 React Router 中处理 404 或“未找到”页面?
在 React Router 中处理 404 或“未找到”页面的方法是使用一个没有 path 属性的 Route 组件,作为 Routes 组件的最后一个子元素。这个“无路径”路由将捕获所有未被前面的路由匹配的路径,从而充当一个通用的回退选项。以下是如何实现这一点的步骤:
步骤 1:创建一个 404 组件
首先,创建一个表示 404 页面的 React 组件:
function NotFound() {
return (
<div>
<h2>404 Not Found</h2>
<p>抱歉,您访问的页面不存在。</p>
</div>
);
}
步骤 2:在路由配置中添加 404 路由
然后,在你的路由配置中,添加一个不带 path 属性的 Route,并将其放在所有其他路由定义的最后:
import { BrowserRouter as Router, Routes, Route } from "react-router-dom";
import Home from "./Home";
import About from "./About";
import NotFound from "./NotFound";
function App() {
return (
<Router>
<Routes>
<Route path="/" element={<Home />} />
<Route path="/about" element={<About />} />
{/* ...其他路由... */}
<Route path="*" element={<NotFound />} />
</Routes>
</Router>
);
}
在这个例子中,<Route path="*" element={<NotFound />}> 是捕获所有未匹配路径的路由。当用户访问一个不存在的路由时,React Router 将渲染 NotFound 组件。
注意
- 确保将 404 路由放在
Routes组件的最后,以便只有在其他所有路由都不匹配时才触发。 - 使用
path="*"是 React Router v6 中推荐的方式,它表示匹配任何未被之前路由捕获的路径。
通过以上步骤,你可以在 React Router v6 中有效地处理 404 或“未找到”页面,为用户提供更好的导航和错误处理体验。
594. 请解释 React Router 中组件的用途及其如何使用。
在 React Router 中,<NavLink>组件是一种特殊类型的<Link>,用于创建导航菜单项。它的主要特点是可以根据当前的路由路径自动改变样式或类名,这对于指示当前激活的导航链接非常有用。
用途
<NavLink>的主要用途是在用户导航到与该链接相关的路由时,能够向用户反馈哪个链接是“活跃”的。这通常通过改变链接的样式或类名来实现,例如,改变字体颜色或背景色。
如何使用
使用<NavLink>时,你可以通过className或style属性来定义活跃和非活跃状态下的样式。React Router v6 提供了一个函数形式的className和style属性,这个函数接收一个状态对象,该对象包含isActive属性,表示链接是否活跃。
基本示例
import { NavLink } from "react-router-dom";
function Navigation() {
return (
<nav>
<NavLink to="/" className={({ isActive }) => (isActive ? "active" : "")}>
Home
</NavLink>
<NavLink
to="/about"
className={({ isActive }) => (isActive ? "active" : "")}
>
About
</NavLink>
{/* 其他链接 */}
</nav>
);
}
在这个示例中,当用户处于对应的路由时,对应的<NavLink>将获得'active'类名。
使用内联样式
你也可以使用内联样式来定义活跃状态:
<NavLink
to="/profile"
style={({ isActive }) =>
isActive ? { color: "green", fontWeight: "bold" } : {}
}
>
Profile
</NavLink>
在这个例子中,当Profile链接活跃时,它的颜色会变为绿色,字体变为粗体。
总结
<NavLink>是 React Router 中用于创建导航链接的组件,它的特点是可以根据路由的活跃状态自动改变样式或类名。这使得它非常适合用于创建反映当前导航状态的菜单项。通过使用className或style属性的函数形式,你可以根据链接是否活跃来动态地应用不同的样式。
595. 在 React Router 中,useHistory、useLocation、useParams和useRouteMatch这些钩子的作用是什么?
在 React Router 中,useHistory, useLocation, useParams 是一组重要的钩子(Hooks),它们提供了访问和操作路由状态的能力。不过,值得注意的是,从 v6 开始,useHistory 被替换为了 useNavigate。我将逐一解释它们的作用:
useNavigate (替代了 useHistory)
-
用途:
useNavigate钩子用于在应用中进行导航。它返回一个函数,该函数允许你编程式地改变当前的路由。 -
示例:
import { useNavigate } from "react-router-dom"; function MyComponent() { let navigate = useNavigate(); function handleClick() { navigate("/home"); // 导航到主页 } return <button onClick={handleClick}>Go to Home</button>; }
useLocation
-
用途:
useLocation钩子用于获取当前路由的位置信息。它返回一个location对象,该对象包含了当前 URL 的路径、搜索查询字符串、状态等信息。 -
示例:
import { useLocation } from "react-router-dom"; function MyComponent() { let location = useLocation(); // 使用 location 对象 console.log(location.pathname); // 当前路径 console.log(location.search); // 查询字符串 return <div>Current path: {location.pathname}</div>; }
useParams
-
用途:
useParams钩子用于访问当前路由路径中的参数。这对于动态路由(如/user/:userId)非常有用。 -
示例:
import { useParams } from "react-router-dom"; function UserDetails() { let { userId } = useParams(); // 假设路由是 /user/:userId // 使用 userId 参数 return <div>User ID: {userId}</div>; }
总结
这些钩子是 React Router 的核心部分,它们提供了访问和操作路由状态的能力,使得在 React 应用中的路由管理变得更加灵活和方便。在 v6 中,通过使用这些钩子,你可以有效地管理路由跳转、获取 URL 参数和路径信息,从而为用户创造一个流畅的导航体验。
596. 如何在 React Router 中实现嵌套路由?
在 React Router 中实现嵌套路由是一个相对直观的过程。嵌套路由允许你在父路由组件内部定义子路由,这样可以更好地组织和管理复杂的路由结构。下面是实现嵌套路由的基本步骤:
1. 创建基本组件
首先,创建你的基本组件。例如,假设你有一个布局组件Layout,一个首页组件Home,和两个子页面组件About和Contact。
const Layout = ({ children }) => (
<div>
<header>Header</header>
<main>{children}</main>
<footer>Footer</footer>
</div>
);
const Home = () => <div>Home Page</div>;
const About = () => <div>About Page</div>;
const Contact = () => <div>Contact Page</div>;
2. 设置路由
在你的应用中设置路由,使用<Routes>和<Route>组件来定义路由结构。在父路由组件内部定义子路由。
import { BrowserRouter, Routes, Route, Link } from "react-router-dom";
function App() {
return (
<BrowserRouter>
<Routes>
<Route path="/" element={<Layout />}>
<Route index element={<Home />} />
<Route path="about" element={<About />} />
<Route path="contact" element={<Contact />} />
</Route>
</Routes>
</BrowserRouter>
);
}
在这个例子中,Layout组件是顶层路由组件,它有三个子路由:Home(作为默认子路由,使用index属性),About和Contact。
3. 在父组件中渲染Outlet
在父组件(在这个例子中是Layout)中,使用<Outlet>组件来渲染子路由。<Outlet>组件是 React Router 提供的一个特殊组件,用于渲染当前路由匹配的子路由组件。
import { Outlet } from "react-router-dom";
const Layout = () => (
<div>
<header>
<nav>
<Link to="/">Home</Link>
<Link to="/about">About</Link>
<Link to="/contact">Contact</Link>
</nav>
</header>
<main>
<Outlet /> {/* 子路由将在这里渲染 */}
</main>
<footer>Footer</footer>
</div>
);
4. 使用链接导航
使用<Link>组件在应用中创建导航链接。这些链接将允许用户在不同的路由之间导航。
<Link to="/">Home</Link>
<Link to="/about">About</Link>
<Link to="/contact">Contact</Link>
总结
通过以上步骤,你可以在 React Router 中实现嵌套路由。嵌套路由提供了一种强大的方式来组织和管理复杂的路由结构,使得代码更加模块化和易于维护。使用<Outlet>组件在父路由中渲染子路由是实现嵌套路由的关键。
597. 函数组件如何实现强制更新
在 React 函数组件中,没有像类组件那样的 forceUpdate() 方法,但我们可以通过一些技巧实现强制更新。
-
封装成自定义 Hook,便于复用:
function useForceUpdate() { const [, setState] = useState(0); return useCallback(() => setState(prev => prev + 1), []); } // 使用 const forceUpdate = useForceUpdate();
598. 什么是React
1)、与2011年由facebook开发,2013年开源,被bat等公司广泛运用 2)原生js很难操作UI界面,React遵循组件设计模式,声明式编程和函数式编程,使用虚拟DOM来操作 DOM,单向响应数据流,组件复用,客户端渲染也支持服务端渲染,还支持移动端app开发,扩展性 强,良好的生态 3)、是一个为数据提供渲染为html试图的javascript库 4)、特点和高效原因
"proxy":{
"/api": {
"target": "http://172.19.5.35:9536",
"ws": true
},
"/apc": {
"target": "http://179.19.5.35:9536",
"ws": true
}
},
//做多个代理的配置文件
constproxy=require('http-proxy-middleware');
module.exports=function (app) {
app.use(
proxy(
'/api', { //遇见 /api前缀的请求,就会触发该代理配置
target: 'http://localhost:5000',
changeOrigin: true, // 控制服务器接收到的请求头host的值
pathRewrite: {
"^/api": "/api"
}
}),
proxy(
'/apc', {
target: 'http://localhost:7000',
changeOrigin: true,
pathRewrite: {
"^/apc": ""
},
}
)
)
};
(1)、声明式编程 (2)、组件化编程 (3)、可使用react native编写原生应用 (4)、优秀的diff算法 (5)、使用虚拟(virtual)DOM,不总是直接操作页面真实 DOM (6)、DOM Diffing 算法,最小化页面重绘
599. 开发准备
1)、React 运行环境的依赖资源
(1)、react.development.js(React 的核心库,当前版本为开发版本) (2)、react-dom.development.js(React 的扩展库,当前版本主要操作 DOM 渲染,因为现在开发环 境是在 PC 网页端) (3)、babel.min.js(ES6 转 ES5,JSX 转 JS) (4)、prop-types.js(属性类型的检测与约束库)
2)、Babel
(1)、Babel 是一个 JavaScript 编译器
3)、能干什么:
(1)、语法转换 (2)、源码转换 (3)、通过 Polyfill 方式在目标环境中添加缺失的特性
4)、Babel与JSX 以及 React的关系
(1)、Babel 能够转换 JSX 语法,之前引入babel.min.js的目的就是将JSX转成ES语法
600. DOM
1)、虚拟DOM创建
2)、虚拟 DOM 与真实 DOM
(1)、虚拟DOM本质是一个Object对象,非常“轻” (2)、真实DOM的属性节点非常多非常“重” (3)、最终是需要将虚拟DOM转成真实DOM
(1)、1. <script type="text/babel"> const VDOM = <h1 id="title"> Hello
React</h1>
(2)、2.<script type="text/javascript"> const VDOM =React.createElement("h1",
{ id: "title" },"Hello React"))
601. JSX 语法规则
1)、虚拟DOM定义的时候不能使用字符串型式,不要写引号 2)、标签结构中需要混入js表达式,要用{}做分割,即:{js表达式} 3)、指定样式的类名不要用class,建议使用className 4)、行内样式,要用style={{}}的形式去编写,且像font-size这样的样式需要改写成驼峰式写法,不是 必须,会出警告 5)、JSX有且只有一个根元素 6)、标签必须闭合 7)、标签首字母 (1)假若标签首字母是小写,即将该标签转为html的同名元素,若html中无该元素,那么则警告 ( 2)若标签首字母是大写,那么则会被认为是React组件,而这时候将会去找这个组件,如果没有定义 过这个组件,将直接报错
602. 组件与模块
1)、模块
(1)、什么是模块:向外提供特定功能的js程序,一般就是一个js文件 (2)、为什么要拆成模块:随着业务逻辑增加,代码越来越多且复杂 (3)、作用:复用js,简化js的编写,提高js运行效率 (4)、什么是模块化开发:模块定义、接口暴露、模块引入、模块调用 (5)、模块化开发规范有哪些?AMD(异步模块定义,代表:requireJs)、CMD(通用模块定义,代 表:seaJs)、CommonJs(nodejs服务器端模块化规范)、ES6
2)、组件
(1)、什么是组件:用来实现局部功能效果的代码和资源的集合(html/css/js/image等等) (2)、为什么要用组件:随着业务功能的增加,相同、相似的功能操作内容重复使用率大幅度提升, 简单的复制粘贴会使得项目代码可维护性降低 (3)、作用:复用编码,简化项目编码,提高运行效率 (4)、什么是组件化开发:组件定义(HTML、CSS、JS、Images、Fonts、Files…)、组件暴露、组件 引入、组件调用
603. React组件
1)、类组件
2)、函数式组件
(1)、使用函数定义一个组件 (1.1)、注意:在函数式组件中,this对象是undefined,其原因是React+Babel默认返回是strict严 格模式 (1.2)、注意:.一般情况在进行渲染的时候不用函数调用模式,而是使用组件调用模式 (1.3)、注意:如果是函数式组件,进行组件化调用,则必须是首字母大写 (2)、渲染组件到页面 (2.1)、注意:是否能写成Hello、Hello()、,不能 (2.2)、注意:在JSX中,Hello是组件,而不是普通函数,所以不是函数调用操作 (2.3)、执行了ReactDOM.render(…后发生了什么??? (2.3.1)、React发现了标签,寻找Hello组件定义的位置 (2.3.2)、React发现Hello组件使用函数定义的,React去调用Hello
六、工程化
604. 同一个页面三个组件请求同一个 API
面试要点/答案要点
- 避免重复请求:使用共享状态或请求去重(dedupe)。
- 可用方案:全局缓存(Redux/Pinia/Zustand)、请求级缓存(axios cache)、请求队列 + Promise 复用、SSR/预取。
- 细节:请求参数相同才复用,考虑缓存失效、并发冲突、错误重试、取消请求(AbortController)。
示例代码(用 Promise 去重 + 简单缓存,适用于 fetch/axios)
// requestPool.js
const pool = new Map(); // key -> Promise
const cache = new Map(); // key -> { data, expire }
function genKey(url, params) {
return url + '::' + JSON.stringify(params || {});
}
export async function request(url, params = {}, opts = {}) {
const key = genKey(url, params);
const now = Date.now();
const ttl = opts.ttl || 0;
if (cache.has(key)) {
const { data, expire } = cache.get(key);
if (!expire || expire > now) return data;
cache.delete(key);
}
if (pool.has(key)) {
// 有正在进行的请求,直接复用 Promise
return pool.get(key);
}
const p = fetch(url, {
method: opts.method || 'GET',
headers: opts.headers,
body: opts.body ? JSON.stringify(opts.body) : undefined,
signal: opts.signal,
})
.then(res => {
if (!res.ok) throw new Error('Network error');
return res.json();
})
.then(data => {
if (ttl > 0) cache.set(key, { data, expire: now + ttl });
return data;
})
.finally(() => {
pool.delete(key);
});
pool.set(key, p);
return p;
}
// ExampleComponent.jsx (React)
import React, { useEffect, useState } from 'react';
import { request } from './requestPool';
function Item() {
const [data, setData] = useState(null);
useEffect(() => {
let ac = new AbortController();
request('/api/items', {}, { ttl: 5000, signal: ac.signal })
.then(setData)
.catch(err => { if (err.name !== 'AbortError') console.error(err);});
return () => ac.abort();
}, []);
return <div>{data ? JSON.stringify(data) : 'loading'}</div>;
}
export default function Page() {
return (
<div>
<Item /><Item /><Item />
</div>
);
}
面试话术:“我们采用请求复用(Promise pooling)+ 可配置 TTL 缓存,避免同一时刻的重复网络请求,同时支持 AbortController 取消与错误边界处理。”
605. cjs / esm / umd 等区别是什么
面试要点
- CJS (CommonJS):Node.js 传统模块(
require/module.exports),同步加载,适用于服务器。 - ESM (ES Modules):
import/export,静态分析、支持 tree-shaking、可以异步加载,浏览器/现代打包器优先。 - UMD (Universal Module Definition):兼容 AMD、CJS、全局变量,常用于发布兼容包(CDN)。
- 选型原则:库发布 -> 提供 ESM + CJS + UMD(兼容旧环境);应用中优先 ESM。
示例:输出多格式(Rollup 配置)
// rollup.config.js
import commonjs from '@rollup/plugin-commonjs';
import nodeResolve from '@rollup/plugin-node-resolve';
import { terser } from 'rollup-plugin-terser';
export default [
{
input: 'src/index.js',
output: { file: 'dist/bundle.cjs.js', format: 'cjs' },
plugins: [nodeResolve(), commonjs()],
},
{
input: 'src/index.js',
output: { file: 'dist/bundle.esm.js', format: 'es' },
plugins: [nodeResolve()],
},
{
input: 'src/index.js',
output: { file: 'dist/bundle.umd.js', format: 'umd', name: 'MyLib' },
plugins: [nodeResolve(), commonjs(), terser()],
},
];
面试话术:“库通常提供 ESM 以便 tree-shaking,CJS 保持 Node 兼容,UMD 提供浏览器直接引入支持。”
606. 前端权限管理的模型
要点
- 权限维度:认证(AuthN) vs 授权(AuthZ)。
- 模型:
- RBAC(基于角色 Role-Based)—— 角色映射权限集合(常见)。
- ABAC(基于属性 Attribute-Based)—— 基于资源/用户/环境属性判断(更灵活)。
- PBAC / ACL(基于策略或访问控制列表)。
- 前端实践:最小权限展示、路由守卫、组件级权限指令、后端返回可授权菜单/按钮、策略中心化(策略服务)。
- 防御性设计:前端只做 UI 隐藏,关键权限必须在后端校验。
代码示例:简单 RBAC(React + route guard)
// auth.js
export const currentUser = { roles: ['editor'] };
export const hasPermission = (permission) => {
const rolePerm = {
admin: ['read','write','delete'],
editor: ['read','write'],
guest: ['read']
};
return currentUser.roles.some(r => (rolePerm[r] || []).includes(permission));
};
// ProtectedButton.jsx
import React from 'react';
import { hasPermission } from './auth';
export default function ProtectedButton({ permission, children, ...rest }) {
if (!hasPermission(permission)) return null; // 或者disabled
return <button {...rest}>{children}</button>;
}
面试话术:“前端以 RBAC 做展示权限,后端做强校验;复杂场景可用 ABAC 实现细粒度策略。”
607. peerDependencies
要点
peerDependencies表示包需要宿主(项目)安装的依赖版本(通常用于插件/库与宿主共享同一份依赖,如 React)。- 作用:避免库自带多份 React(避免版本冲突),让宿主控制依赖版本。
- 注意事项:发布时声明 peerDeps,配合
peerDependenciesMeta标注可选项;在开发时 usenpm/yarn/pnpm的--legacy-peer-deps/workspace 管理。
示例 package.json
{
"name": "my-component-lib",
"version": "1.0.0",
"peerDependencies": {
"react": "^18.0.0",
"react-dom": "^18.0.0"
},
"peerDependenciesMeta": {
"react": { "optional": false }
}
}
面试话术:“peerDependencies 用在插件/组件库,确保宿主项目安装并统一控制依赖的版本,防止重复打包与运行时冲突。”
608. pnpm 有什么优势
要点
- 磁盘节省:内容寻址存储(store)+ 硬链接,避免重复依赖。
- 安装速度快、严格的 node_modules 布局(避免“幽灵依赖”),workspace 支持好,适合 monorepo。
- 对包管理策略(如
pnpmfile、hooks)与锁文件健壮。 - 面试可补充:需处理 Node resolution 的某些老工具兼容问题,但现代工具兼容良好。
示例:pnpm workspace 配置
// pnpm-workspace.yaml
packages:
- 'packages/*'
// package.json (root)
{
"name": "monorepo",
"private": true,
"devDependencies": {}
}
面试话术:“pnpm 在 monorepo 环境下能显著节省磁盘并提高安装速度,同时强制依赖声明,减少运行时问题。”
609. eslint 作用
要点
- 静态代码检查,保持代码风格一致、捕捉潜在错误(未使用变量、语法错误)。
- 支持自定义规则、插件(React、TypeScript、Security)。
- 在工程化中:作为 CI 门槛、pre-commit(husky + lint-staged)环节、IDE 即时反馈。
示例:ESLint + Prettier 配置
// .eslintrc.js
module.exports = {
root: true,
parser: '@typescript-eslint/parser',
plugins: ['@typescript-eslint', 'react'],
extends: [
'eslint:recommended',
'plugin:react/recommended',
'plugin:@typescript-eslint/recommended',
'prettier'
],
rules: {
'no-unused-vars': 'warn',
'react/prop-types': 'off'
},
};
面试话术:“ESLint 是代码质量第一道防线,结合 CI 和 pre-commit 能有效控制代码回退成本。”
610. browserslist
要点
browserslist用来声明支持的浏览器范围,影响 Babel、Autoprefixer、PostCSS、webpack/bundler 的目标转译与 polyfill。- 写法:
"> 1%, last 2 versions, not dead"或针对不同环境(production/development)。
示例:package.json 中配置
{
"browserslist": {
"production": [">0.2%", "not dead", "not op_mini all"],
"development": ["last 1 chrome version", "last 1 firefox version"]
}
}
面试话术:“通过 browserslist 明确目标环境,减小 polyfill 与转译体积,同时提升性能。”
611. minify 代码压缩
要点
- 目的是减小 JS/CSS 体积、提高首屏加载速度。通常使用 terser/uglify/esbuild/terser-webpack-plugin。
- 注意:不要混淆压缩与混淆,压缩保留逻辑,混淆改变变量名;需要处理 source map、console 去除、产物调试。
示例(webpack production 使用 terser)
// webpack.config.prod.js (片段)
const TerserPlugin = require('terser-webpack-plugin');
module.exports = {
mode: 'production',
optimization: {
minimize: true,
minimizer: [new TerserPlugin({
terserOptions: { compress: { drop_console: true } }
})],
},
};
面试话术:“生产构建使用 terser/esbuild 来压缩,同时配置去掉 console 并保留 source map 以便排查。”
612. package-lock.json
要点
package-lock.json(npm)锁定依赖树、保证安装一致性。pnpm-lock.yaml/yarn.lock同理。- 不应手动编辑,CI/CD 中应提交锁文件;在库项目中可有不同策略(应用必须提交,库可视发布策略)。
示例检查命令
# 查看被锁定版本
npm ci # 保证使用 lockfile 安装,适合 CI
npm audit # 安全审计
面试话术:“锁文件保证环境可复现,CI 用 *npm ci* 强制严格安装。”
613. serverless
要点
- Serverless:按需计算(函数)平台(AWS Lambda、Vercel、Netlify、Cloud Functions),免运维,按调用付费。
- 适用场景:事件驱动、API 后端、轻量短时任务;不适合长时任务(需要注意冷启动、资源上限、并发限制)。
- 工程要点:无状态、快速启动、合理冷启动优化、并发与超时、监控与本地调试(serverless-offline)。
示例:简单 AWS Lambda handler(Node)
// handler.js
exports.handler = async (event) => {
const name = event.queryStringParameters?.name || 'world';
return {
statusCode: 200,
body: JSON.stringify({ msg: `hello ${name}` }),
};
};
Vercel Serverless(api/hello.js)
// api/hello.js
export default function handler(req, res) {
res.status(200).json({ hello: 'world' });
}
面试话术:“Serverless 省运维成本,但需要设计无状态、短时任务和冷启动优化策略,CI/CD 与本地模拟是关键。”
614. 常见的 Loader(你用过哪些)
要点
- Webpack Loader 用于对模块进行转换:
babel-loader,ts-loader,css-loader,style-loader,sass-loader,file-loader(v5 推荐 asset modules),url-loader(已废弃),vue-loader。 - 使用场景举例:把 TS 转为 JS,编译 SASS,处理图片、字体。
示例 webpack loader 配置
module.exports = {
module: {
rules: [
{ test: /\.tsx?$/, use: 'ts-loader', exclude: /node_modules/ },
{ test: /\.jsx?$/, use: 'babel-loader', exclude: /node_modules/ },
{ test: /\.css$/, use: ['style-loader', 'css-loader'] },
{ test: /\.(png|jpg|svg)$/, type: 'asset', parser: { dataUrlCondition: { maxSize: 8192 } } }
]
}
};
面试话术:“Loader 是文件到模块的转换器,我常用 babel-loader/ts-loader/vue-loader/css-loader/sass-loader 处理编译与资源。”
615. 常见的 Plugin(见过哪些)
要点
- Webpack 插件用于扩展构建流程:
HtmlWebpackPlugin,MiniCssExtractPlugin,DefinePlugin,HotModuleReplacementPlugin,TerserPlugin,CopyWebpackPlugin,ForkTsCheckerWebpackPlugin。 - 插件职责更广:影响构建生命周期、产物、输出等。
示例(常见插件配置)
const HtmlWebpackPlugin = require('html-webpack-plugin');
const MiniCssExtractPlugin = require('mini-css-extract-plugin');
module.exports = {
plugins: [
new HtmlWebpackPlugin({ template: './index.html' }),
new MiniCssExtractPlugin({ filename: '[name].[contenthash].css' }),
new (require('webpack')).DefinePlugin({ 'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV) })
]
};
面试话术:“Plugin 能干预打包生命周期,常见插件用于 HTML 注入、提取 CSS、并行类型校验、代码压缩等。”
616. Loader 和 Plugin 的区别
要点
- Loader:用于把文件转换为模块(链式、针对单个模块),例如把 SASS -> CSS -> JS。
- Plugin:扩展打包器生命周期(全局影响),可以处理多个文件、控制输出、做优化、注入行为。
- 面试总结句子:Loader = 文件级转换,Plugin = 构建流程级别扩展。
简要示例:想把 .foo 文件转换为 JS 用 Loader;想在每次构建后生成报告用 Plugin。
617. Webpack 构建流程简单说一下
要点:六大阶段
- 解析配置(Configuration)
- 初始化 Compiler(Compiler)并注册插件
- 从 entry 开始构建模块依赖图(Compilation)
- 对模块应用 loader 转换,收集依赖
- 进行优化(tree-shaking、code splitting、minify)
- 输出 assets(emit)
- 插件可以 tap 到这些钩子影响流程。
面试话术:“Webpack 从配置出发创建 Compiler,遍历入口文件构建依赖图、对模块应用 Loader、使用 Plugin 做优化与打包,最后 emit 产物。”
618. 使用 webpack 开发时可以提高效率的插件
常用插件
HtmlWebpackPlugin(自动注入)ForkTsCheckerWebpackPlugin(TS 类型校验异步)HotModuleReplacementPlugin(HMR)webpack-dev-server/webpack-dev-middleware(本地开发)eslint-webpack-plugin(开发时即时 lint)SpeedMeasurePlugin(构建性能分析)
示例:dev config
const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
module.exports = {
mode: 'development',
devtool: 'cheap-module-source-map',
plugins: [
new ForkTsCheckerWebpackPlugin(),
new (require('webpack')).HotModuleReplacementPlugin()
],
devServer: { hot: true, port: 3000 }
};
面试话术:“结合 HMR、异步类型检查和 lint 插件可以保持开发流畅且保证质量。”
619. 文件指纹是什么?怎么用?
要点
- 文件指纹(hash)用于静态资源长缓存(Cache busting)。常见:
[contenthash]、[chunkhash]、[hash]。 - 实践:生成带 hash 的文件名并在 HTML 中引用,CDN 缓存策略使用长缓存,变更时更新文件名。
示例 webpack output
output: {
filename: '[name].[contenthash:8].js',
assetModuleFilename: 'assets/[name].[contenthash:8][ext]'
}
面试话术:“用 contenthash 保证只在内容变化时文件名变化,配合缓存策略大幅提升前端性能。”
620. 如何优化 Webpack 构建速度?
要点(实战清单)
- 使用
cache(filesystem cache) - 使用
thread-loader/esbuild-loader或swc-loader替代 babel 在非复杂转译下加速 - 开启
parallel(terser 的并行) - 使用
include/exclude精准匹配 loader 范围 - 按需编译(DLL、模块联邦、持久化缓存)
- 使用
source-map选择(开发 cheaper map) - 减少 polyfills、合理拆分 vendor
示例:开启 filesystem cache 与 esbuild-loader
module.exports = {
cache: { type: 'filesystem', buildDependencies: { config: [__filename] } },
module: {
rules: [
{ test: /\.tsx?$/, loader: 'esbuild-loader', options: { loader: 'tsx', target: 'es2017' } }
]
}
};
面试话术:“优先开启 filesystem cache 和用更快的编译器(esbuild/swc),再结合按需 loader 配置与并行化即可显著降构建时间。”
621. 写过 Loader 吗?缩写 loader 思路
要点
- Loader 是一个导出函数:接收源内容,返回转换后的内容(或异步回调)。
- 思路:解析输入 -> 进行 transform(babel transform / regex / parse AST)-> 返回 JS module(module.exports / export default)。
- 注意 sourceMap 支持、异步处理、cacheable 声明。
示例:一个简单的 loader(把 **// @upper** 标记的字符串转为大写)
// loaders/upper-loader.js
module.exports = function (source, map) {
this.cacheable && this.cacheable();
const result = source.replace(/\/\/\s*@upper\n([\s\S]*?)\n\/\/\s*@end/gi, (_, txt) => txt.toUpperCase());
this.callback(null, result, map);
};
// webpack config
module.exports = {
module: {
rules: [{ test: /\.txt$/, use: [{ loader: require.resolve('./loaders/upper-loader') }] }]
}
};
面试话术:“写 loader 的关键是处理输入输出与 sourceMap,通常结合 AST(babel/parser)进行复杂转换。”
622. 写过 Plugin 吗?编写 Plugin 思路
要点
- Plugin 是一个类/函数,
apply(compiler)内注册钩子(compiler.hooks)。 - 思路:识别希望插手的阶段(比如 compilation, emit),使用同步/异步 tap 方法,并处理 assets 或信息。
示例:简单插件 — 在 emit 时注入 banner 文件
// plugins/banner-plugin.js
class BannerPlugin {
constructor(options = {}) { this.options = options; }
apply(compiler) {
compiler.hooks.emit.tapAsync('BannerPlugin', (compilation, callback) => {
const banner = this.options.banner || 'Built by BannerPlugin';
compilation.assets['banner.txt'] = {
source: () => banner,
size: () => banner.length
};
callback();
});
}
}
module.exports = BannerPlugin;
// webpack.config.js
const BannerPlugin = require('./plugins/banner-plugin');
module.exports = { plugins: [new BannerPlugin({ banner: 'Hello from build' })] };
面试话术:“Plugin 本质是订阅 webpack 钩子,能全局影响流程,适合跨模块或构建产物级别的操作。”
623. Babel 原理
要点
- Babel 工作流程:parse -> AST -> transform(plugin/transpiler,使用 visitor 修改 AST)-> generate(输出代码 & sourceMap)。
- 插件结构:visitor(节点访问器)对 AST 节点进行替换/插入,preset 是一组插件的集合。
- Babel 的目标:把现代 JS 转为目标环境兼容的 JS(polyfill 与 transform 分开)。
示例:自定义 Babel plugin(把 **log('x')** -> **console.log('x')**)
// babel-plugin-to-console.js
module.exports = function ({ types: t }) {
return {
visitor: {
CallExpression(path) {
if (t.isIdentifier(path.node.callee, { name: 'log' })) {
path.node.callee = t.memberExpression(t.identifier('console'), t.identifier('log'));
}
}
}
};
};
使用:
// .babelrc
{ "plugins": ["./babel-plugin-to-console.js"] }
面试话术:“Babel 是 AST 转换器,插件通过访问器模式在 AST 上做变换,最后再生成代码与 sourcemap。”
624. source map 是什么?生产环境怎么用?
要点
- source map 映射编译/压缩后的代码到源代码,便于调试。
- 生产使用策略:
- 选用合适的映射类型(
source-map/hidden-source-map/nosources-source-map)。 - 若担心源码泄露,使用
hidden-source-map并只在 Sentry/错误收集工具上上传 map,不在浏览器可直接访问。 - 注意:公开 source map 可能泄露源码或注入安全风险。
- 选用合适的映射类型(
示例(webpack)
// dev
devtool: 'eval-cheap-module-source-map'
// prod (不公开,但上传到错误收集)
devtool: 'hidden-source-map'
面试话术:“生产可使用 hidden-source-map 上传到错误监控(Sentry),避免直接暴露源码同时保留可追踪性。”
625. 文件监听原理
要点
- 两种方式:轮询(polling) 与 文件系统事件(inotify on Linux, fsevents on macOS, ReadDirectoryChangesW on Windows)。
- Node.js 使用
fs.watch或fs.watchFile(后者是轮询),工具如 webpack-dev-server / chokidar 使用更稳定的跨平台库 chokidar。 - 面试补充:大量文件时轮询耗资源,inotify 有文件数上限 (可调整
fs.inotify.max_user_watches)。
示例(chokidar)
const chokidar = require('chokidar');
const watcher = chokidar.watch('./src', { ignored: /node_modules/ });
watcher.on('change', path => console.log('changed', path));
面试话术:“一般用 chokidar 做跨平台监听,优先使用文件事件,轮询仅作 fallback 或 CI 环境下使用。”
626. Webpack 热更新(HMR)原理
要点
- HMR:在不刷新页面的情况下替换、添加或删除模块。
- 流程:Dev server 通过 websocket 通知客户端有更新 -> 客户端获取更新模块 -> 运行模块的 accept 回调(module.hot.accept) -> 局部替换模块并执行更新逻辑 -> 若不能处理则触发全页 reload。
- HMR 能保持应用状态(在组件层面实现),适合 UI 开发。
示例(React + webpack HMR)
// index.js
import React from 'react';
import { createRoot } from 'react-dom/client';
import App from './App';
const root = createRoot(document.getElementById('root'));
root.render(<App />);
if (module.hot) {
module.hot.accept('./App', () => {
const NextApp = require('./App').default;
root.render(<NextApp />);
});
}
面试话术:“HMR 将模块热替换并调用模块的 accept 回调,能保留应用内状态,提升开发效率。”
627. Webpack 事件机制了解吗?
要点
- Webpack 使用 Tapable(类似事件/钩子系统),提供同步/异步钩子(tap/tapAsync/tapPromise)。
- 常见钩子:
compiler.hooks.beforeRun,compiler.hooks.emit,compilation.hooks.optimizeChunks等。 - Plugin 利用这些钩子改变构建流程或产物。
示例(插件内 tap)
compiler.hooks.emit.tapAsync('MyPlugin', (compilation, cb) => {
// 修改 compilation.assets
cb();
});
面试话术:“Webpack 钩子基于 Tapable,Plugin 通过 tap 注册不同阶段的逻辑。”
628. 了解 Webpack5 吗,相比 Webpack4 有哪些提升?
要点
- 主要提升:
- 更好的持久化 cache(filesystem cache)提升构建速度。
- 内置 Module Federation(实验/插件生态),改善微前端。
- 更现代的 asset modules(替代 file/url loaders)。
- 更严格的默认性能/Tree shaking 改进。
- 更小的 runtime 与优化机制。
- 面试话术:“Webpack5 将性能与模块共享作为核心改进,尤其是持久化 cache 与 Module Federation 对大型项目受益显著。”
629. 模块联邦(Module Federation)理解
要点
- Module Federation:Webpack5 特性,允许在运行时动态加载并共享多个独立构建的模块(micro-frontends)。
- 优点:独立部署、共享 runtime/库,按需加载远程模块。
- 注意事项:共享依赖版本协调、跨域/运行时加载策略、安全(验证远端模块来源)。
示例(host & remote 简要)
// remote webpack config
new ModuleFederationPlugin({
name: 'remoteApp',
filename: 'remoteEntry.js',
exposes: { './Button': './src/Button' },
shared: { react: { singleton: true, eager: true }, 'react-dom': { singleton: true } }
});
// host webpack config
new ModuleFederationPlugin({
name: 'host',
remotes: { remoteApp: 'remoteApp@http://localhost:3001/remoteEntry.js' },
shared: { react: { singleton: true }, 'react-dom': { singleton: true } }
});
// host usage
const RemoteButton = React.lazy(() => import('remoteApp/Button'));
面试话术:“Module Federation 支持运行时共享模块,便于团队独立部署子应用并共享核心库。”
630. 什么是 Webpack?它的作用是什么?
要点
- Webpack 是模块打包器(module bundler),从入口构建依赖图并输出静态资源(JS/CSS/图片)。
- 作用:模块化、资源处理(loader)、构建优化(plugin)、代码分割、tree-shaking、生产构建。
面试话术:“Webpack 把前端项目的各种资源当模块来处理并生成优化后的静态资源,以支持现代前端开发流程。”
631. Webpack 中有哪些核心概念?
要点列表
- Entry:应用入口
- Output:构建输出
- Module & Rules(Loader):模块及如何转换它
- Plugins:扩展构建流程
- Chunk:按需加载单元
- Asset:静态资源
- Dependency Graph:依赖图
- Mode:production/development
面试话术:“理解 entry/module/plugin/chunk/output 这些基本概念能帮助掌握 webpack 的整体构建模型。”
632. Webpack 的 mode 是什么
要点
mode='development' | 'production' | 'none',配置默认优化项(如 uglify、tree shaking)。development:更快构建、保留调试信息;production:启用优化、压缩、性能优化。
示例
module.exports = { mode: process.env.NODE_ENV || 'development' };
面试话术:“mode 决定内置优化集合,CI 中请显式指定 production 以获得体积与性能优化。”
633. 什么是代码分割(Code Splitting)?如何在 Webpack 中实现?
要点
- 代码分割:将包拆成多个 bundle,按需加载(减少首屏体积)。
- 实现方式:
- 静态:entry 分割(multiple entries)
- 动态:
import()(动态 import)实现懒加载 - CommonsChunk / SplitChunksPlugin(提取 vendor)
- 场景:路由懒加载、按需组件、按功能拆包。
示例:React 路由懒加载 + webpack splitChunks
// App.jsx
import React, { Suspense } from 'react';
const Home = React.lazy(() => import('./Home'));
const Admin = React.lazy(() => import('./Admin'));
function App(){
return (
<Suspense fallback={<div>Loading...</div>}>
{/* 假设基于路由 */}
<Home />
<Admin />
</Suspense>
);
}
export default App;
// webpack optimization
optimization: {
splitChunks: {
chunks: 'all',
cacheGroups: {
vendor: { test: /[\\/]node_modules[\\/]/, name: 'vendors', chunks: 'all' }
}
}
}
面试话术:“首屏加载最小化、路由/组件按需加载和 vendor 提取是代码分割的三大常见策略。”
634. 区别TS与JS?(说说TS的特点)
强类型, 声明变量时可以指定特定类型, 编码时可以有更友好的提示(错误或补全), 易于写出更健壮的 程序 TS支持JS的所有语法特性, 也扩展了一些新的数据类型 新的基本类型: 联合类型, 元组, 枚举 新的复杂类型: 接口, 泛型 TS浏览器是不能直接运行的, 需要编译为JS才能运行
635. 说说你对接口的理解
接口是对状态(属性)或行为(方法)的抽象(描述) 接口可以用来约束一个对象/函数/类
636. 说说你对泛型的理解
泛型: 代表不确定的类型 泛型可以用在函数/接口/类上 什么时候需要泛型呢? 定义函数/接口/类时, 要操作数据类型不确定 泛型的3个操作 定义泛型类型 函数: 定义函数的函数名的右侧 接口: 定义接口的接口名的右侧 类: 定义类的类名的右侧 使用泛型: T 函数: 参数/返回值/函数体 接口: 接口体内 类: 类体内 指定泛型对应的具体类型: <具体类型名> 函数: 调用函数时函数名的右侧 接口: 定义实现类时接口名的右侧 类: 创建实例时类名的右侧
637. Vue3 比 Vue2 有什么优势
更好的代码组织和逻辑抽离
设计composition API 来代替option API
更便于可复用功能代码的封装提取, 代码可阅读性更高 体积更小 将功能以多个函数提供出来, 我们会进行按需引入使用 引入tree-shaking , 可以在打包压缩时, 将无用模块“摇掉” 性能更好/更快 使用proxy代替defineProperty来实现数据劫持 diff算法优化: 静态虚拟节点添加静态标记, 不进行diff比较 静态提升: 静态虚拟节点提升到render的外面, 缓存起来, 不创建新的 更好的 TS 支持 对TS的类型检查更友好 更好的脚手架工具vite 启动运行快了很多
638. Vue3 生命周期
setup → onBeforeMount → onMounted → onBeforeUpdate → onUpdated → onBeforeUnmount → onUnmounted
对应 Vue2 的 beforeCreate/created 由 setup() 本身承担;keep-alive 有 onActivated/onDeactivated,错误捕获用 onErrorCaptured。
639. 组合API VS 选项API
composition API 优点: 更好的代码组织 更好的逻辑复用 更好的类型推导 如何选择: 不建议共用,会引起混乱 小型项目,业务逻辑简单,用 Options API 中大型项目,逻辑复杂,用 Composition API
选项式 API(Options API )
所有方法都写在 methods 中,如果 data 中数据越来越多,找数据会非常困难
<template>
<h1@click="changeCount">{{ count }}</h1>
</template>
<script>
exportdefault {
name: 'App',
data() {
return {
count: 0,
}
},
methods: {
changeCount() {
this.count++
},
组合式 API(Composition API )
逻辑会清晰,可以让功能的代码集中抽取到一个函数中进行逻辑复用
640. 常用的组合API
启动函数 setup() 响应式: 核心 ref() reactive() computed() watch() 响应式: 工具 toRefs() 生命周期勾子 onMounted() onBeforeUnmount()
},
}
</script>
<template>
<h1@click="changeNum">{{ num }}</h1>
</template>
<script>
import { ref } from'vue'
functionuseNum() {
constnum=ref(0)
functionchangeNum() {
num.value++
}
return { changeNum, num }
}
exportdefault {
name: 'App',
setup() {
const { changeNum, num } =useNum()
return {
changeNum,
num,
}
},
}
</script>
641. 比较Vue2与Vue3的响应式(重要)
核心差异:Vue2 用 Object.defineProperty 劫持属性(新增/删除属性、数组下标监听不到,需要 $set 补救);Vue3 改用 Proxy 代理整个对象(13 种拦截操作,新增/删除/下标全都能响应)。详见下面两题。
642. 1) vue2的响应式
核心: 对象: 通过defineProperty对对象的已有属性值的读取和修改进行劫持(监视/拦截) 数组: 通过重写数组更新数组一系列更新元素的方法来实现元素修改的劫持 问题 对象直接新添加的属性或删除已有属性, 界面不会自动更新 直接通过下标替换/添加元素或更新length, 界面不会自动更新
643. 2) Vue3的响应式
核心: 通过Proxy(代理): 拦截对data任意属性的任意(13种)操作, 包括属性值的读写, 属性的添加, 属性 的删除等… 通过 Reflect(反射): 动态对代理对象的相应属性进行特定的操作
Object.defineProperty(data, 'count', {
get () {},
set () {}
})
constp=newProxy(data, {
// 拦截读取属性值
get (target, prop) {
returnReflect.get(target, prop)
},
// 拦截设置属性值或添加新属性
set (target, prop, value) {
returnReflect.set(target, prop, value)
},
// 拦截删除属性
deleteProperty (target, prop) {
returnReflect.deleteProperty(target, prop)
}
})
p.name='tom'
<!DOCTYPE html>
<htmllang="en">
<head>
<metacharset="UTF-8">
<metaname="viewport"content="width=device-width, initial-scale=1.0">
<title>Proxy 与 Reflect</title>
</head>
<body>
<script>
constuser= {
name: "John",
age: 12
};
/*
proxyUser是代理对象, user是被代理对象
后面所有的操作都是通过代理对象来操作被代理对象内部属性
*/
constproxyUser=newProxy(user, {
get(target, prop) {
console.log('劫持get()', prop)
returnReflect.get(target, prop)
},
set(target, prop, val) {
console.log('劫持set()', prop, val)
returnReflect.set(target, prop, val); // (2)
},
deleteProperty (target, prop) {
console.log('劫持delete属性', prop)
returnReflect.deleteProperty(target, prop)
}
});
// 读取属性值
console.log(proxyUser===user)
console.log(proxyUser.name, proxyUser.age)
// 设置属性值
proxyUser.name='bob'
proxyUser.age=13
console.log(user)
// 添加属性
proxyUser.sex='男'
console.log(user)
// 删除属性
deleteproxyUser.sex
console.log(user)
</script>
</body>
</html>
644. pinia VS vuex
Pinia 没有mutations , 在actions中可以直接同步更新state或异步更新state Pinia中可以包含多个store, 而且相互独立, 且不进行合并, 没有模块的嵌套结构 无需手动注册 store,创建出的store直接就可以使用 更好的TypeScript支持, 提示补全很到位
645. vue-router V4的变化
创建路由器有变化 new Router 变成 createRouter createWebHistory()与createWebHashHistory() 取代了 ‘history’ 与 ‘hash’ 动态添加路由 以前可以一次添加多个: router.addRoutes(routes) 现在只能一次添加一个: router.addRoute(route) 通配路由的path变了 以前的path: * 现在的path: /:pathMatch(.*)
646. vue3 & TS 语法
声明接收props 原生事件 原生标签上绑定 组件标签上绑定: 组件内部没有声明为自定义事件 自定义事件 全局事件总线
// 定义接口, 约束prop
interfaceProps {
count: number;
updateCount(val: number): void;
}
defineProps<Props>()
// 声明事件
constemit=defineEmits<{
(e: 'xxx', val: string): void
(e: 'click', val: object): void
(e: 'increment', val: number): void
}>()
// ts 中分发事件
emit('xxx', 'abc')
// 模板中分发事件
$emit('increment', 5)
vue本身不再提供事件总线的API: 没有$on方法了 需要使用mitt或pubsub-js 第三方工具包 v-model的本质 原生标签上: 动态value和原生的input监听 组件标签上: 动态modelValue(默认)和自定义的input监听 向外暴露方法 组件内部的方法默认在外部是不能调用的 可以通过 defineExpose暴露 通过ref得到组件对象
七、性能优化
647. 性能优化之项目初始化
说明 / 关键点
- 项目初始化决定了运行时 & 打包基线:选择构建工具(Vite/webpack/Rollup)、模块系统(ESM/CJS)、语言(TS)、按需加载策略、第三方库替换(例如 lodash -> lodash-es / dayjs 替代 moment)。
- 约定:开启 ESModule、tree-shakeable 包、按需引入 UI 库、开 dev/prod config 分离。
- 初始工程需包含性能可观测点(Lighthouse、Sourcemap、bundle analyzer)及 CI 流程检查体积阈值。
建议步骤
- 选择 Vite(开发启动快)或 modern webpack(如果需要复杂插件)。
- 使用 ESM 包与
sideEffects在 package.json。 - 初始引入 bundle 分析、HMR、缓存策略(esbuild / terser)、压缩。
- 将可选大型依赖列为外部(CDN/动态加载)。
- 配置 CI 下的体积检测(比如
size-limit)。
代码 demo(Vite + React + TypeScript)
package.json
{
"name": "perf-starter",
"version": "0.1.0",
"scripts": {
"dev": "vite",
"build": "vite build",
"serve": "vite preview",
"analyze": "vite build --watch --mode analyze"
},
"dependencies": {
"react": "^18.2.0",
"react-dom": "^18.2.0"
},
"devDependencies": {
"vite": "^5.0.0",
"typescript": "^5.0.0",
"esbuild": "^0.18.0",
"rollup-plugin-visualizer": "^5.5.0"
}
}
vite.config.ts
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import { visualizer } from 'rollup-plugin-visualizer';
export default defineConfig(({ mode }) => ({
plugins: [
react(),
// 在 analyze 模式下开启可视化
...(mode === 'analyze' ? [visualizer({ open: true, gzipSize: true })] : [])
],
build: {
target: 'es2018',
sourcemap: mode === 'development',
// chunkSizeWarningLimit 可调整
chunkSizeWarningLimit: 1000,
rollupOptions: {
output: {
manualChunks: {
// 初始公共chunk示例
vendor: ['react', 'react-dom']
}
}
}
}
}));
示例 CI 检查(size-limit):
npm i -D size-limit @size-limit/preset-small-lib
package.json 加入:
"size-limit": [
{
"path": "dist/index.js",
"limit": "200 KB"
}
]
648. 性能优化之辅助分析插件
说明 / 关键点
- 分析工具用于定位体积热点与慢点:
webpack-bundle-analyzer、rollup-plugin-visualizer、source-map-explorer、esbuild --metafile、Chrome DevTools Performance、Lighthouse。 - 结合 sourcemaps 能把 bundle 中的代码映射回源代码,找出大体积依赖、重复模块、未 tree-shaken 代码。
代码 demo(Webpack & Vite 两个常见例)
Vite(使用 rollup visualizer)—— 已在上题 vite.config.ts 演示。
Webpack:
npm i -D webpack-bundle-analyzer
webpack.config.js:
const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer');
module.exports = {
// ...entry/output
plugins: [
new BundleAnalyzerPlugin({
analyzerMode: 'static',
reportFilename: 'report.html',
openAnalyzer: false
})
]
};
使用 source-map-explorer:
npm i -D source-map-explorer
# 构建之后:
npx source-map-explorer dist/assets/*.js
Chrome DevTools/Lighthouse:在真实设备/模拟慢网下跑 Lighthouse,并结合 Performance Trace 来找 First Contentful Paint / Long Tasks。
649. 性能优化之缩小范围(上)
说明 / 关键点
- “缩小范围” 的上层策略是从宏观定位到微观:先用 Lighthouse / bundle analyzer 定位是网络 / bundle 体积 / 渲染 / JS 执行问题,再逐步聚焦到具体页面或模块。
- 上层方法:全量采样 -> 选定“慢页面” -> 打开 DevTools(Network/Performance/Memory)抓取 trace。
步骤
- 收集数据:用户热力图、页面访问量、性能埋点(RUM)。
- 使用 Lighthouse 报表找出症状(如 TTFB / LCP / CLS / FCP)。
- 根据访问量和影响度确定优化优先级(hot path 优先)。
代码 demo — 采集与分析示例(简单 RUM)
src/rum.ts
// 简单 RUM 上报示例,仅用于采样
export function reportPerf() {
if (!('performance' in window) || Math.random() > 0.05) return; // 5% 采样
window.addEventListener('load', () => {
requestAnimationFrame(() => {
const timing = performance.timing as any;
const data = {
// 注意:Navigation Timing Level 2 推荐使用 PerformanceNavigationTiming
loadTime: timing.loadEventEnd - timing.navigationStart,
fcp: performance.getEntriesByType('paint').find(p=>p.name==='first-contentful-paint')?.startTime
};
navigator.sendBeacon('/rum', JSON.stringify(data));
});
});
}
后台只需简单接收并汇总慢页面。
650. 性能优化之缩小范围(中)
说明 / 关键点
- 中层技术:用 Performance Profiling 的 flame chart 定位 Long Tasks、用 Coverage(Coverage Tab)定位未使用代码/样式、用 Lighthouse 的 “Largest Contentful Paint element” 找到关键渲染资源。
- 热点聚焦后可以用
--inspect/DevTools Profiler结合 CPU profile 来找函数占用。
步骤 & 命令
- DevTools → Performance 录制页面加载(选择“Capture DevTools Timeline”),分析 Long Tasks。
- DevTools → Coverage,Reload with Coverage,查看未使用的 JS/CSS。
- 若使用 React,开启 Profiler 并在开发环境定位频繁 re-render 的组件。
示例:在 React 中用 Profiler
import React, { Profiler } from 'react';
function onRenderCallback(id, phase, actualDuration) {
// 将数据上报用于分析
console.log({ id, phase, actualDuration });
}
export default function App() {
return (
<Profiler id="App" onRender={onRenderCallback}>
{/* ... */}
</Profiler>
);
}
651. 性能优化之缩小范围(下)
说明 / 关键点
- 下层细化:拿到具体模块后,拆分检查依赖链(import graph)、重复依赖(多版本的 lodash)、第三方大包(charts、i18n、date libs)。
- 常用工具:
npm ls <pkg>、depcruise(dependency-cruiser)来检视依赖图,手动替换或将大库外部化(CDN 或动态 import)。
示例脚本:检查多版本
# 检查 lodash 多版本
npm ls lodash
# 或 pnpm why lodash
pnpm why lodash
替换示例
- 将
moment替换为dayjs:
// before
import moment from 'moment';
console.log(moment().format());
// after
import dayjs from 'dayjs';
console.log(dayjs().format());
652. 性能优化之忽略模块
说明 / 关键点
- 忽略(exclude/ignore)不需要打包的模块:例如测试工具、dev-only 模块、大型 polyfills(按需加载)或 server-only 代码。
- Webpack:
IgnorePlugin;Rollup / Vite:externalconfig;也可以在package.json的browser字段或条件导出中排除平台不适用模块。
代码 demo(webpack IgnorePlugin)
const webpack = require('webpack');
module.exports = {
plugins: [
// 忽略 moment 的 locales(常见优化)
new webpack.IgnorePlugin({
resourceRegExp: /^\.\/locale$/,
contextRegExp: /moment$/
})
]
};
Vite / Rollup 外部化
vite.config.ts
export default defineConfig({
build: {
rollupOptions: {
external: ['some-node-only-lib']
}
}
});
653. 性能优化之缓存与线程(上下)
说明 / 关键点
- 缓存:浏览器端(长缓存策略 + content-hash)、Service Worker(Cache API)、HTTP cache headers(Cache-Control, ETag)、构建缓存(esbuild/webpack persistent cache)。
- 线程:将 CPU 密集型任务移到 Web Worker;使用线程池(worker pool)或 node side 的 worker_threads;在构建工具中使用多线程 loader(thread-loader / esbuild 并行)。
- 上下(上):构建时缓存(faster incremental builds);(下):运行时缓存(静态资源 & SW & localStorage)。
代码 demo — Web Worker 计算 hash(避免主线程卡顿)
src/hash.worker.ts(使用 Vite 支持 worker)
// hash.worker.ts
self.onmessage = async (e) => {
const file = e.data as ArrayBuffer;
// 在 worker 中计算(示例使用 SubtleCrypto)
const digest = await crypto.subtle.digest('SHA-256', file);
const hex = Array.from(new Uint8Array(digest)).map(b => b.toString(16).padStart(2,'0')).join('');
postMessage(hex);
};
在主线程中使用:
const worker = new Worker(new URL('./hash.worker.ts', import.meta.url));
worker.onmessage = (e) => console.log('hash', e.data);
worker.postMessage(arrayBuffer);
构建缓存(Vite)
vite.config.ts
export default defineConfig({
cacheDir: 'node_modules/.vite_cache',
build: {
// 开启 esbuild 的 incremental/incremental 默认行为或使用 vite 内建缓存
}
});
thread-loader(webpack)
module.exports = {
module: {
rules: [
{
test: /\.ts$/,
use: [
'thread-loader',
'babel-loader'
],
exclude: /node_modules/
}
]
}
}
654. 性能优化之压缩
说明 / 关键点
- 代码压缩(JS/CSS):Terser/Esbuild(esbuild 更快但 terser 在某些场景有更细腻压缩选项)。开启
drop_console、pure_funcs。 - 传输压缩:gzip / brotli(服务器在构建时预压缩静态资源可提升性能);HTTP/2+ 更有利于多个小文件传输。
- 压缩图片:用 WebP、AVIF,并在构建或上传管道压缩(sharp、imagemin)。
- 体积对比:构建后产生
.br/.gz文件,配合 nginx 配置。
代码 demo — Vite 插件预压缩 & nginx 配置 安装预压缩插件:
npm i -D vite-plugin-compress
vite.config.ts
import compress from 'vite-plugin-compress';
export default defineConfig({
plugins: [
compress({ brotli: true, gzip: true })
],
build: { /* ... */ }
});
nginx 示例(启用 pre-compressed 文件)
server {
location / {
root /var/www/dist;
gzip on;
gzip_static on; # 使用预压缩 .gz
brotli on;
brotli_static on; # 如果有预压缩 .br
add_header Cache-Control "public, max-age=31536000, immutable";
}
}
655. 性能优化之样式
说明 / 关键点
- CSS 优化包含:Critical CSS(抽取关键首屏样式内联)、按需加载样式、移除未用样式(PurgeCSS / uncss)、CSS 分割(按路由拆分)、避免大范围选择器与深层嵌套(影响渲染性能)。
- 用 CSS-in-JS 或 CSS Modules 可以 scope 样式,减少全局覆盖查找成本;但要注意运行时开销。
- 减少使用
:root过多变量、避免 expensive CSS(box-shadow、大量复杂选择器)、减少 layout-triggering 属性变更(width/height -> transform)。
代码 demo — Critical CSS 与 Purge(Tailwind 示例)
Tailwind + purge(tailwind.config)
module.exports = {
content: ['./index.html', './src/**/*.{js,ts,jsx,tsx}'],
// ...
}
抽取 Critical CSS(构建后用 critters 或 critical)
npm i -D critters-webpack-plugin
webpack.config.js:
const Critters = require('critters-webpack-plugin');
module.exports = {
plugins: [
new Critters({
// inline: true,
preload: 'swap'
})
]
}
按路由加载样式(React + dynamic import)
const LazyPage = React.lazy(() => import('./page-with-big-css'));
该页面的 CSS 会随 chunk 被加载。
656. 性能优化之环境变量(上)
说明 / 关键点
- 环境变量影响构建行为与打包结果(如是否启用 mock、是否开启 source map、API 域名等)。
- 在构建时通过 define 插件(Vite 的
define/ webpack 的 DefinePlugin)注入常量,允许构建器做 Dead Code Elimination(DCE)。 - 使用
process.env.NODE_ENV === 'production'作为分支可被 tree-shaking 删除不需要的代码块。
示例(Vite define)
vite.config.ts
export default defineConfig(({ mode }) => ({
define: {
__BUILD_TIME__: JSON.stringify(new Date().toISOString()),
__APP_ENV__: JSON.stringify(process.env.APP_ENV || mode)
}
}));
在代码中使用
if (process.env.NODE_ENV !== 'production') {
console.log('debug only');
}
// 或者使用 define 常量
if (__APP_ENV__ === 'development') {
// dev only
}
这样生产构建会把分支去掉,减少体积。
657. 性能优化之环境变量(下)
细节与实战:条件导入 / 条件打包
- 利用条件编译(Define + dead code elimination)避免引入大型 dev-only lib(例如:只在 dev 引入
why-did-you-render)。 - 使用
import()在运行时按需加载环境相关模块。 - 对第三方库采用 externals/CDN 在生产构建时替换。
代码 demo — dev-only 包
if (process.env.NODE_ENV === 'development') {
// 这里使用 dynamic import,生产构建下该分支被去掉
import('why-did-you-render').then(wdyr => {
// init
});
}
在 webpack/Vite 中开启 Terser/Esbuild 的 DCE 会消除掉这些分支。
658. 性能优化之treeshaking
说明 / 关键点
- Treeshaking 的前提:使用 ES module(
import/export)与支持 treeshake 的打包器(Rollup/Vite/webpack 在 production 模式)。 - package.json 的
sideEffects字段需正确标识模块是否有副作用(false 或列出有副作用的文件)。 - 避免使用会阻止 tree-shaking 的语法(例如:
require()、动态构建的大量export *、对整个库做import * as然后引用属性会阻碍某些优化)。 - 优化第三方库:优先选择提供 ESM 的包(
lodash-es而非lodash)。
代码 demo
package.json
{
"sideEffects": [
"*.css",
"src/some-global-polyfill.js"
]
}
使用 lodash-es:
import { debounce } from 'lodash-es';
避免 import * as _ from 'lodash',会导致无法去掉没用的函数。
659. 性能优化之代码分割(上)
说明 / 关键点
- 代码分割分为路由级分割、组件级分割、库分割(vendor)三类。
- 动态 import(
import()/ React.lazy)是最常用方式;手动设置manualChunks进行长期缓存优化。 - 把首次渲染所需的最少代码放在第一页,其它通过懒加载按需拉取。
示例(React + Vite)
// route-based lazy
import React, { Suspense } from 'react';
const Home = React.lazy(() => import('./pages/Home'));
const Dashboard = React.lazy(() => import('./pages/Dashboard'));
function App() {
return (
<Suspense fallback={<div>loading</div>}>
{/* 根据路由加载 */}
</Suspense>
);
}
vite.config.ts 手工分割:
export default defineConfig({
build: {
rollupOptions: {
output: {
manualChunks(id) {
if (id.includes('node_modules')) {
if (id.includes('react')) return 'vendor_react';
return 'vendor';
}
}
}
}
}
});
660. 性能优化之代码分割(下)
更深入:预加载、预取、优先级控制
- 使用
<link rel="prefetch">或<link rel="preload">控制资源优先级。 - React Router 等可以在空闲时间提前加载下一个页面的 chunk(link prefetch 或
requestIdleCallback)。 - 注意:过度预加载会浪费带宽,应基于访问概率做智能预取。
代码 demo — 在路由改变前预fetch
// 简单的 prefetch util
export function prefetchComponent(loader: () => Promise<any>) {
if ('requestIdleCallback' in window) {
(window as any).requestIdleCallback(() => {
loader();
});
} else {
setTimeout(() => loader(), 2000);
}
}
// 用法:在 hover 或导航预测时调用
button.addEventListener('mouseover', () => prefetchComponent(() => import('./Dashboard')));
661. 性能优化之提取公共组件(上)
说明 / 关键点
- 公共组件提取分为代码级(common chunk / shared library)和组件库(monorepo 的 shared 包)。
- 好处:减少重复代码、便于缓存和复用。缺点:过度共享会增加首屏体积(如果把不常用组件放公共 chunk)。
- 方式:手动
manualChunks、使用 monorepo + pnpm workspace 抽出@company/ui包、或在运行时 CDN 加载公共 UI 库。
代码 demo — monorepo shared package(pnpm workspace) 仓库结构:
/packages
/ui (shared components)
/app (main app depends on @company/ui)
packages/ui/package.json
{
"name": "@company/ui",
"version": "1.0.0",
"main": "dist/index.js",
"module": "dist/index.esm.js",
"sideEffects": false
}
组件示例:
// packages/ui/src/Button.tsx
import React from 'react';
export const Button = (props) => <button {...props} />;
主应用直接 import { Button } from '@company/ui',构建工具会把它作为单独包处理,利于复用与缓存。
662. 性能优化之提取公共组件(中)
策略 & 实践
- 按需打包共享组件(shared chunk),把稳定且常用的组件放到 vendor/chunk,减少多次重复加载。
- 做「按需导出」:不要把整个 component 库以一个巨型 bundle 导出,支持按文件导入(
import { Button } from '@company/ui'或import Button from '@company/ui/Button')。 - 在构建时利用
splitChunks(webpack)或manualChunks(rollup/vite)把常用组件单独分离。
webpack splitChunks 示例
optimization: {
splitChunks: {
chunks: 'all',
cacheGroups: {
commons: {
name: 'commons',
test: /[\\/]src[\\/]components[\\/]/,
minChunks: 2,
priority: 10
}
}
}
}
663. 性能优化之提取公共组件(下)
进阶:运行时共享(Module Federation / microfrontends)
- 对于大型多团队项目,可使用 Module Federation(webpack 5)或微前端框架(single-spa/Wujie)实现运行时共享组件、按需加载并互相复用。
- 好处:团队独立部署、减小单体包;坏处:复杂度高、版本兼容挑战。
Module Federation 简单示例(host/remote)
remote webpack.config.js:
const ModuleFederationPlugin = require('webpack').container.ModuleFederationPlugin;
module.exports = {
plugins: [
new ModuleFederationPlugin({
name: 'remoteApp',
filename: 'remoteEntry.js',
exposes: {
'./Button': './src/Button'
},
shared: { react: { singleton: true }, 'react-dom': { singleton: true } }
})
]
};
host:
new ModuleFederationPlugin({
remotes: {
remoteApp: 'remoteApp@http://localhost:3001/remoteEntry.js'
},
shared: { react: { singleton: true }, 'react-dom': { singleton: true } }
});
Host 可直接动态加载 remote 的 Button 组件。
八、Node.js 与后端基础
664. Node 是什么
答案: Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行时,用于在服务端执行 JavaScript。它采用事件驱动、非阻塞 I/O 模型,非常适合高并发场景。
- 特点:
- 单线程 + 异步非阻塞
- 事件驱动
- 可用于构建网络应用、工具脚本等
代码 demo:
// hello.js
console.log('Hello Node.js');
// 运行方式
// node hello.js
665. Node 优缺点
答案:
- 优点
- 高性能:基于 V8 引擎
- 异步非阻塞 I/O,适合高并发
- JavaScript 全栈统一
- 丰富的 npm 生态
- 缺点
- 单线程 CPU 密集型任务性能差
- 异步编程复杂
- 不适合计算密集型场景
代码示例:
// 异步示例
const fs = require('fs');
fs.readFile('./file.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
666. Node 的应用场景
答案:
- Web 服务器(Express、Koa)
- 实时应用(聊天、游戏)
- API 网关
- 流处理(文件上传、音视频处理)
- 脚本工具(自动化、爬虫)
代码 demo:
const http = require('http');
const server = http.createServer((req, res) => {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello Node Server');
});
server.listen(3000, () => {
console.log('Server running at http://localhost:3000/');
});
667. Node 的 fs 模块
答案:
fs 是 Node 内置模块,用于文件系统操作,包括读、写、删除、监控文件。
代码 demo:
const fs = require('fs');
// 读取文件
fs.readFile('./file.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
668. Node 的 fs 文件基础知识
答案:
- 文件路径:相对路径、绝对路径
- 文件编码:utf8、binary
- 同步/异步方法区别:
- 异步:不阻塞主线程
- 同步:阻塞主线程
代码 demo:
const fs = require('fs');
const path = require('path');
const filePath = path.join(__dirname, 'file.txt');
// 同步读取
const data = fs.readFileSync(filePath, 'utf8');
console.log(data);
669. Node 的 fs 文件方式 — 写入
答案:
fs.writeFile:覆盖写入- 异步、同步均可
代码 demo:
const fs = require('fs');
fs.writeFile('test.txt', 'Hello Node.js', 'utf8', (err) => {
if (err) throw err;
console.log('文件写入成功');
});
670. Node 的 fs 文件方法 — 追加写入
答案:
fs.appendFile:在文件末尾追加内容
代码 demo:
const fs = require('fs');
fs.appendFile('test.txt', '\n追加内容', (err) => {
if (err) throw err;
console.log('追加成功');
});
671. Node 的 fs 文件方法 — 文件拷贝
答案:
fs.copyFile用于拷贝文件- 可指定覆盖模式
代码 demo:
const fs = require('fs');
fs.copyFile('test.txt', 'test_copy.txt', (err) => {
if (err) throw err;
console.log('文件复制成功');
});
672. Node 的 buffer 文件方法
答案:
Buffer是 Node 用于处理二进制数据的全局对象- 文件读取时可以直接获取 buffer
代码 demo:
const fs = require('fs');
fs.readFile('test.txt', (err, data) => {
if (err) throw err;
console.log('Buffer:', data); // <Buffer 48 65 6c 6c 6f ...>
console.log('String:', data.toString());
});
673. Node 的 buffer 使用方法
答案:
- 创建 buffer:
Buffer.alloc(size)、Buffer.from(string) - 常用方法:
toString()slice()length
代码 demo:
const buf1 = Buffer.alloc(10); // 10字节空buffer
const buf2 = Buffer.from('Hello Node'); // 从字符串创建
console.log(buf2.toString()); // Hello Node
console.log(buf2.length); // 10
674. JWT 鉴权机制是什么?
答案:
- JWT(JSON Web Token)是一种基于 JSON 的身份认证方案
- 结构:
header.payload.signature - 特点:
- 无状态(服务端无需存储 session)
- 可跨域
- 自包含(payload 可存储用户信息)
示意:
header.payload.signature
675. JWT 鉴权机制如何实现?
答案:
- 用户登录 -> 服务端生成 JWT -> 返回给客户端
- 客户端每次请求携带 JWT
- 服务端验证 JWT 是否有效
代码 demo:
const jwt = require('jsonwebtoken');
const secret = 'my_secret';
// 登录生成 token
const token = jwt.sign({ userId: 123 }, secret, { expiresIn: '1h' });
console.log('Token:', token);
676. JWT 鉴权机制 — 如何验证 token
答案:
- 服务端使用
jwt.verify(token, secret)验证 - 验证成功即可继续访问,否则拒绝
代码 demo:
try {
const payload = jwt.verify(token, secret);
console.log('验证成功', payload);
} catch (err) {
console.log('验证失败', err.message);
}
677. 分页功能实现
答案:
- 常用思路:
limit+offset- 或使用 cursor 分页(大数据量)
代码 demo(假设数据库查询):
function getPageData(page = 1, pageSize = 10) {
const offset = (page - 1) * pageSize;
return db.query('SELECT * FROM users LIMIT ? OFFSET ?', [pageSize, offset]);
}
678. Node 中 Stream 的基本使用
答案:
- Stream 是处理流式数据的接口,避免一次性读写大文件
- 四种类型:
- Readable
- Writable
- Duplex
- Transform
代码 demo(读取大文件):
const fs = require('fs');
const readStream = fs.createReadStream('large.txt', 'utf8');
readStream.on('data', chunk => {
console.log('读取数据块:', chunk.length);
});
readStream.on('end', () => {
console.log('读取完成');
});
679. Node 中 Stream 的种类
答案:
- Readable:可读
- Writable:可写
- Duplex:读写
- Transform:可转换(例如 gzip 压缩)
代码 demo(可写 stream):
const fs = require('fs');
const writeStream = fs.createWriteStream('output.txt');
writeStream.write('Hello Stream\n');
writeStream.end();
680. Node 中 Stream 的使用场景
答案:
- 大文件处理(上传/下载)
- 数据管道(pipe)
- 实时日志处理
- 网络请求流
代码 demo(pipe):
const fs = require('fs');
const readStream = fs.createReadStream('large.txt');
const writeStream = fs.createWriteStream('copy.txt');
readStream.pipe(writeStream);
681. Node 的 process
答案:
process是 Node 提供的全局对象,表示 Node 进程- 常用属性:
process.argv命令行参数process.env环境变量process.exit()退出进程
代码 demo:
console.log('命令行参数:', process.argv);
console.log('环境变量:', process.env.NODE_ENV);
process.exit(0);
682. Node 中 process 的基本使用
答案:
- 监听事件:
exituncaughtException
- 设置环境变量
- 获取内存使用情况
代码 demo:
process.on('exit', code => {
console.log('进程退出码:', code);
});
console.log('当前内存使用:', process.memoryUsage());
683. Node 的 eventEmitter
答案:
EventEmitter是 Node 事件驱动机制核心类- 可以注册、触发事件
代码 demo:
const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('sayHello', (name) => {
console.log(`Hello, ${name}`);
});
emitter.emit('sayHello', 'Node');
684. Node 中 eventEmitter 的基本使用
答案:
- 注册事件:
on/once - 触发事件:
emit - 移除事件:
removeListener
代码 demo:
const EventEmitter = require('events');
const emitter = new EventEmitter();
function greet(name) { console.log('Hi', name); }
emitter.on('greet', greet);
emitter.emit('greet', 'Alice');
emitter.removeListener('greet', greet);
685. Node 中 eventEmitter 是如何实现的?
答案:
- 内部维护一个事件名称到回调函数数组的映射
emit遍历数组依次调用回调- 基于发布/订阅模式
简化实现 demo:
class MyEmitter {
constructor() { this.events = {}; }
on(event, fn) {
this.events[event] = this.events[event] || [];
this.events[event].push(fn);
}
emit(event, ...args) {
(this.events[event] || []).forEach(fn => fn(...args));
}
}
const emitter = new MyEmitter();
emitter.on('msg', (text) => console.log(text));
emitter.emit('msg', 'Hello!');
686. Node 的中间件
答案:
- 中间件:函数链,接收
req, res, next - 在请求处理前/后做一些处理
- 常见于 Express/Koa
代码 demo(Express):
const express = require('express');
const app = express();
function logger(req, res, next) {
console.log(`${req.method} ${req.url}`);
next();
}
app.use(logger);
app.get('/', (req, res) => res.send('Hello Middleware'));
app.listen(3000);
687. Node 中间件的使用
答案:
- 使用
app.use()或路由级中间件 - 可做鉴权、日志、异常处理等
代码 demo:
app.use((req, res, next) => {
if (!req.headers.authorization) {
return res.status(401).send('Unauthorized');
}
next();
});
688. 在 Node 的中间件中如何添加日志模块?
答案:
- 在中间件中使用
console.log或专业日志库(winston,pino) - 可以记录请求时间、URL、状态码
代码 demo:
const fs = require('fs');
app.use((req, res, next) => {
const log = `${new Date()} ${req.method} ${req.url}\n`;
fs.appendFileSync('access.log', log);
next();
});
689. Node 的事件循环机制是什么?
答案:
- Node 单线程通过事件循环实现高并发
- 异步任务分为宏任务(setTimeout, setImmediate)和微任务(Promise, process.nextTick)
690. Node 的事件循环流程
答案:
- 执行栈执行同步代码
- 执行微任务队列(process.nextTick, Promise.then)
- 执行 I/O 回调(Timer, IO callbacks)
- 执行 setImmediate
- 进入下一轮循环
代码 demo(展示执行顺序):
console.log('start');
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));
Promise.resolve().then(() => console.log('promise'));
process.nextTick(() => console.log('nextTick'));
console.log('end');
输出顺序:
start
end
nextTick
promise
setTimeout
setImmediate
691. Node 的事件循环流程在面试中如何回答?
答案:
- 简洁版:Node 单线程,事件循环 + 异步非阻塞 I/O,微任务优先于宏任务
- 可画图解释执行栈、回调队列和事件循环阶段
- 面试题重点:
- 微任务 vs 宏任务
- setImmediate vs setTimeout
- process.nextTick
692. Node 的性能是什么?
答案:
- 性能指标:
- 响应时间
- 吞吐量
- CPU 占用
- 内存使用
- 性能瓶颈:
- CPU 密集型任务
- 大量同步 I/O
- 阻塞事件循环
693. Node 的监控
答案:
- 常用指标:
- Event Loop 延迟
- CPU/内存
- 请求数、错误率
- 工具:
pm2node-clinicprometheus + grafana- 内置
processAPI
代码 demo(监控 event loop 延迟):
const { performance } = require('perf_hooks');
setInterval(() => {
const start = performance.now();
setImmediate(() => {
const delay = performance.now() - start;
console.log('Event loop delay:', delay.toFixed(2), 'ms');
});
}, 1000);
694. Node 的性能优化
答案:
- 异步 I/O,避免阻塞
- 使用 Stream 处理大文件
- 利用 cluster 或 worker_threads 多线程处理 CPU 密集任务
- 缓存热点数据
- 减少中间件和同步阻塞
代码 demo(cluster 多核):
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
for (let i = 0; i < numCPUs; i++) cluster.fork();
cluster.on('exit', (worker) => {
console.log(`Worker ${worker.process.pid} exited`);
cluster.fork();
});
} else {
http.createServer((req, res) => {
res.end('Hello Cluster');
}).listen(3000);
}
695. MySQL和MongoDB的差异是什么
MySQL 是关系型数据库:固定表结构、事务与外键、强一致,适合核心业务数据;MongoDB 是文档型 NoSQL:schema 灵活、JSON 亲和、易于水平扩展,适合日志、内容等弱结构化数据。详见下一题。
696. 什么是关系型数据库,什么是非关系型数据库
一、二维关系型数据库
什么是关系型数据库
关系型数据库,是指采用了关系模型来组织数据的数据库。 关系模型是在1970年由IBM的研究员E.F.Codd博士首先提出的,在之后的几十年中,关系模型的概念 得到了充分的发展并逐渐成为主流数据库结构的主流模型。 简单来说,关系模型指的就是二维表格模型,而一个关系型数据库就是由二维表及其之间的联系所组 成的一个数据组织。
关系模型中常用的概念:
关系:可以理解为一张二维表,每个关系都具有一个关系名,就是通常说的表名 元组:可以理解为二维表中的一行,在数据库中经常被称为记录 属性:可以理解为二维表中的一列,在数据库中经常被称为字段 域:属性的取值范围,也就是数据库中某一列的取值限制 关键字:一组可以唯一标识元组的属性,数据库中常称为主键,由一个或多个列组成 关系模式:指对关系的描述。其格式为:关系名(属性1,属性2, … … ,属性N),在数据库中成为表 结构
关系型数据库的优点:
容易理解:二维表结构是非常贴近逻辑世界的一个概念,关系模型相对网状、层次等其他模型来说更 容易理解 使用方便:通用的SQL语言使得操作关系型数据库非常方便 易于维护:丰富的完整性(实体完整性、参照完整性和用户定义的完整性)大大减低了数据冗余和数据 不一致的概率
关系型数据库瓶颈
1).高并发读写需求 网站的用户并发性非常高,往往达到每秒上万次读写请求,对于传统关系型数据库来说,硬盘I/O是一 个很大的瓶颈 2).海量数据的高效率读写 网站每天产生的数据量是巨大的,对于关系型数据库来说,在一张包含海量数据的表中查询,效率是 非常低的 3).高扩展性和可用性 在基于web的结构当中,数据库是最难进行横向扩展的,当一个应用系统的用户量和访问量与日俱增 的时候,数据库却没有办法像web server和app server那样简单的通过添加更多的硬件和服务节点来扩 展性能和负载能力。对于很多需要提供24小时不间断服务的网站来说,对数据库系统进行升级和扩展是 非常痛苦的事情,往往需要停机维护和数据迁移。
二、NoSQL
什么是NoSQL
NoSQL一词首先是Carlo Strozzi在1998年提出来的,指的是他开发的一个没有SQL功能,轻量级的, 开源的关系型数据库。这个定义跟我们现在对NoSQL的定义有很大的区别,它确确实实字如其名,指的 就是“没有SQL”的数据库。但是NoSQL的发展慢慢偏离了初衷,我们要的不是“no sql”,而是“no relational”,也就是我们现在常说的非关系型数据库了。 2009年初,Johan Oskarsson举办了一场关于开源分布式数据库的讨论,Eric Evans在这次讨论中再 次提出了NoSQL一词,用于指代那些非关系型的,分布式的,且一般不保证遵循ACID原则的数据存储系 统。Eric Evans使用NoSQL这个词,并不是因为字面上的“没有SQL”的意思,他只是觉得很多经典的关系 型数据库名字都叫“**SQL”,所以为了表示跟这些关系型数据库在定位上的截然不同,就是用了 “NoSQL“一词。 注:数据库事务必须具备ACID特性,ACID是Atomic原子性,Consistency一致性,Isolation隔离性, Durability持久性。 非关系型数据库提出另一种理念,例如,以键值对存储,且结构不固定,每一个元组可以有不一样的 字段,每个元组可以根据需要增加一些自己的键值对,这样就不会局限于固定的结构,可以减少一些时 间和空间的开销。使用这种方式,用户可以根据需要去添加自己需要的字段,这样,为了获取用户的不 同信息,不需要像关系型数据库中,要对多表进行关联查询。仅需要根据id取出相应的value就可以完成 查询。但非关系型数据库由于很少的约束,他也不能够提供像SQL所提供的where这种对于字段属性值 情况的查询。并且难以体现设计的完整性。他只适合存储一些较为简单的数据,对于需要进行较复杂查 询的数据,SQL数据库显的更为合适。
非关系型数据库分类
由于非关系型数据库本身天然的多样性,以及出现的时间较短,因此,不想关系型数据库,有几种数 据库能够一统江山,非关系型数据库非常多,并且大部分都是开源的。 这些数据库中,其实实现大部分都比较简单,除了一些共性外,很大一部分都是针对某些特定的应用 需求出现的,因此,对于该类应用,具有极高的性能。依据结构化方法以及应用场合的不同,主要分为 以下几类: 1).面向高性能并发读写的key-value数据库:key-value数据库的主要特点即使具有极高的并发读写性 能,Redis,Tokyo Cabinet,Flare就是这类的代表 2).面向海量数据访问的面向文档数据库:这类数据库的特点是,可以在海量的数据中快速的查询数 据,典型代表为MongoDB以及CouchDB 3).面向可扩展性的分布式数据库:这类数据库想解决的问题就是传统数据库存在可扩展性上的缺陷, 这类数据库可以适应数据量的增加以及数据结构的变化
三. 关系型数据库 V.S. 非关系型数据库
关系型数据库的最大特点就是事务的一致性:传统的关系型数据库读写操作都是事务的,具有ACID的 特点,这个特性使得关系型数据库可以用于几乎所有对一致性有要求的系统中,如典型的银行系统。 但是,在网页应用中,尤其是SNS应用中,一致性却不是显得那么重要,用户A看到的内容和用户B看 到同一用户C内容更新不一致是可以容忍的,或者说,两个人看到同一好友的数据更新的时间差那么几 秒是可以容忍的,因此,关系型数据库的最大特点在这里已经无用武之地,起码不是那么重要了。 相反地,关系型数据库为了维护一致性所付出的巨大代价就是其读写性能比较差,而像微博、 facebook这类SNS的应用,对并发读写能力要求极高,关系型数据库已经无法应付(在读方面,传统上为 了克服关系型数据库缺陷,提高性能,都是增加一级memcache来静态化网页,而在SNS中,变化太 快,memchache已经无能为力了),因此,必须用新的一种数据结构存储来代替关系数据库。 关系数据库的另一个特点就是其具有固定的表结构,因此,其扩展性极差,而在SNS中,系统的升 级,功能的增加,往往意味着数据结构巨大变动,这一点关系型数据库也难以应付,需要新的结构化数 据存储。 于是,非关系型数据库应运而生,由于不可能用一种数据结构化存储应付所有的新的需求,因此,非 关系型数据库严格上不是一种数据库,应该是一种数据结构化存储方法的集合。 必须强调的是,数据的持久存储,尤其是海量数据的持久存储,还是需要一种关系数据库这员老将。
九、小程序
有哪些参数传值的方法
给 HTML 元素添加 data-*属性来传递我们需要的值,然后通过 e.currentTarget.dataset 或 onload 的 param 参数获取,但 data-名称不能有大写字母和不可以存放对象 设置 id 的方法标识来传值通过 e.currentTarget.id 获取设置的 id 的值,然后通过设置全局对 象的方式来传递数值 在 navigator 中添加参数传值,但需要注意 navigateTo 等进行参数传递的时候有长度的限 制,如果传递的参数是对象,首先需要转化数据类型 JSON.stringify、JSON.parse,再则需 要进行编码类型的转化 encodeURIComponent、decodeURIComponent 使用组件模板 template 传递参数 可以利用 globalData 进行全局数据的设置以及在各个页面的获取处理 可以利用数据缓存的功能进行 setStorage、getStorage 的设值与获取 使用后端程序进行不同页面之间的传递数据
697. 小程序修改数据值与 Vue 和 React 有什么差异
小程序不能直接 this.data.xxx 进行数据值的修改,Vue 可以直接 this.xxx 进行数据值的修改 小程序需要利用 this.setData 进行数据值的修改,而 React 则是利用 this.setState 进行数据 值的修改 小程序利用 this.setData 进行状态值的修改模式是同步及异步的,而 React 的 this.setState 是异步函数 可以看到 setData 函数过程是: 将数据从逻辑层发送到视图层是异步 改变 this.data 是同步的 也就是说改变值是同步的,改变值之后渲染页面是异步的。如此操作的目的是为了 提高性能,不可能改变一次数据渲染一次页面,等所有 data 改变完之后一块渲染 页面
this.setState({
name: 'zhang',
});
console.log(this.state.name); //不能立马获取到新的state值
this.setData({
name: 'zhang',
});
console.log(this.data.name); //可以立马获取到新的data值
698. 如何实现下拉刷新与上拉加载
首先需要思考的是操作的对象不同,有页面级的下拉刷新与上拉加载操作,也有 scroll-view 组件级的下拉刷新和上拉加载处理 针对于页面级: 可以在全局 config 中的 window 配置中设置 enablePullDownRefresh 属性,当然建议 enablePullDownRefresh 属性是在页面级配置中设置,在 Page 中定义 onPullDownRefresh 事件函数 到达下拉刷新条件后,该事件函数执行,发起请求方法,下拉刷新请求返回后,调用 wx.stopPullDownRefresh 停止下拉刷新。 至于上拉加载则可以利用 onReachBottom 事件函数来确认后续的功能操作,一般它与 onReachBottomDistance 进行配合处理,确认距离底部的距离,而它的单位是 px。 针对 scroll-view 组件级: 下拉刷新需要利用 refresher-enabled 开启,对应的阈值设置是 refresher-threshold 需要利用 refresher-triggered 来确认刷新的状态,在下拉刷新结束以后需要设置为 false 状态 利用 bindscrolltolower 实现上拉加载的功能处理 纵向滚动时需要给 scroll-view 设置具体的高度值
699. bindtap 和 catchtap 的区别是什么
相同点:首先他们都是作为点击事件函数,就是点击时触发。在这个作用上他们是一样的, 可以不做区分 不同点:他们的不同点主要是 bindtap 是不会阻止冒泡事件的,catchtap 是阻值冒泡的
700. 小程序有哪些导航 API,它们各自的应用场景与差异区别是什么
导航相关的 API 主要包括:wx.navigateTo()、wx.redirectTo()、wx.switchTab()、 wx.navigateBack()、wx.reLaunch() wx.navigateTo():保留当前页面,跳转到应用内的某个页面,但是不能跳到 tabbar 页面 wx.redirectTo():关闭当前页面,跳转到应用内的某个页面,但是不允许跳转到 tabbar 页面 wx.switchTab():跳转到 tabBar 页面,并关闭其他所有非 tabBar 页面 wx.navigateBack():关闭当前页面,返回上一页面或多级页面。可通过 getCurrentPages() 获取当前的页面栈,决定需要返回几层 wx.reLaunch():关闭所有页面,打开到应用内的某个页面
701. 小程序中如何使用第三方 npm 模块进行功能开发
npm init 项目的初始化操作 npm install lodash —save 等模块安装操作 微信开发者工具->详情->本地设置->使用 npm 模块 微信开发者工具->工具->构建 npm
702. 小程序的定位在开发环境的设置
使用定位操作需要授权处理,需在 app.json 中设置 permission 节点信息,将 useLocation 授权添加上 开发环境使用定位需要在调试器中开启,在 Sensor 中将 Geolocation 的 enable 设置为开启 状态 在测试开发环境下,利用 wx.getLocation 获取位置信息内容,获取到的将会是 Sensor 中设 置的默认值信息
703. 小程序的地图应用可以使用什么方式处理
API 简易地图:先可以利用 wx.getLocation 获取位置的经纬度等信息,再使用 wx.openLocation 打开微信内置地图查看位置,不过获取的信息只有经纬度,所以像 name,address 等内容没有更好的办法进行显示,而且 wx.openLocation 仅限于查看地图查 看位置,其它更多的地图内容不能够处理。 组件功能地图:如果需要标注、路线、俯视、旋转更多的地图操作功能,则需要利用 map 组 件进行地图内容的展示操作
704. 如何获取当前的省市区,并在地图上显示地理信息
需要通过第三方地图 API 接口进行地理信息的获取,比如腾讯地图、百度地图、高德地图 等,但不管哪个第三方地图应用,其操作过程基本雷同 因为要请求第三方地图 API 接口,所以需要在微信平台的授权请求地址中将第三方地图 API 的请求地址内容进行授权设置,否则正式环境将无法允许应用请求对应的地址 如果没有在微信平台的授权请求地址,那么无法进行真机预览操作,但可以进行真机调试处 理 第三方地图 API 接口的一般操作流程如下(以百度地图为例): 创建地图应用
"permission": {
"scope.userLocation": {
“desc”: “你的位置信息将用于小程序位置接口的效果展示”
}
}
选择正确的应用类型以及设置小程序的 AppID 获取 AK 信息 查看对应的文档资料 下载相应支持小程序的第三方地图库文件 利用第三方地图 API 进行地图内容的获取以及利用小程序 map 组件显示对应的地图信 息
varbmap=require('../../utils/bmap-wx.min.js'); // 支持小程序的地
图类库文件
varwxMarkerData= [];
Page({
data: {
markers: [],
latitude: '',
longitude: '',
},
onLoad() {
varthat=this;
varBMap=newbmap.BMapWX({
ak: 'jU4Ww0DiPzXUZmCshR6XjcH5Y3AG6GCE'// AK信息
});
varfail=function (err) {
console.log(err)
};
varsuccess=function (data) {
wxMarkerData=data.wxMarkerData;
that.setData({
markers: wxMarkerData,
latitude: wxMarkerData[0].latitude,
705. 小程序中如何显示 HTML 或者 markdown 的信息
利用第三方插件 wxParse:微信小程序富文本解析,https://github.com/csonchen/wxPars e Towxml:是一个可将HTML 、Markdown 转为微信小程序WXML (WeiXin Markup Language) 的渲染库。用于解决在微信小程序中Markdown 、HTML 不能直接渲染的问题。https://githu b.com/sbfkcel/towxml
706. 小程序中如何使用 echart 图表库
使用第三方插件 echarts-for-weixin:https://github.com/ecomfe/echarts-for-weixin 可以将该项目直接下载解压,并在本地运行,查看各种不同图表类型的示例,注意导入项目 的时候修改自己的 AppId 在使用 echart 图表的时候,需要注意由于 echart 本身比较大,所以最好是将图表的功能内 容规划到分包中去,并且不要在主包中进行图表功能的操作
longitude: wxMarkerData[0].longitude
});
}
// 发起regeocoding检索请求
BMap.regeocoding({
fail: fail,
success: success,
});
},
})
<viewclass="container">
<mapid="map"
longitude="{{longitude}}"
latitude="{{latitude}}"
scale="10"
show-location
style="width: 100%; height: 300px;">
</map>
</view>
- 省市区及详情地址信息在返回的百度地图信息中都已经包含,如果想显示标记信息等内容,可以利用
map组件的markers等属性
源码示例:[小程序地图调用百度地图 API 显示地理信息](http://qn.chinavanes.com/小程
序地图调用百度地图API显示地理信息.rar) 源码示例:小程序中使用 echart 图表功能
707. 小程序如何实现分享功能
在页面中如果不设置 onShareAppMessage 分享的事件回调函数,那么小程序右上角三个点 的操作中不包含分享功能 通过 button 按钮的 open-type 属性设置为 share 则将调用页面中的 onShareAppMessage 事件,可以通过事件的 res 中的 from 内容来判断是按钮 button 的分享处理还是右上角三个 点 menu 的页面分享操作
708. sitemap 配置的作用是什么
微信现已开放小程序内搜索,开发者可以通过sitemap.json配置,或者管理后台页面收录 开关来配置其小程序页面是否允许微信索引。 当开发者允许微信索引时,微信会通过爬虫的形式,为小程序的页面内容建立索引。 当用户的搜索词条触发该索引时,小程序的页面将可能展示在搜索结果中。 小程序的 sitemap 类似网页的 sitemap 概念,提供的是可被抓取的页面内容,主要针对的是 “小程序搜索引擎的 SEO”优化操作
709. 小程序是否支持双向数据绑定
支持双向数据绑定 但仅限于简易双向数据绑定,绑定的对象只能是一个单一字段的绑定,不支持对象等形式的 数据路径设置操作 在自定义组件中也可以实现传递双向绑定操作 它的基本语法操作是
<inputmodel:value="{{value}}"/>
710. 授权验证登录怎么做,用户退出后下次进入还需要再次授权吗
wx.login 获取到一个 code,拿这 code 去请求后台得到 openId, sessionKey, unionId。 调 wx.getUserInfo 获取用户信息内容 一次性授权:每次授权都需要与后台进行权限认证操作 永久授权:调取授权登录接口并把获取到的用户公开信息存入数据库
711. 验证授权是自动弹出还是触发,授权过程如何操作
按钮触发的,open-type 指定为 getUserInfo 类型,可以从 bindgetuserinfo 回调中获取到 用户信息 授权验证操作只执行一次,不会二次执行 授权以后可以通过 wx.getUserInfo 获取基础的用户信息
712. 微信小程序之用户授权
用户授权包括很多内容:用户信息、地理位置、后台定位、录音功能、保存到相册、摄像头 等 授权有效期:一旦用户明确同意或拒绝过授权,其授权关系会记录在后台,直到用户主动删 除小程序。 授权操作主要分两种不同的情况: 弹出授权框用户点击允许,授权信息会直接记录,后续不再确认授权操作 弹出授权框用户点击拒绝,授权信息会直接记录,但用户还想再次操作对应功能,需要 弹窗再次授权 查看所拥有权限 wx.authorize 发起请求用户授权,利用 wx.showModal 弹窗授权确认 wx.showModal 确认后利用 wx.openSetting 打开授权设置 确认授权设置打开授权信息 示例源码:位置授权示例,功能授权流程版 示例源码:位置授权示例,具体地理位置获取
713. 如何利用 createIntersectionObserver 实现图片懒加载
节点布局相交状态 API可用于监听两个或多个组件节点在布局位置上的相交状态。这一组 API 常常可以用于推断某些节点是否可以被用户看见、有多大比例可以被用户看见。 节点布局相交状态 API中有一个wx.createIntersectionObserver(Object this, Object options) Api (支持版本 >= 1.9.3),它的作用是创建并返回一个 IntersectionObserver 对 象实例(交叉区域),这个对象实例在小程序的解说如下: IntersectionObserver 对象,用于推断某些节点是否可以被用户看见、有多大比例可以被用 户看见,它有:relativeTo、relativeToViewport、observe、disconnect 等方法 由此我们可以设置图片进入可见界面某一区域时的监听回调事件,以此实现图片的懒加载
Page({
data: {
group: [
{
src:
"https://csdnimg.cn/feed/20180914/c67d9521db939fc8beb9a27b046ef1a3.jpg",
show: false,
def: "https://img.alicdn.com/tps/i3/T1QYOyXqRaXXaY1rfd-32-32.gif"
},
示例源码:利用 createIntersectionObserver 实现图片懒加载
714. 为什么需要获取界面上节点信息以及如何获取界面上的节点信息
节点信息查询 API 可以用于获取节点属性、样式、在界面上的位置等信息 最常见的用法是使用这个接口来查询某个节点的当前位置,以及界面的滚动位置 可以利用获取节点信息动态计算 scroll-view(纵向滚动需要定高)等组件的高度等内容 可以利用获取节点信息来确定页面中的元素显示与不显示,比如控制 sticky 吸顶操作 示例源码:通过查询节点信息确定页面中的元素显示与不显示
......// 更多图片信息
]
},
onLoad: function () {
letgroup=this.data.group // 获取原数据
for (letiingroup) {
// 设置监听回调事件,当元素 .loadImg{{i}},进入页面20px内就触发回调事件,设置图
片为真正的图片,通过show控制
wx.createIntersectionObserver().relativeToViewport({ bottom: 20
}).observe('.loadImg'+i, (ret) => {
if (ret.intersectionRatio>0) {
group[i].show=true
}
this.setData({ // 更新数据
group
})
})
}
}
})
<blockwx:for="{{group}}"wx:key="1">
<viewclass="loadImg loadImg{{index}} {{item.show? 'active' : ''}}">
<!-- 通过条件判断确认图片的src -->
<imagewx:if="{{item.show}}"style="width:100%;height:100%;"src="
{{item.src}}"></image>
<image
wx:else
style="width:20%;height:20%;margin:0 auto;margin-
top:50%;transform:translateY(-50%);"
src="{{item.def}}"
mode="aspectFit"
></image>
</view>
</block>
.loadImg {
width: 100vw;
height: 46.3vw;
transition: all0.2sease-in-out;
opacity: 0;
}
.loadImg.active {
opacity: 1;
}
示例源码:通过查询节点信息动态计算 scroll-view 的高度值
715. 如何保存图片到相册
需要判断用户是否授权了保存到本地的权限,通过 getSetting 可以获取 authSetting,确认 scope.writePhotosAlbum 确认是否拥有 利用 authorize 进行授权请求操作,这是首次授权处理 如果拥有权限,则利用 downLoadFile 下载图片文件,再使用 saveImageToPhotosAlbum 进行图片保存相册的操作 如果没有授权,还想再次保存图片到相册操作,需要利用 showModal 进行对话框弹出确认 操作,再次确认 openSetting 中的 authSetting 内容(需要用 showModal),这是再次授权 操作 示例源码:保存图片到手机相册
716. 小程序全局样式在哪里设置,一般会设置什么内容
全局样式在 app.wxss 中设置,不管如何,一般会设置 page 的高度为 100% 一般 iconfont 字图体标的内容在 app.wxss 中就已经@import 引入了
717. 如何进行真机调试,真机调试一般进行哪些操作
访客 AppId 没有预览与真机调试功能 点击微信开发者工具上的真机调试,可以同步打开真机微信调试小程序应用 在真机上点击右上角的三个点,可以“打开调试/关闭调试”,“显示性能面板”等操作 真机上会出现 vConsole 控制台以及性能面板内容 查看 console 内容可以在电脑端进行查看,并且打开 wxml 元素审核,在电脑端选择相应的 内容,在真机上则会选中相应的内容
718. 如果小程序中有本地服务器接口请求操作,如何实现真机调试
如果小程序中的接口请求地址为 localhost,那么真机调试时将无法调用到数据接口 简易处理方案是将手机与小程序开发设备调节至同一局域网络,然后将接口设置成 ip 地址形 式,那么真机调试则可以正常请求接口 如果在微信管理平台将某人加入了小程序开发或者测试成员,并且该人员网络并不在公司局 域网内,那么设置 ip 形式的模式也将无法进行真机调试操作 这种情况则可以利用内网穿透技术进行接口地址域名模式的转化: 打开http://u.tools,下载安装utools工具 然后再利用 utools 安装内网穿透插件 配置内网穿透插件,主要是外网域名需要设置一个唯一名称,而且内网地址及端口号需 要设置正确,特别是端口号,如果现在是 3000,那么设置 3000 端口 修改小程序中的 config.js 中的 host 地址为内网穿透插件所提供的地址内容 在真机上进行测试,则可以正常访问,但需注意可能略损耗一些网络速度,毕竟第三方 做了中间处理
719. 如何实现单行文本溢出以及多行文本溢出
单行文本溢出 多行文本溢出
720. 使用 webview 直接加载要注意哪些事项?
个人类型的小程序暂不支持使用 H5 地址需要在小程序后台添加 H5 域名白名单,如果 webview 里面还有跳转到其他的 H5 页面,也是需要添加域名白名单的
在网页内可通过window.__wxjs_environment 变量判断是否在小程序环境
webview 内可以通过桥接方式进行监听,监听事件 onPageStateChange 可以确认小程序是 否在前台 每个页面只能有一个web-view,web-view会自动铺满整个页面,并覆盖其他组件 避免在链接中带有中文字符,在 iOS 中会有打开白屏的问题,建议加一下 encodeURIComponent web-view网页与小程序之间不支持除 JSSDK 提供的接口之外的通信 在 iOS 中,若存在 JSSDK 接口调用无响应的情况,可在web-view的 src 后面加个 #wechat_redirect 解决 开发者工具上,可以在web-view组件上通过右键 - 调试,打开web-view组件的调试
.scrollItemtext {
font-size: 26rpx;
/* 单行文本溢出省略号代替 */
/* 不换行 */
white-space: nowrap;
/* 内容隐藏 */
overflow: hidden;
/* 省略号代替 */
text-overflow: ellipsis;
/* overflow隐藏只对块级元素进行作用,所以需要将行内元素转成块级元素 */
display: block;
}
.scrollItemtext {
font-size: 26rpx;
/* 多行文本溢出省略号代替 */
/* 浏览器厂商前缀,webkit内核 */
display: -webkit-box;
/* 内容隐藏 */
overflow: hidden;
/* 省略号代替 */
text-overflow: ellipsis;
/* 对齐的方向 */
-webkit-box-orient: vertical;
/* 行数 */
-webkit-line-clamp: 2;
}
721. webview 中的页面怎么跳转回小程序
webview 中可以利用 wx.miniProgram.navigateTo 等方式跳转回小程序,跳转方法与小程 序一致 跳转回小程序如果通过 switchTab 等方式进行操作,默认情况是不会重新加载数据,可以尝 试如下方式: 利用 onShow 生命周期钩子函数,跳转之前设置全局变量,在 onShow 中进行条件判 断是否进行业务逻辑操作(减少操作次数,优化性能) 页面重新加载
722. 小程序如何保存用户信息(保持登录状态)
利用 button 按钮进行用户授权及授权信息的获取,将 userInfo 基础信息进行本地缓存存储 利用 wx.login 获取登录凭证 code,通过 code 与开发者服务器交互获取加密后的 openId, 并将 openId 与 session_key 进行服务器数据库信息存储 将加密后的 openId 信息进行本地缓存存储 用户进行后续请求,可以将 userInfo 以及 openId 信息进行发送,服务器端将 openId 进行 解密,再对照数据库内容进行验证筛选与后续操作
wx.miniProgram.switchTab({
url: '/pages/index/index'
success: function(e) {
varpage=getCurrentPages().pop();
if (page==undefined||page==null) return;
page.onLoad();
}
})
723. 如何获取用户手机号码(面试重点难点题)
目前该接口针对非个人开发者,且完成了认证的小程序开放(不包含海外主体) 在微信小程序管理平台设置->基本信息的微信认证中进行确认,是否已经进行认证,认证过 程需要提供公司相关信息,并且涉及到一定费用问题(微信公众平台申请微信认证,需支付 300 元/次认证费) 利用 wx.login 获取登录凭证 code,通过 code 与开发者服务器交互获取加密后的 openId, 并将 openId 与 session_key 进行服务器数据库信息存储(后台利用 nodejs、php、java 等 操作,具体参见:https://developers.weixin.qq.com/miniprogram/dev/api-backend/ope n-api/login/auth.code2Session.html) 利用 jsonwebtoken(或者其它加密方式,前后端人员需要确认)对 openId 进行加密传递回 小程序端 利用 button 进行 open-type 的类型设置,值为 getPhoneNumber,并且需要进行 bindgetphonenumber 事件绑定 绑定回调 getPhoneNumber 中可以找到手机加密数据
<view class="container">
<button open-type="getPhoneNumber"
bindgetphonenumber="getPhoneNumber">getPhoneNumber</button>
</view>
将加密的 openId、encryptedData、iv 等数据发送至服务器端 服务器端通过解密 openId,查询 sesskon_key,获取 encryptedData、iv 以后(4 个内 容),需要对加密手机等信息数据进行解密处理 解密介绍以及对应后台程序语言解密算法示例,https://developers.weixin.qq.com/minipro gram/dev/framework/open-ability/signature.html#%E5%8A%A0%E5%AF%86%E6%95% B0%E6%8D%AE%E8%A7%A3%E5%AF%86%E7%AE%97%E6%B3%95 通过解密以后的数据类似 可以将解密信息等内容进行返回小程序端处理
724. 利用什么方式可以实现页面中的单例操作,为什么需要单例
在列表中进行音、视频播放控制的时候不能创建多个音、视频播放器的实例对象 实例对象创建的多,性能极其低下 在功能操作的时候并不容易找到需要操作的实例对象 每个实例对象的状态不好控制与保持 需要利用单例来进行性能的优化处理,而且通过单例可以不需要查找实例对象,因为需要操 控的只有一个实例 至于每个内容的状态可以保存在缓存数据中,在需要调用的时候从缓存数据中获取,将赋值 给单一实例对象中 可以利用 this.instance 进行单例的设置,将实例对象挂载于当前页面的实例对象上
725. 如何实现动态的取值与设值
在进行多个对象进行同一事件绑定的时候需要进行目标对象的识别与获取数据操作,比如表 单数据的统一获取处理(多个 input 框等数据内容的获取) 需要给多个对象设置区别的标识,比如 id 或者 data-key 等内容 给多个对象进行相同事件绑定操作 利用 event 获取区别标识以及数据信息 利用[]的方式进行动态赋值操作(不能使用对象路径形式)
726. 如果没有唯一值字段,如何设置循环的 key
一般并不建议使用 index 下标作为循环的 key 值(虚拟 DOM 的 Diff 算法原理) 强烈建议使用唯一值进行循环中的 key 的属性设置 如果没有唯一值,则可以利用代码方式创建其唯一值,可以利用 map 循环生成新的数组对象
727. 字符类型转成数字类型的方式有哪些
利用+号转换 利用*1 转换 利用 parseInt 转换 还可以利用>>>0 转换
728. 一段文字如何换行
小程序中唯一可以实现换行的标签组件是 text。
注:text 中不支持
只能使用 n 进行换行。
729. 防止小程序多次点击跳转解决办法
利用函数节流(throttle):函数在一段时间内多次触发只会执行第一次,在这段时间结束前,不管 触发多少次也不会执行函数。 节流函数
handleInput(event) {
lettype=event.target.id; // 区别标识
this.setData({
[type]: event.detail.value, // 动态赋值
});
},
// 利用map循环进行唯一id的生成,需要注意的是map循环需要return返回加工以后的数组元素对象
letindex=0;
letrecentList=recentListData.weekData.map((item) => {
item.id=index++;
returnitem;
});
this.setData({ recentList });
页面按钮 脚本控制 示例源码:节流避免多次触发
730. 如何去掉自定义 button 灰色的圆角边框
通过设置 button 的伪元素样式进行去除: button::after{ display: none;}
731. 开启惯性滚动
惯性滚动会使滚动比较顺畅,在安卓下默认有惯性滚动,而在 iOS 下需要额外设置-webkit-
overflow-scrolling: touch 的样式
732. 如何理解 triggerEvent 的内容
自定义组件向父组件进行事件发送操作,有些类似于 Vue 中的 emit 在子组件中,可以利用 this.triggerEvent(‘myevent’, myEventDetail, myEventOption)进行 向上事件发送操作,myevent 是事件名称,myEventDetail 是附带事件参数,而 myEventOption 则是触发事件的选项包括:bubbles、composed、capturePhase 等参 数。 父组件中,则需要利用 bind+myevent 进行事件绑定操作
constthrottle= (fn, gapTime) => {
if (gapTime==null||gapTime==undefined) {
gapTime=1500;
}
let_lastTime=null;
// 返回新的函数
returnfunction() {
let_nowTime=+newDate();
if (_nowTime-_lastTime>gapTime||!_lastTime) {
fn.apply(this, arguments); //将this和参数传给原函数
_lastTime=_nowTime;
}
};
};
module.exports= {
throttle: throttle,
};
<buttonbindtap="handleTap">节流避免多次触发</button>
import { throttle } from'../../utils/util.js';
Page({
handleTap: throttle(function(e) {
console.log(this);
console.log(e);
console.log(newDate().getSeconds());
}, 1000),
});
733. 如何简化数据请求,是否进行自定义封装,拦截器等操作如何考虑
在开发过程中需要对数据请求进行统一的功能封装,但请求封装的操作过程也比较复杂,考 虑的点与面也非常的多,如果没有极强的业务分析与代码编写能力,一般不考虑自行封装 wx.request 中没有 interceptors 拦截器操作,对于这部分内容需要自行考虑 可以利用 flyio 第三方请求类库进行数据请求的操作,包括拦截器等操作的设置,https://we ndux.github.io/dist/#/doc/flyio/wx
734. 如何自定义 tabbar
配置信息
在app.json中的tabBar项指定custom字段,同时其余tabBar相关配置也补充
完整。 所有 tab 页的 json 里需声明usingComponents项,也可以在app.json全局开启。 添加 tabBar 代码文件,在根目录下新建 custom-tab-bar 目录,并创建 index.js、 index.wxss、index.json、index.wxml 等文件,目录结构与文件结构不可变 编写 tabBar 代码 用自定义组件的方式编写即可,该自定义组件完全接管 tabBar 的渲染。另外,自定义组件新 增getTabBar接口,可获取当前页面下的自定义 tabBar 组件实例。
735. app.json 是对当前小程序的全局配置,讲述三个以上配置内容以及各个配置项的含义
pages 字段:用于描述当前小程序所有页面路径,这是为了让微信客户端知道当前你的小程 序页面定义在哪个目录。 window 字段:小程序所有页面的顶部背景颜色,文字颜色定义在这里的 tabBar 字段:小程序全局顶部或底部 tab subpackages:分包结构配置 requiredBackgroundModes:申明需要后台运行的能力,类型为数组 sitemapLocation:指明 sitemap.json 的位置
736. 页面的生命周期函数主要包括哪些
onLoad:页面加载,调一次 onShow:页面显示,每次打开页面都调用 onReady:初次渲染完成,调一次 onHide:页面隐藏,当 navigateTo 或底部 tab 切换时调用 onUnload:页面卸载,当 redirectTo 或 navigateBack 时调用
737. 谈谈 wxml 与标准的 html 的异同
都是用来描述页面的结构; 都由标签、属性等构成; 标签名字不一样,且小程序标签更少,单一标签更多; 多了一些 wx:if 这样的属性以及 {{ }} 这样的表达式 WXML 仅能在微信小程序开发者工具中预览,而 HTML 可以在浏览器内预览
<my-componentbindmyevent="myEventListener"></my-component>
组件封装不同, WXML 对组件进行了重新封装, 小程序运行在 JS Core 内,没有 DOM 树和 window 对象,小程序中无法使用 window 对象 和 document 对象。
738. 谈谈 WXSS 和 CSS 的异同
都是用来描述页面的样子; WXSS 具有 CSS 大部分的特性,也做了一些扩充和修改; WXSS 新增了尺寸单位,WXSS 在底层支持新的尺寸单位 rpx,规定屏幕宽为 750rpx; WXSS 仅支持部分 CSS 选择器,类、ID、元素、层级、after 和 before 伪类选择器 WXSS 提供全局样式与局部样式
739. 分包的操作以及如何来计划分包
分包主要包括:使用分包、独立分包、分包预下载 分包:主包添加跳转路径,分包放内容,在 app.json 配置 subpakeages 声明项目分包结 构。代码包总包大小为 12M,单个主包/分包大小不能超过 2M。 按照功能划分的打包原则:可以按照功能的划分,拆分成几个分包,当需要用到某个功能 时,才加载这个功能对应的分包;公共逻辑、组件放在主包内。 首次启动时,先下载小程序主包,显示主包内的页面;如果进入了某个分包的页面,再下载 这个对应分包,下载完毕后,显示分包的页面, 总结:首先配置好打包路径,tabbar 页面必须在主包内,各分包之间不能互相调用,能调用 的都在主包内
740. 小程序中是否存在跨域的问题
小程序中不存在跨域的问题,所以可以进行授权地址的请求处理 小程序中需要在管理平台设置对应可访问的授权地址,可以设置多个,最多 20 个域名设置 只能支持 https 协议 最大并发数为 10 个,socket 的并发限制为 5 个
741. AppData 调试面板的作用与常规操作是什么
查看当前小程序所有打开页面的数据信息,方便开发人员进行程序调试操作 可以以 tree 树形结构以及 code 编码两种不同的模式进行查看,能够利用搜索快速找到对应 的数据信息 可以对数据信息进行人员手动修改,以便确认当前程序运行的过程与结果是否匹配,减少不 断重复代码调试的步骤
742. 简述一下小程序的路由概念
不管是 nodejs 的 express、koa,还是 vue 或者是 react,包括小程序,这些应用框架中都 包含了一个基本核心概念也就是路由 所有应用框架中的路由都有共通性,主要包括:静态路由表、分配地址、统一入口、寻址以 及过滤 5 大部分内容 小程序因为针对的主要是移动端应用,所以其路由操作相对比较简单,在 app.json 项目全局 配置文件中通过 pages 节点内容进行设置 pages 是一个单一数组,数组内容是路由地址信息,而这个数组内容就是路由概念中的静态 路表表概念 分配地址是 pages 中所设置的地址,对应的是地址所指向的目录与页面 因为同一个小程序项目内容都是由一个全局配置文件分配,所以对应的入口操作是唯一的 利用 switchTab、reLaunch、redirectTo、navigateTo、navigateBack 可以实现路由导航跳 转操作,而跳转的过程实质就是寻址过程,寻址过程就是指向地址与路由地址的匹配操作 因为小程序页面结构相对简单,用户没有手动输入页面地址的操作,所以类似 404 这样的路 由过滤操作并不明显
743. 什么是 App 应用?什么是 Page 页面?什么是 Component?
应用是完成一整套复杂的功能,包含众多的页面,页面中会使用很多的组件 页面是一个功能整体,一个页面是由一个至多个组件组成 组件再复杂也不能代表页面,只能代表页面中的一部分
744. 一个邮箱可以注册几个小程序?个人、个体工商户和企业分别可以注册几个小程序?
同一个邮箱只能申请注册 1 个小程序 个人和个体工商户可以注册 5 个小程序 企业资质可以注册 50 个小程序
745. 附近的小程序
在小程序后台添加位置,展示这个小程序。当用户在此地点的周围,可在微信小程序入口中 “附近的小程序”发现并使用小程序提供的服务 附近的小程序地点创建要求: 地点的经营主体跟小程序帐号主体一致或相关 能提供经营资质信息,如营业执照或组织机构代码证等 一个经营资质只能添加一个地点,一个地点只能展示一个小程
746. 小程序可以放到公众号的底部菜单吗
可以,登陆公众号点击自定义菜单即可设置
747. 小程序支持哪些支付方式
小程序只支持一种支付方式,也就是微信支付 不支持支付宝支付,微信与支付宝属于互相竞争的关系,是两个不同的支付平台,目前是不 支持互相通用的。微信小程序里面的程序软件属于内嵌于微信的服务,支持微信支付,但不 能使用支付宝支付。也就是说: 在小程序中生成支付宝二维码的方式,不可行 在小程序中内嵌 H5 网页后调用支付宝支付接口,也不可行,由于支付协议 那么我通过诱导的方式直接在浏览器使用支付呢?也就是: 通过点击某个链接直接跳出小程序自动跳转到系统浏览器的方式,也不可行,原因: 微信小程序没办法直接跳转打开 app、网址、手机浏览器,但是可以直接打开其他 的小程序并跳转到指定的小程序页面 微信公众号可以直接打开 app 或 app 指定页面,可以直接打开手机浏览器并跳转 指定网址,可以打开小程序或进入小程序指定页面。 一定要实现支付宝支付: 通过诱导的方式在小程序中生成你需要在浏览器中打开使用支付页面的链接地址 诱导用户手动复制网址并手动切换到系统浏览器中使用,该地址有订单 Id 等参数信息 将小程序的订单内容切换至网页端,利用网页端支付流程序去实现支付宝订单支付操作
748. 通过哪些方式可以打开小程序
线下扫二维码,好友、群、朋友圈分享二维码,公众号关联进入等 60 多个入口
749. 小程序排名如何优化?
小程序的排名规则: 小程序上线时间越早,排名越靠前 描述中出现完全匹配出现关键词次数越多,排名靠前 标题中关键词出现 1 次,且整体标题的字数越短,排名靠前 微信小程序用户使用数量越多,排名靠前 小程序的名称作为核心关键词语排名
750. 小程序设置推广关键词有哪些禁忌?
关键词必须为小程序提供的服务,或小程序提供服务的品牌 禁止使用其他品牌名称 禁止使用未经授权的名人名称 禁止涉及色情、暴力、政治敏感 禁止使用单字符 禁止在关键词中使用特殊符号
751. 公众号和小程序的关联规则是什么
企业、政府、媒体、其他组织主体可以注册 50 个小程序,个体户和个人类型主体可注册 5 个小程序 公众号可关联同一主体的 10 个小程序,不同主体的 3 个小程序 小程序可最多被 50 个公众号关联 公众号一个月可新增关联同主体的 10 个小程序、不同主体的 3 个小程序 一个小程序一个月内可被公众号关联 50 次
752. 小程序的代码版本分成哪几类
开发版:本地代码进行上传提交以后会发布到开发版本 体验版:可以将指定的开发版本设置成体验版本 审核版本:将对应的开发版本进行提交审核操作,审核版本需要小程序官网审核确认 线上版:最终终端用户可以看到的线上应用版本 通过 __wxConfig.envVersion 能判断用户所在的小程序版本
753. 简单描述下微信小程序的相关文件类型
微信小程序项目结构主要有四个文件类型,如下 WXML (WeiXin Markup Language)是框架设计的一套标签语言,结合基础组件、事件系 统,可以构建出页面的结构。内部主要是微信自己定义的一套组件。 WXSS (WeiXin Style Sheets)是一套样式语言,用于描述 WXML 的组件样式, js 逻辑处理,网络请求 json 小程序设置,如页面注册,页面标题及 tabBar。 5app.json 必须要有这个文件,如果没有这个文件,项目无法运行,因为微信框架把这个作为配置 文件入口,整个小程序的全局配置。包括页面注册,网络设置,以及小程序的 window 背景色,配置导航条样式,配置默认标题。
console.log('envVersion', __wxConfig.envVersion);
app.js 必须要有这个文件,没有也是会报错!但是这个文件创建一下就行什么都不需要写以后 我们可以在这个文件中监听并处理小程序的生命周期函数、声明全局变量。 app.wxss
754. 分析下微信小程序的优劣势?
优势:
无需下载,通过搜索和扫一扫就可以打开。 良好的用户体验:打开速度快。 开发成本要比 App 要低。 安卓上可以添加到桌面,与原生 App 差不多。 为用户提供良好的安全保障。小程序的发布,微信拥有一套严格的审查流程,不能通过审查 的小程序是无法发布到线上的。
不足:
限制较多。页面大小不能超过 2M,不能打开超过 5 个层级的页面。 样式单一,小程序的部分组件已经是成型的了,样式可改进的内容比较少,例如:幻灯片、 导航。 推广面窄,不能分享朋友圈,只能通过分享给朋友,附近小程序推广,其中附近小程序也受 到微信的限制。 依托于微信,无法开发后台管理功能。
755. 微信小程序与 H5 的区别
运行环境的不同:传统的 HTML5 的运行环境是浏览器,包括 webview。微信小程序的运行 环境并非完整的浏览器,是微信开发团队基于浏览器内核完全重构的一个内置解析器,针对 小程序专门做了优化,配合自己定义的开发语言标准,提升了小程序的性能。 开发成本的不同:只在微信中运行,所以不用再去顾虑浏览器兼容性,不用担心生产环境中 出现不可预料的奇妙 BUG 获取系统级权限的不同:系统级权限都可以和微信小程序无缝衔接 应用在生产环境的运行流畅度:长久以来,当 HTML5 应用面对复杂的业务逻辑或者丰富的 页面交互时,它的体验总是不尽人意,需要不断的对项目优化来提升用户体验,但是由于微 信小程序运行环境独立。
756. 一般在哪个生命周期钩子函数中进行数据请求,onLoad,onShow 中进行数据请求的差异
一般情况在 onLoad 中进行数据请求,onLoad 钩子函数在生命周期过程中最先触发,但在 视图层也可以查看到渲染的数据,所以建议在 onLoad 中进行请求 onLoad 钩子函数只触发一次,如果想要多次触发并且进行对应的数据请求,则需要在 onShow 钩子函数中进行处理,比如通过 navigateTo 进行路由跳转以后,再返回页面,那么 onLoad 中的数据请求操作将不会触发,只能在 onShow 中进行请求 onShow 在每次页面打开以后都会触发,如果在该钩子函数中进行数据请求操作,一定需要 注意条件判断的处理,以便实现最少请求次数进行性能优化
757. event.target VS event.currentTarget 的差异与区别
在进行事件绑定与触发的时候,通常 event 对象中会包含 target 与 currentTarget,而绝大 多数情况下,这两个对象内容是一样的,但在某些特定情况下会产生区别: target:触发事件的对象不一定是绑定事件的对象,如:事件委托 currentTarget:绑定事件和触发事件的一定是一个对象
758. 浏览器的本地存储与小程序的本地存储有哪些差异与区别
浏览器端的本地存储有哪些方式,主要包括: localStorage 持久化存储,一般大小是 5M sessionStorage 会话级存储,一般大小是 5M IndexedDB 类似 mongodb 是对象化存储,无限存储,有兼容性障碍 Web SQL 类似于 MySql 是关系型存储,无限存储,有兼容性障碍 Cookie 存储,一般大小是 4K,可能会被用户禁用 小程序的存储方式只有 storage,需要注意的事项: 将数据存储在本地缓存中指定的 key 中,会覆盖掉原来该 key 对应的内容。除非用户主动删 除或因存储空间原因被系统清理,否则数据都一直可用。 单个 key 允许存储的最大数据长度为 1MB,所有数据存储上限为 10MB。
759. 页面的下拉刷新与 scroll-view 的下拉刷新它们的回弹操作如何处理
页面下拉刷新 对于 Page 可以实现下拉刷新操作,但需要设置 enablePullDownRefresh 的属性 页面的 onPullDownRefresh 可以进行下拉刷新的事件监听, wx.startPullDownRefresh 可以开始下拉刷新,而 wx.stopPullDownRefresh 则可以停 止下拉刷新,实现回弹操作 scroll-view 下拉刷新 scroll-view 的下拉刷新事件绑定可以利用 bindrefresherrefresh 实现 要实现回弹得先声明一个 trigger 布尔数据值 然后再给 scorll-view 设置 refresher-triggered 的属性值为 trigger 数据值 在完成 bindrefresherrefresh 下拉刷新任务内容以后,对 trigger 布尔值设值为 false 实现下拉刷新的回弹
760. id 取值与 data-key 取值的差异
id 是唯一值的传递 id 的获取可以利用 event.target.id 进行接收 data-kay 可以进行多个属性设置与传递操作 data-key 的获取可以利用 event.currentTarget.dataset.keyName 进行接收
761. Wepay、Mpvue、Mpx、Uniapp 等小程序开发框架的差异比较
| 维度 | 原生小程序 | Wepay(WePY) | Mpvue | mpx | Uniapp |
|---|---|---|---|---|---|
| 语法规范 | 小程序开发规范 | 类 Vue 规范 | Vue 规范 | 小程序+Vue+自定义规范 | Vue 规范 |
| 标签集合 | 小程序标签 | 小程序标签 | html+小程序标签 | 小程序标签 | html+小程序标签 |
| 样式规范 | wxss | sass、less、stylus | sass、less、postcss | sass、less 等 | sass、less、stylus |
| 组件化 | 小程序组件 | 自定义组件 | vue 组件 | 自定义组件 | vue 组件 |
| 多端复用 | 不支持 | 转 H5 | 转 H5 | 多端(微信、支付宝、百度、QQ 和头条…) | 多端(微信、支付宝、百度、QQ 和头条…) |
| 自动构建 | npm 包 | npm 包使用 | webpack | webpack | webpack + vue.config.js |
| 上手成本 | 全新语法 | 熟悉 Vuejs | 熟悉 Vuejs | 小程序+Vue+自有语法 | 熟悉 Vuejs |
| 集中数据管理 | 不支持 | 不支持 | vuex | vuex | vuex |
| 生产商 | 微信 | 微信团队 | 美团(停更) | 滴滴 | DCloud |
dcloud
762. 简述微信小程序原理?
微信小程序采用 JavaScript、WXML、WXSS 三种技术进行开发,从技术讲和现有的前端开发 差不多,但深入挖掘的话却又有所不同。 JavaScript:首先 JavaScript 的代码是运行在微信 App 中的,并不是运行在浏览器中,因此 一些 H5 技术的应用,需要微信 App 提供对应的 API 支持,而这限制住了 H5 技术的应用, 且其不能称为严格的 H5,可以称其为伪 H5,同理,微信提供的独有的某些 API,H5 也不支 持或支持的不是特别好。 WXML:WXML 微信自己基于 XML 语法开发的,因此开发时,只能使用微信提供的现有标 签,HTML 的标签是无法使用的。 WXSS:WXSS 具有 CSS 的大部分特性,但并不是所有的都支持,而且支持哪些,不支持哪 些并没有详细的文档。 微信的架构,是数据驱动的架构模式,它的 UI 和数据是分离的,所有的页面更新,都需要通 过对数据的更改来实现。 小程序分为两个部分 webview 和 appService。其中 webview 主要用来展现 UI, appService 有来处理业务逻辑、数据及接口调用。它们在两个进程中运行,通过系统层 JSBridge 实现通信,实现 UI 的渲染、事件的处理
763. 你使用过哪些方法,来提高微信小程序的应用速度?
提高页面加载速度 用户行为预测 减少默认 data 的大小 组件化方案 控制包的大小 压缩代码,清理无用代码 采用分包策略 启用本地缓存 参考地址:https://blog.csdn.net/wu_xianqiang/article/details/108037685
764. 小程序对 wx:if 和 hidden 使用的理解
wx:if 通过条件判断确认对象的显示与否,有更高的切换消耗。 hidden 利用样式来控制对象的显示与隐藏,有更高的初始渲染消耗。 因此,如果需要频繁切换的情景下,用 hidden 更好,如果在运行时条件不大可能改变则 wx:if 较好。 对比 v-if 和 v-show,性质雷同,但小程序是通过 hidden 作为条件,vue 里是 show 作为条 件
765. 大数据量的时候,单个 setData 以及多次 setStata,对性能有什么影响
大数据量,特别是循环遍历数组追加的时候,进行的是一次性单个 setData 的数据设值,前 期等待时间比较长,用户体验相对较弱,但应用的整体性能比较好 对于同样的情况,如果在循环体内进行 setData 的多性设值与页面渲染操作,那么应用实现 的是多次渲染处理,界面内容逐步更新,用户体验相对较好,但对应用的整体性能损耗较大
766. 通过 wx.getSystemInfo 可获取系统信息,这一 API 在项目进行几次调用,通过什么方式进行性能优化
如果多个页面都需要获取系统信息,那么 wx.getSystemInfo 是否在多个页面不断调用(不 需要) 可以在 app.js 的 onLaunch 生命周期钩子函数中进行调用,然后将系统信息存储于 globalData 中,这样所有页面可以直接获取全局的 globalData 数据内容,以减少 wx.getSystemInfo 内容的重复调用
767. 当用户点击小程序后发生了什么
有三个点的白屏(左侧):下载代码包的阶段 没有三个点的白屏(中间):业务代码注入和渲染的阶段 加载中(右边):业务代码中异步请求数据 总的来说,小程序呈现到用户面前,实际上经历了下面两个阶段: 运行环境的加载:这步是微信做的,微信会在用户打开小程序之前就已经准备好环境, 用户点击小程序入口后,直接下载小程序的代码包即可。 下载代码包:小程序代码包里面的代码,不是小程序的源代码,而是编译、压缩、打包 之后的代码包。 下图中,左侧的“预加载”对应的是运行环境的预加载,右侧的“小程序启动” 对应的是下载代码包启 动小程序。 小程序提供的运行环境,分为逻辑层(AppService)和视图层(webView),逻辑层是执行 javascript 的地方,视图层是渲染页面的地方。当小程序的代码包下载完毕后,业务代码分别注入 逻辑层和渲染层。 提升加载性能的最最最关键性一点是,控制包的大小,这个也是微信官方的说法。
768. 小程序控制包的大小有哪些方式
压缩代码,清理无用的代码 图片放在 cdn 利用 iconfont 进行图标应用,并且图标操作只留 css 样式文件,其它文件则删除不使用 如果使用 echart 图表,可以下载 echart 源码,利用配置操作发布指定功能的自定义的 echart 图表文件 采用分包策略 分包预加载 独立分包(版本要求有点高)
769. 小程序对异步请求的优化有哪些方式
onLoad 阶段就可以发起请求,不用等 ready 如果业务要求在 ready 中进行数据请求,需要利用条件判断减少请求次数 请求结果放在缓存中, 下次接着用 请求中可以先展示骨架图 先反馈,再请求。比如说,点赞的按钮,可以先改变按钮的样式,再发起异步请求。
770. 如何理解 setData 的操作过程,如何实现提升渲染性能
每调用一次 setData, 都是逻辑层向渲染层的一次通讯,这个通信还不是直接传给 webView, 而是通过走了 native 层,通讯的开销很大。 渲染层收到通讯后,还需要重新渲染出来,所以一次 setData 带来两次开销:通信的开销 + webview 更新的开销。 在数据传输时,逻辑层会执行一次JSON.stringify 来去除掉setData 数据中不可传输的部 分,之后将数据发送给视图层。同时,逻辑层还会将setData 所设置的数据字段与data 合 并,使开发者可以用this.data 读取到变更后的数据。 减少 setData 的数据量:如果一个数据不会影响渲染层,则不用放在 setData 里面
合并 setData 的请求,减少通讯的次数
列表的局部更新:
在一个列表中,有n 条数据,采用上拉加载更多的方式,假如这个时候想对其中某一个 数据进行点赞操作,还能及时看到点赞的效果。 此时,可以采用 setData 全局刷新,点赞完成之后,重新获取数据,再次进行全局重新 渲染,这样做的优点是:方便,快捷!缺点是:用户体验极其不好,当用户刷量 100 多 条数据后,重新渲染量大会出现空白期(没有渲染过来)。 如果采用布局刷新,将点赞的id 传过去,知道点的是那一条数据, 将点赞的id 传过 去,知道点的是那一条数据。 重新获取数据,查找相对应 id 的那条数据的下标(index 是不会改变的),用 setData 进行局部刷新
this.setData({
list[index] =newList[index]
})
小心后台页面的 js:定时器、事件监听、长连接等会影响性能的 js 操作对象需要在页面跳转 的时候进行清除。原因是:小程序中可能有 n 个页面,所有的这些页面,虽然都拥有自己的 webview(渲染层),但是却共享同一个 js 运行环境。也就是说,当你跳到了另外一个页面 (假设是 B 页面),本页面(假设是 A 页面)的定时器等 js 操作仍在进行,并且不会被销 毁,并且会抢占 B 页面的资源。 小心 onPageScroll:pageScroll 事件,也是一次通讯,是 webview 层向 js 逻辑层的通讯。 这次通讯也是开销较大,如果考虑到这个事件被频繁的调用,回调函数如果有复杂的 setData 的话,性能就会很差了。 只有在必要的时候监听 onPageScroll 事件 避免在 onPageScroll 中进行复杂的逻辑处理 避免在 onPageScroll 中频繁的 setData 调用 避免频繁查询节点信息 selectQuery 操作 小心获取节点位置:少用 selectQuery,利用 intersectionObject 进行节点信息获取的替代 尽可能使用小程序组件:自定义组件的更新只在组件内部进行,不受页面其他不能分内容的 影响;比如一些运营活动的定时模块可以单独抽出来,做成一个定时组件,定时组件的更新 并不会影响页面上其他元素的更新;各个组件也将具有各自独立的逻辑空间。每个组件都分 别拥有自己的独立的数据、setData 调用。
771. 微信开发者工具能够很好的进行性能调优测试吗
在微信开发者工具没有办法复现某些性能问题,是因为从逻辑层到 webview 的通讯,开发者 工具底层是通过 onpostMessage, 微信 ios 好像是微信自己实现的桥接,所以强烈建议使用 真机进行调试 微信开发者工具,没有办法在【network】里面看到图片资源的加载,通过【trace】面板连 接安卓真机也没有办法看到。如果想测试懒加载的效果,就比较麻烦,需要通过设置微信开 发者工具的代理到 127.0.0.1,通过 charles 可以抓包看到
772. 什么是小程序的体验评分,在哪里进行设置操作
体验评分是一项给小程序的体验好坏打分的功能,它会在小程序运行过程中实时检查,分析出一些 可能导致体验不好的地方,并且定位出哪里有问题,以及给出一些优化建议。 使用流程:在调试器区域切换到Audits面板。点击”开始“按钮,然后自行操作小程序界面,运 行过的页面就会被“体验评分”检测到。点击 “停止” 则结束检测,在当前面板显示相应的检测报告, 开发者可根据报告中的建议对相应功能进行优化。如需再次运行体验评分,可点击报告上方的“清 空体验评分”恢复初始状态。请注意,目前系统不提供报告存储服务,一旦清空体验评分,将无法 再查看本次评分结果。 自动运行:为了方便开发者能够及时发现小程序的体验问题,小程序还支持体验评分的 “自动运行” 功能。该功能会在开发调试小程序时,实时检查,一旦发现体验分数低于70分时,系统会在 console面板打印一个warning信息提示开发者,此时开发者可以切到Audits面板查看详 情。开发者在工具的右上角 “详情” 面板的本地设置中勾选 “自动运行体验评分” 选项即可开启。
773. 如何实现上拉加载分页列表的性能优化
我们的功能里面有个滚动到底部加载的功能,优化前我们的做法是这样的: 大部分人面对长列表滚动的时候,一开始的处理方式都是这样的,如果数据不多,只有 几页可能不会太暴露问题,如果页数过多,几十页甚至上百页的情况,list 的数据会越 来越大,每次 setData 的数据就会越来越多,因而每次页面重新渲染的节点就会越来越 多,从而导致滚动到后面,加载越来越慢。 另外,由于小程序的视图渲染层和数据逻辑处理层是分开的,不是在同一个线程上面 的,从用户触发页面交互,到处理数据逻辑,最后层现页面,数据到视图是需要传输 的,因而小程序本身对数据大小也有限制,不能超过 1M。 利用 setData 数据路径优化:可以通过数据路径的写法来将数据分批的传输到视图层中,减 少一次性 setData 的数据大小。具体写法如下:
774. 存在短时间内发起太多图片请求的优化(懒加载)
就是渲染页面时,一次性发送了过多的图片请求,导致了同一时间发起了过多的 http 请求, http 连接是非常耗时的,尤其是一次性发起这么多,并且一次性发起的 http 链接也是有限制 的,比如 chrome 浏览器就限制一次性最多 6 个。 所以在渲染页面时,不在视图范围内的图片我们不加载,只有元素出现在视图范围内了,再 渲染。 常规的做法是,通过getBoundingClientRect()获取元素的位置,然后与页面滚动位置比 较,如果出现在视图内,就将img显示。这种方式有 2 个问题 getBoundingClientRect()方法调用本身容易引起页面重排 监听滚动事件本身就频繁触发,虽然可以通过节流的方式来减少,但还是容易增加无谓 代码处理
775. 存在图片太大而显示区域过小
这个问题就是指图片尺寸太大了,而页面上我们显示的尺寸又太小了,图片尺寸大,请求图 片就越慢,导致页面渲染速度下降。 对于页面里面的图片,最好都把图片存储在 cdn 服务器上,一个是能充分利用 cdn 缓存来加 快请求速度,另外一个就是 cdn 上能够将图片进行一定的处理,比如裁剪。就是通过 cdn 来 响应图片处理,然后请求图片时告诉 cdn 服务器需要什么要的尺寸图片,由 cdn 服务器响应 对应尺寸图片。 比如阿里云 oss 图片缩放:https://help.aliyun.com/document_detail/44688.html?spm=5 176.13910061.sslink.1.1a38601648eLCx // 只阐述逻辑,非真实代码 // 1: 初始一个list,存储列表数据
data=startList
// 2: 监听滚动事件,滚动到底部获取新数据,并追加到list尾部,最后重新setData
onReachBottom:()=>{
const {list} =this.datajs
fetchNewData().then((res)=>{
list.push(res.list);
this.setData({list}) // 数据更新操作(注意的重点)
}
}
// 1.通过一个二维数组来存储数据
letfeedList= [[array]];
// 2.维护一个页面变量值,加载完一次数据page++
letpage=1
// 3.页面每次滚动到底部,通过数据路径更新数据
onReachBottom:()=>{
fetchNewData().then((newVal)=>{
// 利用数据路径分批设置数据进行传递
this.setData({
['feedList['+ (page-1) +']']: newVal,
})
}
}
// 4.最终我们的数据是[[array1],[array2]]这样的格式,然后通过wx:for遍历渲染数据
776. 利用 key 实现列表性能的提升
key 值在列表渲染的时候,能够提升列表渲染性能,为什么呢?首先得想想小程序的页面是如何渲 染的,主要分为以下几步: 将 wxml 结构的文档构建成一个 vdom 虚拟数 页面有新的交互,产生新的 vdom 数,然后与旧数进行比较,看哪里有变化了,做对应的修 改(删除、移动、更新值)等操作(对比 vue、react) 最后再将 vdom 渲染成真实的页面结构 key 值的作用就在第二步,当数据改变触发渲染层重新渲染的时候,会校正带有 key 的组件,框架 会确保他们被重新排序,而不是重新创建,以确保使组件保持自身的状态,并且提高列表渲染时的 效率。key 值如果不指明,默认会按数组的索引来处理,因而会导致一些类似 input 等输入框组件 的值出现混乱的问题。 不加 key,在数组末尾追加元素,之前已渲染的元素不会重新渲染。但如果是在头部或者中 间插入元素,整个 list 被删除重新渲染,且 input 组件的值还出现了混乱,值没有正常被更 新 添加 key,在数组末尾、中间、或者头部插入元素,其它已存在的元素都不会被重新渲染, 值也能正常被更新 因而,在做 list 渲染时,如果 list 的顺序发生变化时,最好增加 key,且不要简单的使用数组索引 当做 key,需要用唯一值当成 key。
777. 图片资源优化
使用 WebP 格式,WebP 是 Google 推出的一种支持有损/无损压缩的图片文件格式,得益于 更优的图像数据压缩算法,其与 JPG、PNG 等格式相比,在肉眼无差别的图片质量前提下具 有更小的图片体积(据官方说明,WebP 无损压缩体积比 PNG 小 26%,有损压缩体积比 JPEG 小 25-34%) 需注意 android 设备支持 webp 格式,但 ios 设备不支持 webp 格式
778. 骨架屏的应用
可以从降低网络请求时延、减少关键渲染的节点数这两个角度出发,缩短完成 FMP(首次有 效绘制)的时间。 骨架屏的应用从用户感知的角度可以优化加载体验。
779. 利用事件委托减少子元素事件绑定
列表循环的时候,每个子元素如果都需要进行事件绑定将会损耗大量的属性设置以及事件绑 定操作,降低应用的性能 可以将事件委托于父元素,这样就只需要进行一个事件对象的绑定操作即可,性能可以得到 极大的提升 而且子元素不管是固定还是动态追加,都可以利用事件冒泡触发委托于父元素的事件回调函 数
780. 利用防抖与节流进行性能优化
在屏幕滚动与拖拽的时候,经常会用到一些持续触发的事件,而这类事件不可控触发频率非常高, 大大影响了性能,而我们想要让其变得可控,就可以用到节流和防抖两种方案。 防抖:指的是事件在高频触发状态时,只收集事件最后一次执行的结果。例如滚动时候产生 的 scrollTop,只收集停止滚动时候的 scrollTop,实现原理是每次滚动触发时,都清除定时 器队列,只执行最后一个定义的定时器。 节流:指的是降低事件的触发频率,周期性获取事件的执行结果,例如滚动 1 像素便会触发 的滚动事件,我们可以让它周期性每隔一段时间执行一次。实现原理是下一个定时器任务必 须等待当前定时器任务执行完才执行。
781. 利用事件总线进行数据传递
利用事件总线替代组件间数据绑定的通信方式,WXML 数据绑定是小程序中父组件向子组件 传递动态数据的较为常见的方式,在此过程中,不可避免地需要经历一次组件的 setData 调 用方可完成任务,这就会产生线程间的通信。通过事件总线(EventBus),也就是发布/订阅 模式,来完成由父向子的数据传递。子组件被创建时事先监听数据下发事件,当父组件获取 到数据后触发事件把数据传递给子组件,这整个过程都是在小程序的逻辑层里同步执行,比 数据绑定的方式速度更快。 不过需要注意事件发布与订阅的次数的合理性问题,如果在不合适的位置进行订阅操作可能 会出现多次重复订阅同一事件问题 在合适的位置进行订阅取消操作,防止无效订阅操作
782. 接口聚合,减少请求数
小程序 request 请求最大并发数为 10 个,需要合理控制最大并发数 超出并发限制数目的 HTTP 请求将会被阻塞,需要在队列中等待前面的请求完成,从而一定 程度上增加了请求时延。 // 由于作用域的原因,let timer必须放在页面构造器Page外边,否则无法清除定时器队列,导致重 复触发!
lettimer;
Page({
debounce(e) {
clearTimeout(timer);
timer=setTimeout(() => {
console.log(e.detail.scrollTop);
}, 500);
},
});
Page({
data: {
lock: true,
},
throttling(e) {
lettimer;
if (this.data.lock) {
this.setData({
lock: false,
});
setTimeout(() => {
this.setData({
lock: true,
});
console.log(e.detail.scrollTop);
}, 500);
}
},
});
对于职责类似的网络请求,最好采用节流的方式,先在一定时间间隔内收集数据,再合并到 一个请求体中发送给服务端,以便实现请求合并操作
783. 视频播放列表如何实现性能优化
视频列表多个 video 视频播放器性能极差(视频播放器本身占用资源大) 优化方案: 将列表中的视频组件更换成 image 组件,列表中没有视频组件 要对某个视频进行播放,选中时再将 image 替换成 video,这样列表中的视频组件有且 只有一个,可以极大提升列表及播放器等性能
784. 小程序关联微信公众号如何确定用户的唯一性
如果开发者拥有多个移动应用、网站应用、和公众帐号(包括小程序),可通过unionid 来区分 用户的唯一性,因为只要是同一个微信开放平台帐号下的移动应用、网站应用和公众帐号(包括小 程序),用户的unionid是唯一的。换句话说,同一用户,对同一个微信开放平台下的不同应
用,unionid是相同的。
785. 你熟悉哪些小程序的 UI 框架
WeUI:WeUI 是微信官方出品的组件库,它沿用了微信的视觉设计与交互设计,提供了各类 原生组件的基础样式,风格简约大方。选用这一套组件库,可以让你的小程序与微信本身保 持一致的界面风格。 Vant-Weapp:适用于电商、餐饮、外卖平台、票务预订等购物类小程序 ColorUI:ColorUI 是由文晓港发布的高颜值组件库,侧重于视觉交互,适用于日记类、记账 类、博客、Vlog 类小程序 iView-Weapp:了解 vue 技术,使用 iview 进行后台管理系统开发人员应该对 iview 的 UI 框 不会陌生 TaroUI:TaroUI 是由京东·凹凸实验室发布的多端 UI 组件库。这套组件库,可以在 H5、微 信小程序、支付宝小程序、百度小程序多端适配运行,适用小程序:工具、读书、资讯、教 育、商务等,但 Taro 主要的技术体系是 React 技术方向 WuxUI:适用于开发工具类小程序,项目更新还是比较及时的
786. 登录操作的一般流程
准备工作:收集表单项数据 验证过程主要分成两大部分,一部分是对前端数据有效性的认证,主要通过正则等方式进行 操作处理,第二部分是对后台返回的数据进行验证,通常利用的是状态进行判断 前端验证 用户输入的内容是否合法(利用正则表达式对不同的表单数据进行条件判断) 前端验证通过才发请求进行后端验证 后台开发操作 收集请求的参数 根据用户的信息查询数据库 如果查不到到该用户,该用户不存在,直接返回 如果查到该用户,匹配用户密码,如果密码正确返回对应的数据 后端验证 对后台返回的数据进行获取 先判断正常的状态码信息,比如 200 状态码 然后对指定的非正常状态码进行逐一判断,该状态码由后台开发接口进行指定,并不是 标准 http 的状态码 对除上述两种状态以外的状态作统一操作,以减少状态码判断操作的类型
787. 用户 cookie 一般使用流程
需求:某些项目后台接口需要利用 header 头信息中的 cookie 内容进行是否为合法用户的判 断操作,所以在指定接口请求的时候需要前端传递合法 cookie 有效值 小程序端 cookie 的获取与传递实现: 用户登录的时候获取到用户的 cookie,将用户的 cookie 存入至本地 在统一的请求接口封装函数中对 request 部分设置 header 属性,并且设置其 cookie 值 只需要进行统一设置即可,因为如果接口不需要 cookie,我们进行传递也不会有任何影 响,但需要 cookie 的时候,则需要一定传递 注意点:
- 只有在登陆的时候存 cookie
- 读取 cookie 设置 header 的时候注意数据类型
- cookie 要求必须是字符串
788. 导航切换时一般需要注意哪些操作流程
导航切换时通常会进行不同的数据列表获取,则需要添加 Loading 加载指示器以便进行用户 体验的提升 导航切换的时候就需要开始 Loading 加载指示器 在数据获取并进行 setData 设值以后再进行 Loading 加载指示器的隐藏操作 在切换导航的时候,一般会考虑将之前的数据信息进行清除,这样有利于用户体验的提升
789. 视频、音频等内容的播放状态存储操作流程一般如何
在进行音、视频播放的时候会涉及到播放不同的音、视频内容 一般会要求应用能够记录每一个音、视频播放的历史记录点,以便于下次播放可以从指定位 置开始 我们可以将音、视频播放的记录存储于本地缓存当中,存储的方式是数组对象 要求是每个对象只保留一条信息记录,需要记录音、视频的唯一标识以及音、视频的播放进 度时间等信息 再次播放的时候可以先通过音、视频唯一标识进行数据匹配,找到对应的播放进度时间,然 后再进行播放操作
790. 列表到详情页的参数传递一般传递的内容是什么?为什么?
不管是新闻列表、产品列表、订单列表等内容都有可能会导航跳转至对应的详情页 因为要显示指定的详情信息,所以需要进行参数的相应操作 一般来讲涉及到参数包括:设参、传参、接参、用参等 4 个部分,但是到底是需要将列表中 的整个数据对象进行传递还是只传唯一标识是需要思考的问题 一般情况并不会将整个对象进行传递,因为这种传递模式数据量比较大,而且导航参数传递 又只支持字符串模式,所以需要进行数据类型转化操作,转化过程也会出现一定的问题 而且导航参数一般会有长度的限制 关键的因素是列表页只会显示一部分关键信息,它们与详情页的数据并不是完整对应的,详 情页的数据一般会比较完整,字段信息内容会更多 所以会考虑传递唯一标识符的传递,这样传递的数据内容比较少,速度比较快,但是在详情 页则需要进行与后台的交互进行进一步的数据接口请求 需要考虑详情页数据请求操作在哪个钩子函数中进行处理,如果在 onLoad 或者 onReady 中,只会执行一次,在 onShow 中又是多次查询,所以需要条件判断来确认是否有必要进行 再次请求操作,以优化性能
791. 订单列表中不同的状态列表用什么方式进行实现?需要注意哪些问题?
订单中心界面中订单的状态包含多种多样 用户可以在不同的状态订单下进行滑动切换以及上拉加载等操作 在不同状态订单列表切换过程中,需要查看到的是之前界面中原来查看的数据与状态 基于性能优化的考虑,需要将每个状态的数据进行单独的存储与记录,这里就涉及到选项卡 循环与定位、当前的选项卡下标、订单列表、分页、加载状态等信息。 为了实现左右滑动手势操作等,可以利用 swiper 组件进行不同订单状态的列表功能 对于数据部分需要利用二维数组进行存放,这样每个状态订单的数据都不会产生冲突: 订单数据:将每个状态下的订单根据 tabs 做对应,存放于 orders 对象当中 分页码:可以以一维数组进行不同 tabs 分页码的记录 加载状态:确认每个状态下的订单数是否是,不可载加、可加载、加载完毕等不同加载 状态 注意:可能需要利用 createSelectorQuery 获取 swiper 以及 scroll-view 的高度,因为它们的高 度都是定高的,所以可以动态计算与赋值
792. 电商平台购物车流程的处理方式有哪几种,操作流程与优势不足各有哪些
购物车数据本地缓存存储模式,单设备存储与应用,切换设备将无法同步,但性能优良 以 id 为参数模式的操作方式 用户查看产品详情,将产品添加到购物车,而购物车中生成的是一个单一数组,类 似[1,2,1,1,3,4,4] 1,2,3,4 为产品 id,出现的次数为购买的数量 在购物车清单页面需要进行再次的数据请求与查询 选中购物车产品等操作则增加程序复杂层度 以对象为参数模式的操作方式 用户查看产品详情,将产品添加到购物车,而购物车中生成的是一个对象数组,将 会把产品整体对象传递并存储于数组当中 可以给数组对象添加 count(购买数量),selected(是否选中)等属性值 在购物车清单页面不再需要进行数据请求与查询操作,减少性能开销 选中购物车产品等操作简化程序复杂层度 购物车数据远程序服务器存储模式,与本地设备无关,切换设备也可以同步数据,请求次数 多,服务器压力大,性能略低下 将用户信息、产品 id 以及购买数量等信息作为参数进行订单接口的请求操作 由服务器端进行订单内容的查询、新增、更新与删除的操作 订单列表页则需要进行订单列表接口的请求获取与显示操作 每个商品信息任何一次变化都需要与后台接口进行交互,http 请求次数巨大
793. 小程序支付流程
不管是小程序还是支付宝以后其它的第三方支付,其支付的主要操作流程由后台开发工程师负责, 前端部分主要负责产品信息的收集、预支订单的发送、资金支付的发起、订单结果的回调等操作, 并不处理负责复杂的业务逻辑操作。 用户下单以后客户端需要发请求给商家服务器端,请求下单支付 商家服务器发请求给微信服务器获取当前用户的唯一标识,生成商户订单 商家服务器端发请求给微信服务器端请求统一下单支付(获取最终的预支付订单信息) 商家服务器收到预支单的信息对该信息进行签名和加密处理 商家服务器端签名以后将支付的参数的信息返回给客户端 客户端展示给用预支单信息 用户确认支付,授权掉起支付的 API(wx.requestPayment),直接发请求给微信服务器请求 扣款
data: {
mainHeight: 0, //
swiperCurrentIndex: 0, // 当前swiper的下标
tabs: ['全部', '待付款', '待收货', '已完成', '已取消'],
// 订单数据订单数组和订单状态数组元素一致
orders: [[], [], [], [], []],
// 订单页码
pages: [1, 1, 1, 1, 1],
// 加载状态
loadingTypes: [3, 3, 3, 3, 3],
},
微信服务器扣款结束以后将支付的结果返回给客户端,客户端需要将支付的结果展示给用户 看 微信服务器将支付的结果推送给商家服务器端,用于更新订单状态
794. 怎样生成朋友圈小程序海报
实现类似功能的方法都差不多,就是调用小程序的 Canvas 模块 可以利用第三方插件,比如:小程序海报组件https://www.npmjs.com/package/wxa-plugi n-canvas进行功能处理
795. 有没有开发过小程序直播功能,操作流程是如何的
在小程序中可以进行直接功能的开启,但需要注意一些条件限制 小程序直接只支持单设备直播,不支持多镜头多设备切换直播,但它是免费的 如果需要多设备多镜头切换直接,需要自己搭建或利用第三方流媒体服务器做支撑,这将耗 费极大成本 在小程序管理平台功能->直播模块可以开启直播功能 直播功能需要有小程序应用存有支付操作行业,否则不能申请直接 如果申请通过,小程序管理平台可以进行直播间的管理操作 小程序端直接间的引入与使用操作,具体:https://developers.weixin.qq.com/miniprogra m/dev/framework/liveplayer/live-player-plugin.html 直播组件引入:分包与主包引入需要在不同配置文件引入配置,而且 provider 编号是 不变的,就是 wx2b03c6e691cd7370 获取直播房间列表:该接口仅供商家后台调用,调用限额 500 次/天,建议开发者自己 做缓存(后台开发人员处理),开发者自己公司的服务器上再进行自己服务器接口的开 发与提供 利用路由跳转进入直播间:
<navigator
url="plugin-private://wx2b03c6e691cd7370/pages/live-player-
plugin?room_id={{roomId}}&custom_params={{customParams}}"
></navigator>
letroomId= [直播房间id]; // 填写具体的房间号,可通过下面【获取直播房间列
表】 API 获取
letcustomParams=encodeURIComponent(JSON.stringify({ path:
'pages/index/index', pid: 1 }));
wx.navigateTo({
url: `plugin-private://wx2b03c6e691cd7370/pages/live-player-
plugin?room_id=${roomId}&custom_params=${customParams}`,
});
// 其中wx2b03c6e691cd7370是直播组件appid不能修改
796. 微信小程序的实现原理
要点(概念层面)
- 小程序是一个运行在微信容器(WeChat runtime)内的轻量级应用。它由两部分组成:
- 视图层(View):WXML + WXSS(类似 HTML/CSS)在微信内置渲染引擎里渲染,是受限的 DOM。
- 逻辑层(Logic):JS 运行在 V8/C++ 等环境里,与视图层通过**消息机制(异步桥)**交互(通过 setData / 事件回传等)。
- 组件化 + 沙箱:每个小程序被沙箱化运行,权限受限制(API 由微信提供),资源使用受限(包体、API 调用等)。
- 网络/存储:网络请求走 wx.request(有域名白名单),本地有缓存(wx.setStorageSync)、文件系统(wx.getFileSystemManager)。
- 分包/按需加载:支持分包加载(主包 + 分包 + 子包),可优化首包体积。
- 生命周期与页面栈:小程序维护页面栈(最多10层),路由 API 在容器层实现(navigateTo、redirectTo 等)。
简短图示(文字) 用户操作 → 微信容器 → 视图层渲染 + 逻辑层 JS 处理 → 通过异步消息桥修改视图(setData)或调用原生 API(支付、定位等)
代码演示(最小运行示例) 项目结构:
/minapp-demo
/pages/index/index.wxml
/pages/index/index.js
/app.json
/app.js
/app.wxss
app.json
{
"pages": ["pages/index/index"],
"window": {
"navigationBarTitleText": "示例"
}
}
app.js
App({
onLaunch() {
console.log('App onLaunch');
// 初始化逻辑,例如获取用户授权、读取本地缓存等
}
});
pages/index/index.wxml
<view class="container">
<text>{{msg}}</text>
<button bindtap="onTap">点击改变数据</button>
</view>
pages/index/index.js
Page({
data: { msg: 'Hello 小程序' },
onTap() {
// 逻辑层修改数据后,视图层刷新
this.setData({ msg: '数据已更新:' + Date.now() });
}
});
app.wxss
.container { padding: 20px; }
797. 微信小程序的支付流程
要点(高层流程)
- 小程序调用
wx.login获取code(临时登录凭证),或直接走支付流程时先登录拿到 user info(非必需)。 - 小程序向自己后端发起“创建支付订单”请求(包含订单信息、用户标识等)。
- 后端使用微信商户平台的 API(统一下单 API:
/pay/unifiedorder)向微信服务器申请生成prepay_id。后端需要签名(商户 key)、商户号、appId、notify_url 等。 - 微信返回
prepay_id给后端,后端将所需参数(nonceStr、timeStamp、package=prepay_id、signType、paySign)签名后返回给小程序。 - 小程序调用
wx.requestPayment({...})使用后端返回的参数拉起支付界面。 - 支付完成后,微信服务器异步回调商户后端的
notify_url(需校验签名并处理订单状态)。 - 后端更新订单状态并通知小程序/前端(可通过轮询/推送/消息)。
关键点与注意事项
- 所有与商户密钥相关的签名必须在后端完成(不能在客户端做),商户 key 不能暴露。
notify_url必须可公网访问且可校验签名。- 小程序 prepay 流程需要在微信商户平台配置小程序 appId、商户号、API key、证书(部分接口)。
- 调试时使用沙箱或真机环境,微信开发者工具支持模拟
wx.requestPayment但真实支付需真机。
示例代码(后端 Node + 小程序端)
后端:server.js(Express + axios + xml2js)
这是最简示例,真实项目要做签名、错误处理、幂等、证书、回调验证等更严谨的实现。
// server.js
const express = require('express');
const axios = require('axios');
const xml2js = require('xml2js');
const crypto = require('crypto');
const bodyParser = require('body-parser');
const app = express();
app.use(bodyParser.text({ type: '*/xml' }));
app.use(express.json());
const MCH_ID = 'your_mch_id';
const APP_ID = 'your_appid';
const API_KEY = 'your_api_key';
const UNIFIED_ORDER_URL = 'https://api.mch.weixin.qq.com/pay/unifiedorder';
// util: build sign (MD5 uppercase)
function buildSign(params) {
const ordered = Object.keys(params).sort().map(k => `${k}=${params[k]}`).join('&');
return crypto.createHash('md5').update(ordered + `&key=${API_KEY}`).digest('hex').toUpperCase();
}
function toXml(obj) {
const builder = new xml2js.Builder({ headless: true, rootName: 'xml' });
return builder.buildObject(obj);
}
function parseXml(xml) {
return xml2js.parseStringPromise(xml, { explicitArray: false, trim: true });
}
// 创建预支付订单
app.post('/create-unified-order', async (req, res) => {
const { openid, out_trade_no, total_fee, body } = req.body;
const nonce_str = crypto.randomBytes(16).toString('hex');
const params = {
appid: APP_ID,
mch_id: MCH_ID,
nonce_str,
body,
out_trade_no,
total_fee: String(total_fee), // 分
spbill_create_ip: req.ip.replace('::ffff:', ''),
notify_url: 'https://yourdomain.com/pay/notify',
trade_type: 'JSAPI',
openid
};
params.sign = buildSign(params);
const xml = toXml(params);
try {
const r = await axios.post(UNIFIED_ORDER_URL, xml, { headers: { 'Content-Type': 'text/xml' } });
const parsed = await parseXml(r.data);
const result = parsed.xml;
if (result.return_code === 'SUCCESS' && result.result_code === 'SUCCESS') {
// 返回 prepay_id 给小程序(后端需再生成签名给前端)
const prepay_id = result.prepay_id;
const timeStamp = String(Math.floor(Date.now() / 1000));
const paySignParams = {
appId: APP_ID,
timeStamp,
nonceStr: nonce_str,
package: `prepay_id=${prepay_id}`,
signType: 'MD5'
};
const paySign = buildSign(paySignParams);
res.json({ success: true, data: { ...paySignParams, paySign } });
} else {
res.json({ success: false, error: result });
}
} catch (err) {
console.error(err);
res.status(500).json({ success: false, error: err.message });
}
});
// 支付结果通知(微信回调)
app.post('/pay/notify', async (req, res) => {
// req.body is xml
try {
const parsed = await parseXml(req.body);
const data = parsed.xml;
// TODO: 校验签名,更新订单状态
// 返回给微信 SUCCESS
const ok = { return_code: 'SUCCESS', return_msg: 'OK' };
res.set('Content-Type', 'text/xml').send(toXml(ok));
} catch (e) {
res.status(500).send('error');
}
});
app.listen(3000, () => console.log('server listening 3000'));
小程序端:
pages/pay/pay.js
// 调用后端创建订单并拉起支付
Page({
async createOrderAndPay() {
try {
const openid = wx.getStorageSync('openid'); // 事先登录并保存
const resp = await wx.request({
url: 'https://yourdomain.com/create-unified-order',
method: 'POST',
data: {
openid,
body: '商品描述',
out_trade_no: 'order' + Date.now(),
total_fee: 1 // 分
}
});
const data = resp.data.data;
wx.requestPayment({
timeStamp: data.timeStamp,
nonceStr: data.nonceStr,
package: data.package,
signType: data.signType,
paySign: data.paySign,
success(res) { console.log('支付成功', res); },
fail(err) { console.error('支付失败', err); }
});
} catch (err) {
console.error(err);
}
}
});
798. 提高微信小程序应用速度的手段(性能优化)
按“启动/渲染/网络/运行时”分类列出常用手段,并给代码/配置示例。
启动/包体与分包
- 主包最小化:把非首屏资源放到分包、子包、异步组件里。
app.json中配置subPackages。
{
"subPackages": [
{
"root": "packageA",
"pages": ["pages/a/index"]
}
]
}
- 使用插件 & 云函数按需加载:将耗时逻辑放到后端/云函数。
渲染优化
- 尽量减少 setData 的数据量与频繁调用:只更新必要字段,批量更新。
// 不建议:每项单独 setData
this.setData({ a: 1 });
this.setData({ b: 2 });
// 建议:
this.setData({ a: 1, b: 2 });
- 组件化/纯数据组件:避免把大量无关数据放在父组件导致不必要重渲染。
- WXS 用于小量计算/模板逻辑:在视图层做少量处理,减少逻辑层通信。
// utils.wxs
module.exports = {
format: function(s) { return s + '!' }
}
网络/请求
- 开启 gzip,使用 CDN:后端返回静态资源使用 CDN;接口响应体支持 gzip。
- 缓存策略:使用
wx.setStorageSync缓存列表/静态数据,利用 ETag/If-Modified-Since。 - 合并请求与接口分页:接口聚合或多路合并减少网络多次往返。
列表渲染
- 虚拟列表(长列表不可一次渲染):用第三方或手写虚拟滚动(只渲染可视区)。
- 分段渲染:首屏先渲染必要项,非关键延后。
主线程/计算密集
- 使用 Worker(小程序支持 Worker):把 hash、图片压缩等放到 Worker,避免卡 UI。
// main.js
const worker = wx.createWorker('workers/task.js');
worker.postMessage({ cmd: 'hash', filePath: '/tmp/x' });
worker.onMessage(res => console.log(res));
workers/task.js
// worker script
onMessage((msg) => {
if (msg.cmd === 'hash') {
// 假装计算
postMessage({ result: 'done' });
}
});
渲染性能工具与监控
- 使用小程序性能面板(微信开发者工具)查看 FPS、页面渲染耗时;在产品中埋点采集首屏时间、接口耗时等。
代码示例:分包 + 延迟加载组件
app.json
{
"pages": ["pages/index/index"],
"subPackages": [
{ "root": "packageLarge", "pages": ["pages/large/index"] }
]
}
在首页点击跳转时再加载:
wx.navigateTo({ url: '/packageLarge/pages/large/index' });
799. 微信小程序中路由跳转方式与区别
微信提供 5 种主要路由 API:
wx.navigateTo({url})
- 向页面栈添加一页(保留当前页面),最多 10 层。用于非 tab 页面之间的跳转。
- 返回后页面保持状态(未卸载)。
wx.redirectTo({url})
- 替换当前页面(不保留当前页面),不会增加页面栈深度。用于不需要返回的场景(例如登录后跳转)。
wx.switchTab({url})
- 切换到 tabBar 页面(tab 必须在 app.json 的 tabBar 中配置)。会关闭所有非 tab 页面。用于底部导航切换。
wx.reLaunch({url})
- 关闭所有页面并打开到指定页面。通常用于重大流程后重置栈(如登出后回到登录页)。
wx.navigateBack({delta})
- 回退到上一个页面或指定层级。不能用于打开新页面。
区别总结
- 保留与否:
navigateTo保留当前,redirectTo不保留,reLaunch全部清空。 - 目标类型:
switchTab只能跳 tabBar 页面。 - 场景:
navigateTo用于细节页,redirectTo用于替换页面(如一步完成跳转),reLaunch用于重置整个 app 流程。
示例代码
// 从首页 navigateTo 详情页
wx.navigateTo({ url: '/pages/detail/index?id=123' });
// 登录后替换到主页(不需要后退)
wx.redirectTo({ url: '/pages/home/index' });
// 切换底部 tab
wx.switchTab({ url: '/pages/tab/home' });
// 完成结账后重启到成功页
wx.reLaunch({ url: '/pages/success/index' });
// 返回两级页面
wx.navigateBack({ delta: 2 });
800. 微信小程序的登录流程
要点(标准流程)
- 小程序端:调用
wx.login()获得code(有效期短)。 - 小程序端:把
code发给自己后端(不要直接把 code 发给微信)。 - 后端 调用微信服务器的
code2session接口(https://api.weixin.qq.com/sns/jscode2session),传appId、secret、js_code,获取openid、session_key(以及unionid可选)。 - 后端 使用
session_key进行后续数据解密(如解密getUserInfo的 encryptedData),或者基于openid创造自家用户体系并发放自签名 Token(例如 JWT)。 - 小程序端 存储后端返回的 token(wx.setStorageSync),后续接口携带 token 做鉴权。
注意点
code要在后端换取session_key,并且不要把session_key或secret踢到客户端。- 如果需要解密用户信息(encryptedData + iv),必须在后端用
session_key解密以确保安全。 session_key有效期,后端需要设计登录态续期(刷新或重新 login)。
示例代码(小程序 + 后端 Node)
小程序端:
// login.js
async function loginToServer() {
const res = await new Promise((resolve, reject) => {
wx.login({ success: resolve, fail: reject });
});
const code = res.code;
// 调用自己服务端
const r = await wx.request({ url: 'https://yourdomain.com/auth/login', method: 'POST', data: { code } });
// 后端返回 token
wx.setStorageSync('token', r.data.token);
}
后端(Node + axios):
// auth.js
const express = require('express');
const axios = require('axios');
const jwt = require('jsonwebtoken');
const APPID = 'your_appid';
const SECRET = 'your_secret';
const router = express.Router();
router.post('/login', async (req, res) => {
const { code } = req.body;
const r = await axios.get('https://api.weixin.qq.com/sns/jscode2session', {
params: { appid: APPID, secret: SECRET, js_code: code, grant_type: 'authorization_code' }
});
const data = r.data;
if (data.errcode) return res.status(500).json({ error: data });
const openid = data.openid;
// 查库/创建用户
const user = { id: openid };
const token = jwt.sign({ uid: user.id }, 'your_jwt_key', { expiresIn: '7d' });
res.json({ token });
});
module.exports = router;
801. 微信小程序的生命周期函数有哪些
分两类:App 生命周期 与 Page(页面)生命周期。
App 生命周期(在 **app.js**)
onLaunch(options):小程序初始化时触发,且只触发一次。可做全局初始化、获取系统信息、登录等。onShow(options):小程序启动,或从后台进入前台时触发。options包含scene、query等。onHide():小程序从前台进入后台时触发。onError(msg):脚本错误/API 调用报错时触发。onPageNotFound(res):页面不存在时触发(可重定向)。
Page 生命周期(在 **pages/.../index.js**)
onLoad(options):页面加载时触发(只触发一次),可接收路由参数options。onShow():页面显示/切到前台时触发(每次显示都会触发)。onReady():页面第一次渲染完成后触发(只触发一次)。onHide():页面被遮挡或切到后台时触发。onUnload():页面被关闭时触发(navigateBack 或 redirectTo 替换会触发)。- 页面相关事件:
onPullDownRefresh():下拉刷新触发(需在 page config 打开)。onReachBottom():滚动到底部触发。onShareAppMessage():用户点击右上角转发时触发(返回转发信息)。onResize():窗口尺寸变化时触发(部分平台)。
- 组件也有生命周期(如
lifetimes/attached/detached等)。
示例
Page({
onLoad(options) { console.log('onLoad', options); },
onShow() { console.log('onShow'); },
onReady() { console.log('onReady'); },
onHide() { console.log('onHide'); },
onUnload() { console.log('onUnload'); },
onPullDownRefresh() { console.log('refresh'); wx.stopPullDownRefresh(); },
onReachBottom() { console.log('reach bottom'); }
});
802. 你对微信小程序的理解?优缺点?
理解(一句话): 微信小程序是“在微信生态内可快速触达、低门槛发布、受限容器环境下运行”的轻量级应用形态,适合轻量业务、入口导流、工具型场景。
优点
- 低门槛分发:用户无需安装即可使用,强大的流量入口(公众号、社群、扫一扫、分享等)。
- 统一平台 SDK:微信提供支付、授权、位置、开放能力、模板消息等一站式能力。
- 快速迭代:发布流程简单,上线速度快。
- 跨平台(近):在微信生态内能覆盖 iOS/Android,同时对开发者门槛友好。
缺点 / 局限
- 受限的能力:沙箱限制、API 受限(如复杂 native 能力弱),不能随意访问设备底层。
- 包体与性能限制:首包体积限制、页面栈限制(10 层),渲染能力不及原生应用,在复杂可视化、高性能场景下受限。
- 平台依赖:依赖微信生态,商业规则与审核可能限制某些功能。
- 调试与兼容性:微信版本差异、真机差异、不同手机厂商表现差异等。
面试展示角度(建议回答模板)
- 说明应用场景(适合电商轻量成交页、工具、活动页、SaaS 轻量客户端等),并给出优缺点,最后给出一个 mitigation 策略,例如在高性能场景用原生小程序或 H5 + 原生容器,或把复杂计算放服务端/Worker。
803. A. setData 性能优化示例(批量更新/最小化更新)
// 误用:每次都 setData
for (let i = 0; i < 100; i++) {
this.setData({ ['items[' + i + '].value']: i });
}
// 优化:先构建对象,再一次 setData
const update = {};
for (let i = 0; i < 100; i++) update['items[' + i + '].value'] = i;
this.setData(update);
804. B. 分包示例(app.json)
{
"pages":["pages/index/index"],
"subPackages":[
{
"root":"packageA",
"pages":["pages/a/index","pages/a/detail"]
}
],
"tabBar": {
"list": [{ "pagePath": "pages/index/index", "text": "首页" }]
}
}
805. 面试答题小策略(如何包装回答)
- 给出定义 → 原理 → 场景 → 注意点 → 代码示例 五段式回答,既有理论又能展示工程实践。
- 遇到开放题(性能/优缺点),用“分层/分类”方式列举(启动/渲染/网络/运算),并至少给 2 个真实项目中可落地的优化措施。
- 代码 demo 要能直接运行(可脱敏),并标注“关键安全点(签名/密钥在后端)”。
806. 谈谈你对微信小程序的理解
<inputtype="text":value="msg1"@input="msg1=($event.target as
HTMLInputElement).value"/>
<custom-inputtitle="消息2":modelValue="msg2"
@update:modelValue="msg2=$event"/>
defineExpose({
borrowMoney
})
// 使用ref标识子组件
<Sonref="sonRef"/>
// 定义ref
const sonRef = ref<InstanceType<typeof Son> | null>(null)
// 通过ref得到子组件对象, 调用其暴露的方法
sonRef.value?.borrowMoney(num)
807. 微信小程序的分包
在 app.json 里声明 subPackages(root + pages),主包只保留启动页和 tabBar 页面;单个分包/主包上限 2MB、整包 20MB(以平台最新规则为准)。分包按需下载、显著降低首屏时间,独立分包还可以不依赖主包独立运行。
808. vue和小程序的区别
- 2017年度百度百科十大热词之一
- 张小龙对其的定义是无需安装,用完即走,实际上是需要安装的,只不过小程序的体积特别小,下载速度很快, 用户感觉不到下载的过程
3. 2017年1月9日0点上线
4. 没有DOM,组件化开发
- 体积小,单个压缩包体积不能大于2M,否则无法上线
- 小程序的四个重要的文件
a) *.js
b) *.wxml ---> view结构 ----> html
c) *.wxss ---> view样式 -----> css
d) *. json ----> view 数据 -----> json文件
7. 小程序适配方案: rpx (responsive pixel响应式像素单位)
1 什么要分包
- 小程序要求压缩包体积不能大于2M,否则无法发布
- 实际开发中小程序体积如果大于2M就需要使用分包机制进行发布上传
- 分包后可解决2M限制,并且能分包加载内容,提高性能
- 分包后单个包的体积不能大于2M
- 分包后所有包的体积不能大于20M 2 分包形式
1. 常规分包
2. 独立分包
3. 分包预下载
3 常规分包
1. 开发者通过在 app.json subpackages 字段声明项目分包结构
2. 特点:
a) 加载小程序的时候先加载主包,当需要访问分包的页面时候才加载分包内容 b) 分包的页面可以访问主包的文件,数据,图片等资源
c) 主包:
- 主包来源:除了分包以外的内容都会被打包到主包中
4. 通常放置启动页/tabBar页面
4 独立分包
1. 设置independent为true
2. 特点:
a) 独立分包可单独访问分包的内容,不需要下载主包 b) 独立分包不能依赖主包或者其他包的内容
3. 使用场景
a) 通常某些页面和当前小程序的其他页面关联不大的时候可进行独立分包
b) 如:临时加的广告页 || 活动页
5 分包预下载
1. 配置
a) app.json中设置preloadRule选项
b) key(页面路径): {packages: [预下载的包名 || 预下载的包的根路径])}
809. 小程序部分常见面试题
vue是渐进式的框架 小程序是一种全新的连接用户与服务的方式,它可以在微信内被便捷地获取和传播
- vue的生命周期和小程序的生命周期对比
- vue中的数据代理和小程序中的是否有数据代理进行对比
- 组件化的对比
- vue中的组件通信,小程序中的页面之间通信
- vue中的路由和小程序的路由对比
- vue组件中的方法定义位置和小程序中的方法定义位置对比
7. 异步请求的方式(axios/wx.request)
- vue需要ie8以上浏览器,小程序在安卓/ios系统上 提高微信小程序的应用速度的常见方式有哪些?
- 提高页面加载速度
2. 用户行为预测
3. 减少默认data的大小
4. 组件化方案
5. 分包预下载
小程序与原生App相比优缺点? 优点: 基于微信平台开发,微信本身自带的流量是最大的优势,无需安装,只要打开微信就能用,不占用用户手机内存,体验 好,开发周期短,一般最多一个月可以上线完成,开发所需的资金少,所需资金是开发原生APP一半不到,小程序名称是 唯一性的,在微信的搜索里权重很高 容易上手,只要之前有HTML+CSS+JS基础知识,写小程序基本上没有大问题;当然如果了解ES6+CSS3则完全可以编 写出即精简又动感的小程序; 基本上不需要考虑兼容性问题,只要微信可以正常运行的机器,就可以运行小程序; 发布、审核高效,基本上上午发布审核,下午就审核通过,升级简单,而且支持灰度发布; 开发文档比较完善,开发社区比较活跃; 新增webview组件,可以展示网页 支持插件式开发,一些基本功能可以开发成插件,供多个小程序调用; 缺点: 1.局限性很强,(比如压缩体积不能超过2M。样式单一。小程序的部分组件已经是成型的了,样式不可以修改。例 如:幻灯片、导航。)只能依赖于微信依托于微信,无法开发后台管理功能。 2.不利于推广推广面窄,不能分享朋友圈,只能通过分享给朋友,附近小程序推广。其中附近小程序也受到微信的限 制 3.后台调试麻烦,因为API接口必须https请求,且公网地址,也就是说后台代码必须发布到远程服务器上;当然我们 可以修改host进行dns映射把远程服务器转到本地,或者开启tomcat远程调试;不管怎么说终归调试比较麻烦。 4.前台测试有诸多坑,最头疼莫过于模拟器与真机显示不一致
5.小程序中对js使用做了很多限制,不能使用:new Function,eval,Generator,不能操作cookie,不能操作
DOM;
原生App优点: 1、原生的响应速度快 2、对于有无网络操作时,譬如离线操作基本选用原生开发 3、需要调用系统硬件的功能(摄像头、方向传感器、重力传感器、拨号、GPS、语音、短信、蓝牙等功能) 4、在无网络或者若网的情况下体验好。 缺点: 开发周期长,开发成本高 需要下载 简述微信小程序原理? 答:微信小程序采用JavaScript、WXML、WXSS三种技术进行开发,从技术讲和现有的前端开发差不多,但深入挖 掘的话却又有所不同。 JavaScript:首先JavaScript的代码是运行在微信App中的,并不是运行在浏览器中,因此一些H5技术的应用,需 要微信App提供对应的API支持,而这限制住了H5技术的应用,且其不能称为严格的H5,可以称其为伪H5,同理,微 信提供的独有的某些API,H5也不支持或支持的不是特别好。 WXML:WXML微信自己基于XML语法开发的,因此开发时,只能使用微信提供的现有标签,HTML的标签是无法使用的。 WXSS:WXSS具有CSS的大部分特性,但并不是所有的都支持,而且支持哪些,不支持哪些并没有详细的文档。 微信的架构,是数据驱动的架构模式,它的UI和数据是分离的,所有的页面更新,都需要通过对数据的更改来实现。
小程序分为两个部分webview和appService。其中webview主要用来展现UI,appService有来处理业务逻辑、数
据及接口调用。它们在两个进程中运行,通过系统层JSBridge实现通信,实现UI的渲染、事件的处理 分析下微信小程序的优劣势? 优势: 1、无需下载,通过搜索和扫一扫就可以打开。 2、良好的用户体验:打开速度快。 3、开发成本要比App要低。 4、安卓上可以添加到桌面,与原生App差不多。 5、为用户提供良好的安全保障。小程序的发布,微信拥有一套严格的审查流程,不能通过审查的小程序是无法发布 到线上的。 劣势: 1、限制较多。页面大小不能超过1M。不能打开超过5个层级的页面。 2、样式单一。小程序的部分组件已经是成型的了,样式不可以修改。例如:幻灯片、导航。 3、推广面窄,不能分享朋友圈,只能通过分享给朋友,附近小程序推广。其中附近小程序也受到微信的限制。 4、依托于微信,无法开发后台管理功能。 小程序的发布流程(开发流程) 注册微信小程序账号 获取微信小程序的 AppID 下载微信小程序开发者工具
创建demo项目
去微信公众平台配置域名 手机预览 代码上传 提交审核 小程序发布 webview中的页面怎么跳回小程序中 首先,需要在你的html页面中引用一个js文件。
<script type="text/javascript" src="https://res.wx.qq.com/open/js/jweixin-1.3.0.js">
</script>
然后为你的按钮标签注册一个点击事件:
$(".kaiqi").click(function(){undefined
wx.miniProgram.redirectTo({url: '/pages/indexTwo/indexTwo'})
});
这里的redirectTo跟小程序中的wx.redirectTo()跳转页面是一样的,会关闭当前页跳转到页面。 你也可以替换成navigateTo,跳转页面不会关闭当前页。 使用webview直接加载要注意哪些事项? 一、必须要在小程序后台使用管理员添加业务域名; 二、h5页面跳转至小程序的脚本必须是1.3.1以上; 三、微信分享只可以都是小程序的主名称了,如果要自定义分享的内容,需小程序版本在1.7.1以上; 四、h5的支付不可以是微信公众号的appid,必须是小程序的appid,而且用户的openid也必须是用户和小程序的。 小程序授权登录流程。
十、场景题
810. 01 场景题 — 小程序双线程模型(微信小程序 / 类似平台)
目标:解释小程序“双线程/双进程”模型(主线程/UI 线程 + 后台逻辑线程 / Worker)与实现注意点。
说明(面试要点)
- 小程序通常存在
主线程(渲染 & UI 调度)和逻辑线程(JS 引擎运行)——不同平台细节不同(微信、支付宝等实现差异)。 - 小程序支持
Web Worker/子线程(后端运行 heavy 任务,如 hash、压缩、计算),避免阻塞 UI/渲染。 - 跨线程通讯通过
postMessage(序列化)进行,注意不能直接共享 DOM、复杂引用。 - 可利用
Worker做:图片压缩、文件切片、hash 计算、长耗时计算。 - 注意:资源限制(Worker 数量限制、内存限制),序列化成本(大量数据可用 Transferable objects)。
示例(微信小程序 Worker)
// main.js
if (wx.canIUse('createWorker')) {
const worker = wx.createWorker('workers/task.js');
worker.postMessage({ cmd: 'hash', filePath: '/path/to/file' });
worker.onMessage(function(res) {
console.log('worker result', res);
});
}
// workers/task.js
onMessage(function(msg) {
if (msg.cmd === 'hash') {
// do heavy work
const result = doHash(msg.filePath);
postMessage({ result });
}
});
811. 02 场景面试 — 大文件上传(分片、断点续传、失败重试、hash 校验、Web Worker 切片)
目标:实现稳定的大文件上传方案,支持断点续传、分片重试、并发上传、校验(MD5/SHA1)、避免主线程卡顿(Worker 做 hash 切片)。
关键点
- 切片(chunkSize,例如 2MB)
- 每片带索引、hash、size
- 后端提供
/upload/init(创建任务)、/upload/chunk(单片上传)、/upload/complete(合并) - 客户端保存上传进度(localStorage/IndexedDB)
- Worker 计算文件 hash,且负责切片准备
- 并发上传(PromisePool)
- 单片失败重试(指数退避、最大重试次数)
- 断点续传:init 返回已经接收的 chunk 列表
前端(核心)代码(包含 Worker)
// worker.js(Web Worker: 负责计算 hash 与切片元数据)
// worker.js
self.onmessage = async (e) => {
const { file, chunkSize } = e.data;
const total = Math.ceil(file.size / chunkSize);
const chunks = [];
for (let i = 0; i < total; i++) {
const start = i * chunkSize;
const end = Math.min(file.size, start + chunkSize);
const blob = file.slice(start, end);
// 可以额外计算分片的简单 hash(如md5),这里示例不引入库,使用 size+index
chunks.push({ index: i, start, end, size: blob.size });
// 为避免一次加载太多,可 postProgress
if (i % 50 === 0) self.postMessage({ progress: i / total });
}
// 计算文件简单 fingerprint(注意:真实md5需引入spark-md5等)
const fingerprint = `${file.name}-${file.size}-${file.lastModified}`;
self.postMessage({ done: true, chunks, fingerprint });
};
// upload.tsx(前端主逻辑)
// upload.ts (React + TS, 关键函数)
type InitResp = { uploadId: string; uploaded?: number[] };
async function initUpload(apiBase: string, filename: string, totalChunks: number, fingerprint: string): Promise<InitResp> {
const res = await fetch(`${apiBase}/upload/init`, {
method: "POST",
headers: {"Content-Type":"application/json"},
body: JSON.stringify({ filename, totalChunks, fingerprint })
});
return res.json();
}
async function uploadChunk(apiBase: string, uploadId: string, chunkIndex: number, chunkBlob: Blob, retry=3) {
const form = new FormData();
form.append("uploadId", uploadId);
form.append("index", String(chunkIndex));
form.append("file", chunkBlob);
for (let attempt=0; attempt<retry; attempt++) {
try {
const resp = await fetch(`${apiBase}/upload/chunk`, { method:"POST", body: form });
if (resp.ok) return await resp.json();
} catch (err) {
const wait = Math.pow(2, attempt) * 300;
await new Promise(r => setTimeout(r, wait));
}
}
throw new Error(`Chunk ${chunkIndex} upload failed`);
}
export async function uploadFileWithWorker(file: File, apiBase: string) {
const chunkSize = 2 * 1024 * 1024; // 2MB
const worker = new Worker("/worker.js");
const chunksMeta: any[] = await new Promise((resolve) => {
worker.onmessage = (e) => {
if (e.data.done) {
resolve(e.data.chunks.map((c)=>({...c})));
}
};
worker.postMessage({ file, chunkSize });
});
const fingerprint = `${file.name}-${file.size}-${file.lastModified}`;
const totalChunks = chunksMeta.length;
const init = await initUpload(apiBase, file.name, totalChunks, fingerprint);
const uploadId = init.uploadId;
const uploadedSet = new Set(init.uploaded || []);
// 并发池
const concurrency = 4;
const queue = chunksMeta.map((meta, idx) => ({ ...meta, index: idx }));
let active = 0;
let i = 0;
return new Promise<void>((resolve, reject) => {
const runNext = async () => {
if (i >= queue.length && active === 0) {
// 请求合并
await fetch(`${apiBase}/upload/complete`, { method:"POST", headers:{"Content-Type":"application/json"}, body: JSON.stringify({ uploadId }) });
resolve();
return;
}
while (active < concurrency && i < queue.length) {
const chunk = queue[i++];
if (uploadedSet.has(chunk.index)) continue;
active++;
(async () => {
const blob = file.slice(chunk.start, chunk.end);
try {
await uploadChunk(apiBase, uploadId, chunk.index, blob);
// 可更新本地进度
} catch (err) {
reject(err);
return;
} finally {
active--;
runNext();
}
})();
}
};
runNext();
});
}
后端(伪代码 Node/Express)
// /upload/init
// 接收 fingerprint, totalChunks, filename
// 如果已存在 unfinished record, 返回已接收的 chunk 索引列表
// 否则创建 uploadId = uuid(), 存 db (uploadId, fingerprint, totalChunks, uploaded:[])
// /upload/chunk
// 接收 uploadId, index, file
// 将 chunk 存储到临时目录 /uploads/{uploadId}/{index}
// 标记 DB: push index
// /upload/complete
// 合并文件(按 index 读取文件流 concat),保存为目标文件;验证大小/hash;清理临时
面试亮点要点(说给面试官听)
- 说明为什么用 Worker(避免主线程卡顿:hash、切片),为什么要并发限制(避免服务器/网络拥塞),为什么要断点续传(网络不稳定),如何保证幂等(uploadId+index)、安全(token、签名)、如何处理碎片合并的内存优化(流式合并避免把所有片读到内存)。
812. 03 场景面试 — 页面截图(前端实现网页截屏/保存/导出:整页、可视区、带滚动)
目标:实现页面截图(可视区 / 整页),并支持导出 PNG/PDF。 关键点:Canvas 渲染(html2canvas)、整页滚动截图(分段拼接)、处理跨域图片(CORS 或 proxy)、高 DPI(devicePixelRatio),性能与内存限制。
方案
- 使用成熟库 html2canvas 或 puppeteer(后端无头浏览器);
- 前端:html2canvas 支持大部分用例;整页利用
window.scrollTo+ 分片截图拼接到 canvas; - 特殊:如果页面中有跨域图片,需要确保图片有 CORS header 或通过后端代理。
前端示例(使用 html2canvas,整页分片)
import html2canvas from "html2canvas";
async function captureVisible(element: HTMLElement) {
const canvas = await html2canvas(element, { useCORS: true, scale: window.devicePixelRatio || 1 });
return canvas.toDataURL("image/png");
}
// 整页截图(分段拼接)
async function captureFullPage() {
const body = document.body;
const totalHeight = Math.max(body.scrollHeight, document.documentElement.scrollHeight);
const viewportHeight = window.innerHeight;
const canvases = [];
for (let y = 0; y < totalHeight; y += viewportHeight) {
window.scrollTo(0, y);
// 等待重排
await new Promise(r => setTimeout(r, 200));
const base = await html2canvas(document.documentElement, { useCORS: true, scale: 1 });
canvases.push(base);
}
// 拼接
const finalCanvas = document.createElement("canvas");
finalCanvas.width = canvases[0].width;
finalCanvas.height = totalHeight;
const ctx = finalCanvas.getContext("2d")!;
let offset = 0;
canvases.forEach(c => {
ctx.drawImage(c, 0, offset);
offset += c.height;
});
return finalCanvas.toDataURL("image/png");
}
后端无头浏览器(面试高分项)
- 用 Puppeteer 做后端渲染截图,更稳定,适合生成 PDF、定时抓取。
813. 场景面试 — 移动端适配
目标:从 UI / 性能 / 体验角度实现兼容各种屏幕(安卓/iOS、机型差异)。 关键点:视口 meta、弹性布局、响应式单位(rem / vw)、媒体查询、图片/资源按需加载、触控优化(点击延迟、滚动节流)、高 DPI 资源、字体和行高、可访问性。
推荐策略(实战)
- 视口
<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1"> - 使用 REM:根字体动态根据设备宽度设置(如 375px 对应 1rem = 16px)
- CSS Grid / Flexbox + 断点设计(mobile-first)
- 图片:
srcset+picture或按 DPR 提供 @1x,@2x - 性能:懒加载(IntersectionObserver)、长列表虚拟化
- 触控:
touch-action与避免300ms点击问题(现代浏览器已解决) - 软键盘:输入框聚焦时避免布局跳动(监听
visualViewport)
示例:动态 root font-size(适配)
/* index.css */
html { font-size: 16px; } /* fallback */
// adapt.js
function setRem(baseWidth = 375, baseRem = 16) {
const dpr = Math.min(window.devicePixelRatio || 1, 3);
const clientWidth = document.documentElement.clientWidth || window.innerWidth;
const rem = (clientWidth / baseWidth) * baseRem;
document.documentElement.style.fontSize = rem + "px";
document.documentElement.setAttribute("data-dpr", String(dpr));
}
window.addEventListener("resize", () => setRem());
setRem();
814. 场景题 — 如何修改第三方 npm 包(例如:修改 bug / 定制化需求)
目标:在不直接修改 node_modules 的前提下安全地修改第三方包并可维护地使用。 方法:
- Fork + Patch + Publish to private registry(公司内 npm 私服 / GitHub Packages);
- 使用
patch-package:在项目中对 node_modules 修改后,运行npx patch-package pkg-name,并把 patch 提交到仓库,安装后postinstall自动应用; - 提交 PR 给原作者(长期方案);
- 使用 alias/替换(pnpm / webpack alias / vite resolve.alias)重定向到本地修改版本。
示例:使用 patch-package(推荐面试答案)
# 安装 patch-package
npm install patch-package --save-dev
# 修改 node_modules/some-lib/index.js
# 生成补丁
npx patch-package some-lib
# package.json
{
"scripts": {
"postinstall": "patch-package"
}
}
复杂方案(Fork & private publish)
- Fork 到自己 org,修改代码,维护版本号,发布到私服
npm publish --registry http://your-registry,package.json 指向该私服版本。
815. 场景题 — 一个链接两应用(同一链接/按钮在两个不同应用中打开/路由)
场景解释:单一 URL 同时被多个子应用/入口使用(微前端场景),或一个链接在不同应用中打开(主应用/子应用共享跳转)。
解决思路
- 统一路由策略(例如:hash / path)并通过 query 参数或 fragment 指明目标 app。
- 主入口处理:当链接进入主应用,根据 path 或参数决定 mount 哪个子应用(微前端框架如 qiankun/Wujie/micro-app)。
- 如果需要在两个应用中同时打开(一个新窗口打开另一个),使用 target + window.open with URL + params。
示例(微前端 qiankun 路由策略)
// link: https://host/app?app=react-demo#/pageA
// 主应用读取 app 参数,决定 mount 子应用并将路由传递
const url = new URL(location.href);
const targetApp = url.searchParams.get("app"); // react-demo 或 vue-demo
// 主应用加载对应子应用并传入生命周期 props(例如 initialPath)
registerMicroApps([
{
name: 'react-demo',
entry: '//localhost:7100',
container: '#subapp',
activeRule: (location) => location.search.includes('app=react-demo')
},
// ...
]);
816. 场景题 — 实现网页加载进度条
目标:页面加载时(首屏/路由切换/资源加载)展示进度条(类似 NProgress),并尽量模拟真实进度。
实现要点
- 对静态资源:使用
window.fetch/ XHR 拦截或 Resource Timing API 来估计进度(有限)。 - 对路由切换:在路由开始时 start(), 在请求成功/页面渲染完成时 done()。
- 模拟进度策略:快速到 80%-95%,等待真实事件完成再到 100%,并加上缓慢推进(decay)避免瞬间跳满。
- 使用 CSS 动画 + requestAnimationFrame 做平滑。
简单实现(NProgress 风格)
// progress.ts
let progress = 0;
let rafId: number | null = null;
function start() {
progress = 0;
tick();
document.body.classList.add('show-progress');
}
function tick() {
progress += Math.random() * 6; // 随机推进
if (progress >= 95) progress = 95;
update(progress);
rafId = requestAnimationFrame(() => setTimeout(tick, 200));
}
function done() {
if (rafId) cancelAnimationFrame(rafId);
progress = 100;
update(100);
setTimeout(() => {
document.body.classList.remove('show-progress');
update(0);
}, 300);
}
function update(val:number){ const el=document.getElementById('top-progress')!; el.style.width=val+'%'; }
export { start, done };
<!-- index.html -->
<!-- index.html -->
<div id="top-progress" style="position:fixed;left:0;top:0;height:3px;background:#1890ff;transition:width .2s"></div>
817. 场景题 — web 应用中静态资源加载失败的降级处理
目标:当静态资源(JS/CSS/图片/字体)加载失败时优雅降级,保证核心功能和可用性。
策略
- 资源重试(指数退避,最多 N 次);
- 备用 CDN / 本地备份(先尝试主 CDN,失败后切换备选);
- 功能降级:按优先级分离关键/非关键资源(critical CSS/JS 内联/延迟加载可选功能);
- 图片占位/矢量占位:使用
<img onerror=>替换为占位图或 SSG 的 Base64 占位; - 字体回退:CSS 中定义备选字体,使用
font-display: swap;; - 监控/上报:捕获
window.onerror,resource timing, 上报失败日志。
代码 demo:资源加载重试与备用 URL
async function loadScriptWithRetry(urls: string[], maxRetry = 3) {
for (let u of urls) {
for (let attempt = 0; attempt < maxRetry; attempt++) {
try {
await new Promise<void>((resolve, reject) => {
const s = document.createElement('script');
s.src = u;
s.onload = () => resolve();
s.onerror = () => reject(new Error('load fail'));
document.head.appendChild(s);
});
return;
} catch (e) {
await new Promise(r => setTimeout(r, Math.pow(2, attempt) * 200));
}
}
}
throw new Error("All script urls failed");
}
// 使用:优先 CDN1, CDN2, 本地
loadScriptWithRetry(["//cdn1/lib.js","//cdn2/lib.js","/static/lib.js"]).catch(err => {
console.error("lib load failed", err);
// 进入降级方案:隐藏相关功能、显示提示等
});
818. 场景面试 — 前端水印功能(图片/页面/导出到 PDF 的水印)
目标:实现抗篡改、可配置的文本/图片水印,能在导出/截图中保留。
思路
- 页面水印:使用 fixed/flexible 的重复背景层(CSS + Canvas 生成图片,设置
pointer-events:none)。 - 防移除:用多层水印或定期校正(定时检查 DOM)。
- 导出(PDF/截图):在导出前把水印绘制到 canvas/PDF。
示例(Canvas 生成图像作为背景)
function createWatermarkDataURL(text: string) {
const canvas = document.createElement('canvas');
canvas.width = 300; canvas.height = 200;
const ctx = canvas.getContext('2d')!;
ctx.fillStyle = 'rgba(0,0,0,0.08)';
ctx.font = '16px sans-serif';
ctx.translate(150,100);
ctx.rotate(-Math.PI/12);
ctx.fillText(text, -50, 0);
return canvas.toDataURL('image/png');
}
function applyWatermark(text: string) {
const url = createWatermarkDataURL(text);
const div = document.createElement('div');
div.id = 'app-watermark';
Object.assign(div.style, {
position: 'fixed', left:0, top:0, right:0, bottom:0,
pointerEvents:'none', backgroundImage:`url(${url})`, opacity:'0.8', zIndex: 999999
});
document.body.appendChild(div);
}
819. 场景面试 — 大数运算(JS 精度问题、实现大整数/高精度浮点)
目标:处理精度丢失(JS Number)场景,支持加减乘除/四舍五入/大整数、任意精度小数。
做法
- 使用 BigInt(原生)处理整数(但不支持小数)。
- 使用高精度库
decimal.js、big.js、bignumber.js来处理小数场景。 - 或者实现字符串算术(手写大数加减乘),适合面试考题实现。
简单字符串大整数加法(面试算法题)
function addBigIntStr(a, b) {
let carry = 0, res = [];
a = a.split('').reverse(); b = b.split('').reverse();
const n = Math.max(a.length, b.length);
for (let i=0;i<n;i++){
const x = parseInt(a[i]||'0',10);
const y = parseInt(b[i]||'0',10);
const s = x+y+carry;
res.push(String(s%10));
carry = Math.floor(s/10);
}
if (carry) res.push(String(carry));
return res.reverse().join('');
}
820. 场景面试 — 设计全站请求耗时统计工具(APM-lite)
目标:客户端采集全站请求耗时(XHR/Fetch/资源/路由变更)并上报到后端,便于性能分析。
采集点
- XHR/Fetch 拦截(包装原生);
- Resource Timing API(图片、css、js);
- Navigation Timing / PerformanceObserver(first paint, first contentful paint);
- 页面路由(SPA)– 记录路由开始/结束时间;
- 后端接收并聚合(时间窗口、聚合维度:url、status、用户、traceId)。
前端核心实现(拦截 Fetch & XHR)
// wrapFetch.ts
const originalFetch = window.fetch;
window.fetch = async function(...args) {
const start = performance.now();
try {
const res = await originalFetch.apply(this, args);
const duration = performance.now() - start;
sendPerf({ url: args[0], type:'fetch', status: res.status, duration });
return res;
} catch (err) {
const duration = performance.now() - start;
sendPerf({ url: args[0], type:'fetch', status: 0, duration, error: String(err) });
throw err;
}
};
function sendPerf(payload: any) {
// 用 beacon 优先
if (navigator.sendBeacon) {
const blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
navigator.sendBeacon('/perf/collect', blob);
} else {
fetch('/perf/collect', { method:'POST', body: JSON.stringify(payload), headers: {'Content-Type':'application/json'}});
}
}
后端聚合(思路)
- 接收事件并写入时序 DB(InfluxDB / ClickHouse / ES / Kafka),
- 聚合成接口平均耗时、P95、错误率,按 URL/TAG 分组,做告警。
821. 场景面试 — 函数式编程(FP 在前端的应用)
目标:解释函数式编程概念并举例(纯函数、不可变数据、高阶函数、组合、柯里化、侧边效果最小化)。
面试要点与示例
- 纯函数:相同输入返回相同输出,无副作用。
- 不可变:使用
Object.freeze/ 结构性共享(immer) - 高阶函数:
map,filter,reduce或自定义compose - 柯里化/组合:提高可复用性
const compose = (...fns) => x => fns.reduceRight((v,f)=>f(v), x);
const add = a => b => a + b;
const double = x => x*2;
const incThenDouble = compose(double, add(1));
console.log(incThenDouble(2)); // (2+1)*2 = 6
在前端的应用示例
- 数据转换流水线(normalize -> enrich -> filter)
- 事件处理链(pure handlers -> side-effect at edge)
- 状态管理策略(不可变 reducers)
822. 场景面试 — 电影票选座功能(座位布局、并发抢占、锁座、支付完成释放)
目标:设计票选座功能,解决并发冲突、锁定、超时释放、支付一致性。
关键设计
- 座位模型:
seat { id, status: available|locked|sold, lockedBy, lockedAt } - 锁座机制(短期锁,例如 5 分钟):通过接口
POST /seat/lock返回 lockId 或失败 - 乐观/悲观策略:悲观锁适合高并发(直接写 DB 标记 locked),乐观通过 compare-and-swap(version 或 SQL where status = available)
- 支付与最终确认:支付成功后
POST /seat/confirm把 locked -> sold;如果超时或取消,自动解锁(后台定时任务或延迟队列) - 并发策略:数据库事务或 Redis 分布式锁;使用消息队列确保幂等
前端交互(示例)
async function tryLockSeat(seatId) {
const resp = await fetch(`/api/seat/lock`, { method:'POST', body: JSON.stringify({ seatId }), headers:{'Content-Type':'application/json'}});
const data = await resp.json();
return data; // { success: true/false, lockId, expiresAt }
}
后端示例(伪代码)
-- 悲观 SQL (Postgres)
BEGIN;
UPDATE seats SET status='locked', locked_by=$1, locked_at=now()
WHERE id=$2 AND status='available';
-- check affected rows == 1 then commit else rollback
COMMIT;
或 Redis:
SETNX seat:{id} {lockInfo} EX 300
823. 场景面试 — 图片性能优化方案
目标:降低页面图片的加载成本和渲染成本,提高 UX 和 CLS。
关键措施
- 图片格式:WebP/AVIF > JPEG/PNG(按浏览器支持)。
- 响应式:
srcset/sizes/<picture>。 - Lazy loading (
loading="lazy"或 IntersectionObserver)。 - 占位(LQIP / SVG 占位 / blur-up)。
- CDN + 缩放/裁剪服务:根据 breakpoints 生成合适尺寸。
- 图片压缩(lossy/lossless)、按需惰性解码
decoding="async"。 - 使用
prefetch或preload关键图(首屏 hero)。 - 避免 layout shift:为图片预留宽高(或使用 aspect-ratio)。
- 精细处理背景图片和 icon(SVG sprite 或 icon font)。
简单示例(picture + srcset + lazy)
<picture>
<source type="image/avif" srcset="cat-400.avif 400w,cat-800.avif 800w" sizes="(max-width:600px) 400px,800px">
<source type="image/webp" srcset="cat-400.webp 400w,cat-800.webp 800w">
<img src="cat-800.jpg" alt="cat" loading="lazy" width="800" height="450" decoding="async">
</picture>
824. 场景题 — 移动端上拉加载 / 下拉刷新
目标:实现移动端上拉加载更多与下拉刷新体验(带阻尼效果、节流、避免冲突)。
要点
- 用 touch 事件或 pointer events 实现下拉;要兼容浏览器默认下拉(在 WebView 中常禁用默认)。
- 下拉刷新:拖拽距离阈值(e.g. 60px)+ 回弹动画 + 状态机(idle -> pulling -> ready -> refreshing -> done)。
- 上拉加载:监听滚动到接近底部
scroll或 IntersectionObserver(更优)。 - 避免冲突:在下拉时禁用滚动或在顶部检测才启下拉。
简单实现(下拉刷新)
let startY = 0, pulling = false;
const threshold = 60;
const el = document.getElementById('scrollWrap');
el.addEventListener('touchstart', (e) => {
if (el.scrollTop === 0) { startY = e.touches[0].clientY; pulling = true; }
});
el.addEventListener('touchmove', (e) => {
if (!pulling) return;
const delta = e.touches[0].clientY - startY;
if (delta > 0) {
e.preventDefault();
const dist = Math.min(delta / 2, 120);
document.getElementById('ptr').style.transform = `translateY(${dist}px)`;
// update UI status if > threshold
}
});
el.addEventListener('touchend', async (e) => {
if (!pulling) return;
pulling = false;
const endY = e.changedTouches[0].clientY;
if (endY - startY > threshold) {
// 执行刷新
document.getElementById('ptr').classList.add('refreshing');
await doRefresh();
document.getElementById('ptr').classList.remove('refreshing');
}
document.getElementById('ptr').style.transform = '';
});
上拉加载用 IntersectionObserver 监听底部 sentinel 元素即可(节省资源,避免频繁 scroll 事件)。
825. 场景面试 — 深度 SEO 优化(前端可做的 SEO)
目标:提高搜索引擎抓取和排名(技术和内容层面的结合)。
前端可做项(面试重点)
- 服务端渲染(SSR)或预渲染(SSG)以确保搜索引擎抓取到完整 HTML(尤其是动态内容)。
- 语义化 HTML(正确 H1-H6,article, nav, main),结构化数据(schema.org JSON-LD)。
- 优化 meta(title/description)、Open Graph、canonical 链接、hreflang(多语言)。
- 页面性能(首屏速度、LCP、CLS)直接影响 SEO;使用 Lighthouse 指标优化。
- URL 设计:静态、友好、避免参数过多。
- robots.txt、sitemap.xml、XML sitemap 动态生成并提交到搜索引擎。
- 图片 lazy +
alt属性+ 图片 sitemap。 - 使用
rel="next/prev"、分页优化、避免重复内容(canonical)。 - 移动优先(移动端友好)和安全 (HTTPS)。
代码示例:JSON-LD schema
<script type="application/ld+json">
{
"@context":"https://schema.org",
"@type":"Article",
"headline":"如何优化图片性能",
"author": { "@type":"Person", "name":"大伟" },
"datePublished":"2025-10-15",
"image":"https://example.com/cover.jpg"
}
</script>
826. 无感刷新Token:如何做到让用户“永不掉线”
没有什么比在用户操作得正嗨时,突然提示“登录已过期,请重新登录”的提示更让人沮丧的了。这种突兀的中断不仅破坏了用户体验,甚至可能导致未保存的数据丢失。
然而,我们都知道,出于安全考虑,用于身份验证的 Token(通常是 Access Token)必须有较短的有效期。那么,我们如何在保证安全的前提下,创造一种“永不掉线”的丝滑体验呢?
问题的根源:Access Token 的“天生矛盾”
首先,我们要理解为什么需要刷新 Token。
我们通常使用 Access Token 来验证用户的每一次 API 请求。为了安全,Access Token 的生命周期被设计得很短(例如 30 分钟或 1 小时)。如果有效期太长,一旦泄露,攻击者就能在很长一段时间内冒充用户进行操作,风险极高。
这就产生了一个矛盾:
- 安全性要求:
Access Token有效期要短。 - 用户体验要求:用户不想频繁地被强制重新登录。
为了解决这个矛盾,Refresh Token 应运而生。
核心理念:双 Token 认证系统
无感刷新机制的核心在于引入了两种类型的 Token:
-
Access Token(访问令牌)- 用途:用于访问受保护的 API 资源,附加在每个请求的
Header中。 - 特点:生命周期短(如 1 小时),无状态,服务器无需存储。
- 存储:通常存储在客户端内存中(如 Vuex/Redux),因为需要频繁读取。
- 用途:用于访问受保护的 API 资源,附加在每个请求的
-
Refresh Token(刷新令牌)- 用途:当
Access Token过期时,专门用于获取一个新的Access Token。 - 特点:生命周期长(如 7 天或 30 天),与特定用户绑定,服务器需要安全存储其有效性记录。
- 存储:必须安全存储。最佳实践是存储在
HttpOnlyCookie 中,这样可以防止客户端 JavaScript 脚本(如 XSS 攻击)读取它。
- 用途:当
既然如此,为何不直接使用 Refresh Token 呢?
Access Token 通常是无状态的,服务器无需记录它,也导致 JWT 无法主动吊销,而 Refresh Token 是有状态的,服务器需要一个列表(数据库中的“白名单”或“吊销列表”)来记录哪些 Refresh Token 是有效的,当用户更改密码、或从某个设备上“主动登出”时,服务器端可以主动将对应的 Refresh Token 设为无效。
无感刷新的详细工作流
下面是这个“魔法”发生的具体步骤:
-
首次登录:用户使用用户名和密码登录。服务器验证成功后,返回一个
Access Token和一个Refresh Token。 -
正常请求:客户端将
Access Token存储起来,并在后续的每次 API 请求中,通过Authorization请求头将其发送给服务器。 -
Token 过期:当
Access Token过期后,客户端再次用它请求 API。服务器会拒绝该请求,并返回一个特定的状态码,通常是401 Unauthorized。 -
拦截 401 错误:客户端的请求层(如 Axios 拦截器)会捕获这个
401错误。此时,它不会立即通知用户“你已掉线”,而是暂停这个失败的请求。 -
发起刷新请求:拦截器使用
Refresh Token去调用一个专门的刷新接口(例如/api/auth/refresh)。 -
处理刷新结果:
- 刷新成功:服务器验证
Refresh Token有效,生成一个新的Access Token(有时也会返回一个新的Refresh Token,这被称为“刷新令牌旋转”策略,可以提高安全性),并将其返回给客户端。 - 刷新失败:如果
Refresh Token也过期了或无效,服务器会返回错误(如403 Forbidden)。这意味着用户的登录会话彻底结束。
- 刷新成功:服务器验证
-
重试与终结:
- 若刷新成功:客户端用新的
Access Token自动重发刚才失败的那个 API 请求。用户完全感觉不到任何中断,数据操作无缝衔接。 - 若刷新失败:客户端清除所有认证信息,强制用户登出,并重定向到登录页面。
- 若刷新成功:客户端用新的
实战演练:使用 Axios 拦截器实现无感刷新
Axios 的拦截器是实现这一流程的完美工具。下面是一个完整且考虑了并发问题的实现方案。
1. 创建 Axios 实例
首先,我们创建一个单独的 Axios 实例,方便统一管理。
// a-pi/request.js
import axios from 'axios';
const service = axios.create({
baseURL: '/api',
timeout: 10000,
});
// 请求拦截器
service.interceptors.request.use(
config => {
// 在发送请求之前,从 state management (e.g., Vuex/Pinia/Redux) 获取 token
const accessToken = getAccessTokenFromStore();
if (accessToken) {
config.headers['Authorization'] = `Bearer ${accessToken}`;
}
return config;
},
error => {
return Promise.reject(error);
}
);
2. 核心:响应拦截器
这是实现无感刷新的关键。
// a-pi/request.js (续)
// 用于刷新 token 的 API
import { refreshTokenApi } from './auth';
let isRefreshing = false; // 控制刷新状态的标志
let requests = []; // 存储因 token 过期而挂起的请求
service.interceptors.response.use(
response => response, // 对成功响应直接返回
async error => {
const { config, response: { status } } = error;
// 1. 如果不是 401 错误,直接返回错误
if (status !== 401) {
return Promise.reject(error);
}
// 2. 避免重复刷新:如果正在刷新 token,将后续请求暂存
if (isRefreshing) {
return new Promise(resolve => {
requests.push(() => resolve(service(config)));
});
}
isRefreshing = true;
try {
// 3. 调用刷新 token 的 API
const { newAccessToken } = await refreshTokenApi(); // 假设 refresh token 通过 HttpOnly cookie 自动发送
// 4. 更新本地存储的 access token
setAccessTokenInStore(newAccessToken);
// 5. 重试刚才失败的请求
config.headers['Authorization'] = `Bearer ${newAccessToken}`;
// 6. 重新执行所有被挂起的请求
requests.forEach(cb => cb());
requests = []; // 清空队列
return service(config); // 返回重试请求的结果
} catch (refreshError) {
// 7. 如果刷新 token 也失败了,则执行登出操作
console.error('Unable to refresh token.', refreshError);
logoutUser(); // 清除 token,重定向到登录页
return Promise.reject(refreshError);
} finally {
isRefreshing = false;
}
}
);
export default service;
代码解析:
- 并发处理:
isRefreshing标志和requests数组是关键。当第一个401错误触发刷新时,isRefreshing变为true。后续在刷新完成前到达的401请求,都会被推进requests队列中挂起,而不是重复发起刷新请求。当刷新成功后,再遍历队列,依次执行这些被挂起的请求。 - 原子操作:通过这种“加锁”机制,确保了刷新 Token 的操作是原子的,避免了资源浪费和潜在的竞态条件。
- 优雅降级:当
Refresh Token也失效时,系统会执行logoutUser(),进行清理工作并引导用户重新登录,这是一个优雅的失败处理方案。
无感刷新 Token 机制是现代 Web 应用提升用户体验的“标配”。它将身份验证的复杂性隐藏在后台,为用户提供了一个流畅、不间断的操作环境。
实现这一机制,不仅仅是写几行代码,更是对认证流程、安全性和用户体验三者之间平衡的深刻理解。
827. 前端请求数据URL由谁来写?
在开发中,URL主要是由后台来写的,写好了给前端开发者.如果后台在查询数据,需要借助查询条件才能查 询到前端需要的数据时,这时后台会要求前端提供相关的查询参数,这里的查询参数也就是URL请求的参 数。
828. 接口文档主要由谁来写?
接口文档也是主要由后台开发者来写的,因为直接跟数据打交道的就是后台,后台是最清楚,数据库里面有 什么数据,能返回什么数据.前端开发只是数据的被动接受者.所以接口文档也主要是由后台来完成的,前端 只是接口文档的使用者,使用过程中,发现返回的数据不对,则需要跟后台进行商量,由后台来修改.切记前端 不要随意更改接口文档,除非在取得后台开发人员的同意的情况下.总的来讲,接口文档主要由后台来设计, 修改,前端开发者起到了辅助的作用。
829. 前端开发与后台交互的数据格式主要是什么?
主要是JSON,XML现在用的不多
830. 前端开发的后台交互原理?
在项目的时候,前后端会大概说一下接口地址,前端请求的参数,后端返回的参数,然后大家就开始 写,写的差不多的时候,大家调一下接口看一下返回的数据,没问题就可以了。
十一、技术方案精讲
831. 线上 SPA 首屏要 6 秒才能交互,让你系统性优化,你怎么做?
问题类型:性能优化类。考察有没有「先量化、再定位、后优化」的方法论,而不是上来就背「路由懒加载、CDN」。关键在于分清楚瓶颈在网络层(TTFB)、资源层(包体积)还是渲染层(JS 执行)。
怎么解决:
-
量化先行:用 Lighthouse / WebPageTest 拿到 FCP、LCP、TTI,先确认瓶颈在哪一层;同时在线上用
PerformanceObserver采样上报真实用户数据(RUM),本地快不代表用户快。 -
网络层:
- 静态资源上 CDN,开启 HTTP/2;
- gzip / brotli 预压缩(构建时直接产出
.gz/.br,Nginxgzip_static on); - 缓存策略:文件名带
contenthash,Cache-Control: public, max-age=31536000, immutable,HTML 本身不缓存。
-
资源层(包体积):
- 路由级代码分割:React 用
React.lazy+Suspense,Vue 用defineAsyncComponent; manualChunks把稳定的大依赖(vendor)单独拆出,利用长缓存;- tree-shaking:用
lodash-es、dayjs替代lodash、moment,package.json正确声明sideEffects; - UI 库按需引入,图片换 WebP/AVIF 并用
srcset按设备出图。
- 路由级代码分割:React 用
-
渲染层:
- 首屏关键 CSS 内联,非关键 JS 全部
defer; - 骨架屏替代白屏,降低用户体感等待;
- 数据接口预取:HTML 里注入首屏接口的
<link rel="preload" as="fetch">,或 SSR 时同构请求。
- 首屏关键 CSS 内联,非关键 JS 全部
-
加载时机优化:对高概率访问的下一个页面,在空闲时间预取它的 chunk:
// 场景:路由 chunk 空闲预取,避免点过去才下载 export function prefetchRoute(loader) { if ('requestIdleCallback' in window) { requestIdleCallback(() => loader()); } else { setTimeout(() => loader(), 2000); } } // 鼠标悬停导航时提前拉取下一个页面的 chunk nav.addEventListener('mouseover', () => prefetchRoute(() => import('./pages/Dashboard'))); -
如果还不够:首屏内容型页面直接上 SSR / SSG(Nuxt / Next),把白屏问题转嫁给服务端渲染解决。
有哪些坑:
- 懒加载带来「切换白屏」:首屏确实快了,但用户点进 Dashboard 才开始下载 chunk + 请求数据,二级页面体验崩了,投诉从「首屏慢」变成「页面切换慢」。
- manualChunks 拆得太碎:vendor 被拆成十几个小 chunk,HTTP/1.1 下浏览器同域 6 连接限制排队,瀑布图惨不忍睹,反而比一个包更慢。
- preload 滥用:给所有资源都加
<link rel="preload">,把首屏关键资源(LCP 图片、字体)的带宽抢占了,LCP 不降反升。 - 图片没有预留宽高:懒加载的图片加载完成后撑开布局,CLS 飙高,Lighthouse 评分没达标;只在自己电脑的光纤上验证,弱网用户毫无改善。
怎么修补:
- 高频路由做空闲预取 + hover 预取(上面代码);低频路由保持懒加载。React Router 的
React.lazy配合link的onMouseEnter触发import()即可。 - 用
rollup-plugin-visualizer/webpack-bundle-analyzer看真实体积再决定拆分粒度;HTTP/2 下小 chunk 可接受,但单个 chunk 不应小于几 KB。 preload只给首屏关键资源:字体、LCP 大图、首屏接口;其余用低优先级的prefetch或干脆不加。- 所有图片写死
width/height或aspect-ratio;上线前用 DevTools 的 Slow 4G + CPU 4x slowdown 节流验证,并看 RUM 分位数(P75)而不是平均值。
832. 一个页面要展示 10 万条数据(不分页),怎么让渲染不卡?
问题类型:性能优化类(渲染)。考察对「DOM 数量 = 性能杀手」的理解,以及虚拟滚动的原理能不能手写。10 万个节点插进去,光布局排版就要数秒,内存几百 MB——思路必须是「只渲染看得见的」。
怎么解决:
-
先反问需求:真的需要前端一次给 10 万条吗?优先争取分页、游标加载、搜索代替滚动。虚拟滚动是「需求谈不动时」的方案。
-
虚拟滚动原理(定高版,能手写):
- 外层容器固定高度、
overflow: auto; - 内层用一个 spacer 元素把高度撑到
total × itemHeight,让滚动条真实; - 监听
scroll(或IntersectionObserver),由scrollTop算出可视窗口的startIndex / endIndex,只渲染这一段 ± overscan(上下各多渲染几条);
// 场景:定高虚拟滚动核心逻辑(框架无关,React/Vue 都这样算) const itemHeight = 48; const visibleCount = Math.ceil(containerHeight / itemHeight); const overscan = 5; function onScroll(e) { const scrollTop = e.target.scrollTop; const start = Math.max(0, Math.floor(scrollTop / itemHeight) - overscan); const end = Math.min(list.length, start + visibleCount + overscan * 2); render(list.slice(start, end).map(item => // 绝对定位:item 的 top = index * itemHeight renderItem(item, item.index * itemHeight))); } - 外层容器固定高度、
-
不定高列表:预估高度先渲染,渲染后用
getBoundingClientRect()/ResizeObserver测量真实高度并缓存(heightCache),滚动定位时对缓存的前缀和做二分查找求 offset。自己写容易翻车,生产建议直接用库:Vue 用vue-virtual-scroller,React 用react-window/react-virtuoso,通用TanStack Virtual。 -
数据层同样要优化:
- 10 万条别塞进深响应式:Vue 用
shallowRef/markRaw或Object.freeze(冻结后 Vue 2 跳过响应式劫持,Vue 3 也无需深代理); - 数据用 Web Worker 做过滤 / 排序,结果 Transferable 回主线程;
- 首次插入分批:每批 500 条用
requestAnimationFrame逐步 push,避免一帧内干完卡死。
- 10 万条别塞进深响应式:Vue 用
-
框架特有补充:React 大列表 item 组件包
React.memo,避免滚动时无关行重渲染;Vue 侧注意v-for用稳定 id 作 key,不要用 index。
有哪些坑:
- 快速滚动白屏:鼠标滚轮一划几十屏,渲染追不上滚动位置,中间全是空白(俗称「fast-scroll 白屏」)。
- 不定高列表滚动条抖动 / 定位漂移:预估高度和真实高度差 accumulating,滚到一半滚动条来回跳,
scrollTop换算错位,底部永远「够不到」。 - 10 万条直接放进响应式系统:Vue 2 递归
defineProperty、Vue 3 递归 Proxy,列表还没渲染初始化就卡了几秒;React 把 10 万条放进单个 Context/state,每次更新全树 diff。 - 搜索过滤后没重置滚动位置:列表从 10 万条过滤成 30 条,
scrollTop还是 80000,页面空白,用户以为 bug。 - iOS 惯性滚动(momentum scrolling)期间不触发 scroll 之外的渲染时机,快速甩动时白屏比 PC 更明显。
怎么修补:
- 加大
overscan(移动端给 8~10),item 用transform: translate3d定位(走合成层);item 内容保持简单,复杂卡片拆成「滚动时占位 + 停止后渲染详情」。 - 不定高必须上「高度缓存 + 前缀和 + 二分查找」,或在业务允许时把 item 高度收敛为少数几档;用
react-virtuoso/vue-virtual-scroller的DynamicSize这类已经踩平坑的实现。 - 列表数据放普通数组(模块变量 /
shallowRef),渲染所需的那一小段才进响应式;10 万条本身用Object.freeze包一层。 - 过滤 / 排序等导致
list引用变化时,主动scrollTop = 0(或按记录的 key 恢复位置)。 - 白屏兜底:容器加纯 CSS 方案
content-visibility: auto+contain-intrinsic-size: 48px,让浏览器跳过屏外渲染,与虚拟滚动互补。
833. 一个表单有几百上千个字段(低代码 / 审批流场景),输入时整页卡顿,怎么设计?
问题类型:性能优化类(交互渲染)。考察「状态更新的影响范围」意识:一个输入框每敲一个字符就触发整表单重渲染,几百个字段必然卡死。方案核心是把更新范围切小。
怎么解决:
- schema 驱动:表单结构用 JSON Schema 描述,渲染器循环生成字段组件——字段类型注册、联动规则(inter dependencies)都写在 schema 里,新增字段不发版。
- 字段级组件,更新范围最小化:
- React:每个 Field 是独立受控小组件,state 放在 Field 内部(或
useDeferredValue),整表单只在提交 / 失焦时汇总;父级绝不持有「每键入都变」的全量 state; - Vue:
v-model本身就是组件级更新,天然没有这个问题,但要避免在父组件上对整个 form 对象开深层watch;
- React:每个 Field 是独立受控小组件,state 放在 Field 内部(或
- 校验降频:
- 失焦 / change 时校验单个字段,而不是每次 keypress 全表单校验;
- 输入类校验(如字数)用防抖 300ms;
- 异步校验(重名检查)用
AbortController取消上一次未完成请求,避免结果乱序覆盖。
- 数据结构扁平化:值用
{ 'a.b.0.c': value }的 path 扁平存储,避免深嵌套的深比较与不可变更新成本。 - 草稿自动保存:
requestIdleCallback+ 防抖把表单快照写进 IndexedDB / localStorage,崩溃后恢复。 - 超大表单交互降级:分步(Steps)或折叠分组,未展开的字段不渲染(React 用
React.lazy分组、Vue 用v-if+ 异步组件)。
有哪些坑:
- React 把整表单 state 放在顶层组件,每敲一个字,几百个 Field 全部 re-render,输入法都跟不上(肉眼可见的延迟)。
- Vue 里用
watch(form, handler, { deep: true })监听整个表单对象,每次键入都递归遍历上千个属性。 - 动态增删字段用
index作 key:删掉中间一行,后面所有行的数据「串位」到错误组件上,v-model 回填错乱。 - 自动保存的竞态:保存请求(旧数据)在网络里飘着,用户又改了两个字,保存完成回调把本地新数据覆盖成旧数据。
- 低代码联动写成「任何字段变化 → 全表单重算联动」,输入一个字触发几百个字段的 visible/required 重算。
怎么修补:
- Field 级独立 state +
React.memo(props 只有 path 和 onChange);或直接用react-hook-form(非受控注册,重渲染范围天然是单字段)。Vue 侧信任v-model的组件粒度,别把值全提到父级。 - 不监听整对象:watch 具体字段 path,或用 getter /
computed收敛依赖;必须整体监听时用防抖 +watchEffect明确依赖。 - key 一律用稳定业务 id(后端 id / uuid),index 只用于纯展示列表。
- 保存请求带版本号(seq),回来时比对本地版本,只有「本地没再变」才写回;或保存只写不回读。
- 联动声明式化:每个字段只声明自己依赖的字段,变更时按依赖图只重算受影响的字段(拓扑受限的 dirty 标记),而不是全表广播。
834. 设计一套前端登录态管理:token 存哪、怎么无感刷新、路由守卫怎么做?
问题类型:鉴权架构类。考察安全(存储位置、XSS/CSRF)、体验(无感刷新)、工程(拦截器、守卫)三位一体的设计能力。这是中高级前端必考题。
怎么解决:
-
双 Token 模型:
- Access Token:短寿命(30min~1h),无状态,随每个请求放
Authorization: Bearer xxx; - Refresh Token:长寿命(7~30 天),有状态(服务端可吊销),只用于换新 access。
- Access Token:短寿命(30min~1h),无状态,随每个请求放
-
存储选型(关键考点):
- Access Token 放内存(Pinia / Zustand / 模块变量),刷新页面丢失没关系,靠启动时静默 refresh 恢复;
- Refresh Token 放 HttpOnly + Secure + SameSite 的 Cookie:JS 读不到,XSS 偷不走;SameSite 顺带防 CSRF;
- 不推荐全放 localStorage——理由见坑。
-
无感刷新(响应拦截器 + 单飞):
// 场景:axios 拦截器实现 401 无感刷新(挂起并发请求,刷新成功后重放) let isRefreshing = false; let pending = []; // 刷新期间到达的 401 请求 service.interceptors.response.use( (res) => res, async (error) => { const { config, response } = error; if (response?.status !== 401) return Promise.reject(error); if (isRefreshing) { // 已有刷新在进行,把自己挂到队列,等新 token return new Promise((resolve) => { pending.push((token) => { config.headers.Authorization = `Bearer ${token}`; resolve(service(config)); }); }); } isRefreshing = true; try { const { accessToken } = await refreshTokenApi(); // refresh token 走 HttpOnly cookie 自动携带 setAccessToken(accessToken); pending.forEach((cb) => cb(accessToken)); pending = []; config.headers.Authorization = `Bearer ${accessToken}`; return service(config); // 重放首个失败的请求 } catch (e) { logout(); // refresh 也失效,彻底登出 return Promise.reject(e); } finally { isRefreshing = false; } } ); -
路由守卫:
- Vue Router:
router.beforeEach里检查to.meta.requiresAuth,未登录跳 login 并带redirectquery; - React Router v6+ 用 loader 或包裹
<RequireAuth>高阶组件; - 守卫只做「粗校验」(有没有登录态),精细鉴权交给接口层 401 拦截器兜底。
- Vue Router:
-
启动恢复:应用入口(main.tsx / main.ts)先尝试一次静默 refresh,再挂载应用,避免刷新页面即被踢出。
-
登出:清内存 token + 调服务端过期 Cookie + 调用服务端吊销 refresh token(拉黑名单),再跳登录页。
有哪些坑:
- token 全放 localStorage,被 XSS 一锅端:任何一条第三方脚本被投毒(供应链攻击)、任何一个存储型 XSS,就能把 refresh token 读走,攻击者获得最长 30 天的身份。
- 并发 401 引发重复刷新:页面并行发 5 个请求同时过期,5 个拦截器同时去 refresh;如果服务端是「刷新令牌旋转」策略(旧的 refresh 用过即作废),第 2~5 次刷新必然失败,用户直接被登出。
- 只用内存存 access token,刷新页面就丢:用户 F5 一下回到登录页,「无感」变成「有感」,运维收到一堆『是不是又登出了』的工单。
- 路由守卫只判断 token 是否存在,不看过期:token 早过期了照样放行进页面,然后所有接口 401,页面进去又弹回登录,redirect 参数还可能丢。
- 用 setTimeout 在「快过期时」主动刷新:标签页切后台定时器被浏览器节流到分钟级,用户切回来时早已过期,定时器策略形同虚设。
怎么修补:
- Refresh Token 进 HttpOnly Cookie;Access Token 只放内存,启动时(上面第 5 步)静默 refresh 恢复;再辅 CSP(限制脚本来源)降低 XSS 面积。
isRefreshing单飞 +pending等待队列(上面代码),保证任意时刻只有一个刷新请求;refresh 失败统一走 logout,不重试。- 入口先
await silentRefresh()再createApp().mount(),失败再走未登录流程;做到 F5 无感。 - 守卫里可做本地预判:解析 access token payload 的
exp(Base64 解码第二段),快过期就直接先刷新再放行;真正有效性仍由后端 401 兜底。 - 不猜过期时间,统一「401 驱动」刷新;再加
visibilitychange监听,切回前台时主动校验一次登录态。
835. 后台系统要做权限管理,精确到「某个角色能看到某个按钮」,怎么设计?
问题类型:权限模型类(工程架构 + 安全)。考察 RBAC 建模、前后端职责划分。核心考点一句话:前端权限只是体验,后端校验才是安全。
怎么解决:
-
建模 RBAC:用户 → 角色 → 权限点。权限点用
资源:动作编码规范,如order:export、user:delete;一个用户多角色时权限取并集。 -
数据来源:登录后(或单独接口)返回
{ roles, permissions: ['order:export', ...] },存入全局 store;菜单可以由后端直接下发(推荐,改菜单不发前端版),也可以前端全量配置 + 按 permission 过滤。 -
路由级权限:
- 静态注册 + 守卫校验
to.meta.permission(简单); - 或登录后根据 permissions 动态
addRoute注册(菜单完全由数据驱动)。
- 静态注册 + 守卫校验
-
按钮级权限,双栈实现:
// 场景:React 通用权限组件 export function Auth({ permission, children, fallback = null }) { const has = usePermission(permission); // 从 store 读 return has ? children : fallback; } // 使用:<Auth permission="order:export"><Button>导出订单</Button></Auth>// 场景:Vue 自定义指令 v-permission(直接移除 DOM,而非隐藏) app.directive('permission', { mounted(el, binding) { if (!store.state.permissions.includes(binding.value)) { el.parentNode?.removeChild(el); } }, }); -
接口级兜底:所有接口 403 统一拦截提示「无权限」;菜单 / 按钮被隐藏,但直接调接口的越权由后端中间件拦截。
-
权限点治理:权限 code 用常量枚举集中管理(前后端共用一份 JSON/TS 文件),避免魔法字符串散落。
有哪些坑:
- 只藏按钮不校验接口:用户打开 DevTools 直接
fetch('/api/order/export', { method: 'POST' })就越权导出了——前端隐藏只是 UX,黑盒工具(curl / Postman)完全绕过。 - 前端按角色名硬编码:模板里写
v-if="role === 'admin'",新加一个「运营主管」角色时所有页面要改代码发版,权限矩阵失控。 - 动态路由只注册一次:用户 A 登录注册了 A 的路由,退出换用户 B 登录,路由表残留 A 的路由(或重复注册告警),B 能直接输 URL 进 A 才有的页面。
- v-permission 用
display: none实现:DOM 还在,用户 F12 改一行 CSS 按钮就「复活」了,顺手就点了。 - 按钮级权限粒度太细,权限点爆炸:每个按钮一个 code,半年后几千个权限点没人说得清含义,配置管理员摆烂直接发 admin。
怎么修补:
- 后端每个接口强制鉴权(中间件统一做,按接口声明的 permission 校验);前端 403 兜底提示。安全边界永远在服务端。
- 前端一律判断 permission code,不判断角色;角色只是权限的集合,角色变更不影响前端代码。
- 登录 / 登出时
router.addRoute前先 resetRouter(移除所有动态路由),每个用户的路由表按其权限现场重建。 - 指令实现直接
removeChild移除 DOM(上面代码);或用组件式渲染层判断(has ? children : null),DOM 里根本没有。 - 权限点分层:页面级(粗)、操作级(细)两级;给权限点加「归属模块 + 描述」的元信息管理,定期清理无引用的 code(用 ESLint 规则 / 脚本扫描代码中的常量引用)。
836. 前后端分离项目接口跨域了,有哪些方案?怎么选型?
问题类型:浏览器安全 / 网络类。考察对同源策略、CORS 预检机制的理解,以及「开发环境和生产环境是两回事」的工程意识。
怎么解决:
-
先讲清原理:跨域是浏览器同源策略的限制,协议 / 域名 / 端口任一不同即跨域;请求其实发出去并被服务端处理了,只是响应被浏览器拦截。所以任何「纯前端解决跨域」的方案本质都是绕开「跨域的响应」。
-
开发环境:devServer 反向代理(Node 服务转发,浏览器只看到同源请求):
// 场景:Vite / webpack 开发代理(生产环境无效!) // vite.config.js export default { server: { proxy: { '/api': { target: 'https://backend.example.com', changeOrigin: true, }, }, }, }; -
生产环境主流方案:
- Nginx / 网关反向代理,前后端统一域名(
/走静态资源,/api转发后端)——首选,根本不存在跨域; - CORS:后端 / 网关返回
Access-Control-Allow-Origin(白名单回显具体域名)、-Methods、-Headers;带 cookie 时再加Allow-Credentials: true,前端 axios 设withCredentials: true(fetch 用credentials: 'include'); - JSONP(历史方案):利用
<script>不受同源限制,只能 GET,需要后端配合拼callback(...)响应,现在基本只作为「知其然」考点。
- Nginx / 网关反向代理,前后端统一域名(
-
特殊场景:
postMessage(跨窗口 / iframe 通信)、img打点(单向)、WebSocket(不受同源策略限制,但有自己的校验)。 -
选型口径:内网后台 → 反代同源;开放 API 多域名 → CORS 白名单;遗留系统只支持 JSONP → 包一层 BFF。
有哪些坑:
- 带 cookie 时
Allow-Origin: *直接失效:withCredentials: true的请求遇到通配符*,浏览器直接拒绝,且报错只在「已登录带 cookie」的请求上出现——联调时没人登录,根本发现不了,上线后才炸。 - 自定义 header 触发预检,后端没处理 OPTIONS:
Authorization、X-Requested-With这类头让请求变成「非简单请求」,先发OPTIONS预检;后端没配,返回 404/405,预检失败,真实请求根本不发出去。新手以为「GET 怎么也跨域了」。 - 开发用 proxy 一切正常,生产全挂:proxy 只是 devServer 的能力,打包后的静态文件没有 Node 服务帮你转发,而团队忘了在生产 Nginx 配
/api转发。 - Nginx 的
add_header在非 200 响应不生效:后端返回 500 时响应没有 CORS 头,浏览器把「服务端报错」误报成「跨域错误」,排查方向被带偏半天。 - JSONP 的 callback 参数不校验:攻击者构造
callback=alert(1)//之类的注入,响应变成可执行脚本,造成 XSS。
怎么修补:
- 带凭证时 Origin 必须回显具体域名(服务端维护白名单),不能用
*;Allow-Credentials: true同步开启。 - 网关统一拦截
OPTIONS:直接回204+ CORS 头,并设Access-Control-Max-Age: 86400让浏览器缓存预检结果,减少往返。 - 把「生产环境的跨域方案」写进部署清单:要么 Nginx
location /api反代,要么网关配 CORS;CI 里加一条冒烟测试(对生产域名发一个带凭证的预检请求)。 - Nginx 的 CORS 头加
always后缀:add_header Access-Control-Allow-Origin $cors_origin always;,保证 4xx/5xx 也带头,错误能被正确归因。 - callback 白名单校验(
/^[\w.]+$/);新项目直接禁用 JSONP,用 CORS。
837. 要上传 2GB 的大文件,要求支持断点续传、失败重试、最好能秒传,方案怎么设计?
问题类型:可靠性保障类(网络)。考察分片上传全链路设计,以及「重活不进主线程」的意识。这是场景题里最成体系的一道,答好了非常加分。
怎么解决:
-
整体流程: 选文件 → Web Worker 计算文件 hash(spark-md5 增量计算)→ 调
/upload/init带指纹(若服务端已有同 hash 完整文件则秒传;若有未完成任务则返回已上传分片列表)→ 前端跳过已传分片,并发池上传其余分片(FormData,单片失败指数退避重试)→ 全部完成后/upload/complete通知服务端流式合并。 -
hash 放 Worker:File 对象可以直接 postMessage 给 Worker(引用级传递),Worker 里
FileReader逐片读 +SparkMD5.increment,主线程零卡顿;超大文件可先「首片 + 尾片 + size」做指纹探测秒传,再决定是否全量 hash。 -
分片上传 + 重试:
// 场景:单片上传,FormData 携带索引,失败指数退避重试 async function uploadChunk({ uploadId, index, blob }, retry = 3) { const form = new FormData(); form.append('uploadId', uploadId); form.append('index', String(index)); form.append('file', blob); // 注意:文件在 FormData 里,不在 JSON body 里 for (let i = 0; i < retry; i++) { const res = await fetch('/upload/chunk', { method: 'POST', body: form }); if (res.ok) return res.json(); if (res.status >= 400 && res.status < 500) throw new Error('不可重试错误'); await new Promise((r) => setTimeout(r, 2 ** i * 500)); // 500ms/1s/2s } throw new Error(`分片 ${index} 上传失败`); } -
并发控制:并发池限 3~6 个分片;进度 = 已完成分片数 / 总分片数;
AbortController支持暂停 / 取消。 -
直传 OSS(云存储):后端只签发 STS 临时凭证或 PostObject 签名,前端拿签名后直传 OSS,分片流量完全不经过业务服务器;上传完成由 OSS 回调 / 前端通知后端登记。
-
服务端配合:
/upload/init记录任务与已收分片;/upload/complete用流(createReadStream顺序pipe)合并,校验总大小 / hash。
有哪些坑:
- 在主线程对 2GB 文件算 MD5:页面直接冻结十几秒,连 loading 动画都停了,用户以为崩溃直接刷新,前功尽弃。
- 并发不限制:一次性发出几百个分片请求,HTTP/1.1 下同域只有 6 个 TCP 连接,连刷新 token 的请求都被排队饿死,整站「网络瘫痪」。
- 文件指纹用
name + size + lastModified:用户把 A 文件改名成 B 文件的名字,秒传直接返回了 B 的内容(脏数据);反过来同名同大小不同内容也会误判。 - 断点续传只存 localStorage:换浏览器 / 无痕模式 / 清缓存后本地记录全丢;而且文件在续传间隔里被改过,本地记录的分片已经是脏的。
- 直传 OSS 忘了配 CORS 和 STS 过期:浏览器对 OSS bucket 的 POST 被 CORS 拦截;或大文件传到一半 STS 临时凭证(通常 1 小时)过期,后面全部分片 403。
- 服务端合并时把所有分片读进内存再拼:2GB 文件直接把 Node 进程 OOM 杀掉。
- FormData 用错了:把分片塞进 JSON body(
JSON.stringify一个 Blob 只会得到{}),服务端收到的 file 字段是空的——文件必须在 multipart 的 FormData 里。
怎么修补:
- hash / 切片全部进 Web Worker;超大文件先「抽样指纹」探秒传,命中就免全量 hash;UI 上把「计算指纹」做成独立进度阶段。
- 并发池限 3~6(上面方案),并给上传通道与业务 API 用不同子域(或 HTTP/2 多路复用)避免连接争抢。
- 指纹以内容 hash(MD5/SHA-1)为准,
init时 hash + size 双重匹配才秒传;name 只做展示。 - 续传的权威记录在服务端(init 返回已传分片),localStorage 只做加速缓存;续传前先重新校验文件 hash 未变。
- OSS 控制台给 bucket 配 CORS(PostObject);STS 过期前(如剩余 10 分钟)主动刷新凭证,收到 403 时重新签名再重试当前分片。
- 合并用流式追加(
appendFileSync逐片 /createReadStreampipe),边合边删临时分片。 - 团队约定 + 代码评审检查:凡带文件的请求一律
FormData,并把这段写进请求层封装的注释。
838. 线上出了 JS 报错用户投诉才知道,让你设计一套前端错误监控上报,怎么做?
问题类型:稳定性保障类(可观测性)。考察错误分类采集是否完整、上报通道是否可靠、以及「压缩后的堆栈怎么还原」这类工程细节。
怎么解决:
-
采集面要全:
window.addEventListener('error', ..., true):捕获阶段能同时拿到 JS 运行时错误和资源加载失败(e.target instanceof HTMLImageElement之类区分 img/script/link);unhandledrejection:兜住所有没 catch 的 Promise;- 接口错误:封装层统一记录(fetch 包装 / axios 拦截器,记 status、耗时、url);
- 框架兜底:React 用 ErrorBoundary(componentDidCatch),Vue 用
app.config.errorHandler,否则组件渲染错误可能吞掉事件; - 行为回放线索(breadcrumb):最近 N 次点击、路由变化、请求,随错误一起上报。
-
上报通道:
// 场景:错误上报,sendBeacon 优先(页面卸载不丢),fetch keepalive 兜底 function report(error) { const payload = JSON.stringify({ message: error.message, stack: error.stack?.split('\n').slice(0, 5).join('\n'), // 只取前几行,省体积 url: location.href, ua: navigator.userAgent, ts: Date.now(), }); if (navigator.sendBeacon) { navigator.sendBeacon('/monitor/error', new Blob([payload], { type: 'application/json' })); } else { fetch('/monitor/error', { method: 'POST', body: payload, keepalive: true }); } } -
source map 还原:构建时生成 sourcemap 并上传到监控平台,不随静态资源发布(对公网关闭
.map访问),平台用 map 把压缩后的行列号还原为源码位置。 -
聚合与告警:按
message + stack 首行做指纹聚合成 issue;告警指标用「错误率 = 错误数 / PV」而非绝对数,设阈值(如 > 1%)分级别通知。 -
自研 or 采购:中小团队直接 Sentry(开源可自建),把上面 1~4 全吃掉;有定制需求(合规、私域)再自研采集端,后端复用 ClickHouse / ES 聚合。
有哪些坑:
- CDN / 跨域脚本只报
Script error.:堆栈、行号全部拿不到,因为是跨域脚本,浏览器同源策略屏蔽了错误详情——监控上线第一天就发现一半错误没法定位。 - 没存 sourcemap(或 map 暴露在公网):压缩后的
a is not defined在第 1 行第 83921 列,没人能定位;反过来把 map 部署到线上等于把源码开源。 - 监控 SDK 自己请求失败又抛错:上报接口 500,SDK 的 catch 里再上报,又 500……无限循环,一晚上刷出几十万条垃圾日志,还可能把服务端打挂。
- 同一错误每个 PV 都记一条 + 绝对数告警:一次发版引入小 bug,早高峰直接万级告警轰炸;或者大促流量涨 5 倍,错误率没变但绝对数翻阈值,全员半夜被叫起来看「事故」。
- 页面卸载阶段的错误用普通 XHR 上报:浏览器直接 cancel 掉,「白屏了但一条日志都没有」。
- 只监控 window.onerror:Promise 链里 reject 没 catch、async 函数抛错,window.onerror 根本收不到,线上静默失败。
怎么修补:
- 第三方/CDN 脚本加
crossorigin="anonymous",其响应带Access-Control-Allow-Origin,即可拿到完整堆栈。 - 构建流水线:产出 map → 上传监控平台(sentry-cli / 自研脚本)→ 删除 dist 里的 map 再发布;线上 Nginx 对
*.map返回 403。 - SDK 的上报代码包 try-catch,失败只 console;对上报域名做黑名单过滤(自身错误不再上报自身)。
- 服务端按指纹去重聚合成 issue(同指纹只记 PV 数);告警用错误率 + 环比突增,单 issue 限频(如每小时最多提醒一次)。
- 卸载阶段统一
sendBeacon/fetch keepalive(上面代码);监听pagehide而非unload(移动端unload不保证触发)。 unhandledrejection全局兜底 + ESLint 规则 / Code Review 强制 async 调用链有 catch;两个钩子都必须上,缺一不可。
839. 产品要求全站埋点(点击、曝光、PV),怎么设计不拖垮业务的埋点体系?
问题类型:数据采集类(工程 + 性能)。考察埋点模型设计、以及「埋点不能伤害业务性能」的边界意识。
怎么解决:
-
事件模型统一:
{ trackId, properties, userId, sessionId, ts, channel };trackId 全局唯一管理(枚举常量),properties 用 JSON 但字段有 schema 约束,不然数仓同学会提刀来见。 -
三种埋点方式分层:
- 全埋点(无痕):自动采集 PV、点击、性能——覆盖率广但语义弱;
- 代码埋点:关键转化(下单、支付)手动埋——语义准确;
- 可视化埋点:运营圈选,适合营销页。
-
采集实现要点:
- 点击全埋点:document 级事件委托,读
data-track-id属性,不需要每个按钮绑事件; - 曝光:用
IntersectionObserver(可见比例 ≥ 50% 且停留 ≥ 500ms 才算曝光),不要监听 scroll; - SPA 的 PV:劫持
history.pushState / replaceState+ 监听popstate / hashchange,路由变化即 PV;
// 场景:SPA 路由 PV——原生 history API 不会触发任何事件,必须补丁 const rawPushState = history.pushState; history.pushState = function (...args) { rawPushState.apply(this, args); window.dispatchEvent(new Event('track:route-change')); }; window.addEventListener('popstate', trackPageView); window.addEventListener('track:route-change', trackPageView); - 点击全埋点:document 级事件委托,读
-
上报策略:本地队列攒批(50 条或 5s flush);优先
navigator.sendBeacon(卸载不丢),需要自定义 header 的用fetch keepalive;失败落 IndexedDB,恢复网络后重传。 -
不拖垮业务:SDK 异步动态
import()加载、requestIdleCallback初始化;上报域名与业务 API 分离,避免争抢连接;埋点调用全部 try-catch,埋点挂了不能影响页面。
有哪些坑:
- sendBeacon 的 Content-Type 限制:它的 body 不能带
Content-Type: application/json的正式声明(部分网关 / 框架直接解析失败),也不能设置任何自定义 header(比如鉴权头),后端一直收不到或解析为空。 - SPA 只有首屏一个 PV:传统 PV 靠 unload,SPA 路由切换不刷新页面,数据看起来「人均 1 页」,转化漏斗全是断的。
- 埋点 SDK 同步打包进主 bundle:首屏多出 200~300KB,埋点把 LCP 优化成果全部吃回去,性能团队和数据团队打架。
- 曝光埋点用 scroll 监听 + getBoundingClientRect:滑动时每秒几十次回调 + 强制布局(layout thrashing),长列表页直接掉帧。
- 卸载时用同步 XHR flush:浏览器取消请求,支付成功页的转化埋点丢了一半,大促复盘数据对不上。
- 弱网 / 断网直接丢事件:地铁里浏览的用户行为全部蒸发,渠道投放 ROI 算错。
怎么修补:
- sendBeacon 用
Blob且 type 与后端约定(或干脆text/plain),后端按原始 body 解析;必须带 header 的场景改fetch(url, { keepalive: true })。 - 劫持 pushState/replaceState + popstate/hashchange 三件套统一触发 SPA PV(上面代码)。
- SDK 独立异步 chunk + 采样(长尾事件采 10%),首屏关键事件才全量;SDK 体积纳入 size-limit 卡口。
- 曝光全部
IntersectionObserver,阈值与停留时长满足才上报,observer 记得 disconnect 复用。 pagehide / visibilitychange(hidden)时统一sendBeaconflush(不要依赖 unload)。- 队列本地持久化(IndexedDB),
navigator.onLine+ online 事件恢复重传;给每条事件加客户端生成的事件 id,服务端幂等去重防重复入库。
840. H5 要在千奇百怪的安卓 iOS 设备上还原设计稿,你的移动端适配方案是什么?
问题类型:布局适配类。考察 viewport / rem / vw 的原理差别,以及真机上那些「只有踩过才知道」的系统行为。
怎么解决:
-
viewport 基线:
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">;viewport-fit=cover是使用安全区的前提。 -
布局单位方案(选一种为主):
- vw 方案(当前主流):postcss-px-to-viewport 把设计稿 px 自动转 vw,1vw = 视口宽 1%,天然随屏缩放,无需 JS;
- rem 方案:动态设置根字号 + postcss-pxtorem;
// 场景:rem 方案的动态根字号(375 设计稿,1rem = 16px) function setRem(baseWidth = 375, baseRem = 16) { const w = document.documentElement.clientWidth; document.documentElement.style.fontSize = (w / baseWidth) * baseRem + 'px'; } setRem(); window.addEventListener('resize', setRem); window.addEventListener('orientationchange', setRem);- 弹性布局兜底:flex / grid +
min()/max()/clamp()做流式区间,而不是所有元素都随屏等比缩。
-
断点响应:>= 768px(iPad / 折叠屏)切平板布局或响应式栅格,而不是把手机页等比拉大成「大号手机」。
-
细节三件套:
- 1px 边框:
transform: scaleY(0.5)伪元素或border: 0.5px(iOS 支持); - 安全区:
padding-bottom: env(safe-area-inset-bottom); - 高清图:
srcset/<picture>按 DPR 出 2x/3x。
- 1px 边框:
-
软键盘处理:监听
visualViewport的 resize,输入框聚焦时滚动到位,避免键盘顶起布局。 -
禁止转屏乱套:
orientationchange后重算布局(rem 方案),或用媒体查询给横屏单独样式。
有哪些坑:
user-scalable=no+ 输入框字号小于 16px:iOS 聚焦输入框时浏览器自动放大页面且无法缩回,页面错乱;而禁止缩放本身还有可访问性问题。100vh在 iOS Safari 是「大 vh」:它按地址栏收起前的高度算,页面底部按钮被地址栏挡住,滚动时页面还会跳动。- rem 方案只监听 resize:分屏 / 折叠屏展开 / 某些 WebView 中 resize 不触发或时机滞后,根字号没更新,布局停留在旧宽度;微信等 WebView 的「强制字体缩放」还会覆盖根字号。
- 刘海屏没留安全区:内容顶进状态栏挖孔,返回按钮被吃掉。
- iPad 上被当成大手机:整页 vw 等比放大,一行只显示 3 个巨型卡片,浪费空间且滑稽。
怎么修补:
- 允许缩放(去掉 user-scalable=no),把输入框
font-size提到 ≥ 16px 规避聚焦自动放大;要禁双击缩放用touch-action: manipulation。 - 用
100dvh(动态 vh,iOS 15.4+ / 现代 Chrome)+@supports回退到-webkit-fill-available;底部固定条改position: sticky布局在文档流尾部。 - resize + orientationchange 都重算,且用
document.documentElement.clientWidth(排除滚动条);加-webkit-text-size-adjust: 100%防 WebView 文本缩放。 viewport-fit=cover+env(safe-area-inset-*)常量化到公共样式变量里,底部操作条统一引用。- 明确断点策略:手机等比适配(vw/rem),>= 768px 切换布局结构(栅格列数、侧边栏),用
<picture>/ 媒体查询切换资源。
841. 应用要支持暗黑模式和多主题(品牌换肤),怎么设计一套不闪烁、可切换的主题系统?
问题类型:体验 / 样式架构类。考察 CSS 变量的架构能力,以及 FOUC(样式闪烁)这个经典暗坑。
怎么解决:
-
CSS 变量做主题层:颜色绝不能硬编码,统一走变量;
:root { --bg: #fff; --text: #222; --primary: #1677ff; } [data-theme='dark'] { --bg: #111; --text: #eee; --primary: #4096ff; } /* 品牌主题同理:[data-brand='b'] 覆盖另一组变量 */ -
三态模型:用户选择 =
light | dark | system;选 system 时跟随matchMedia('(prefers-color-scheme: dark)'),并监听其 change 事件实时切换;用户显式选择后存储并优先于 system。 -
防闪烁(关键):在 head 里、所有 CSS 之前放一段阻塞的内联脚本,先定主题再渲染:
<!-- 场景:head 第一行内联脚本,先于渲染确定主题,避免暗色用户看到白色闪屏 --> <script> (function () { var saved = localStorage.getItem('theme') || 'system'; var dark = saved === 'dark' || (saved === 'system' && matchMedia('(prefers-color-scheme: dark)').matches); document.documentElement.dataset.theme = dark ? 'dark' : 'light'; })(); </script> -
双栈实现:Vue 直接用 VueUse 的
useDark/useToggle;React 用next-themes(Next)或自己封装同逻辑的 hook;切换只改documentElement上的data-theme。 -
配套同步:
<meta name="color-scheme" content="light dark">+ CSScolor-scheme属性(让表单控件、滚动条跟着变);theme-colormeta 同步状态栏颜色;图表(ECharts)按主题重新 setOption;图片 / logo 用<picture>或 CSS 变量切换暗色专用资源。 -
动画:给
body加transition: background-color .2s, color .2s(只限颜色属性)。
有哪些坑:
- 首屏闪烁(FOUC):主题脚本放在 body 底部或外链 JS 里,暗色用户每次刷新都先白屏一闪再变黑,「闪瞎眼」是暗黑模式差评第一名。
- 只改背景色,没设
color-scheme:input、select、滚动条、autofill 高亮还是白的,暗色页面里嵌着几个刺眼的白控件。 - 把「跟随系统」做成两态:只有 light/dark 两个选项,用户选了 light 后系统切到暗色,应用还固执地亮着(或反之),需求理解错了三态语义。
- 暗色下的图片 / 透明底 PNG:白底的截图在暗色页面上是一块刺眼的白板;品牌 logo 的透明底在暗色下变成黑块。
- 切换时用
transition: all:整页所有属性参与过渡 + 全页重绘,切主题瞬间掉帧、滚动卡顿。
怎么修补:
- 阻塞内联脚本放 head 第一行(上面代码),localStorage 读取 +
data-theme设置必须发生在首次绘制前。 - CSS 里声明
:root { color-scheme: light }、[data-theme='dark'] { color-scheme: dark },meta 也同步;表单控件随即跟随。 - 存储三态
theme = light | dark | system,只有 system 才绑matchMedia监听;切换组件用三段式(含「跟随系统」选项)。 - 暗色专用资源:
<picture><source media="(prefers-color-scheme: dark)">或[data-theme=dark] .logo { filter: invert(1) }/ 换图;图表初始化时传入主题并在切换时重建。 - transition 白名单只列
background-color / color / border-color,时长 200ms 左右;大面积视觉变化的组件(地图)不做过渡直接切。
842. 单页应用(SPA)的内容 Google 收录很差,SEO 怎么救?
问题类型:渲染架构类。考察对 CSR/SSR/SSG 取舍的理解,以及「hash 路由不能 SEO」这类架构级硬伤。
怎么解决:
- 先反问:这是后台系统还是内容站?后台系统根本不需要 SEO,别过度设计;内容站(资讯、电商详情、博客)才值得做。
- 渲染方案分级:
- SSR(Nuxt / Next / Remix):内容动态、实时性强(商品页、搜索结果),服务端输出完整 HTML;
- SSG:内容构建时已知(博客、文档),构建时生成静态 HTML,CDN 直发,最快;
- 预渲染(prerender /
vite-plugin-prerender):老 CSR 项目里少量营销页的低成本补救; - 动态渲染(按 UA 给爬虫单独的 HTML)已是过时方案,只作为「知道但不推荐」提及。
- SPA 自身必须改的:
- 放弃 hash 路由,换 history 路由,服务端把所有路径 rewrite 到 index.html;
- 每页独立的 title / description / OG 标签(Nuxt
useSeoMeta、Next Metadata、SPA 用react-helmet/usehead); - canonical 防重复收录;sitemap.xml 动态生成并提交;robots.txt 放行内容页。
- 结构化数据:页面注入 JSON-LD(Product / Article / BreadcrumbList),争取富摘要。
- 语义化与性能:h1~h6 层级、
<main>/<nav>/<article>;Core Web Vitals(LCP/CLS)本身是排名因素——又回到 Q1。 - 框架差异:Nuxt / Next 都提供混合渲染(每路由独立选 SSR/SSG/ISR),按页面类型分别配置,不必全站一刀切。
有哪些坑:
- hash 路由整个站只收录一个首页:爬虫不把
#/detail/1的 fragment 当不同 URL,几万个详情页在搜索引擎眼里都是同一个地址。 - meta 全靠客户端 JS 改:爬虫抓取时机和浏览器渲染时机对不齐,经常抓到的是模板里那句写死的默认 title;分享到社交软件的卡片也一直是默认图。
- SSR 水合(hydration)不一致报错:服务端渲染用了
Date.now()、Math.random()、window判断,客户端水合时结构对不上,React 直接卸载整棵树重新渲染,白屏一闪,SEO 分也没了。 - SSR 输出不了登录态个性化内容:服务端拿不到用户 cookie 之外的数据,首屏先渲染「请登录」,客户端再闪成用户昵称,爬虫抓到的是未登录版,真实用户看着也难受。
- SSG 硬套动态路由:10 万个详情页都要构建时静态化,构建从 5 分钟涨到 3 小时,发版窗口全占满。
怎么修补:
- 迁移到 history 路由 + 服务端 rewrite(
try_files $uri /index.html);老 URL 做 301 跳转保权重。 - SEO 关键内容(title、meta、正文首屏)由服务端输出;SPA 场景用 head 管理库并保证首屏 HTML 模板包含兜底 meta。
- 时间 / 随机数 / 浏览器 API 全部移到客户端钩子里取(React
useEffect、VueonMounted);确实无法对齐的节点局部标记suppressHydrationWarning。 - 个性化内容 CSR 兜底:SSR 输出公共内容 + 占位骨架,登录态在客户端补;对爬虫而言公共内容已完整。
- 动态路由改 SSR 或 ISR(增量静态再生成,Next 的
revalidate/ Nuxt 的 routeRules),只构建热点页,长尾按需再生成;构建产物按路由分片缓存。
843. 单体前端应用几百个页面、多个团队一起改,冲突严重,要不要拆微前端?怎么拆、公共依赖怎么共享?
问题类型:工程架构类。考察微前端的适用边界(不是所有项目都该拆)、沙箱与样式隔离、共享依赖与版本治理。答「先问要不要拆」是加分起点。
怎么解决:
- 先判断该不该拆:拆的信号——多团队并行发版互相阻塞、单体构建超过 10 分钟、不同模块技术栈要分头演进。只是「目录乱」用 monorepo + 模块化就够了,微前端是重武器,有通信 / 隔离 / 样式一堆新成本。
- 拆分粒度:按业务域 + 团队边界拆(交易域、履约域、客服域),不是按页面数量越细越好;基座(shell)只负责登录态、菜单、路由分发和全局布局。
- 技术选型:
- qiankun:基于 single-spa,JS 沙箱(proxy 快照)+ 样式隔离(Shadow DOM / scoped),社区最成熟;
- micro-app(WebComponent 风格)、wujie(iframe + proxy,天然隔离最彻底);
- Module Federation:构建层共享模块,适合「同技术栈想共享代码」而非「跨团队独立部署」。
- 公共依赖共享:
- 框架层(react / react-dom / vue)声明
shared: { react: { singleton: true, requiredVersion: '^18' } },基座与子应用共享同一实例——既省体积,又保证 context / hooks 跨应用可用; - 或统一 externals + CDN 由基座注入全局变量;
- 组件库(@company/ui)按 minor 版本对齐,shared 配 eager 兼容。
- 框架层(react / react-dom / vue)声明
- 路由:基座统一持有路由,子应用按
activeRule前缀挂载(/trade/**→ 交易应用);Vue 子应用由基座把base传进去,React Router 传basename。 - 通信:克制——props 下发(基座 → 子应用)、CustomEvent 事件总线、极少量共享状态(只放用户信息 / 主题);严禁子应用互相 import。
- 部署:每个子应用独立仓库、独立 CI、独立发版;
remoteEntry.js(或子应用入口)由 manifest / 版本接口管理。
有哪些坑:
- 样式互相污染:子应用的全局样式(
body { font-size: 12px }、reset.css)污染基座和其他子应用;反过来基座的 less 全局变量渗透进子应用,两个应用的按钮样式忽对忽错。 - Shadow DOM 隔离又引入新问题:element-ui / antd 的弹窗(MessageBox、Select 下拉)默认挂到
document.body,逃出 Shadow DOM 后丢样式,下拉菜单变成无样式裸奔。 - 公共依赖没共享:每个子应用各自打包一份 React + 组件库,首屏加载了 3 份 200KB+;或者反过来 shared 没配
singleton,两个 React 实例导致 hooks 报「Invalid hook call」。 - 子应用污染 window 且卸载不清理:子应用直接挂
window.xxx、改document.title、往 body 塞节点,切换后残留,下一个子应用读到脏数据(沙箱逃逸)。 - 路由互相打架:两个子应用都劫持了 history / popstate,或 basename 没由基座注入而是写死,直接跳转拼错前缀,来回重定向死循环。
- remoteEntry 被强缓存:入口文件名不带 hash 且
Cache-Control很长,子应用发版后基座还在加载旧入口,「发布成功了但线上没变化」,排查一下午。
怎么修补:
- 样式:子应用一律 CSS Modules / scoped / 前缀(postcss-prefix);qiankun 开
sandbox: { experimentalStyleIsolation: true }(scoped 方案,不用 Shadow DOM);弹窗类组件统一配置挂载回应用容器内(antdgetPopupContainer)。 - 依赖:
shared+singleton: true+requiredVersion区间,基座与子应用锁定同一主版本;构建分析里出现多份框架时 CI 直接报警。 - 子应用严守沙箱:全局变量通过 props / 通信层拿;
unmount生命周期里清理定时器、事件监听、DOM 残留;qiankun 用 strict 沙箱模式兜底。 - 路由前缀强约定(子应用路径 =
/{appName}/...),base 由基座在 mount props 里下发,子应用内不写死;popstate 只由基座监听再分发。 - 入口文件短缓存(或
no-cache),真正带 hash 的是它引用的 chunk;发版后由 manifest 接口 / 版本号通知基座拉新入口,必要时提示用户刷新。
844. 业务要求弱网 / 断网时应用还能浏览和下单,怎么做离线可用(PWA)?
问题类型:可用性保障类(缓存架构)。考察 Service Worker 的缓存策略矩阵,以及「发版后用户被锁在旧版本」这个 PWA 最著名的事故。
怎么解决:
-
Service Worker 基础:HTTPS(或 localhost)下
navigator.serviceWorker.register('/sw.js');SW 在 install 预缓存 App Shell(HTML 骨架 + 关键 CSS/JS),fetch 事件里按资源类型分流。 -
缓存策略矩阵(核心考点,按资源分别配):
资源 策略 理由 HTML 导航请求 NetworkFirst(失败回缓存) 保证拿到新版本,离线兜底 带 hash 的静态资源 CacheFirst + immutable 内容寻址,永不过期 GET 接口(列表类) StaleWhileRevalidate 秒开旧数据,后台更新 实时性接口(库存 / 价格) NetworkFirst + 超时回缓存 宁可慢不可错 写操作(POST / 下单) 永不缓存,离线进队列 见第 4 点 -
用 Workbox 实现:
precacheAndRoute(self.__WB_MANIFEST)+registerRoute按正则 / 域名匹配策略,别裸写 SW(裸写的更新 / 清理逻辑极易出 bug)。 -
离线写操作:POST 下单进 IndexedDB 队列,
Background Sync API(注册 sync,网络恢复时 SW 里重放);重放请求必须带幂等键(衔接 Q15)。 -
版本更新:
skipWaiting()+clients.claim()让新 SW 立即接管,配合页面提示条「新版本可用,点击刷新」;新 SW 激活时caches.keys()清理旧版本缓存(按版本号前缀)。 -
配套:manifest.json(name / icons / display: standalone)支持「添加到主屏」;专门做一个离线兜底页(offline fallback)。
有哪些坑:
- HTML 也配了 CacheFirst:发版后用户永远打开旧入口、旧入口引用的旧 chunk,「发布十次线上纹丝不动」,直到用户手动清缓存——PWA 第一大事故。
- 更新了 sw.js 但没 skipWaiting:新 SW 一直在 waiting,要等所有旧页面标签关闭才激活,用户第二天回来才用上新版,产品怀疑你没发。
- 把带鉴权的接口响应缓存进 Cache Storage:换账号登录后,第二个用户看到了上一个用户的订单列表——隐私事故,比不可用严重得多。
- 离线时 POST 直接失败:表单填了十分钟,提交时断网,数据全丢,用户当场卸载。
- iOS Safari 的 PWA 支持短板:早期不支持 Push、Web Share 限制多、WebKit 会清理 7 天未使用的站点数据,把离线缓存悄悄删了。
- Cache Storage 配额溢出:视频 / 图片缓存几十 GB,超出配额后
cache.put静默失败,没有任何报错,离线功能悄悄失效。
怎么修补:
- 导航请求(HTML)一律 NetworkFirst,并把
install时的预缓存清单限制为 App Shell 而非全部页面;新 HTML 拿到后顺带预热其引用的关键资源。 - 更新流程:SW 检测到 bytes different →
self.skipWaiting()+clients.claim(),页面监听controllerchange弹「立即刷新」提示条,用户主动刷新(不打断正在填写的表单)。 - 含
Authorization的响应不缓存,或缓存键里拼上用户 id 分区;登出时清空全部 caches + IndexedDB 队列。 - 写操作进 IndexedDB 队列 + Background Sync 重放,提交时生成幂等键随请求带上,服务端去重;UI 上明确标记「离线已暂存,联网后自动提交」。
- 特性检测渐进增强:iOS 上降级为「仅离线浏览 + 提示加到主屏」;关键写操作提示用户当前网络不可用,而不是假装成功。
- 定期
navigator.storage.estimate()检查配额,LRU 清理(Workboxexpiration插件配 maxEntries / maxAgeSeconds);调用navigator.storage.persist()申请持久存储降低被清理概率。
845. 用户双击提交按钮重复下了两单,怎么防止重复提交?说说幂等设计。
问题类型:数据一致性类(可用性保障)。考察前端防御 + 后端幂等的双层设计,以及「防抖 ≠ 防重」的概念辨析。这道题答得出幂等键,基本就到高级了。
怎么解决:
-
前端第一层:状态锁:
- 提交函数入口检查
submitting标志,请求期间loading = true且按钮disabled; - 注意:提交场景用状态锁,不要用防抖(辨析见坑);防抖只适合搜索输入这类「以最后一次为准」的场景。
- 提交函数入口检查
-
请求层第二层:
- 可安全中断的重复请求(搜索、GET):用
AbortController取消上一次; - POST 不做 abort 中断(abort 只是放弃等待响应,服务端照样处理),靠锁 + 幂等。
- 可安全中断的重复请求(搜索、GET):用
-
幂等键(核心):
- 进入填写页 / 打开弹窗时生成一次
requestId = crypto.randomUUID(); - 提交时随表单带上(header
X-Idempotency-Key或 body 字段); - 服务端用 Redis
SETNX/ 唯一索引:同 key 的重复请求直接返回第一次的执行结果(而不是报错); - 一次业务操作生命周期内 key 固定:失败重试复用,成功后丢弃(进新页面重新生成)。
- 进入填写页 / 打开弹窗时生成一次
-
超时重试规范:网络超时重试必须携带同一个幂等键 + 指数退避,最多 2~3 次;顺序必须「先确认结果(查单)再重试」,避免第一次实际已成功。
-
后端双保险:业务唯一约束(订单号 + 用户 id 唯一索引)兜底,即便前端和缓存全部失守,数据库最后防住重复数据;冲突时返回 409,前端提示「请勿重复提交」。
// 场景:提交函数——状态锁 + 幂等键,失败重试复用同一个 key let submitting = false; async function submitOrder(form) { if (submitting) return; // 状态锁:双击第二次直接短路 submitting = true; const idempotencyKey = form.__requestId ??= crypto.randomUUID(); try { for (let attempt = 0; attempt < 3; attempt++) { try { return await api.post('/order', form, { headers: { 'X-Idempotency-Key': idempotencyKey }, }); } catch (e) { if (attempt === 2) throw e; await sleep(2 ** attempt * 500); // 重试仍用同一个 key } } } finally { submitting = false; // 失败后允许再试,但 key 不变 } }
有哪些坑:
- 只做前端 disabled:接口慢 3 秒,用户等不及刷新页面再提交一次;或者直接 F5 / 回车重放请求——重复订单照出,前端防御形同虚设。
- 把防抖(debounce)用在提交按钮上:防抖是「延迟执行最后一次」,等待窗口内用户看到没反应会再点,而且防抖到期照样会把第二次点击发出去(它防的是频率,不是重复语义);更糟的是防抖期间路由切走,请求照样发出。
- 超时自动重试没带幂等键:第一次请求实际已到达并成功(只是响应超时丢了),重试又下一单——重试机制本身制造了重复。
- 误用 AbortController 中断 POST:以为 abort 了服务端就没处理,实际上请求已发出,服务端订单已创建;前端放弃了响应,数据照样入库,还丢了结果展示。
- 幂等键每次重试都重新生成:等于没有幂等;或者把 key 放在会被序列化丢弃的位置(body 里嵌了但 header 没带),网关层根本读不到。
- 提交成功后不重置 / 不丢弃 key:用户在本页继续下第二单(加购场景),key 没换,服务端把第二单当成重复请求返回了第一单的结果,用户「下单成功」却没生成新订单。
怎么修补:
- 前端锁只作为体验层,安全由后端幂等键 + 数据库唯一索引双保险(上面第 3、5 步);联调时就用 curl 并发两个相同请求验证幂等。
- 提交一律用「状态锁(短路 + loading)」,防抖只留给输入类交互;锁的释放放在 finally,失败可重试、成功后销毁表单实例。
- 重试永远复用同一个幂等键(上面代码);拿不准第一次是否成功时,先调查询接口确认,再决定重试。
AbortController只用于 GET / 搜索类;POST 的「取消」语义是隐藏 UI + 依赖幂等,而不是 abort。- key 在「一次业务操作」生命周期内固定:进页面 / 打开弹窗生成,失败重试不变,成功或关闭时销毁;经 header 传输并纳入接口契约文档。
- 成功回调里显式作废旧 key(置 null / 重新生成),让下一次提交天然是新事务;后端幂等记录加 TTL(如 24h)兼顾内存与窗口。