Runtime API Examples
This page demonstrates usage of some of the runtime APIs provided by VitePress.
The main useData() API can be used to access site, theme, and page data for the current page. It works in both .md and .vue files:
md
<script setup>
import { useData } from 'vitepress'
const { theme, page, frontmatter } = useData()
</script>
## Results
### Theme Data
<pre>{{ theme }}</pre>
### Page Data
<pre>{{ page }}</pre>
### Page Frontmatter
<pre>{{ frontmatter }}</pre>Results
Theme Data
{
"logo": "/logo.svg",
"nav": [
{
"text": "Home",
"link": "/"
},
{
"text": "Examples",
"link": "/markdown-examples"
},
{
"text": "基础",
"items": [
{
"text": "HTML",
"link": "/basic/HTML/"
},
{
"text": "CSS",
"link": "/basic/CSS/"
},
{
"text": "JavaScript",
"link": "/basic/JavaScript/"
}
]
},
{
"text": "编程",
"items": [
{
"text": "前端安全",
"link": "/coding/前端安全/"
},
{
"text": "场景题",
"link": "/coding/场景题/"
},
{
"text": "工程化",
"link": "/coding/工程化/"
},
{
"text": "性能优化",
"link": "/coding/性能优化/"
},
{
"text": "编程题",
"link": "/coding/编程题/"
},
{
"text": "跨端技术",
"link": "/coding/跨端技术/"
}
]
},
{
"text": "框架",
"items": [
{
"text": "Node",
"link": "/framework/Node/"
},
{
"text": "React",
"link": "/framework/React/"
},
{
"text": "TypeScript",
"link": "/framework/TypeScript/"
},
{
"text": "Vue",
"link": "/framework/Vue/"
},
{
"text": "小程序",
"link": "/framework/小程序/"
},
{
"text": "计算机网络",
"link": "/framework/计算机网络/"
}
]
},
{
"text": "其他",
"items": [
{
"text": "AI相关",
"link": "/others/AI相关/"
},
{
"text": "leetcode",
"link": "/others/leetcode/"
},
{
"text": "工具",
"link": "/others/工具/"
},
{
"text": "算法",
"link": "/others/算法/"
},
{
"text": "计算机基础",
"link": "/others/计算机基础/"
},
{
"text": "趣味题",
"link": "/others/趣味题/"
},
{
"text": "选择题",
"link": "/others/选择题/"
}
]
}
],
"sidebar": {
"/basic/HTML/": [
{
"text": "** link 标签的 rel 属性中，preload 和 prefetch 这两个值的作用是什么？",
"link": "/basic/HTML/** link 标签的 rel 属性中，preload 和 prefetch 这两个值的作用是什么？"
},
{
"text": "**Canvas和SVG有什么区别？",
"link": "/basic/HTML/**Canvas和SVG有什么区别？"
},
{
"text": "**HTML 部分标签中的 crossorigin 属性，作用是什么？",
"link": "/basic/HTML/**HTML 部分标签中的 crossorigin 属性，作用是什么？"
},
{
"text": "**HTML5的离线储存怎么使用，它的工作原理是什么",
"link": "/basic/HTML/**HTML5的离线储存怎么使用，它的工作原理是什么"
},
{
"text": "**SPA应用怎么进行SEO？",
"link": "/basic/HTML/**SPA应用怎么进行SEO？"
},
{
"text": "**canvas 与 svg 在可视化领域优劣如何",
"link": "/basic/HTML/**canvas 与 svg 在可视化领域优劣如何"
},
{
"text": "**html 中前缀为 data- 开头的元素属性是什么？",
"link": "/basic/HTML/**html 中前缀为 data- 开头的元素属性是什么？"
},
{
"text": "**html 中有哪些常见的实体字符？",
"link": "/basic/HTML/**html 中有哪些常见的实体字符？"
},
{
"text": "**html 中的视频，怎么添加字幕？",
"link": "/basic/HTML/**html 中的视频，怎么添加字幕？"
},
{
"text": "**html 文档中常见的 是什么，有什么作用？",
"link": "/basic/HTML/**html 文档中常见的 是什么，有什么作用？"
},
{
"text": "**html和css中的图片加载与渲染规则是什么样的？",
"link": "/basic/HTML/**html和css中的图片加载与渲染规则是什么样的？"
},
{
"text": "**link 标签有哪些属性，分别有什么作用？",
"link": "/basic/HTML/**link 标签有哪些属性，分别有什么作用？"
},
{
"text": "**mete标签中的viewport 有什么用？",
"link": "/basic/HTML/**mete标签中的viewport 有什么用？"
},
{
"text": "**script 标签上有那些属性，作用分别是什么？",
"link": "/basic/HTML/**script 标签上有那些属性，作用分别是什么？"
},
{
"text": "**web components 是什么？",
"link": "/basic/HTML/**web components 是什么？"
},
{
"text": "**一台设备的dpr，是否是可变的？",
"link": "/basic/HTML/**一台设备的dpr，是否是可变的？"
},
{
"text": "**什么是 HTML 文档的预解析？",
"link": "/basic/HTML/**什么是 HTML 文档的预解析？"
},
{
"text": "**在 DOM 中，如何判定 a 元素是否是 b 元素的子元素？",
"link": "/basic/HTML/**在 DOM 中，如何判定 a 元素是否是 b 元素的子元素？"
},
{
"text": "**如何使用 JavaScript 控制 <audio> 和 <video> 元素？",
"link": "/basic/HTML/**如何使用 JavaScript 控制 <audio> 和 <video> 元素？"
},
{
"text": "**如何避免重绘或者重排？",
"link": "/basic/HTML/**如何避免重绘或者重排？"
},
{
"text": "**怎么在页面上获取用户的定位信息？",
"link": "/basic/HTML/**怎么在页面上获取用户的定位信息？"
},
{
"text": "**怎么让页面上的某块区域全屏展示？",
"link": "/basic/HTML/**怎么让页面上的某块区域全屏展示？"
},
{
"text": "**浏览器是怎么解析 HTML 文档的？",
"link": "/basic/HTML/**浏览器是怎么解析 HTML 文档的？"
},
{
"text": "**说说你对 html 嵌套规则的了解",
"link": "/basic/HTML/**说说你对 html 嵌套规则的了解"
},
{
"text": "<!DOCTYPE html> 标签有什么用？",
"link": "/basic/HTML/<!DOCTYPE html> 标签有什么用？"
},
{
"text": "CSSOM树和DOM树是同时解析的吗？",
"link": "/basic/HTML/CSSOM树和DOM树是同时解析的吗？"
},
{
"text": "DNS 预解析是什么？怎么实现？",
"link": "/basic/HTML/DNS 预解析是什么？怎么实现？"
},
{
"text": "HTML 标签中的 src 和 href 有什么区别",
"link": "/basic/HTML/HTML 标签中的 src 和 href 有什么区别"
},
{
"text": "HTML5 有哪些 drag 相关的 API ？",
"link": "/basic/HTML/HTML5 有哪些 drag 相关的 API ？"
},
{
"text": "HTML5 有哪些新特性？",
"link": "/basic/HTML/HTML5 有哪些新特性？"
},
{
"text": "Node 和 Element 是什么关系？",
"link": "/basic/HTML/Node 和 Element 是什么关系？"
},
{
"text": "SEO是什么？",
"link": "/basic/HTML/SEO是什么？"
},
{
"text": "SEO的原理是什么？",
"link": "/basic/HTML/SEO的原理是什么？"
},
{
"text": "canvas在标签上设置宽高，与在style中设置宽高有什么区别？",
"link": "/basic/HTML/canvas在标签上设置宽高，与在style中设置宽高有什么区别？"
},
{
"text": "iconfont是什么？有什么优缺点？",
"link": "/basic/HTML/iconfont是什么？有什么优缺点？"
},
{
"text": "iframe是什么？有哪些优缺点？",
"link": "/basic/HTML/iframe是什么？有哪些优缺点？"
},
{
"text": "img的srcset属性的作⽤？",
"link": "/basic/HTML/img的srcset属性的作⽤？"
},
{
"text": "input上传文件可以同时选择多张吗？怎么设置？",
"link": "/basic/HTML/input上传文件可以同时选择多张吗？怎么设置？"
},
{
"text": "js和css是否阻塞DOM树构建和渲染？",
"link": "/basic/HTML/js和css是否阻塞DOM树构建和渲染？"
},
{
"text": "label标签有什么用？",
"link": "/basic/HTML/label标签有什么用？"
},
{
"text": "script 标签中， async 和 defer 两个属性有什么用途和区别？",
"link": "/basic/HTML/script 标签中， async 和 defer 两个属性有什么用途和区别？"
},
{
"text": "script 标签为什么建议放在 body 标签的底部（defer、async）",
"link": "/basic/HTML/script 标签为什么建议放在 body 标签的底部（defer、async）"
},
{
"text": "style标签写在body后与body前有什么区别？",
"link": "/basic/HTML/style标签写在body后与body前有什么区别？"
},
{
"text": "title与h1的区别、b与strong的区别、i与em的区别？",
"link": "/basic/HTML/title与h1的区别、b与strong的区别、i与em的区别？"
},
{
"text": "webSocket如何兼容低浏览器",
"link": "/basic/HTML/webSocket如何兼容低浏览器"
},
{
"text": "什么是 DOM 和 BOM？",
"link": "/basic/HTML/什么是 DOM 和 BOM？"
},
{
"text": "什么是 HTML 语义化？",
"link": "/basic/HTML/什么是 HTML 语义化？"
},
{
"text": "什么是HTML5，以及和HTML的区别是什么？",
"link": "/basic/HTML/什么是HTML5，以及和HTML的区别是什么？"
},
{
"text": "什么是渐进增强和优雅降级？",
"link": "/basic/HTML/什么是渐进增强和优雅降级？"
},
{
"text": "使用input标签上传图片时，怎样触发默认拍照功能？",
"link": "/basic/HTML/使用input标签上传图片时，怎样触发默认拍照功能？"
},
{
"text": "假设我要上传图片，怎么在选择图片后，通过浏览器预览待上传的图片？",
"link": "/basic/HTML/假设我要上传图片，怎么在选择图片后，通过浏览器预览待上传的图片？"
},
{
"text": "前端该如何选择图片的格式？",
"link": "/basic/HTML/前端该如何选择图片的格式？"
},
{
"text": "前端跨页面通信，你知道哪些方法？",
"link": "/basic/HTML/前端跨页面通信，你知道哪些方法？"
},
{
"text": "如何实现SEO优化",
"link": "/basic/HTML/如何实现SEO优化"
},
{
"text": "如何实现浏览器内多个标签页之间的通信？",
"link": "/basic/HTML/如何实现浏览器内多个标签页之间的通信？"
},
{
"text": "如何控制 input 输入框的输入字数？",
"link": "/basic/HTML/如何控制 input 输入框的输入字数？"
},
{
"text": "如何禁止input展示输入的历史记录？",
"link": "/basic/HTML/如何禁止input展示输入的历史记录？"
},
{
"text": "如何禁用a标签跳转页面或定位链接？",
"link": "/basic/HTML/如何禁用a标签跳转页面或定位链接？"
},
{
"text": "导致页面加载白屏时间长的原因有哪些，怎么进行优化？",
"link": "/basic/HTML/导致页面加载白屏时间长的原因有哪些，怎么进行优化？"
},
{
"text": "常用的 meta 元素有哪些？",
"link": "/basic/HTML/常用的 meta 元素有哪些？"
},
{
"text": "怎么实现“点击回到顶部”的功能？",
"link": "/basic/HTML/怎么实现“点击回到顶部”的功能？"
},
{
"text": "标签上title属性与alt属性的区别是什么？",
"link": "/basic/HTML/标签上title属性与alt属性的区别是什么？"
},
{
"text": "浏览器乱码的原因是什么？如何解决？",
"link": "/basic/HTML/浏览器乱码的原因是什么？如何解决？"
},
{
"text": "浏览器是如何对 HTML5 的离线储存资源进行管理和加载？",
"link": "/basic/HTML/浏览器是如何对 HTML5 的离线储存资源进行管理和加载？"
},
{
"text": "渐进式jpg有了解过吗？",
"link": "/basic/HTML/渐进式jpg有了解过吗？"
},
{
"text": "简单描述从输入网址到页面显示的过程",
"link": "/basic/HTML/简单描述从输入网址到页面显示的过程"
},
{
"text": "简述 html 页面渲染过程",
"link": "/basic/HTML/简述 html 页面渲染过程"
},
{
"text": "能否使用自闭合script标签引入脚本文件？",
"link": "/basic/HTML/能否使用自闭合script标签引入脚本文件？"
},
{
"text": "行内元素有哪些？块级元素有哪些？ 空(void)元素有那些？",
"link": "/basic/HTML/行内元素有哪些？块级元素有哪些？ 空(void)元素有那些？"
},
{
"text": "说说 HTML、XML、XHTML 的区别",
"link": "/basic/HTML/说说 HTML、XML、XHTML 的区别"
},
{
"text": "说说你对 Dom 树的理解",
"link": "/basic/HTML/说说你对 Dom 树的理解"
},
{
"text": "说说你对 SSG 的理解",
"link": "/basic/HTML/说说你对 SSG 的理解"
},
{
"text": "说说你对以下几个页面生命周期事件的理解：DOMContentLoaded，load，beforeunload，unload",
"link": "/basic/HTML/说说你对以下几个页面生命周期事件的理解：DOMContentLoaded，load，beforeunload，unload"
},
{
"text": "页面导入样式时，使用link和@import有什么区别？",
"link": "/basic/HTML/页面导入样式时，使用link和@import有什么区别？"
},
{
"text": "页面统计数据中，常用的 PV、UV 指标分别是什么？",
"link": "/basic/HTML/页面统计数据中，常用的 PV、UV 指标分别是什么？"
}
],
"/basic/CSS/": [
{
"text": "**CSS 中的文档流是什么？",
"link": "/basic/CSS/**CSS 中的文档流是什么？"
},
{
"text": "**CSS 伪类和伪元素有哪些，它们的区别和实际应用",
"link": "/basic/CSS/**CSS 伪类和伪元素有哪些，它们的区别和实际应用"
},
{
"text": "**CSS 尺寸单位有哪些？",
"link": "/basic/CSS/**CSS 尺寸单位有哪些？"
},
{
"text": "**CSS 属性值计算 - calc 怎么使用，具体有哪些使用场景？",
"link": "/basic/CSS/**CSS 属性值计算 - calc 怎么使用，具体有哪些使用场景？"
},
{
"text": "**PostCSS 是什么，有什么作用？",
"link": "/basic/CSS/**PostCSS 是什么，有什么作用？"
},
{
"text": "**css module 是什么？",
"link": "/basic/CSS/**css module 是什么？"
},
{
"text": "**css 中三栏布局的实现方案有哪些？",
"link": "/basic/CSS/**css 中三栏布局的实现方案有哪些？"
},
{
"text": "**gap 属性是用来设置什么的？",
"link": "/basic/CSS/**gap 属性是用来设置什么的？"
},
{
"text": "**html 元素节点上， 有多个 class 名称，这几个class 名称对应的样式渲染优先级是如何的？",
"link": "/basic/CSS/**html 元素节点上， 有多个 class 名称，这几个class 名称对应的样式渲染优先级是如何的？"
},
{
"text": "**html和css中的图片加载与渲染规则是什么样的？",
"link": "/basic/CSS/**html和css中的图片加载与渲染规则是什么样的？"
},
{
"text": "**less 文件中怎么使用函数？",
"link": "/basic/CSS/**less 文件中怎么使用函数？"
},
{
"text": "**position 的 sticky 有什么应用场景？",
"link": "/basic/CSS/**position 的 sticky 有什么应用场景？"
},
{
"text": "**你都了解哪些 CSS 布局技术？它们各自的特点和适用场景是什么？",
"link": "/basic/CSS/**你都了解哪些 CSS 布局技术？它们各自的特点和适用场景是什么？"
},
{
"text": "**全局样式命名冲突和样式覆盖问题怎么解决？",
"link": "/basic/CSS/**全局样式命名冲突和样式覆盖问题怎么解决？"
},
{
"text": "**如何避免全局样式污染？",
"link": "/basic/CSS/**如何避免全局样式污染？"
},
{
"text": "**怎么实现一段文字颜色渐变的效果？",
"link": "/basic/CSS/**怎么实现一段文字颜色渐变的效果？"
},
{
"text": "**怎么给某个元素的背景设置渐变色？",
"link": "/basic/CSS/**怎么给某个元素的背景设置渐变色？"
},
{
"text": "**未知高度和宽度元素的水平垂直居中的方案有哪些， 简单手写一下？",
"link": "/basic/CSS/**未知高度和宽度元素的水平垂直居中的方案有哪些， 简单手写一下？"
},
{
"text": "**浏览器如何解析css选择器？",
"link": "/basic/CSS/**浏览器如何解析css选择器？"
},
{
"text": "**说下 css 中的 BFC、IFC、GFC 和 FFC 分别指什么？",
"link": "/basic/CSS/**说下 css 中的 BFC、IFC、GFC 和 FFC 分别指什么？"
},
{
"text": "**说说你对 CSS 变量的了解",
"link": "/basic/CSS/**说说你对 CSS 变量的了解"
},
{
"text": "**说说你对原子化 CSS 的了解",
"link": "/basic/CSS/**说说你对原子化 CSS 的了解"
},
{
"text": "**请使用 css 实现卡片翻转的动画",
"link": "/basic/CSS/**请使用 css 实现卡片翻转的动画"
},
{
"text": "::before 和 :after中双冒号和单冒号有什么区别？解释一下这2个伪元素的作用",
"link": "/basic/CSS/::before 和 :after中双冒号和单冒号有什么区别？解释一下这2个伪元素的作用"
},
{
"text": "::before 和::after 中双冒号和单冒号有什么区别、作用？",
"link": "/basic/CSS/::before 和::after 中双冒号和单冒号有什么区别、作用？"
},
{
"text": "Atom CSS 是什么？",
"link": "/basic/CSS/Atom CSS 是什么？"
},
{
"text": "CSS 中有哪几种定位方式？",
"link": "/basic/CSS/CSS 中有哪几种定位方式？"
},
{
"text": "CSS 中，有哪些方式可以隐藏页面元素？有什么区别？",
"link": "/basic/CSS/CSS 中，有哪些方式可以隐藏页面元素？有什么区别？"
},
{
"text": "CSS 垂直居中有哪些实现方式？",
"link": "/basic/CSS/CSS 垂直居中有哪些实现方式？"
},
{
"text": "CSS3 中 transition 和 animation 的属性分别有哪些？",
"link": "/basic/CSS/CSS3 中 transition 和 animation 的属性分别有哪些？"
},
{
"text": "CSS3新增了哪些特性？",
"link": "/basic/CSS/CSS3新增了哪些特性？"
},
{
"text": "CSS3新增伪类有那些？",
"link": "/basic/CSS/CSS3新增伪类有那些？"
},
{
"text": "CSSOM树和DOM树是同时解析的吗？",
"link": "/basic/CSS/CSSOM树和DOM树是同时解析的吗？"
},
{
"text": "CSS中的 “flex:1;” 是什么意思？",
"link": "/basic/CSS/CSS中的 “flex:1;” 是什么意思？"
},
{
"text": "CSS中的1像素问题是什么？有哪些解决方案？",
"link": "/basic/CSS/CSS中的1像素问题是什么？有哪些解决方案？"
},
{
"text": "CSS中，box-sizing属性值有什么用？",
"link": "/basic/CSS/CSS中，box-sizing属性值有什么用？"
},
{
"text": "CSS优化、提高性能的方法有哪些？",
"link": "/basic/CSS/CSS优化、提高性能的方法有哪些？"
},
{
"text": "CSS动画和JS实现的动画分别有哪些优缺点？",
"link": "/basic/CSS/CSS动画和JS实现的动画分别有哪些优缺点？"
},
{
"text": "CSS匹配规则顺序是怎么样的？",
"link": "/basic/CSS/CSS匹配规则顺序是怎么样的？"
},
{
"text": "CSS预处理器-后处理器是什么？为什么要使用它们？",
"link": "/basic/CSS/CSS预处理器-后处理器是什么？为什么要使用它们？"
},
{
"text": "IconFont 的原理是什么",
"link": "/basic/CSS/IconFont 的原理是什么"
},
{
"text": "Js 动画与 CSS 动画区别及相应实现",
"link": "/basic/CSS/Js 动画与 CSS 动画区别及相应实现"
},
{
"text": "Sass、Less 是什么？为什么要使用他们？",
"link": "/basic/CSS/Sass、Less 是什么？为什么要使用他们？"
},
{
"text": "canvas在标签上设置宽高，与在style中设置宽高有什么区别？",
"link": "/basic/CSS/canvas在标签上设置宽高，与在style中设置宽高有什么区别？"
},
{
"text": "css sprites是什么，怎么使用？",
"link": "/basic/CSS/css sprites是什么，怎么使用？"
},
{
"text": "css 中的 animation、transition、transform 有什么区别？",
"link": "/basic/CSS/css 中的 animation、transition、transform 有什么区别？"
},
{
"text": "css加载会造成阻塞吗？",
"link": "/basic/CSS/css加载会造成阻塞吗？"
},
{
"text": "css选择器有哪些？优先级分别是什么？哪些属性可以继承？",
"link": "/basic/CSS/css选择器有哪些？优先级分别是什么？哪些属性可以继承？"
},
{
"text": "display 有哪些取值？",
"link": "/basic/CSS/display 有哪些取值？"
},
{
"text": "display:none与visibility:hidden 有什么区别？",
"link": "/basic/CSS/display:none与visibility:hidden 有什么区别？"
},
{
"text": "em-px-rem-vh-vw 这些单位有什么区别？",
"link": "/basic/CSS/em-px-rem-vh-vw 这些单位有什么区别？"
},
{
"text": "flex 布局下，怎么改变元素的顺序？",
"link": "/basic/CSS/flex 布局下，怎么改变元素的顺序？"
},
{
"text": "flexbox（弹性盒布局模型）是什么，适用什么场景？",
"link": "/basic/CSS/flexbox（弹性盒布局模型）是什么，适用什么场景？"
},
{
"text": "grid网格布局是什么？",
"link": "/basic/CSS/grid网格布局是什么？"
},
{
"text": "margin和padding分别适合什么场景使用？",
"link": "/basic/CSS/margin和padding分别适合什么场景使用？"
},
{
"text": "object-fit 用法",
"link": "/basic/CSS/object-fit 用法"
},
{
"text": "position: fixed 一定是相对于浏览器窗口进行定位吗？",
"link": "/basic/CSS/position: fixed 一定是相对于浏览器窗口进行定位吗？"
},
{
"text": "position：absolute绝对定位，是相对于谁的定位？",
"link": "/basic/CSS/position：absolute绝对定位，是相对于谁的定位？"
},
{
"text": "style标签写在body后与body前有什么区别？",
"link": "/basic/CSS/style标签写在body后与body前有什么区别？"
},
{
"text": "transition和animation的区别",
"link": "/basic/CSS/transition和animation的区别"
},
{
"text": "z-index属性在什么情况下会失效？",
"link": "/basic/CSS/z-index属性在什么情况下会失效？"
},
{
"text": "”flex: auto;“是什么意思？",
"link": "/basic/CSS/”flex: auto;“是什么意思？"
},
{
"text": "下面代码中，p标签的背景色是什么？",
"link": "/basic/CSS/下面代码中，p标签的背景色是什么？"
},
{
"text": "下面这段代码中，class为content的元素，实际高度是100px吗？",
"link": "/basic/CSS/下面这段代码中，class为content的元素，实际高度是100px吗？"
},
{
"text": "两个同级的相邻元素之间，有看不见的空白间隔，是什么原因引起的？有什么解决办法？",
"link": "/basic/CSS/两个同级的相邻元素之间，有看不见的空白间隔，是什么原因引起的？有什么解决办法？"
},
{
"text": "为什么会出现浮动？什么时候需要清除浮动？清除浮动的方式有哪些？",
"link": "/basic/CSS/为什么会出现浮动？什么时候需要清除浮动？清除浮动的方式有哪些？"
},
{
"text": "为什么有时候⽤translate来改变位置⽽不是使用position进行定位？",
"link": "/basic/CSS/为什么有时候⽤translate来改变位置⽽不是使用position进行定位？"
},
{
"text": "为何CSS不支持父选择器？",
"link": "/basic/CSS/为何CSS不支持父选择器？"
},
{
"text": "什么是BFC？",
"link": "/basic/CSS/什么是BFC？"
},
{
"text": "什么是CSS Sprites？",
"link": "/basic/CSS/什么是CSS Sprites？"
},
{
"text": "什么是CSS媒体查询？",
"link": "/basic/CSS/什么是CSS媒体查询？"
},
{
"text": "什么是响应式设计？响应式设计的基本原理是什么？如何进行实现？",
"link": "/basic/CSS/什么是响应式设计？响应式设计的基本原理是什么？如何进行实现？"
},
{
"text": "什么是硬件加速？",
"link": "/basic/CSS/什么是硬件加速？"
},
{
"text": "你知道哪些css模块化的方案？",
"link": "/basic/CSS/你知道哪些css模块化的方案？"
},
{
"text": "使用css实现一个无限循环动画",
"link": "/basic/CSS/使用css实现一个无限循环动画"
},
{
"text": "使用原生js实现以下效果：点击容器内的图标，图标边框变成border:1px solid red，点击空白处重置",
"link": "/basic/CSS/使用原生js实现以下效果：点击容器内的图标，图标边框变成border:1px solid red，点击空白处重置"
},
{
"text": "假设下面样式都作用于同一个节点元素`span`，判断下面哪个样式会生效",
"link": "/basic/CSS/假设下面样式都作用于同一个节点元素`span`，判断下面哪个样式会生效"
},
{
"text": "元素竖向的百分比设定是相对于容器的高度吗？",
"link": "/basic/CSS/元素竖向的百分比设定是相对于容器的高度吗？"
},
{
"text": "分析比较 opacity: 0、visibility: hidden、display: none 优劣和适用场景",
"link": "/basic/CSS/分析比较 opacity: 0、visibility: hidden、display: none 优劣和适用场景"
},
{
"text": "前端实现动画有哪些方式？",
"link": "/basic/CSS/前端实现动画有哪些方式？"
},
{
"text": "前端项目中为什么要初始化CSS样式？",
"link": "/basic/CSS/前端项目中为什么要初始化CSS样式？"
},
{
"text": "单行文本怎么实现两端对齐？",
"link": "/basic/CSS/单行文本怎么实现两端对齐？"
},
{
"text": "在解决动画卡顿问题时，会引导硬件加速，那么硬件加速的原理是什么？",
"link": "/basic/CSS/在解决动画卡顿问题时，会引导硬件加速，那么硬件加速的原理是什么？"
},
{
"text": "如何从html元素继承box-sizing？",
"link": "/basic/CSS/如何从html元素继承box-sizing？"
},
{
"text": "如何使用css完成视差滚动效果？",
"link": "/basic/CSS/如何使用css完成视差滚动效果？"
},
{
"text": "如何使用css来实现禁止移动端页面的左右划动手势？",
"link": "/basic/CSS/如何使用css来实现禁止移动端页面的左右划动手势？"
},
{
"text": "如何实现两栏布局，右侧自适应？三栏布局中间自适应呢？",
"link": "/basic/CSS/如何实现两栏布局，右侧自适应？三栏布局中间自适应呢？"
},
{
"text": "如何实现单行／多行文本溢出的省略样式？",
"link": "/basic/CSS/如何实现单行／多行文本溢出的省略样式？"
},
{
"text": "如何检测浏览器所支持的最小字体大小？",
"link": "/basic/CSS/如何检测浏览器所支持的最小字体大小？"
},
{
"text": "如果使用CSS提高页面性能？",
"link": "/basic/CSS/如果使用CSS提高页面性能？"
},
{
"text": "如果需要手动写动画，你认为最小时间间隔是多久，为什么？",
"link": "/basic/CSS/如果需要手动写动画，你认为最小时间间隔是多久，为什么？"
},
{
"text": "怎么使用 CSS 如何画一个三角形",
"link": "/basic/CSS/怎么使用 CSS 如何画一个三角形"
},
{
"text": "怎么使用 CSS3 实现动画？",
"link": "/basic/CSS/怎么使用 CSS3 实现动画？"
},
{
"text": "怎么做移动端的样式适配？",
"link": "/basic/CSS/怎么做移动端的样式适配？"
},
{
"text": "怎么实现一个宽高自适应的正方形？",
"link": "/basic/CSS/怎么实现一个宽高自适应的正方形？"
},
{
"text": "怎么实现单行、多行文本溢出隐藏？",
"link": "/basic/CSS/怎么实现单行、多行文本溢出隐藏？"
},
{
"text": "怎么实现样式隔离？",
"link": "/basic/CSS/怎么实现样式隔离？"
},
{
"text": "怎么理解回流跟重绘？什么场景下会触发？",
"link": "/basic/CSS/怎么理解回流跟重绘？什么场景下会触发？"
},
{
"text": "怎么触发BFC，BFC有什么应用场景？",
"link": "/basic/CSS/怎么触发BFC，BFC有什么应用场景？"
},
{
"text": "怎么让CSS flex布局最后一行列表左对齐？",
"link": "/basic/CSS/怎么让CSS flex布局最后一行列表左对齐？"
},
{
"text": "怎么让Chrome支持小于12px 的文字？",
"link": "/basic/CSS/怎么让Chrome支持小于12px 的文字？"
},
{
"text": "相邻的两个inline-block节点为什么会出现间隔，该如何解决？",
"link": "/basic/CSS/相邻的两个inline-block节点为什么会出现间隔，该如何解决？"
},
{
"text": "第二个子元素的高度是多少",
"link": "/basic/CSS/第二个子元素的高度是多少"
},
{
"text": "脱离文档流有哪些方法？",
"link": "/basic/CSS/脱离文档流有哪些方法？"
},
{
"text": "行内元素和块级元素有什么区别",
"link": "/basic/CSS/行内元素和块级元素有什么区别"
},
{
"text": "设备像素、css像素、设备独立像素、dpr、ppi 之间有什么区别？",
"link": "/basic/CSS/设备像素、css像素、设备独立像素、dpr、ppi 之间有什么区别？"
},
{
"text": "说说你对 CSS 模块化的理解",
"link": "/basic/CSS/说说你对 CSS 模块化的理解"
},
{
"text": "说说你对盒子模型的理解",
"link": "/basic/CSS/说说你对盒子模型的理解"
},
{
"text": "说说对 CSS 工程化的理解",
"link": "/basic/CSS/说说对 CSS 工程化的理解"
},
{
"text": "说说对 CSS 预编语言的理解，以及它们之间的区别",
"link": "/basic/CSS/说说对 CSS 预编语言的理解，以及它们之间的区别"
},
{
"text": "页面导入样式时，使用link和@import有什么区别？",
"link": "/basic/CSS/页面导入样式时，使用link和@import有什么区别？"
}
],
"/basic/JavaScript/": [
{
"text": "'1'.toString()为什么不会报错？",
"link": "/basic/JavaScript/'1'.toString()为什么不会报错？"
},
{
"text": "** 说说对 XMLHttpRequest 对象的了解",
"link": "/basic/JavaScript/** 说说对 XMLHttpRequest 对象的了解"
},
{
"text": "**ES6-ESM 与 CJS 的差异有哪些？",
"link": "/basic/JavaScript/**ES6-ESM 与 CJS 的差异有哪些？"
},
{
"text": "**ES6-JS 有哪些迭代器，该如何使用？",
"link": "/basic/JavaScript/**ES6-JS 有哪些迭代器，该如何使用？"
},
{
"text": "**ES6-JS里的类就是构造函数的语法糖，这个说法是否正确？",
"link": "/basic/JavaScript/**ES6-JS里的类就是构造函数的语法糖，这个说法是否正确？"
},
{
"text": "**ES6-Map 的键是引用类型时，如何防止内存泄漏？",
"link": "/basic/JavaScript/**ES6-Map 的键是引用类型时，如何防止内存泄漏？"
},
{
"text": "**ES6-Promise then 第二个参数和 Promise.catch 的区别是什么？",
"link": "/basic/JavaScript/**ES6-Promise then 第二个参数和 Promise.catch 的区别是什么？"
},
{
"text": "**ES6-Promise 构造函数是同步执行还是异步执行，那么 then 方法呢？",
"link": "/basic/JavaScript/**ES6-Promise 构造函数是同步执行还是异步执行，那么 then 方法呢？"
},
{
"text": "**ES6-Proxy 和 Reflect 有什么关系？",
"link": "/basic/JavaScript/**ES6-Proxy 和 Reflect 有什么关系？"
},
{
"text": "**ES6-es5 和 es6 使用 new 关键字实例化对象的流程是一样的吗？",
"link": "/basic/JavaScript/**ES6-es5 和 es6 使用 new 关键字实例化对象的流程是一样的吗？"
},
{
"text": "**ES6-promise 是否可以取消？",
"link": "/basic/JavaScript/**ES6-promise 是否可以取消？"
},
{
"text": "**ES6-promise.race、promise.all、promise.allSettled 有哪些区别？",
"link": "/basic/JavaScript/**ES6-promise.race、promise.all、promise.allSettled 有哪些区别？"
},
{
"text": "**ES6-为什么 WeakMap 的键不能是基本类型？",
"link": "/basic/JavaScript/**ES6-为什么 WeakMap 的键不能是基本类型？"
},
{
"text": "**ES6-使用 async-await 时，是否有必要加 try catch？",
"link": "/basic/JavaScript/**ES6-使用 async-await 时，是否有必要加 try catch？"
},
{
"text": "**ES6-如何使对象 iterable 化， 使其可以支持 for...of 迭代",
"link": "/basic/JavaScript/**ES6-如何使对象 iterable 化， 使其可以支持 for...of 迭代"
},
{
"text": "**ES6-如何使用 WeakMap 封装私有属性？",
"link": "/basic/JavaScript/**ES6-如何使用 WeakMap 封装私有属性？"
},
{
"text": "**ES6-如何理解 ES6 模块化方案的缓存机制？",
"link": "/basic/JavaScript/**ES6-如何理解 ES6 模块化方案的缓存机制？"
},
{
"text": "**ES6-怎么理解 ESM 中的 export * from \"a.js\" 这种写法？",
"link": "/basic/JavaScript/**ES6-怎么理解 ESM 中的 export * from \"a.js\" 这种写法？"
},
{
"text": "**ES6-怎么遍历 ES6 中的 Map 对象？",
"link": "/basic/JavaScript/**ES6-怎么遍历 ES6 中的 Map 对象？"
},
{
"text": "**ES6-怎么遍历 ES6 中的 Set 对象？",
"link": "/basic/JavaScript/**ES6-怎么遍历 ES6 中的 Set 对象？"
},
{
"text": "**ES6-详细讲一下 Symbol 数据类型特征与实际使用案例？",
"link": "/basic/JavaScript/**ES6-详细讲一下 Symbol 数据类型特征与实际使用案例？"
},
{
"text": "**JS 中如何实现大对象深度对比",
"link": "/basic/JavaScript/**JS 中如何实现大对象深度对比"
},
{
"text": "**JS 中的数组和函数在内存中是如何存储的？",
"link": "/basic/JavaScript/**JS 中的数组和函数在内存中是如何存储的？"
},
{
"text": "**JS 代码放在 head 里和放在 body 里有什么区别？",
"link": "/basic/JavaScript/**JS 代码放在 head 里和放在 body 里有什么区别？"
},
{
"text": "**JS 内存泄露的问题该如何排查？",
"link": "/basic/JavaScript/**JS 内存泄露的问题该如何排查？"
},
{
"text": "**JS 创建对象的方式有哪些？",
"link": "/basic/JavaScript/**JS 创建对象的方式有哪些？"
},
{
"text": "**JS 的严格模式为什么会禁用 with 语句？",
"link": "/basic/JavaScript/**JS 的严格模式为什么会禁用 with 语句？"
},
{
"text": "**JS 的严格模式有什么作用？",
"link": "/basic/JavaScript/**JS 的严格模式有什么作用？"
},
{
"text": "**JSON.stringify 遇到 bigint 的类型的数据，会怎么处理？",
"link": "/basic/JavaScript/**JSON.stringify 遇到 bigint 的类型的数据，会怎么处理？"
},
{
"text": "**JavaScript 中循环有哪些常见方法？它们在遍历不同数据结构时的适用情况如何？",
"link": "/basic/JavaScript/**JavaScript 中循环有哪些常见方法？它们在遍历不同数据结构时的适用情况如何？"
},
{
"text": "**JavaScript 中的变量在内存中的具体存储形式是什么",
"link": "/basic/JavaScript/**JavaScript 中的变量在内存中的具体存储形式是什么"
},
{
"text": "**JavaScript 中， 隐藏类是什么概念？",
"link": "/basic/JavaScript/**JavaScript 中， 隐藏类是什么概念？"
},
{
"text": "**JavaScript 和 BOM、DOM 、ECMAScript、Nodejs 之间是什么关系",
"link": "/basic/JavaScript/**JavaScript 和 BOM、DOM 、ECMAScript、Nodejs 之间是什么关系"
},
{
"text": "**JavaScript 对象的底层数据结构是什么？",
"link": "/basic/JavaScript/**JavaScript 对象的底层数据结构是什么？"
},
{
"text": "**JavaScript 是怎么做内存管理的？",
"link": "/basic/JavaScript/**JavaScript 是怎么做内存管理的？"
},
{
"text": "**Javascript 数组中有哪些方法可以改变自身，哪些不可以？",
"link": "/basic/JavaScript/**Javascript 数组中有哪些方法可以改变自身，哪些不可以？"
},
{
"text": "**Js 中，有哪些方法可以退出循环",
"link": "/basic/JavaScript/**Js 中，有哪些方法可以退出循环"
},
{
"text": "**Object 对象有哪些场景 api ？",
"link": "/basic/JavaScript/**Object 对象有哪些场景 api ？"
},
{
"text": "**Object.prototype.hasOwnProperty() 作用是什么？",
"link": "/basic/JavaScript/**Object.prototype.hasOwnProperty() 作用是什么？"
},
{
"text": "**WebWorker、SharedWorker 和 ServiceWorker 有哪些区别？",
"link": "/basic/JavaScript/**WebWorker、SharedWorker 和 ServiceWorker 有哪些区别？"
},
{
"text": "**[3, 15, 8, 29, 102, 22].sort()，结果是多少，为什么？",
"link": "/basic/JavaScript/**[3, 15, 8, 29, 102, 22].sort()，结果是多少，为什么？"
},
{
"text": "**ajax 和 xhr 是什么关系？",
"link": "/basic/JavaScript/**ajax 和 xhr 是什么关系？"
},
{
"text": "**async-await 原理， 手写 async 函数？",
"link": "/basic/JavaScript/**async-await 原理， 手写 async 函数？"
},
{
"text": "**axios 请求的底层依赖是什么？",
"link": "/basic/JavaScript/**axios 请求的底层依赖是什么？"
},
{
"text": "**documentFragment api 是什么， 有哪些使用场景？",
"link": "/basic/JavaScript/**documentFragment api 是什么， 有哪些使用场景？"
},
{
"text": "**escape、encodeURI、encodeURIComponent 有什么区别？",
"link": "/basic/JavaScript/**escape、encodeURI、encodeURIComponent 有什么区别？"
},
{
"text": "**for...of、for...in、for 循环， 三者有什么区别？",
"link": "/basic/JavaScript/**for...of、for...in、for 循环， 三者有什么区别？"
},
{
"text": "**get 请求的参数是否能够使用数组？",
"link": "/basic/JavaScript/**get 请求的参数是否能够使用数组？"
},
{
"text": "**hasOwnProperty 与 instanceof 有什么区别",
"link": "/basic/JavaScript/**hasOwnProperty 与 instanceof 有什么区别"
},
{
"text": "**js 中对于超过 Number 最大值的数怎么处理？",
"link": "/basic/JavaScript/**js 中对于超过 Number 最大值的数怎么处理？"
},
{
"text": "**js 函数参数有默认值时，如果传递的参数是 undefined 那么会被默认值赋值吗？",
"link": "/basic/JavaScript/**js 函数参数有默认值时，如果传递的参数是 undefined 那么会被默认值赋值吗？"
},
{
"text": "**js 对象可以使用 for...of 迭代吗？",
"link": "/basic/JavaScript/**js 对象可以使用 for...of 迭代吗？"
},
{
"text": "**js对象中，可枚举性（enumerable）是什么？",
"link": "/basic/JavaScript/**js对象中，可枚举性（enumerable）是什么？"
},
{
"text": "**mouseEnter、mouseLeave、mouseOver、mouseOut 有什么区别？",
"link": "/basic/JavaScript/**mouseEnter、mouseLeave、mouseOver、mouseOut 有什么区别？"
},
{
"text": "**onpopstate 可以监听到 pushstate 的事件吗？",
"link": "/basic/JavaScript/**onpopstate 可以监听到 pushstate 的事件吗？"
},
{
"text": "**postMessage 是如何解决跨域问题的？",
"link": "/basic/JavaScript/**postMessage 是如何解决跨域问题的？"
},
{
"text": "**qiankun 是如何实现 JS 隔离的？",
"link": "/basic/JavaScript/**qiankun 是如何实现 JS 隔离的？"
},
{
"text": "**splice 和 slice 有什么区别？",
"link": "/basic/JavaScript/**splice 和 slice 有什么区别？"
},
{
"text": "**typeof null 的结果是什么，为什么？",
"link": "/basic/JavaScript/**typeof null 的结果是什么，为什么？"
},
{
"text": "**use strict是什么，有什么用？",
"link": "/basic/JavaScript/**use strict是什么，有什么用？"
},
{
"text": "**一直在 window 上面挂内容（数据，方法等等），是否有什么风险？",
"link": "/basic/JavaScript/**一直在 window 上面挂内容（数据，方法等等），是否有什么风险？"
},
{
"text": "**下面代码的输出是什么？-1",
"link": "/basic/JavaScript/**下面代码的输出是什么？-1"
},
{
"text": "**为什么普通 for 循环的性能高于 forEach ？",
"link": "/basic/JavaScript/**为什么普通 for 循环的性能高于 forEach ？"
},
{
"text": "**什么是伪数组（类数组）？",
"link": "/basic/JavaScript/**什么是伪数组（类数组）？"
},
{
"text": "**什么是匿名函数？",
"link": "/basic/JavaScript/**什么是匿名函数？"
},
{
"text": "**使用 const 定义函数和直接用 function 声明有什么区别？",
"link": "/basic/JavaScript/**使用 const 定义函数和直接用 function 声明有什么区别？"
},
{
"text": "**全局作用域中，用 const 和 let 声明的变量不在 window 上，那到底在哪里？如何去获取？",
"link": "/basic/JavaScript/**全局作用域中，用 const 和 let 声明的变量不在 window 上，那到底在哪里？如何去获取？"
},
{
"text": "**函数声明与函数表达式有什么区别",
"link": "/basic/JavaScript/**函数声明与函数表达式有什么区别"
},
{
"text": "**函数的原型和对象的原型分别是什么？它们之间有何关联？结合代码进行说明。",
"link": "/basic/JavaScript/**函数的原型和对象的原型分别是什么？它们之间有何关联？结合代码进行说明。"
},
{
"text": "**判断数组的方式有哪些？",
"link": "/basic/JavaScript/**判断数组的方式有哪些？"
},
{
"text": "**副作用是什么概念",
"link": "/basic/JavaScript/**副作用是什么概念"
},
{
"text": "**原型链的终点是什么？",
"link": "/basic/JavaScript/**原型链的终点是什么？"
},
{
"text": "**原生 js 如何进行监听路由的变化？",
"link": "/basic/JavaScript/**原生 js 如何进行监听路由的变化？"
},
{
"text": "**哪些原因会导致js里this指向混乱？",
"link": "/basic/JavaScript/**哪些原因会导致js里this指向混乱？"
},
{
"text": "**如何冻结一个 JS 对象？",
"link": "/basic/JavaScript/**如何冻结一个 JS 对象？"
},
{
"text": "**如何减少项目里的 if-else",
"link": "/basic/JavaScript/**如何减少项目里的 if-else"
},
{
"text": "**如何判断一个元素是否在可视区域中？",
"link": "/basic/JavaScript/**如何判断一个元素是否在可视区域中？"
},
{
"text": "**如何在前端项目中实现动态路由？",
"link": "/basic/JavaScript/**如何在前端项目中实现动态路由？"
},
{
"text": "**如何实现上拉加载，下拉刷新？",
"link": "/basic/JavaScript/**如何实现上拉加载，下拉刷新？"
},
{
"text": "**如何拦截 web 应用的请求",
"link": "/basic/JavaScript/**如何拦截 web 应用的请求"
},
{
"text": "**如何检测对象是否循环引用？",
"link": "/basic/JavaScript/**如何检测对象是否循环引用？"
},
{
"text": "**如何用Promise.all实现并发请求？如何处理部分请求失败？",
"link": "/basic/JavaScript/**如何用Promise.all实现并发请求？如何处理部分请求失败？"
},
{
"text": "**如何自定义鼠标右键菜单？",
"link": "/basic/JavaScript/**如何自定义鼠标右键菜单？"
},
{
"text": "**如何通过bind或箭头函数固定this指向？",
"link": "/basic/JavaScript/**如何通过bind或箭头函数固定this指向？"
},
{
"text": "**如何避免setInterval可能导致的定时器堆积问题？",
"link": "/basic/JavaScript/**如何避免setInterval可能导致的定时器堆积问题？"
},
{
"text": "**实现一个函数， 计算两个日期之间的天数差",
"link": "/basic/JavaScript/**实现一个函数， 计算两个日期之间的天数差"
},
{
"text": "**实现日期格式化 format 函数",
"link": "/basic/JavaScript/**实现日期格式化 format 函数"
},
{
"text": "**对象取值中 a.b.c.d 和 a['b']['c']['d'] 有何区别？",
"link": "/basic/JavaScript/**对象取值中 a.b.c.d 和 a['b']['c']['d'] 有何区别？"
},
{
"text": "**引用类型有哪些，有什么特点",
"link": "/basic/JavaScript/**引用类型有哪些，有什么特点"
},
{
"text": "**微前端中的应用隔离是什么，一般是怎么实现的？",
"link": "/basic/JavaScript/**微前端中的应用隔离是什么，一般是怎么实现的？"
},
{
"text": "**微前端架构中，一般是如何做到 JavaScript 隔离的？",
"link": "/basic/JavaScript/**微前端架构中，一般是如何做到 JavaScript 隔离的？"
},
{
"text": "**数组里面有10万个数据，取第一个元素和第10万个元素的时间相差多少？",
"link": "/basic/JavaScript/**数组里面有10万个数据，取第一个元素和第10万个元素的时间相差多少？"
},
{
"text": "**普通函数动态参数 和 箭头函数的动态参数有什么区别？",
"link": "/basic/JavaScript/**普通函数动态参数 和 箭头函数的动态参数有什么区别？"
},
{
"text": "**箭头函数为何不能作为构造函数使用？",
"link": "/basic/JavaScript/**箭头函数为何不能作为构造函数使用？"
},
{
"text": "**箭头函数解决了什么问题",
"link": "/basic/JavaScript/**箭头函数解决了什么问题"
},
{
"text": "**虚拟滚动如何动态计算可视区域？无限滚动如何结合Intersection Observer优化性能？",
"link": "/basic/JavaScript/**虚拟滚动如何动态计算可视区域？无限滚动如何结合Intersection Observer优化性能？"
},
{
"text": "**解释一下原型、构造函数、实例、原型链 之间的关系？",
"link": "/basic/JavaScript/**解释一下原型、构造函数、实例、原型链 之间的关系？"
},
{
"text": "**说说 axios 的拦截器原理及应用，并简单手写核心逻辑",
"link": "/basic/JavaScript/**说说 axios 的拦截器原理及应用，并简单手写核心逻辑"
},
{
"text": "**说说你对 API IntersectionObserver 的理解，它有什么使用场景？",
"link": "/basic/JavaScript/**说说你对 API IntersectionObserver 的理解，它有什么使用场景？"
},
{
"text": "**说说你对 MutationObserver 的理解",
"link": "/basic/JavaScript/**说说你对 MutationObserver 的理解"
},
{
"text": "**说说你对 Promise 的了解？",
"link": "/basic/JavaScript/**说说你对 Promise 的了解？"
},
{
"text": "**说说你对 eval 的理解",
"link": "/basic/JavaScript/**说说你对 eval 的理解"
},
{
"text": "**说说你对高阶函数的理解",
"link": "/basic/JavaScript/**说说你对高阶函数的理解"
},
{
"text": "**说说对 new Function 的理解",
"link": "/basic/JavaScript/**说说对 new Function 的理解"
},
{
"text": "0.1+0.2为什么不等于0.3？",
"link": "/basic/JavaScript/0.1+0.2为什么不等于0.3？"
},
{
"text": "123['toString'].length + 123 的输出值是多少？",
"link": "/basic/JavaScript/123['toString'].length + 123 的输出值是多少？"
},
{
"text": "== 和 ===有什么区别，分别在什么情况使用？",
"link": "/basic/JavaScript/== 和 ===有什么区别，分别在什么情况使用？"
},
{
"text": "AST语法树是什么？",
"link": "/basic/JavaScript/AST语法树是什么？"
},
{
"text": "Axios的原理是什么？",
"link": "/basic/JavaScript/Axios的原理是什么？"
},
{
"text": "Babel 是什么？",
"link": "/basic/JavaScript/Babel 是什么？"
},
{
"text": "CSR和SSR分别是什么？",
"link": "/basic/JavaScript/CSR和SSR分别是什么？"
},
{
"text": "CSS动画和JS实现的动画分别有哪些优缺点？",
"link": "/basic/JavaScript/CSS动画和JS实现的动画分别有哪些优缺点？"
},
{
"text": "ES5怎么实现继承",
"link": "/basic/JavaScript/ES5怎么实现继承"
},
{
"text": "ES6-ES6中函数新增了哪些扩展？",
"link": "/basic/JavaScript/ES6-ES6中函数新增了哪些扩展？"
},
{
"text": "ES6-ES6中对象新增了哪些扩展？",
"link": "/basic/JavaScript/ES6-ES6中对象新增了哪些扩展？"
},
{
"text": "ES6-ES6中数组新增了哪些扩展？",
"link": "/basic/JavaScript/ES6-ES6中数组新增了哪些扩展？"
},
{
"text": "ES6-ES6中新增的Set、Map两种数据结构怎么理解？",
"link": "/basic/JavaScript/ES6-ES6中新增的Set、Map两种数据结构怎么理解？"
},
{
"text": "ES6-ES6中的 Reflect 对象有什么用？",
"link": "/basic/JavaScript/ES6-ES6中的 Reflect 对象有什么用？"
},
{
"text": "ES6-ES6有哪些新特性？",
"link": "/basic/JavaScript/ES6-ES6有哪些新特性？"
},
{
"text": "ES6-JavaScript中的简单数据类型有哪些？",
"link": "/basic/JavaScript/ES6-JavaScript中的简单数据类型有哪些？"
},
{
"text": "ES6-Map 和 Set 的用法以及区别",
"link": "/basic/JavaScript/ES6-Map 和 Set 的用法以及区别"
},
{
"text": "ES6-Map 和 WeakMap 有什么区别？",
"link": "/basic/JavaScript/ES6-Map 和 WeakMap 有什么区别？"
},
{
"text": "ES6-async-await 和 Promise 有什么关系？",
"link": "/basic/JavaScript/ES6-async-await 和 Promise 有什么关系？"
},
{
"text": "ES6-async-await 怎么进行错误处理？",
"link": "/basic/JavaScript/ES6-async-await 怎么进行错误处理？"
},
{
"text": "ES6-common.js和es6中模块引入的区别？",
"link": "/basic/JavaScript/ES6-common.js和es6中模块引入的区别？"
},
{
"text": "ES6-es5 中的类和es6中的class有什么区别？",
"link": "/basic/JavaScript/ES6-es5 中的类和es6中的class有什么区别？"
},
{
"text": "ES6-object.assign和扩展运算法是深拷贝还是浅拷贝，两者区别是什么？",
"link": "/basic/JavaScript/ES6-object.assign和扩展运算法是深拷贝还是浅拷贝，两者区别是什么？"
},
{
"text": "ES6-symbol 有什么用处？",
"link": "/basic/JavaScript/ES6-symbol 有什么用处？"
},
{
"text": "ES6-什么是 let 的临时性死区？",
"link": "/basic/JavaScript/ES6-什么是 let 的临时性死区？"
},
{
"text": "ES6-你是怎么理解ES6中 Decorator 的？使用场景有哪些？",
"link": "/basic/JavaScript/ES6-你是怎么理解ES6中 Decorator 的？使用场景有哪些？"
},
{
"text": "ES6-你是怎么理解ES6中Module的？使用场景有哪些？",
"link": "/basic/JavaScript/ES6-你是怎么理解ES6中Module的？使用场景有哪些？"
},
{
"text": "ES6-你是怎么理解ES6中Proxy的？使用场景有哪些？",
"link": "/basic/JavaScript/ES6-你是怎么理解ES6中Proxy的？使用场景有哪些？"
},
{
"text": "ES6-如何把一个对象变成可迭代对象？",
"link": "/basic/JavaScript/ES6-如何把一个对象变成可迭代对象？"
},
{
"text": "ES6-如果new一个箭头函数会怎么样？",
"link": "/basic/JavaScript/ES6-如果new一个箭头函数会怎么样？"
},
{
"text": "ES6-怎么理解ES6中 Generator的？使用场景有哪些？",
"link": "/basic/JavaScript/ES6-怎么理解ES6中 Generator的？使用场景有哪些？"
},
{
"text": "ES6-简单介绍下 ES6 中的 Iterator 迭代器",
"link": "/basic/JavaScript/ES6-简单介绍下 ES6 中的 Iterator 迭代器"
},
{
"text": "ES6-箭头函数和普通函数有啥区别？箭头函数能当构造函数吗？",
"link": "/basic/JavaScript/ES6-箭头函数和普通函数有啥区别？箭头函数能当构造函数吗？"
},
{
"text": "ES6-箭头函数的 this 指向哪⾥？",
"link": "/basic/JavaScript/ES6-箭头函数的 this 指向哪⾥？"
},
{
"text": "ES6-说说你对 Iterator, Generator 和 Async-Await 的理解",
"link": "/basic/JavaScript/ES6-说说你对 Iterator, Generator 和 Async-Await 的理解"
},
{
"text": "ES6-说说你对 new.target 的理解",
"link": "/basic/JavaScript/ES6-说说你对 new.target 的理解"
},
{
"text": "ES6-说说对 ES6 中rest参数的理解",
"link": "/basic/JavaScript/ES6-说说对 ES6 中rest参数的理解"
},
{
"text": "ES6-谈谈 Object.defineProperty 与 Proxy 的区别",
"link": "/basic/JavaScript/ES6-谈谈 Object.defineProperty 与 Proxy 的区别"
},
{
"text": "ES6中函数新增了哪些扩展？",
"link": "/basic/JavaScript/ES6中函数新增了哪些扩展？"
},
{
"text": "ES6中对象新增了哪些扩展？",
"link": "/basic/JavaScript/ES6中对象新增了哪些扩展？"
},
{
"text": "ES6中新增的Set、Map两种数据结构怎么理解？",
"link": "/basic/JavaScript/ES6中新增的Set、Map两种数据结构怎么理解？"
},
{
"text": "ES6中的 Reflect 对象有什么用？",
"link": "/basic/JavaScript/ES6中的 Reflect 对象有什么用？"
},
{
"text": "ES6有哪些新特性？",
"link": "/basic/JavaScript/ES6有哪些新特性？"
},
{
"text": "JQuery中的$(document).ready与window.onload有什么区别？",
"link": "/basic/JavaScript/JQuery中的$(document).ready与window.onload有什么区别？"
},
{
"text": "JSBridge是什么？",
"link": "/basic/JavaScript/JSBridge是什么？"
},
{
"text": "JS中怎么阻止事件冒泡和默认事件？",
"link": "/basic/JavaScript/JS中怎么阻止事件冒泡和默认事件？"
},
{
"text": "JS中本地对象、内置对象、宿主对象分别是什么，有什么区别？",
"link": "/basic/JavaScript/JS中本地对象、内置对象、宿主对象分别是什么，有什么区别？"
},
{
"text": "JS代码中的use strict是什么意思？",
"link": "/basic/JavaScript/JS代码中的use strict是什么意思？"
},
{
"text": "JavaScript 中如何取消请求",
"link": "/basic/JavaScript/JavaScript 中如何取消请求"
},
{
"text": "JavaScript中执行上下文和执行栈是什么？",
"link": "/basic/JavaScript/JavaScript中执行上下文和执行栈是什么？"
},
{
"text": "JavaScript中的 sort 方法是怎么实现的？",
"link": "/basic/JavaScript/JavaScript中的 sort 方法是怎么实现的？"
},
{
"text": "JavaScript中的事件模型有哪些",
"link": "/basic/JavaScript/JavaScript中的事件模型有哪些"
},
{
"text": "JavaScript中的原型，原型链分别是什么？",
"link": "/basic/JavaScript/JavaScript中的原型，原型链分别是什么？"
},
{
"text": "JavaScript中的错误有哪几种类型？",
"link": "/basic/JavaScript/JavaScript中的错误有哪几种类型？"
},
{
"text": "JavaScript脚本延迟加载的方式有哪些？",
"link": "/basic/JavaScript/JavaScript脚本延迟加载的方式有哪些？"
},
{
"text": "Javascript中如何实现函数缓存？函数缓存有哪些应用场景？",
"link": "/basic/JavaScript/Javascript中如何实现函数缓存？函数缓存有哪些应用场景？"
},
{
"text": "Javascript如何实现继承？",
"link": "/basic/JavaScript/Javascript如何实现继承？"
},
{
"text": "Javascript字符串的常用方法有哪些？",
"link": "/basic/JavaScript/Javascript字符串的常用方法有哪些？"
},
{
"text": "Javascript本地存储的方式有哪些，有什么区别，及有哪些应用场景？",
"link": "/basic/JavaScript/Javascript本地存储的方式有哪些，有什么区别，及有哪些应用场景？"
},
{
"text": "Javscript数组的常用方法有哪些？",
"link": "/basic/JavaScript/Javscript数组的常用方法有哪些？"
},
{
"text": "Js 动画与 CSS 动画区别及相应实现",
"link": "/basic/JavaScript/Js 动画与 CSS 动画区别及相应实现"
},
{
"text": "Map 和 WeakMap 有什么区别？",
"link": "/basic/JavaScript/Map 和 WeakMap 有什么区别？"
},
{
"text": "Math.ceil 和 Math.floor 有什么区别？",
"link": "/basic/JavaScript/Math.ceil 和 Math.floor 有什么区别？"
},
{
"text": "Math.ceil()、Math.round()、Math.floor()三者的区别是什么？",
"link": "/basic/JavaScript/Math.ceil()、Math.round()、Math.floor()三者的区别是什么？"
},
{
"text": "MessageChannel 是什么，有什么使用场景？",
"link": "/basic/JavaScript/MessageChannel 是什么，有什么使用场景？"
},
{
"text": "NaN 是什么，用 typeof 会输出什么？",
"link": "/basic/JavaScript/NaN 是什么，用 typeof 会输出什么？"
},
{
"text": "Object.create 和 new 有什么区别？",
"link": "/basic/JavaScript/Object.create 和 new 有什么区别？"
},
{
"text": "Object.is() 与比较操作符 “===”、“==” 的区别？",
"link": "/basic/JavaScript/Object.is() 与比较操作符 “===”、“==” 的区别？"
},
{
"text": "Object.is和===有什么区别？",
"link": "/basic/JavaScript/Object.is和===有什么区别？"
},
{
"text": "Object与Map有什么区别？",
"link": "/basic/JavaScript/Object与Map有什么区别？"
},
{
"text": "Promise then 第二个参数和catch的区别是什么？",
"link": "/basic/JavaScript/Promise then 第二个参数和catch的区别是什么？"
},
{
"text": "Promise 的 finally 怎么实现的？",
"link": "/basic/JavaScript/Promise 的 finally 怎么实现的？"
},
{
"text": "Promise.all 和 Promise.allSettled 有什么区别？",
"link": "/basic/JavaScript/Promise.all 和 Promise.allSettled 有什么区别？"
},
{
"text": "Promise中的值穿透是什么？",
"link": "/basic/JavaScript/Promise中的值穿透是什么？"
},
{
"text": "Promise中，resolve后面的语句是否还会执行？",
"link": "/basic/JavaScript/Promise中，resolve后面的语句是否还会执行？"
},
{
"text": "Proxy 能够监听到对象中的对象的引用吗？",
"link": "/basic/JavaScript/Proxy 能够监听到对象中的对象的引用吗？"
},
{
"text": "RESTful 接口规范是什么？",
"link": "/basic/JavaScript/RESTful 接口规范是什么？"
},
{
"text": "Service worker是什么？",
"link": "/basic/JavaScript/Service worker是什么？"
},
{
"text": "Web Worker 是什么？",
"link": "/basic/JavaScript/Web Worker 是什么？"
},
{
"text": "WebSocket 中的心跳是为了解决什么问题？",
"link": "/basic/JavaScript/WebSocket 中的心跳是为了解决什么问题？"
},
{
"text": "['1','2','3'].map(parseInt) 的返回值是什么？",
"link": "/basic/JavaScript/['1','2','3'].map(parseInt) 的返回值是什么？"
},
{
"text": "['10', '10', '10', '10', '10'].map(parseInt)",
"link": "/basic/JavaScript/['10', '10', '10', '10', '10'].map(parseInt)"
},
{
"text": "[] == ![]结果是什么？",
"link": "/basic/JavaScript/[] == ![]结果是什么？"
},
{
"text": "addEventListener 第三个参数",
"link": "/basic/JavaScript/addEventListener 第三个参数"
},
{
"text": "ajax、axios、fetch有什么区别？",
"link": "/basic/JavaScript/ajax、axios、fetch有什么区别？"
},
{
"text": "async-await 和 Promise 有什么关系？",
"link": "/basic/JavaScript/async-await 和 Promise 有什么关系？"
},
{
"text": "async-await 怎么进行错误处理？",
"link": "/basic/JavaScript/async-await 怎么进行错误处理？"
},
{
"text": "async-await、generator、promise 这三者的关联和区别是什么？",
"link": "/basic/JavaScript/async-await、generator、promise 这三者的关联和区别是什么？"
},
{
"text": "async、await 实现原理",
"link": "/basic/JavaScript/async、await 实现原理"
},
{
"text": "base64编码图片，为什么会让数据量变大？",
"link": "/basic/JavaScript/base64编码图片，为什么会让数据量变大？"
},
{
"text": "bind() 连续调用多次，this的绑定值是什么呢？",
"link": "/basic/JavaScript/bind() 连续调用多次，this的绑定值是什么呢？"
},
{
"text": "bind、call、apply 有什么区别？如何实现一个bind？",
"link": "/basic/JavaScript/bind、call、apply 有什么区别？如何实现一个bind？"
},
{
"text": "canvas 和 webgl 有什么区别？",
"link": "/basic/JavaScript/canvas 和 webgl 有什么区别？"
},
{
"text": "cookie 的有效时间设置为 0 会怎么样",
"link": "/basic/JavaScript/cookie 的有效时间设置为 0 会怎么样"
},
{
"text": "cookie、localStorage和sessionStorage 三者之间有什么区别",
"link": "/basic/JavaScript/cookie、localStorage和sessionStorage 三者之间有什么区别"
},
{
"text": "document.write和innerHTML有什么区别",
"link": "/basic/JavaScript/document.write和innerHTML有什么区别"
},
{
"text": "e.target 和 e.currentTarget 有什么区别？",
"link": "/basic/JavaScript/e.target 和 e.currentTarget 有什么区别？"
},
{
"text": "es5 中的类和es6中的class有什么区别？",
"link": "/basic/JavaScript/es5 中的类和es6中的class有什么区别？"
},
{
"text": "flexible.js实现移动端适配的原理是什么？",
"link": "/basic/JavaScript/flexible.js实现移动端适配的原理是什么？"
},
{
"text": "for...in和for...of有什么区别？",
"link": "/basic/JavaScript/for...in和for...of有什么区别？"
},
{
"text": "forEach 中能否使用 await ？",
"link": "/basic/JavaScript/forEach 中能否使用 await ？"
},
{
"text": "forEach中return有效果吗？如何中断forEach循环？",
"link": "/basic/JavaScript/forEach中return有效果吗？如何中断forEach循环？"
},
{
"text": "generator 是怎么做到中断和恢复的？",
"link": "/basic/JavaScript/generator 是怎么做到中断和恢复的？"
},
{
"text": "html文档渲染过程，css文件和js文件的下载，是否会阻塞渲染？",
"link": "/basic/JavaScript/html文档渲染过程，css文件和js文件的下载，是否会阻塞渲染？"
},
{
"text": "instanceof能否判断基本数据类型？",
"link": "/basic/JavaScript/instanceof能否判断基本数据类型？"
},
{
"text": "isNaN 和 Number.isNaN 函数有什么区别？",
"link": "/basic/JavaScript/isNaN 和 Number.isNaN 函数有什么区别？"
},
{
"text": "jquery的链式调用是怎么实现的？",
"link": "/basic/JavaScript/jquery的链式调用是怎么实现的？"
},
{
"text": "js 中的倒计时，怎么实现纠正偏差？",
"link": "/basic/JavaScript/js 中的倒计时，怎么实现纠正偏差？"
},
{
"text": "js中如何判断一个值是否是数组类型？",
"link": "/basic/JavaScript/js中如何判断一个值是否是数组类型？"
},
{
"text": "js中数组是如何在内存中存储的？",
"link": "/basic/JavaScript/js中数组是如何在内存中存储的？"
},
{
"text": "js中的undefined和 ReferenceError: xxx is not defined 有什么区别？",
"link": "/basic/JavaScript/js中的undefined和 ReferenceError: xxx is not defined 有什么区别？"
},
{
"text": "js函数有哪几种声明方式？有什么区别？",
"link": "/basic/JavaScript/js函数有哪几种声明方式？有什么区别？"
},
{
"text": "map 和 forEach 有什么区别？",
"link": "/basic/JavaScript/map 和 forEach 有什么区别？"
},
{
"text": "map和 filter 有什么区别？",
"link": "/basic/JavaScript/map和 filter 有什么区别？"
},
{
"text": "mouseEnter 和 mouseOver 有什么区别？",
"link": "/basic/JavaScript/mouseEnter 和 mouseOver 有什么区别？"
},
{
"text": "new fn与new fn()有什么区别吗？",
"link": "/basic/JavaScript/new fn与new fn()有什么区别吗？"
},
{
"text": "npm 是什么？",
"link": "/basic/JavaScript/npm 是什么？"
},
{
"text": "null 和 undefined 有什么区别？",
"link": "/basic/JavaScript/null 和 undefined 有什么区别？"
},
{
"text": "null是对象吗？为什么？",
"link": "/basic/JavaScript/null是对象吗？为什么？"
},
{
"text": "object.assign和扩展运算法是深拷贝还是浅拷贝，两者区别是什么？",
"link": "/basic/JavaScript/object.assign和扩展运算法是深拷贝还是浅拷贝，两者区别是什么？"
},
{
"text": "offsetWidth-offsetHeight,clientWidth-clientHeight 与 scrollWidth-scrollHeight 的区别？",
"link": "/basic/JavaScript/offsetWidth-offsetHeight,clientWidth-clientHeight 与 scrollWidth-scrollHeight 的区别？"
},
{
"text": "postMessage 有哪些使用场景？",
"link": "/basic/JavaScript/postMessage 有哪些使用场景？"
},
{
"text": "promise.catch后面的.then还会执行吗？",
"link": "/basic/JavaScript/promise.catch后面的.then还会执行吗？"
},
{
"text": "setTimeout 为什么不能保证能够及时执行？",
"link": "/basic/JavaScript/setTimeout 为什么不能保证能够及时执行？"
},
{
"text": "setTimeout 延时写成0，一般可以什么场景下使用？",
"link": "/basic/JavaScript/setTimeout 延时写成0，一般可以什么场景下使用？"
},
{
"text": "toPrecision 和 toFixed 和 Math.round 有什么区别？",
"link": "/basic/JavaScript/toPrecision 和 toFixed 和 Math.round 有什么区别？"
},
{
"text": "try...catch 可以捕获到异步代码中的错误吗？",
"link": "/basic/JavaScript/try...catch 可以捕获到异步代码中的错误吗？"
},
{
"text": "typeof NaN 的结果是什么？",
"link": "/basic/JavaScript/typeof NaN 的结果是什么？"
},
{
"text": "typeof 与 instanceof 有什么区别",
"link": "/basic/JavaScript/typeof 与 instanceof 有什么区别"
},
{
"text": "typeof 是否能正确判断类型？",
"link": "/basic/JavaScript/typeof 是否能正确判断类型？"
},
{
"text": "var、let、const之间有什么区别？",
"link": "/basic/JavaScript/var、let、const之间有什么区别？"
},
{
"text": "webSocket如何兼容低浏览器",
"link": "/basic/JavaScript/webSocket如何兼容低浏览器"
},
{
"text": "web常见的攻击方式有哪些，以及如何进行防御？",
"link": "/basic/JavaScript/web常见的攻击方式有哪些，以及如何进行防御？"
},
{
"text": "xml和json有什么区别？",
"link": "/basic/JavaScript/xml和json有什么区别？"
},
{
"text": "arguments 这种类数组，如何遍历类数组？",
"link": "/basic/JavaScript/arguments 这种类数组，如何遍历类数组？"
},
{
"text": "const声明了数组，还能push元素吗，为什么？",
"link": "/basic/JavaScript/const声明了数组，还能push元素吗，为什么？"
},
{
"text": "“严格模式”是什么？",
"link": "/basic/JavaScript/“严格模式”是什么？"
},
{
"text": "【Promise第10题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第10题】下面代码的输出是什么？"
},
{
"text": "【Promise第11题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第11题】下面代码的输出是什么？"
},
{
"text": "【Promise第12题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第12题】下面代码的输出是什么？"
},
{
"text": "【Promise第13题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第13题】下面代码的输出是什么？"
},
{
"text": "【Promise第14题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第14题】下面代码的输出是什么？"
},
{
"text": "【Promise第15题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第15题】下面代码的输出是什么？"
},
{
"text": "【Promise第16题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第16题】下面代码的输出是什么？"
},
{
"text": "【Promise第17题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第17题】下面代码的输出是什么？"
},
{
"text": "【Promise第18题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第18题】下面代码的输出是什么？"
},
{
"text": "【Promise第19题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第19题】下面代码的输出是什么？"
},
{
"text": "【Promise第20题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第20题】下面代码的输出是什么？"
},
{
"text": "【Promise第21题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第21题】下面代码的输出是什么？"
},
{
"text": "【Promise第22题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第22题】下面代码的输出是什么？"
},
{
"text": "【Promise第23题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第23题】下面代码的输出是什么？"
},
{
"text": "【Promise第24题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第24题】下面代码的输出是什么？"
},
{
"text": "【Promise第25题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第25题】下面代码的输出是什么？"
},
{
"text": "【Promise第26题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第26题】下面代码的输出是什么？"
},
{
"text": "【Promise第27题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第27题】下面代码的输出是什么？"
},
{
"text": "【Promise第28题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第28题】下面代码的输出是什么？"
},
{
"text": "【Promise第29题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第29题】下面代码的输出是什么？"
},
{
"text": "【Promise第30题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第30题】下面代码的输出是什么？"
},
{
"text": "【Promise第31题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第31题】下面代码的输出是什么？"
},
{
"text": "【Promise第32题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第32题】下面代码的输出是什么？"
},
{
"text": "【Promise第33题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第33题】下面代码的输出是什么？"
},
{
"text": "【Promise第34题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第34题】下面代码的输出是什么？"
},
{
"text": "【Promise第35题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第35题】下面代码的输出是什么？"
},
{
"text": "【Promise第36题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第36题】下面代码的输出是什么？"
},
{
"text": "【Promise第37题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第37题】下面代码的输出是什么？"
},
{
"text": "【Promise第38题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第38题】下面代码的输出是什么？"
},
{
"text": "【Promise第39题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第39题】下面代码的输出是什么？"
},
{
"text": "【Promise第40题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第40题】下面代码的输出是什么？"
},
{
"text": "【Promise第一题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第一题】下面代码的输出是什么？"
},
{
"text": "【Promise第七题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第七题】下面代码的输出是什么？"
},
{
"text": "【Promise第三题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第三题】下面代码的输出是什么？"
},
{
"text": "【Promise第九题】下面两段代码分别输出什么？",
"link": "/basic/JavaScript/【Promise第九题】下面两段代码分别输出什么？"
},
{
"text": "【Promise第二题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第二题】下面代码的输出是什么？"
},
{
"text": "【Promise第五题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第五题】下面代码的输出是什么？"
},
{
"text": "【Promise第八题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第八题】下面代码的输出是什么？"
},
{
"text": "【Promise第六题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第六题】下面代码的输出是什么？"
},
{
"text": "【Promise第四题】下面代码的输出是什么？",
"link": "/basic/JavaScript/【Promise第四题】下面代码的输出是什么？"
},
{
"text": "一个滚动公告组件，如何在鼠标滑入时停止播放，在鼠标离开时继续等待滑入时的剩余等待时间后播放？",
"link": "/basic/JavaScript/一个滚动公告组件，如何在鼠标滑入时停止播放，在鼠标离开时继续等待滑入时的剩余等待时间后播放？"
},
{
"text": "下面代码会输出什么？",
"link": "/basic/JavaScript/下面代码会输出什么？"
},
{
"text": "下面代码的输出是什么？-2",
"link": "/basic/JavaScript/下面代码的输出是什么？-2"
},
{
"text": "下面代码的输出是什么？-3",
"link": "/basic/JavaScript/下面代码的输出是什么？-3"
},
{
"text": "下面代码的输出是什么？-4",
"link": "/basic/JavaScript/下面代码的输出是什么？-4"
},
{
"text": "下面执行后输出什么？",
"link": "/basic/JavaScript/下面执行后输出什么？"
},
{
"text": "不会冒泡的事件有哪些？",
"link": "/basic/JavaScript/不会冒泡的事件有哪些？"
},
{
"text": "为什么JavaScript是单线程？",
"link": "/basic/JavaScript/为什么JavaScript是单线程？"
},
{
"text": "为什么要区分宏任务和微任务？它们的执行优先级是什么？",
"link": "/basic/JavaScript/为什么要区分宏任务和微任务？它们的执行优先级是什么？"
},
{
"text": "为什么部分请求中，参数需要使用 encodeURIComponent 进行转码？",
"link": "/basic/JavaScript/为什么部分请求中，参数需要使用 encodeURIComponent 进行转码？"
},
{
"text": "举例说明你对尾递归的理解，以及有哪些应用场景",
"link": "/basic/JavaScript/举例说明你对尾递归的理解，以及有哪些应用场景"
},
{
"text": "什么是 PWA？",
"link": "/basic/JavaScript/什么是 PWA？"
},
{
"text": "什么是 Polyfill ？",
"link": "/basic/JavaScript/什么是 Polyfill ？"
},
{
"text": "什么是BigInt？",
"link": "/basic/JavaScript/什么是BigInt？"
},
{
"text": "什么是“事件代理”",
"link": "/basic/JavaScript/什么是“事件代理”"
},
{
"text": "什么是“前端路由”？什么时候适合使用“前端路由”？“前端路由”有哪些优点和缺点？",
"link": "/basic/JavaScript/什么是“前端路由”？什么时候适合使用“前端路由”？“前端路由”有哪些优点和缺点？"
},
{
"text": "什么是事件代理，以及它的应用场景有哪些？",
"link": "/basic/JavaScript/什么是事件代理，以及它的应用场景有哪些？"
},
{
"text": "什么是作用域链？",
"link": "/basic/JavaScript/什么是作用域链？"
},
{
"text": "什么是内存泄漏？什么原因会导致呢？",
"link": "/basic/JavaScript/什么是内存泄漏？什么原因会导致呢？"
},
{
"text": "什么是变量提升",
"link": "/basic/JavaScript/什么是变量提升"
},
{
"text": "什么是同步和异步？",
"link": "/basic/JavaScript/什么是同步和异步？"
},
{
"text": "什么是尾调用优化和尾递归？",
"link": "/basic/JavaScript/什么是尾调用优化和尾递归？"
},
{
"text": "什么是微前端？",
"link": "/basic/JavaScript/什么是微前端？"
},
{
"text": "什么是点击穿透，怎么解决？",
"link": "/basic/JavaScript/什么是点击穿透，怎么解决？"
},
{
"text": "什么是类数组对象？",
"link": "/basic/JavaScript/什么是类数组对象？"
},
{
"text": "什么是跨域？",
"link": "/basic/JavaScript/什么是跨域？"
},
{
"text": "什么是防抖和节流，以及如何编码实现？",
"link": "/basic/JavaScript/什么是防抖和节流，以及如何编码实现？"
},
{
"text": "介绍一下 setTimeout 的运行机制",
"link": "/basic/JavaScript/介绍一下 setTimeout 的运行机制"
},
{
"text": "以下代码的输出是什么？",
"link": "/basic/JavaScript/以下代码的输出是什么？"
},
{
"text": "以下代码输出什么？解释原因",
"link": "/basic/JavaScript/以下代码输出什么？解释原因"
},
{
"text": "以下等式是成立的吗：1_000_000 === 1000000 ？",
"link": "/basic/JavaScript/以下等式是成立的吗：1_000_000 === 1000000 ？"
},
{
"text": "你是怎么理解ES6中 Decorator 的？使用场景有哪些？",
"link": "/basic/JavaScript/你是怎么理解ES6中 Decorator 的？使用场景有哪些？"
},
{
"text": "你是怎么理解ES6中 Promise的？使用场景有哪些？",
"link": "/basic/JavaScript/你是怎么理解ES6中 Promise的？使用场景有哪些？"
},
{
"text": "你是怎么理解ES6中Module的？使用场景有哪些？",
"link": "/basic/JavaScript/你是怎么理解ES6中Module的？使用场景有哪些？"
},
{
"text": "你是怎么理解ES6中Proxy的？使用场景有哪些？",
"link": "/basic/JavaScript/你是怎么理解ES6中Proxy的？使用场景有哪些？"
},
{
"text": "使用Promise实现每隔1秒输出1,2,3",
"link": "/basic/JavaScript/使用Promise实现每隔1秒输出1,2,3"
},
{
"text": "使用Promise实现：限制异步操作的并发个数，并尽可能快的完成全部",
"link": "/basic/JavaScript/使用Promise实现：限制异步操作的并发个数，并尽可能快的完成全部"
},
{
"text": "使用Promise封装一个异步加载图片的方法",
"link": "/basic/JavaScript/使用Promise封装一个异步加载图片的方法"
},
{
"text": "使用js实现二分查找",
"link": "/basic/JavaScript/使用js实现二分查找"
},
{
"text": "使用js生成1-10000的数组",
"link": "/basic/JavaScript/使用js生成1-10000的数组"
},
{
"text": "使用原生js给一个按钮绑定两个onclick事件",
"link": "/basic/JavaScript/使用原生js给一个按钮绑定两个onclick事件"
},
{
"text": "全排列",
"link": "/basic/JavaScript/全排列"
},
{
"text": "写一个 LRU 缓存函数",
"link": "/basic/JavaScript/写一个 LRU 缓存函数"
},
{
"text": "写一个 repeat 方法，实现字符串的复制拼接",
"link": "/basic/JavaScript/写一个 repeat 方法，实现字符串的复制拼接"
},
{
"text": "写一个返回数据类型的函数，要求自定义的类实例化的对象返回定义的类名",
"link": "/basic/JavaScript/写一个返回数据类型的函数，要求自定义的类实例化的对象返回定义的类名"
},
{
"text": "写出一个函数trans，将数字转换成汉语的输出，输入为不超过10000亿的数字。",
"link": "/basic/JavaScript/写出一个函数trans，将数字转换成汉语的输出，输入为不超过10000亿的数字。"
},
{
"text": "前端实现动画有哪些方式？",
"link": "/basic/JavaScript/前端实现动画有哪些方式？"
},
{
"text": "前端怎么实现跨域请求？",
"link": "/basic/JavaScript/前端怎么实现跨域请求？"
},
{
"text": "前端的页面截图怎么实现？",
"link": "/basic/JavaScript/前端的页面截图怎么实现？"
},
{
"text": "前端跨页面通信，你知道哪些方法？",
"link": "/basic/JavaScript/前端跨页面通信，你知道哪些方法？"
},
{
"text": "前端路由 `a -> b -> c`这样前进，也可以返回 `c -> b -> a`，用什么数据结构来存比较高效",
"link": "/basic/JavaScript/前端路由 `a -> b -> c`这样前进，也可以返回 `c -> b -> a`，用什么数据结构来存比较高效"
},
{
"text": "堆与栈有什么区别？",
"link": "/basic/JavaScript/堆与栈有什么区别？"
},
{
"text": "大文件怎么实现断点续传？",
"link": "/basic/JavaScript/大文件怎么实现断点续传？"
},
{
"text": "如何中断Promise？",
"link": "/basic/JavaScript/如何中断Promise？"
},
{
"text": "如何使用js计算一个html页面有多少种标签？",
"link": "/basic/JavaScript/如何使用js计算一个html页面有多少种标签？"
},
{
"text": "如何判断一个对象是不是空对象？",
"link": "/basic/JavaScript/如何判断一个对象是不是空对象？"
},
{
"text": "如何判断当前脚本运行在浏览器还是 node 环境中？",
"link": "/basic/JavaScript/如何判断当前脚本运行在浏览器还是 node 环境中？"
},
{
"text": "如何判断某个字符串长度（要求支持表情）？",
"link": "/basic/JavaScript/如何判断某个字符串长度（要求支持表情）？"
},
{
"text": "如何判断页面是通过PC端还是移动端访问？",
"link": "/basic/JavaScript/如何判断页面是通过PC端还是移动端访问？"
},
{
"text": "如何区分数组和对象？",
"link": "/basic/JavaScript/如何区分数组和对象？"
},
{
"text": "如何实现浏览器内多个标签页之间的通信？",
"link": "/basic/JavaScript/如何实现浏览器内多个标签页之间的通信？"
},
{
"text": "如何把一个对象变成可迭代对象？",
"link": "/basic/JavaScript/如何把一个对象变成可迭代对象？"
},
{
"text": "如何确保你的构造函数只能被new调用，而不能被普通调用？",
"link": "/basic/JavaScript/如何确保你的构造函数只能被new调用，而不能被普通调用？"
},
{
"text": "如何获取到一个实例对象的原型对象？",
"link": "/basic/JavaScript/如何获取到一个实例对象的原型对象？"
},
{
"text": "如何获取页面的滚动距离值？",
"link": "/basic/JavaScript/如何获取页面的滚动距离值？"
},
{
"text": "如何让 Proxy 去监听基本数据类型？",
"link": "/basic/JavaScript/如何让 Proxy 去监听基本数据类型？"
},
{
"text": "如何让 var [a, b] = {a: 1, b: 2} 解构赋值成功？",
"link": "/basic/JavaScript/如何让 var [a, b] = {a: 1, b: 2} 解构赋值成功？"
},
{
"text": "如何让Promise.all在抛出异常后依然有效",
"link": "/basic/JavaScript/如何让Promise.all在抛出异常后依然有效"
},
{
"text": "如何顺序执行10个异步任务？",
"link": "/basic/JavaScript/如何顺序执行10个异步任务？"
},
{
"text": "如果new一个箭头函数会怎么样？",
"link": "/basic/JavaScript/如果new一个箭头函数会怎么样？"
},
{
"text": "如果使用 Math.random() 计算中奖概率会有什么问题吗？",
"link": "/basic/JavaScript/如果使用 Math.random() 计算中奖概率会有什么问题吗？"
},
{
"text": "如果空数组调用reduce会发生什么？",
"link": "/basic/JavaScript/如果空数组调用reduce会发生什么？"
},
{
"text": "如果要实现一个类似“谷歌图片”的系统，你会有哪些方面的考虑？",
"link": "/basic/JavaScript/如果要实现一个类似“谷歌图片”的系统，你会有哪些方面的考虑？"
},
{
"text": "如果要设计一个转盘组件，你会考虑哪些方面？有哪些是需要和业务方确认的技术细节？另外，如何从前端的角度进行防刷？",
"link": "/basic/JavaScript/如果要设计一个转盘组件，你会考虑哪些方面？有哪些是需要和业务方确认的技术细节？另外，如何从前端的角度进行防刷？"
},
{
"text": "实现mergePromise函数",
"link": "/basic/JavaScript/实现mergePromise函数"
},
{
"text": "实现一个数字转中文的方法",
"link": "/basic/JavaScript/实现一个数字转中文的方法"
},
{
"text": "实现以下转换，合并连续的数字",
"link": "/basic/JavaScript/实现以下转换，合并连续的数字"
},
{
"text": "实现微前端有哪些技术方案？",
"link": "/basic/JavaScript/实现微前端有哪些技术方案？"
},
{
"text": "导致 JavaScript 中 this 指向混乱的原因是什么？",
"link": "/basic/JavaScript/导致 JavaScript 中 this 指向混乱的原因是什么？"
},
{
"text": "导致页面加载白屏时间长的原因有哪些，怎么进行优化？",
"link": "/basic/JavaScript/导致页面加载白屏时间长的原因有哪些，怎么进行优化？"
},
{
"text": "将数组的length设置为0，取第一个元素会返回什么？",
"link": "/basic/JavaScript/将数组的length设置为0，取第一个元素会返回什么？"
},
{
"text": "岛屿数量",
"link": "/basic/JavaScript/岛屿数量"
},
{
"text": "异步编程有哪些实现方式？",
"link": "/basic/JavaScript/异步编程有哪些实现方式？"
},
{
"text": "微前端可以解决什么问题？",
"link": "/basic/JavaScript/微前端可以解决什么问题？"
},
{
"text": "怎么使用 Math.max、Math.min 获取数组中的最值？",
"link": "/basic/JavaScript/怎么使用 Math.max、Math.min 获取数组中的最值？"
},
{
"text": "怎么使用 js 动态生成海报？",
"link": "/basic/JavaScript/怎么使用 js 动态生成海报？"
},
{
"text": "怎么使用 js 实现拖拽功能？",
"link": "/basic/JavaScript/怎么使用 js 实现拖拽功能？"
},
{
"text": "怎么使用 setTimeout 实现 setInterval？",
"link": "/basic/JavaScript/怎么使用 setTimeout 实现 setInterval？"
},
{
"text": "怎么实现一个扫描二维码登录PC网站的需求？",
"link": "/basic/JavaScript/怎么实现一个扫描二维码登录PC网站的需求？"
},
{
"text": "怎么实现图片懒加载？",
"link": "/basic/JavaScript/怎么实现图片懒加载？"
},
{
"text": "怎么实现大型文件上传？",
"link": "/basic/JavaScript/怎么实现大型文件上传？"
},
{
"text": "怎么实现虚拟列表？",
"link": "/basic/JavaScript/怎么实现虚拟列表？"
},
{
"text": "怎么把函数中的 arguments 转成数组？",
"link": "/basic/JavaScript/怎么把函数中的 arguments 转成数组？"
},
{
"text": "怎么把十进制的 0.2 转换成二进制？",
"link": "/basic/JavaScript/怎么把十进制的 0.2 转换成二进制？"
},
{
"text": "怎么检测浏览器版本？",
"link": "/basic/JavaScript/怎么检测浏览器版本？"
},
{
"text": "怎么理解ES6中 Generator的？使用场景有哪些？",
"link": "/basic/JavaScript/怎么理解ES6中 Generator的？使用场景有哪些？"
},
{
"text": "怎么解决canvas中获取跨域图片数据的问题？",
"link": "/basic/JavaScript/怎么解决canvas中获取跨域图片数据的问题？"
},
{
"text": "怎么预防按钮的重复点击？",
"link": "/basic/JavaScript/怎么预防按钮的重复点击？"
},
{
"text": "怎么预防用户快速连续点击，造成数据多次提交？",
"link": "/basic/JavaScript/怎么预防用户快速连续点击，造成数据多次提交？"
},
{
"text": "我现在有一个canvas，上面随机布着一些黑块，请实现方法，计算canvas上有多少个黑块。",
"link": "/basic/JavaScript/我现在有一个canvas，上面随机布着一些黑块，请实现方法，计算canvas上有多少个黑块。"
},
{
"text": "描述下列代码的执行结果",
"link": "/basic/JavaScript/描述下列代码的执行结果"
},
{
"text": "改变this指向的方法有哪些？",
"link": "/basic/JavaScript/改变this指向的方法有哪些？"
},
{
"text": "数据类型检测的方式有哪些？",
"link": "/basic/JavaScript/数据类型检测的方式有哪些？"
},
{
"text": "数组中的reduce方法有用过吗，说说它的具体用途？",
"link": "/basic/JavaScript/数组中的reduce方法有用过吗，说说它的具体用途？"
},
{
"text": "是否有使用过空值合并运算符（？？），举几个可以使用的场景。",
"link": "/basic/JavaScript/是否有使用过空值合并运算符（？？），举几个可以使用的场景。"
},
{
"text": "正则表达式是什么，有哪些应用场景？",
"link": "/basic/JavaScript/正则表达式是什么，有哪些应用场景？"
},
{
"text": "浏览器一帧都会干些什么？",
"link": "/basic/JavaScript/浏览器一帧都会干些什么？"
},
{
"text": "浏览器为什么要有跨域限制？",
"link": "/basic/JavaScript/浏览器为什么要有跨域限制？"
},
{
"text": "浏览器和 Node 中的事件循环有什么区别？",
"link": "/basic/JavaScript/浏览器和 Node 中的事件循环有什么区别？"
},
{
"text": "浏览器有哪几种缓存，各种缓存的优先级是什么样的？",
"link": "/basic/JavaScript/浏览器有哪几种缓存，各种缓存的优先级是什么样的？"
},
{
"text": "浏览器的同源策略是什么？",
"link": "/basic/JavaScript/浏览器的同源策略是什么？"
},
{
"text": "浏览器的垃圾回收机制有哪些？",
"link": "/basic/JavaScript/浏览器的垃圾回收机制有哪些？"
},
{
"text": "深拷贝浅拷贝有什么区别？怎么实现深拷贝？",
"link": "/basic/JavaScript/深拷贝浅拷贝有什么区别？怎么实现深拷贝？"
},
{
"text": "版本号排序",
"link": "/basic/JavaScript/版本号排序"
},
{
"text": "用js实现二叉树的定义和基本操作",
"link": "/basic/JavaScript/用js实现二叉树的定义和基本操作"
},
{
"text": "直接在script标签中写 export 为什么会报错？",
"link": "/basic/JavaScript/直接在script标签中写 export 为什么会报错？"
},
{
"text": "相比于npm和yarn，pnpm的优势是什么？",
"link": "/basic/JavaScript/相比于npm和yarn，pnpm的优势是什么？"
},
{
"text": "移动端的点击事件的有延迟，时间是多久，为什么会有？ 怎么解决这个延时？",
"link": "/basic/JavaScript/移动端的点击事件的有延迟，时间是多久，为什么会有？ 怎么解决这个延时？"
},
{
"text": "简单介绍下 ES6 中的 Iterator 迭代器",
"link": "/basic/JavaScript/简单介绍下 ES6 中的 Iterator 迭代器"
},
{
"text": "箭头函数和普通函数有啥区别？箭头函数能当构造函数吗？",
"link": "/basic/JavaScript/箭头函数和普通函数有啥区别？箭头函数能当构造函数吗？"
},
{
"text": "箭头函数的 this 指向哪⾥？",
"link": "/basic/JavaScript/箭头函数的 this 指向哪⾥？"
},
{
"text": "给一个dom同时绑定两个点击事件，一个用捕获，一个用冒泡，说下会执行几次事件，然后会先执行冒泡还是捕获？",
"link": "/basic/JavaScript/给一个dom同时绑定两个点击事件，一个用捕获，一个用冒泡，说下会执行几次事件，然后会先执行冒泡还是捕获？"
},
{
"text": "给某个资源的链接，如 https:--www.baidu.com-index.html ，请实现一个方法，获取该资源的后缀，如 html",
"link": "/basic/JavaScript/给某个资源的链接，如 https:--www.baidu.com-index.html ，请实现一个方法，获取该资源的后缀，如 html"
},
{
"text": "编程实现温度转换，已知温度转换的关系式是：华氏度＝32＋摄氏度×1.8，现在要求输入摄氏度，输出对应的华氏度，小数保留两位",
"link": "/basic/JavaScript/编程实现温度转换，已知温度转换的关系式是：华氏度＝32＋摄氏度×1.8，现在要求输入摄氏度，输出对应的华氏度，小数保留两位"
},
{
"text": "背包问题",
"link": "/basic/JavaScript/背包问题"
},
{
"text": "虚拟dom渲染到页面的时候，框架会做哪些处理？",
"link": "/basic/JavaScript/虚拟dom渲染到页面的时候，框架会做哪些处理？"
},
{
"text": "解释下如下代码的意图：Array.prototype.slice.apply(arguments)",
"link": "/basic/JavaScript/解释下如下代码的意图：Array.prototype.slice.apply(arguments)"
},
{
"text": "说说 JavaScript 中内存泄漏有哪几种情况？",
"link": "/basic/JavaScript/说说 JavaScript 中内存泄漏有哪几种情况？"
},
{
"text": "说说 Javascript 为什么会存在数字精度丢失的问题，以及如何进行解决？",
"link": "/basic/JavaScript/说说 Javascript 为什么会存在数字精度丢失的问题，以及如何进行解决？"
},
{
"text": "说说ajax的原理，以及如何实现？",
"link": "/basic/JavaScript/说说ajax的原理，以及如何实现？"
},
{
"text": "说说new操作符具体干了什么？",
"link": "/basic/JavaScript/说说new操作符具体干了什么？"
},
{
"text": "说说sourcemap的原理？",
"link": "/basic/JavaScript/说说sourcemap的原理？"
},
{
"text": "说说下面代码执行后的输出是什么？",
"link": "/basic/JavaScript/说说下面代码执行后的输出是什么？"
},
{
"text": "说说下面代码的执行过程",
"link": "/basic/JavaScript/说说下面代码的执行过程"
},
{
"text": "说说下面代码的输出是什么？",
"link": "/basic/JavaScript/说说下面代码的输出是什么？"
},
{
"text": "说说下面代码的输出结果",
"link": "/basic/JavaScript/说说下面代码的输出结果"
},
{
"text": "说说你对 Iterator, Generator 和 Async-Await 的理解",
"link": "/basic/JavaScript/说说你对 Iterator, Generator 和 Async-Await 的理解"
},
{
"text": "说说你对 Object.defineProperty 的理解",
"link": "/basic/JavaScript/说说你对 Object.defineProperty 的理解"
},
{
"text": "说说你对 ToPrimitive 的理解",
"link": "/basic/JavaScript/说说你对 ToPrimitive 的理解"
},
{
"text": "说说你对 new.target 的理解",
"link": "/basic/JavaScript/说说你对 new.target 的理解"
},
{
"text": "说说你对 pnpm 的了解",
"link": "/basic/JavaScript/说说你对 pnpm 的了解"
},
{
"text": "说说你对 webpack5 模块联邦的了解？",
"link": "/basic/JavaScript/说说你对 webpack5 模块联邦的了解？"
},
{
"text": "说说你对BOM的理解，以及常见的BOM对象有哪些？",
"link": "/basic/JavaScript/说说你对BOM的理解，以及常见的BOM对象有哪些？"
},
{
"text": "说说你对JS的模块化方案的了解",
"link": "/basic/JavaScript/说说你对JS的模块化方案的了解"
},
{
"text": "说说你对SPA的理解",
"link": "/basic/JavaScript/说说你对SPA的理解"
},
{
"text": "说说你对“立即执行函数”的理解",
"link": "/basic/JavaScript/说说你对“立即执行函数”的理解"
},
{
"text": "说说你对事件循环的理解",
"link": "/basic/JavaScript/说说你对事件循环的理解"
},
{
"text": "说说你对以下几个页面生命周期事件的理解：DOMContentLoaded，load，beforeunload，unload",
"link": "/basic/JavaScript/说说你对以下几个页面生命周期事件的理解：DOMContentLoaded，load，beforeunload，unload"
},
{
"text": "说说你对函数式编程的理解，以及优缺点？",
"link": "/basic/JavaScript/说说你对函数式编程的理解，以及优缺点？"
},
{
"text": "说说你对模块化方案的理解，比如 CommonJS、AMD、CMD、ES Module 分别是什么？",
"link": "/basic/JavaScript/说说你对模块化方案的理解，比如 CommonJS、AMD、CMD、ES Module 分别是什么？"
},
{
"text": "说说你对轮询的理解",
"link": "/basic/JavaScript/说说你对轮询的理解"
},
{
"text": "说说你对闭包的理解，以及闭包使用场景",
"link": "/basic/JavaScript/说说你对闭包的理解，以及闭包使用场景"
},
{
"text": "说说你的ES6-ES12的了解",
"link": "/basic/JavaScript/说说你的ES6-ES12的了解"
},
{
"text": "说说对 WebSocket 的了解",
"link": "/basic/JavaScript/说说对 WebSocket 的了解"
},
{
"text": "说说对 requestIdleCallback 的理解",
"link": "/basic/JavaScript/说说对 requestIdleCallback 的理解"
},
{
"text": "请对以下数组，根据 `born` 的值降序排列",
"link": "/basic/JavaScript/请对以下数组，根据 `born` 的值降序排列"
},
{
"text": "请简述 == 的机制",
"link": "/basic/JavaScript/请简述 == 的机制"
},
{
"text": "谈谈 Javascript 中的类型转换机制",
"link": "/basic/JavaScript/谈谈 Javascript 中的类型转换机制"
},
{
"text": "谈谈 Object.defineProperty 与 Proxy 的区别",
"link": "/basic/JavaScript/谈谈 Object.defineProperty 与 Proxy 的区别"
},
{
"text": "谈谈你对事件冒泡和捕获的理解",
"link": "/basic/JavaScript/谈谈你对事件冒泡和捕获的理解"
},
{
"text": "谈谈你对浏览器中进程和线程的理解",
"link": "/basic/JavaScript/谈谈你对浏览器中进程和线程的理解"
},
{
"text": "谈谈你知道的DOM常见的操作",
"link": "/basic/JavaScript/谈谈你知道的DOM常见的操作"
},
{
"text": "谈谈对 this 对象的理解",
"link": "/basic/JavaScript/谈谈对 this 对象的理解"
},
{
"text": "谈谈对 window.requestAnimationFrame 的理解",
"link": "/basic/JavaScript/谈谈对 window.requestAnimationFrame 的理解"
},
{
"text": "连续 bind()多次，输出的值是什么？",
"link": "/basic/JavaScript/连续 bind()多次，输出的值是什么？"
},
{
"text": "遍历一个任意长度的list中的元素并依次创建异步任务，如何获取所有任务的执行结果？",
"link": "/basic/JavaScript/遍历一个任意长度的list中的元素并依次创建异步任务，如何获取所有任务的执行结果？"
},
{
"text": "遍历数组的方式有哪些？",
"link": "/basic/JavaScript/遍历数组的方式有哪些？"
},
{
"text": "需要在本地实现一个聊天室，多个tab页相互通信，不能用websocket，你会怎么做？",
"link": "/basic/JavaScript/需要在本地实现一个聊天室，多个tab页相互通信，不能用websocket，你会怎么做？"
},
{
"text": "非递归遍历二叉树",
"link": "/basic/JavaScript/非递归遍历二叉树"
},
{
"text": "页面加载的过程中，JS 文件是不是一定会阻塞 DOM 和 CSSOM 的构建？",
"link": "/basic/JavaScript/页面加载的过程中，JS 文件是不是一定会阻塞 DOM 和 CSSOM 的构建？"
}
],
"/coding/前端安全/": [
{
"text": "**HTTP是一个无状态的协议，那么Web应用是怎么保持用户的登录态的呢？",
"link": "/coding/前端安全/**HTTP是一个无状态的协议，那么Web应用是怎么保持用户的登录态的呢？"
},
{
"text": "**OAuth2.0 是什么，是怎么实现授权第三方应用登录的？",
"link": "/coding/前端安全/**OAuth2.0 是什么，是怎么实现授权第三方应用登录的？"
},
{
"text": "**cookie 可以实现在不同域名下共享吗？",
"link": "/coding/前端安全/**cookie 可以实现在不同域名下共享吗？"
},
{
"text": "**cookie 构成部分有哪些",
"link": "/coding/前端安全/**cookie 构成部分有哪些"
},
{
"text": "**介绍下如何实现 token 加密？",
"link": "/coding/前端安全/**介绍下如何实现 token 加密？"
},
{
"text": "**使用第三方库可能带来哪些安全风险？",
"link": "/coding/前端安全/**使用第三方库可能带来哪些安全风险？"
},
{
"text": "**前端如何防止加载外域脚本？",
"link": "/coding/前端安全/**前端如何防止加载外域脚本？"
},
{
"text": "**在域名 A 的网站上，跨域请求域名 B 上的接口，怎么在跨域请求中携带域名 B 的 Cookie 呢？",
"link": "/coding/前端安全/**在域名 A 的网站上，跨域请求域名 B 上的接口，怎么在跨域请求中携带域名 B 的 Cookie 呢？"
},
{
"text": "**如何禁止他人使用控制台调试前端页面代码？",
"link": "/coding/前端安全/**如何禁止他人使用控制台调试前端页面代码？"
},
{
"text": "**浏览器有同源策略，但是为什么我们可以将静态资源放到 CDN 上，使用不同的域名访问，这不会有跨域限制吗？",
"link": "/coding/前端安全/**浏览器有同源策略，但是为什么我们可以将静态资源放到 CDN 上，使用不同的域名访问，这不会有跨域限制吗？"
},
{
"text": "**说说 jwt 中的 token，是怎么进行身份验证的？",
"link": "/coding/前端安全/**说说 jwt 中的 token，是怎么进行身份验证的？"
},
{
"text": "**说说对数字证书的了解",
"link": "/coding/前端安全/**说说对数字证书的了解"
},
{
"text": "CSP（Content Security Policy）可以解决什么问题？",
"link": "/coding/前端安全/CSP（Content Security Policy）可以解决什么问题？"
},
{
"text": "CSRF攻击及防护",
"link": "/coding/前端安全/CSRF攻击及防护"
},
{
"text": "Cookie 的 SameSite 属性有什么作用？",
"link": "/coding/前端安全/Cookie 的 SameSite 属性有什么作用？"
},
{
"text": "HTTPS 有哪些优点？",
"link": "/coding/前端安全/HTTPS 有哪些优点？"
},
{
"text": "cookie中的 HttpOnly 属性有什么用途？",
"link": "/coding/前端安全/cookie中的 HttpOnly 属性有什么用途？"
},
{
"text": "iframe 安全",
"link": "/coding/前端安全/iframe 安全"
},
{
"text": "sql 注入",
"link": "/coding/前端安全/sql 注入"
},
{
"text": "webSocket 有哪些安全问题，应该如何应对？",
"link": "/coding/前端安全/webSocket 有哪些安全问题，应该如何应对？"
},
{
"text": "web常见的攻击方式有哪些，以及如何进行防御？",
"link": "/coding/前端安全/web常见的攻击方式有哪些，以及如何进行防御？"
},
{
"text": "中间人攻击是什么？",
"link": "/coding/前端安全/中间人攻击是什么？"
},
{
"text": "什么是 Samesite Cookie 属性？",
"link": "/coding/前端安全/什么是 Samesite Cookie 属性？"
},
{
"text": "什么是点击劫持？如何防范点击劫持？",
"link": "/coding/前端安全/什么是点击劫持？如何防范点击劫持？"
},
{
"text": "前端怎么实现跨域请求？",
"link": "/coding/前端安全/前端怎么实现跨域请求？"
},
{
"text": "前端数据安全",
"link": "/coding/前端安全/前端数据安全"
},
{
"text": "前端的常规安全策略",
"link": "/coding/前端安全/前端的常规安全策略"
},
{
"text": "如何禁止别人调试自己的前端代码？",
"link": "/coding/前端安全/如何禁止别人调试自己的前端代码？"
},
{
"text": "点击劫持",
"link": "/coding/前端安全/点击劫持"
},
{
"text": "网络劫持",
"link": "/coding/前端安全/网络劫持"
},
{
"text": "说说你对 XSS 的了解",
"link": "/coding/前端安全/说说你对 XSS 的了解"
},
{
"text": "说说你对前端鉴权的理解",
"link": "/coding/前端安全/说说你对前端鉴权的理解"
},
{
"text": "静态资源完整性校验",
"link": "/coding/前端安全/静态资源完整性校验"
}
],
"/coding/场景题/": [
{
"text": "**ChatGPT 的对话功能实现，为什么选择 SSE 协议而非 Websocket ？",
"link": "/coding/场景题/**ChatGPT 的对话功能实现，为什么选择 SSE 协议而非 Websocket ？"
},
{
"text": "**React 如何实现 vue 中 keep-alive 的功能？",
"link": "/coding/场景题/**React 如何实现 vue 中 keep-alive 的功能？"
},
{
"text": "**Redux 和 Vuex 的设计思想是什么？",
"link": "/coding/场景题/**Redux 和 Vuex 的设计思想是什么？"
},
{
"text": "**SPA首屏加载速度慢的怎么解决",
"link": "/coding/场景题/**SPA首屏加载速度慢的怎么解决"
},
{
"text": "**react 中怎么实现下拉菜单场景，要求点击区域外能关闭下拉组件",
"link": "/coding/场景题/**react 中怎么实现下拉菜单场景，要求点击区域外能关闭下拉组件"
},
{
"text": "**token过期后，页面如何实现无感刷新？",
"link": "/coding/场景题/**token过期后，页面如何实现无感刷新？"
},
{
"text": "**web 应用中如何对静态资源加载失败的场景做降级处理？",
"link": "/coding/场景题/**web 应用中如何对静态资源加载失败的场景做降级处理？"
},
{
"text": "**web 网页如何禁止别人移除水印",
"link": "/coding/场景题/**web 网页如何禁止别人移除水印"
},
{
"text": "**一般怎么做代码重构？",
"link": "/coding/场景题/**一般怎么做代码重构？"
},
{
"text": "**业务需要实现前端项目的灰度发布，你会怎么设计？",
"link": "/coding/场景题/**业务需要实现前端项目的灰度发布，你会怎么设计？"
},
{
"text": "**为什么在技术选型中选择了 webpack？",
"link": "/coding/场景题/**为什么在技术选型中选择了 webpack？"
},
{
"text": "**什么是单点登录，以及如何进行实现？",
"link": "/coding/场景题/**什么是单点登录，以及如何进行实现？"
},
{
"text": "**低代码平台怎么设计渲染模块？",
"link": "/coding/场景题/**低代码平台怎么设计渲染模块？"
},
{
"text": "**低代码平台的页面数据结构该怎么设计？",
"link": "/coding/场景题/**低代码平台的页面数据结构该怎么设计？"
},
{
"text": "**你参与过哪些前端基建方面的建设？",
"link": "/coding/场景题/**你参与过哪些前端基建方面的建设？"
},
{
"text": "**你是怎么理解前端架构的？",
"link": "/coding/场景题/**你是怎么理解前端架构的？"
},
{
"text": "**假如让你负责一个商城系统的开发，现在需要统计商品的点击量，你有什么样设计与实现的思路？",
"link": "/coding/场景题/**假如让你负责一个商城系统的开发，现在需要统计商品的点击量，你有什么样设计与实现的思路？"
},
{
"text": "**做前端错误监控时，有什么办法能将报错的源码地址，包括代码行数也进行上报吗？",
"link": "/coding/场景题/**做前端错误监控时，有什么办法能将报错的源码地址，包括代码行数也进行上报吗？"
},
{
"text": "**前端单页应用 History 路由模式， 需要如何配置 nginx？",
"link": "/coding/场景题/**前端单页应用 History 路由模式， 需要如何配置 nginx？"
},
{
"text": "**前端如何实现即时通讯？",
"link": "/coding/场景题/**前端如何实现即时通讯？"
},
{
"text": "**前端如何实现截图？",
"link": "/coding/场景题/**前端如何实现截图？"
},
{
"text": "**前端实现的倒计时为什么会有误差？有什么减小误差的解决方案吗？",
"link": "/coding/场景题/**前端实现的倒计时为什么会有误差？有什么减小误差的解决方案吗？"
},
{
"text": "**前端应用上线后，怎么通知用户刷新当前页面？",
"link": "/coding/场景题/**前端应用上线后，怎么通知用户刷新当前页面？"
},
{
"text": "**前端怎么做错误监控？",
"link": "/coding/场景题/**前端怎么做错误监控？"
},
{
"text": "**前端渲染和后端渲染分别有什么优缺点， 为什么现在的技术大方向，又逐渐往“后端渲染”方向靠了呢？",
"link": "/coding/场景题/**前端渲染和后端渲染分别有什么优缺点， 为什么现在的技术大方向，又逐渐往“后端渲染”方向靠了呢？"
},
{
"text": "**前端系统中，怎么统一处理登录态过期的场景？",
"link": "/coding/场景题/**前端系统中，怎么统一处理登录态过期的场景？"
},
{
"text": "**前端项目里，一般对请求 request 做哪些统一的封装？",
"link": "/coding/场景题/**前端项目里，一般对请求 request 做哪些统一的封装？"
},
{
"text": "**在前端应用中，怎么进行系统权限的设计？",
"link": "/coding/场景题/**在前端应用中，怎么进行系统权限的设计？"
},
{
"text": "**在表单校验场景中， 如何实现页面视口滚动到报错的位置",
"link": "/coding/场景题/**在表单校验场景中， 如何实现页面视口滚动到报错的位置"
},
{
"text": "**在项目中封装组件时，你会有些什么样的原则？",
"link": "/coding/场景题/**在项目中封装组件时，你会有些什么样的原则？"
},
{
"text": "**多个项目共用组件时，如何保证版本一致性？",
"link": "/coding/场景题/**多个项目共用组件时，如何保证版本一致性？"
},
{
"text": "**如何从 0 到 1 搭建前端基建？",
"link": "/coding/场景题/**如何从 0 到 1 搭建前端基建？"
},
{
"text": "**如何做一个前端项目工程的自动化部署，有哪些规范和流程设计？",
"link": "/coding/场景题/**如何做一个前端项目工程的自动化部署，有哪些规范和流程设计？"
},
{
"text": "**如何在前端团队快速落地代码规范",
"link": "/coding/场景题/**如何在前端团队快速落地代码规范"
},
{
"text": "**如何在浏览器中实现 PDF 文件的预览？",
"link": "/coding/场景题/**如何在浏览器中实现 PDF 文件的预览？"
},
{
"text": "**如何封装一个请求，让其多次调用的时候，实际只发起一个请求的时候，返回同一份结果？",
"link": "/coding/场景题/**如何封装一个请求，让其多次调用的时候，实际只发起一个请求的时候，返回同一份结果？"
},
{
"text": "**如何将JavaScript代码解析成抽象语法树(AST)？",
"link": "/coding/场景题/**如何将JavaScript代码解析成抽象语法树(AST)？"
},
{
"text": "**如何搭建一套灰度系统？",
"link": "/coding/场景题/**如何搭建一套灰度系统？"
},
{
"text": "**如何检测网页空闲状态（即一定时间内无操作）？",
"link": "/coding/场景题/**如何检测网页空闲状态（即一定时间内无操作）？"
},
{
"text": "**如何监控前端页面的崩溃？",
"link": "/coding/场景题/**如何监控前端页面的崩溃？"
},
{
"text": "**如何给自己团队的大型前端项目设计单元测试？",
"link": "/coding/场景题/**如何给自己团队的大型前端项目设计单元测试？"
},
{
"text": "**如何解决 node_modules 中，同一个包安装了多个不同版本的问题？",
"link": "/coding/场景题/**如何解决 node_modules 中，同一个包安装了多个不同版本的问题？"
},
{
"text": "**如何解决页面请求接口大规模并发问题",
"link": "/coding/场景题/**如何解决页面请求接口大规模并发问题"
},
{
"text": "**如何设计一套统计全站请求耗时的工具",
"link": "/coding/场景题/**如何设计一套统计全站请求耗时的工具"
},
{
"text": "**如果你有一个业务组件库，希望打包输出为 esm + cjs + dts，有什么思路？",
"link": "/coding/场景题/**如果你有一个业务组件库，希望打包输出为 esm + cjs + dts，有什么思路？"
},
{
"text": "**如果你有一个内容站点，怎么防止其他人爬虫？",
"link": "/coding/场景题/**如果你有一个内容站点，怎么防止其他人爬虫？"
},
{
"text": "**如果公司要做一个低代码平台，你会怎么进行架构设计？",
"link": "/coding/场景题/**如果公司要做一个低代码平台，你会怎么进行架构设计？"
},
{
"text": "**如果想在小程序中嵌入 markdown 的文档，你有什么思路？",
"link": "/coding/场景题/**如果想在小程序中嵌入 markdown 的文档，你有什么思路？"
},
{
"text": "**如果想将一个前端项目中的 px 全部转为 rem，你有什么思路",
"link": "/coding/场景题/**如果想将一个前端项目中的 px 全部转为 rem，你有什么思路"
},
{
"text": "**如果用户说 web 应用感觉很反应慢或者卡顿，该如何排查？",
"link": "/coding/场景题/**如果用户说 web 应用感觉很反应慢或者卡顿，该如何排查？"
},
{
"text": "**如果让你实现一个前端日志埋点 SDK，你会有什么样的设计思路？",
"link": "/coding/场景题/**如果让你实现一个前端日志埋点 SDK，你会有什么样的设计思路？"
},
{
"text": "**如果需要使用 JS 执行 100 万个任务，如何保证浏览器不卡顿？",
"link": "/coding/场景题/**如果需要使用 JS 执行 100 万个任务，如何保证浏览器不卡顿？"
},
{
"text": "**实现 table header 吸顶， 有哪些实现方式？",
"link": "/coding/场景题/**实现 table header 吸顶， 有哪些实现方式？"
},
{
"text": "**对于 PC 端的 banner 组件，你会怎么适配超宽的屏幕？",
"link": "/coding/场景题/**对于 PC 端的 banner 组件，你会怎么适配超宽的屏幕？"
},
{
"text": "**对于分页的列表，怎么解决快速翻页场景下的竞态问题？",
"link": "/coding/场景题/**对于分页的列表，怎么解决快速翻页场景下的竞态问题？"
},
{
"text": "**对于富文本编辑器中的划词交互（鼠标滑动选择一组字符， 对该组字符进行操作），你有什么实现思路？",
"link": "/coding/场景题/**对于富文本编辑器中的划词交互（鼠标滑动选择一组字符， 对该组字符进行操作），你有什么实现思路？"
},
{
"text": "**常见的登录鉴权方式有哪些？",
"link": "/coding/场景题/**常见的登录鉴权方式有哪些？"
},
{
"text": "**当需要更改组件库中组件的主题时，有哪些常见的方法？请以你熟悉的组件库为例，说明如何实现主题定制。",
"link": "/coding/场景题/**当需要更改组件库中组件的主题时，有哪些常见的方法？请以你熟悉的组件库为例，说明如何实现主题定制。"
},
{
"text": "**怎么使用 webpack，将 JS 文件中的 css 提取到单独的样式文件中？",
"link": "/coding/场景题/**怎么使用 webpack，将 JS 文件中的 css 提取到单独的样式文件中？"
},
{
"text": "**怎么分析页面加载慢的原因？",
"link": "/coding/场景题/**怎么分析页面加载慢的原因？"
},
{
"text": "**怎么在 react 技术栈的低代码平台中，实现组件的脚本注入？",
"link": "/coding/场景题/**怎么在 react 技术栈的低代码平台中，实现组件的脚本注入？"
},
{
"text": "**怎么在前端页面中添加水印？",
"link": "/coding/场景题/**怎么在前端页面中添加水印？"
},
{
"text": "**怎么实现同一个链接，PC 访问是 web 应用，而手机打开是一个 H5 应用？",
"link": "/coding/场景题/**怎么实现同一个链接，PC 访问是 web 应用，而手机打开是一个 H5 应用？"
},
{
"text": "**怎么实现扫码登录？",
"link": "/coding/场景题/**怎么实现扫码登录？"
},
{
"text": "**怎么实现表单项间的联动？",
"link": "/coding/场景题/**怎么实现表单项间的联动？"
},
{
"text": "**有一个新的前端项目需要部署到线上，你有什么思路？",
"link": "/coding/场景题/**有一个新的前端项目需要部署到线上，你有什么思路？"
},
{
"text": "**现在要开发一个响应式的网站，怎么实现根据设备的尺寸和分辨率，加载不同尺寸的 banner？要求不使用 JavaScript",
"link": "/coding/场景题/**现在要开发一个响应式的网站，怎么实现根据设备的尺寸和分辨率，加载不同尺寸的 banner？要求不使用 JavaScript"
},
{
"text": "**用户访问页面白屏了， 原因是啥， 如何排查？",
"link": "/coding/场景题/**用户访问页面白屏了， 原因是啥， 如何排查？"
},
{
"text": "**站点一键换肤的实现方式有哪些？",
"link": "/coding/场景题/**站点一键换肤的实现方式有哪些？"
},
{
"text": "**设计一个技术方案，能在排查问题时，还原用户的操作流程",
"link": "/coding/场景题/**设计一个技术方案，能在排查问题时，还原用户的操作流程"
},
{
"text": "**说说你对 package.json 中配置项的了解",
"link": "/coding/场景题/**说说你对 package.json 中配置项的了解"
},
{
"text": "**请求失败会弹出一个 toast，如何保证批量请求失败时， 只弹出一个 toast？",
"link": "/coding/场景题/**请求失败会弹出一个 toast，如何保证批量请求失败时， 只弹出一个 toast？"
}
],
"/coding/工程化/": [
{
"text": "**ES6 代码转成 ES5 代码的实现思路是什么？",
"link": "/coding/工程化/**ES6 代码转成 ES5 代码的实现思路是什么？"
},
{
"text": "**Husky 和 lint-staged 有什么区别？",
"link": "/coding/工程化/**Husky 和 lint-staged 有什么区别？"
},
{
"text": "**Webpack 中的运行时 chunk 是什么？在项目工程中， 如何打包和加载这个运行时 chunk ？",
"link": "/coding/工程化/**Webpack 中的运行时 chunk 是什么？在项目工程中， 如何打包和加载这个运行时 chunk ？"
},
{
"text": "**Webpack 怎么配置多入口应用， 并实现公共依赖的提取？",
"link": "/coding/工程化/**Webpack 怎么配置多入口应用， 并实现公共依赖的提取？"
},
{
"text": "**Webpack 有哪些常见配置？",
"link": "/coding/工程化/**Webpack 有哪些常见配置？"
},
{
"text": "**babel 的工作流程是怎么样的？",
"link": "/coding/工程化/**babel 的工作流程是怎么样的？"
},
{
"text": "**babel 的核心库有哪些？",
"link": "/coding/工程化/**babel 的核心库有哪些？"
},
{
"text": "**babel-runtime 有什么作用？",
"link": "/coding/工程化/**babel-runtime 有什么作用？"
},
{
"text": "**esbuild 和 rollup 都是 vite 的基础依赖，它们有什么不同呢？",
"link": "/coding/工程化/**esbuild 和 rollup 都是 vite 的基础依赖，它们有什么不同呢？"
},
{
"text": "**npm lock 文件了解多少？",
"link": "/coding/工程化/**npm lock 文件了解多少？"
},
{
"text": "**npm script 了解多少？",
"link": "/coding/工程化/**npm script 了解多少？"
},
{
"text": "**npm script 生命周期有哪些？",
"link": "/coding/工程化/**npm script 生命周期有哪些？"
},
{
"text": "**npm 中的“幽灵依赖”是什么？",
"link": "/coding/工程化/**npm 中的“幽灵依赖”是什么？"
},
{
"text": "**package.json 里面 sideEffects 属性的作用是什么？",
"link": "/coding/工程化/**package.json 里面 sideEffects 属性的作用是什么？"
},
{
"text": "**vite 使用了哪些编译器，分别有什么作用？",
"link": "/coding/工程化/**vite 使用了哪些编译器，分别有什么作用？"
},
{
"text": "**vite 和 webpack 在热更新的实现上有什么区别？",
"link": "/coding/工程化/**vite 和 webpack 在热更新的实现上有什么区别？"
},
{
"text": "**webpack tree-shaking 在什么情况下会失效？",
"link": "/coding/工程化/**webpack tree-shaking 在什么情况下会失效？"
},
{
"text": "**webpack 中 module、chunk 、bundle 的区别是什么？",
"link": "/coding/工程化/**webpack 中 module、chunk 、bundle 的区别是什么？"
},
{
"text": "**webpack 中的 externals 作用是什么？",
"link": "/coding/工程化/**webpack 中的 externals 作用是什么？"
},
{
"text": "**webpack 中的 webpack-dev-server 为什么不适用于线上环境？",
"link": "/coding/工程化/**webpack 中的 webpack-dev-server 为什么不适用于线上环境？"
},
{
"text": "**webpack 中的 webpack-dev-server 有什么作用？",
"link": "/coding/工程化/**webpack 中的 webpack-dev-server 有什么作用？"
},
{
"text": "**webpack 分包的方式有哪些？",
"link": "/coding/工程化/**webpack 分包的方式有哪些？"
},
{
"text": "**webpack 在打包时，给生成的文件名上添加的 hash 码，是如何生成的？",
"link": "/coding/工程化/**webpack 在打包时，给生成的文件名上添加的 hash 码，是如何生成的？"
},
{
"text": "**webpack 是如何给 web 应用注入环境变量的，说说它的原理",
"link": "/coding/工程化/**webpack 是如何给 web 应用注入环境变量的，说说它的原理"
},
{
"text": "**一个使用了 Webpack 的前端项目，该怎么配置，实现使用 babel-loader 来编译 tsx 文件？",
"link": "/coding/工程化/**一个使用了 Webpack 的前端项目，该怎么配置，实现使用 babel-loader 来编译 tsx 文件？"
},
{
"text": "**为什么 SPA 应用都会提供一个 hash 路由，好处是什么？",
"link": "/coding/工程化/**为什么 SPA 应用都会提供一个 hash 路由，好处是什么？"
},
{
"text": "**为什么 webpack 可以通过文件打包，让浏览器可以支持 CommonJS 规范？",
"link": "/coding/工程化/**为什么 webpack 可以通过文件打包，让浏览器可以支持 CommonJS 规范？"
},
{
"text": "**为什么现代前端应用需要打包工具进行打包编译？",
"link": "/coding/工程化/**为什么现代前端应用需要打包工具进行打包编译？"
},
{
"text": "**什么情况下会导致 webpack treeShaking 失效？",
"link": "/coding/工程化/**什么情况下会导致 webpack treeShaking 失效？"
},
{
"text": "**在Babel里，stage0、stage1、stage2 和 stage3 分别代表什么含义？",
"link": "/coding/工程化/**在Babel里，stage0、stage1、stage2 和 stage3 分别代表什么含义？"
},
{
"text": "**如何清理源码里面没有被使用的代码？主要是 JS、TS、CSS 代码",
"link": "/coding/工程化/**如何清理源码里面没有被使用的代码？主要是 JS、TS、CSS 代码"
},
{
"text": "**如何组织 monorepo 工程？",
"link": "/coding/工程化/**如何组织 monorepo 工程？"
},
{
"text": "**对于一个使用 Webpack 的项目，如果需要直接通过 script 标签引入第三方的资源，应该怎么处理？",
"link": "/coding/工程化/**对于一个使用 Webpack 的项目，如果需要直接通过 script 标签引入第三方的资源，应该怎么处理？"
},
{
"text": "**微前端中的路由加载流程是怎么样的？",
"link": "/coding/工程化/**微前端中的路由加载流程是怎么样的？"
},
{
"text": "**微前端的设计原则有哪些？",
"link": "/coding/工程化/**微前端的设计原则有哪些？"
},
{
"text": "**浏览器是否支持 CommonJs 规范？",
"link": "/coding/工程化/**浏览器是否支持 CommonJs 规范？"
},
{
"text": "**说说 package.json 中 dependencies、devDependencies、peerDependencies 有哪些不同，分别适合什么场景",
"link": "/coding/工程化/**说说 package.json 中 dependencies、devDependencies、peerDependencies 有哪些不同，分别适合什么场景"
},
{
"text": "**说说 webpack 异步加载的原理",
"link": "/coding/工程化/**说说 webpack 异步加载的原理"
},
{
"text": "**说说你对 Source Map 的了解",
"link": "/coding/工程化/**说说你对 Source Map 的了解"
},
{
"text": "Babel的原理是什么",
"link": "/coding/工程化/Babel的原理是什么"
},
{
"text": "Webpack中 loader的作用是什么，以及常用loader有哪些",
"link": "/coding/工程化/Webpack中 loader的作用是什么，以及常用loader有哪些"
},
{
"text": "package.json 文件中的 devDependencies 和 dependencies 对象有什么区别？",
"link": "/coding/工程化/package.json 文件中的 devDependencies 和 dependencies 对象有什么区别？"
},
{
"text": "webpack 5 的主要升级点有哪些？",
"link": "/coding/工程化/webpack 5 的主要升级点有哪些？"
},
{
"text": "webpack loader 和 plugin 实现原理",
"link": "/coding/工程化/webpack loader 和 plugin 实现原理"
},
{
"text": "webpack treeShaking机制的原理是什么？",
"link": "/coding/工程化/webpack treeShaking机制的原理是什么？"
},
{
"text": "webpack、rollup、parcel优劣",
"link": "/coding/工程化/webpack、rollup、parcel优劣"
},
{
"text": "webpack有哪些常见的Plugin",
"link": "/coding/工程化/webpack有哪些常见的Plugin"
},
{
"text": "webpack的Loader和Plugin的不同",
"link": "/coding/工程化/webpack的Loader和Plugin的不同"
},
{
"text": "webpack的module、bundle、chunk分别指的是什么？",
"link": "/coding/工程化/webpack的module、bundle、chunk分别指的是什么？"
},
{
"text": "webpack的构建流程是什么",
"link": "/coding/工程化/webpack的构建流程是什么"
},
{
"text": "webpack的热更新是如何做到的？说明其原理",
"link": "/coding/工程化/webpack的热更新是如何做到的？说明其原理"
},
{
"text": "与webpack类似的工具还有哪些？区别？",
"link": "/coding/工程化/与webpack类似的工具还有哪些？区别？"
},
{
"text": "什么是 CI-CD？",
"link": "/coding/工程化/什么是 CI-CD？"
},
{
"text": "你对 babel 了解吗，能不能说说几个 stage 代表什么意思？",
"link": "/coding/工程化/你对 babel 了解吗，能不能说说几个 stage 代表什么意思？"
},
{
"text": "前后端分离是什么？",
"link": "/coding/工程化/前后端分离是什么？"
},
{
"text": "如何提高webpack的打包速度",
"link": "/coding/工程化/如何提高webpack的打包速度"
},
{
"text": "如何提高webpack的构建速度？",
"link": "/coding/工程化/如何提高webpack的构建速度？"
},
{
"text": "如何用webpack来优化前端性能",
"link": "/coding/工程化/如何用webpack来优化前端性能"
},
{
"text": "聊聊 vite 和 webpack 的区别",
"link": "/coding/工程化/聊聊 vite 和 webpack 的区别"
},
{
"text": "说下Vite的原理",
"link": "/coding/工程化/说下Vite的原理"
},
{
"text": "说说 webpack-dev-server 的原理",
"link": "/coding/工程化/说说 webpack-dev-server 的原理"
},
{
"text": "说说webpack proxy工作原理？为什么能解决跨域？",
"link": "/coding/工程化/说说webpack proxy工作原理？为什么能解决跨域？"
},
{
"text": "说说webpack中常见的Loader？解决了什么问题？",
"link": "/coding/工程化/说说webpack中常见的Loader？解决了什么问题？"
},
{
"text": "说说webpack中常见的Plugin？解决了什么问题？",
"link": "/coding/工程化/说说webpack中常见的Plugin？解决了什么问题？"
},
{
"text": "说说webpack的构建流程？",
"link": "/coding/工程化/说说webpack的构建流程？"
},
{
"text": "说说webpack的热更新是如何做到的？原理是什么？",
"link": "/coding/工程化/说说webpack的热更新是如何做到的？原理是什么？"
},
{
"text": "说说你对 SSG 的理解",
"link": "/coding/工程化/说说你对 SSG 的理解"
},
{
"text": "说说你对webpack的理解？解决了什么问题？",
"link": "/coding/工程化/说说你对webpack的理解？解决了什么问题？"
},
{
"text": "说说你对前端工程化的理解",
"link": "/coding/工程化/说说你对前端工程化的理解"
},
{
"text": "说说如何借助webpack来优化前端性能？",
"link": "/coding/工程化/说说如何借助webpack来优化前端性能？"
},
{
"text": "谈谈你对 Webpack的认识",
"link": "/coding/工程化/谈谈你对 Webpack的认识"
},
{
"text": "面试官：说说Loader和Plugin的区别？编写Loader，Plugin的思路？",
"link": "/coding/工程化/面试官：说说Loader和Plugin的区别？编写Loader，Plugin的思路？"
}
],
"/coding/性能优化/": [
{
"text": "**CSR、SSR、SSG、NSR、ESR、ISR 都是什么？",
"link": "/coding/性能优化/**CSR、SSR、SSG、NSR、ESR、ISR 都是什么？"
},
{
"text": "**JS 的加载是否会阻塞浏览器渲染？",
"link": "/coding/性能优化/**JS 的加载是否会阻塞浏览器渲染？"
},
{
"text": "**SPA首屏加载速度慢的怎么解决",
"link": "/coding/性能优化/**SPA首屏加载速度慢的怎么解决"
},
{
"text": "**Service Worker 是如何缓存 http 请求资源的？",
"link": "/coding/性能优化/**Service Worker 是如何缓存 http 请求资源的？"
},
{
"text": "**canvas 性能为何会比 html-css 好？",
"link": "/coding/性能优化/**canvas 性能为何会比 html-css 好？"
},
{
"text": "**dom 渲染能使用 GPU 加速吗？",
"link": "/coding/性能优化/**dom 渲染能使用 GPU 加速吗？"
},
{
"text": "**script 预加载方式有哪些，这些加载方式有何区别？",
"link": "/coding/性能优化/**script 预加载方式有哪些，这些加载方式有何区别？"
},
{
"text": "**为何现在市面上做表格渲染可视化技术的，大多数都是 canvas ， 而很少用 svg 的？",
"link": "/coding/性能优化/**为何现在市面上做表格渲染可视化技术的，大多数都是 canvas ， 而很少用 svg 的？"
},
{
"text": "**以用户为中心的前端性能指标有哪些？",
"link": "/coding/性能优化/**以用户为中心的前端性能指标有哪些？"
},
{
"text": "**后端一次性返回树形结构数据，数据量非常大, 前端该如何处理？",
"link": "/coding/性能优化/**后端一次性返回树形结构数据，数据量非常大, 前端该如何处理？"
},
{
"text": "**在 JS 中， 如何解决递归导致栈溢出问题？",
"link": "/coding/性能优化/**在 JS 中， 如何解决递归导致栈溢出问题？"
},
{
"text": "**在 html 页面渲染过程中，哪些因素可能会影响页面的渲染性能？如何优化？",
"link": "/coding/性能优化/**在 html 页面渲染过程中，哪些因素可能会影响页面的渲染性能？如何优化？"
},
{
"text": "**如何优化 DOM 树解析过程？",
"link": "/coding/性能优化/**如何优化 DOM 树解析过程？"
},
{
"text": "**如何优化大规模 dom 操作的场景？",
"link": "/coding/性能优化/**如何优化大规模 dom 操作的场景？"
},
{
"text": "**如何优化音频和视频的加载性能？",
"link": "/coding/性能优化/**如何优化音频和视频的加载性能？"
},
{
"text": "**如何取消重复请求？",
"link": "/coding/性能优化/**如何取消重复请求？"
},
{
"text": "**如何避免JavaScript代码对浏览器渲染的阻塞？",
"link": "/coding/性能优化/**如何避免JavaScript代码对浏览器渲染的阻塞？"
},
{
"text": "**如何防止 CSS 阻塞渲染？",
"link": "/coding/性能优化/**如何防止 CSS 阻塞渲染？"
},
{
"text": "**如果想在图片这块做性能优化，你有哪些思路？",
"link": "/coding/性能优化/**如果想在图片这块做性能优化，你有哪些思路？"
},
{
"text": "**将静态资源缓存在本地的方式有哪些？",
"link": "/coding/性能优化/**将静态资源缓存在本地的方式有哪些？"
},
{
"text": "**怎么统计页面的性能指标？",
"link": "/coding/性能优化/**怎么统计页面的性能指标？"
},
{
"text": "**想要实现页面加载速度提升（性能优化），可以从哪些方向来尝试？",
"link": "/coding/性能优化/**想要实现页面加载速度提升（性能优化），可以从哪些方向来尝试？"
},
{
"text": "**浏览器缓存中 Memory Cache 和 Disk Cache，有什么区别？",
"link": "/coding/性能优化/**浏览器缓存中 Memory Cache 和 Disk Cache，有什么区别？"
},
{
"text": "**衡量页面性能的指标有哪些？",
"link": "/coding/性能优化/**衡量页面性能的指标有哪些？"
},
{
"text": "CSS优化、提高性能的方法有哪些？",
"link": "/coding/性能优化/CSS优化、提高性能的方法有哪些？"
},
{
"text": "DNS 预解析是什么？怎么实现？",
"link": "/coding/性能优化/DNS 预解析是什么？怎么实现？"
},
{
"text": "React.memo() 和 useMemo() 的用法是什么，有哪些区别？",
"link": "/coding/性能优化/React.memo() 和 useMemo() 的用法是什么，有哪些区别？"
},
{
"text": "SPA（单页应用）首屏加载速度慢怎么解决？",
"link": "/coding/性能优化/SPA（单页应用）首屏加载速度慢怎么解决？"
},
{
"text": "css加载会造成阻塞吗？",
"link": "/coding/性能优化/css加载会造成阻塞吗？"
},
{
"text": "script 标签中， async 和 defer 两个属性有什么用途和区别？",
"link": "/coding/性能优化/script 标签中， async 和 defer 两个属性有什么用途和区别？"
},
{
"text": "script标签放在header里和放在body底部里有什么区别？",
"link": "/coding/性能优化/script标签放在header里和放在body底部里有什么区别？"
},
{
"text": "什么是CSS Sprites？",
"link": "/coding/性能优化/什么是CSS Sprites？"
},
{
"text": "什么是内存泄漏？什么原因会导致呢？",
"link": "/coding/性能优化/什么是内存泄漏？什么原因会导致呢？"
},
{
"text": "前端性能优化指标有哪些？怎么进行性能检测？",
"link": "/coding/性能优化/前端性能优化指标有哪些？怎么进行性能检测？"
},
{
"text": "在 React 中可以做哪些性能优化？",
"link": "/coding/性能优化/在 React 中可以做哪些性能优化？"
},
{
"text": "如何用webpack来优化前端性能",
"link": "/coding/性能优化/如何用webpack来优化前端性能"
},
{
"text": "如何确定页面的可用性时间，什么是 Performance API？",
"link": "/coding/性能优化/如何确定页面的可用性时间，什么是 Performance API？"
},
{
"text": "如果一个列表有 100000 个数据，这个该怎么进行展示？",
"link": "/coding/性能优化/如果一个列表有 100000 个数据，这个该怎么进行展示？"
},
{
"text": "如果使用CSS提高页面性能？",
"link": "/coding/性能优化/如果使用CSS提高页面性能？"
},
{
"text": "如果某个页面有几百个函数需要执行，可以怎么优化页面的性能？",
"link": "/coding/性能优化/如果某个页面有几百个函数需要执行，可以怎么优化页面的性能？"
},
{
"text": "导致页面加载白屏时间长的原因有哪些，怎么进行优化？",
"link": "/coding/性能优化/导致页面加载白屏时间长的原因有哪些，怎么进行优化？"
},
{
"text": "怎么进行站点内的图片性能优化？",
"link": "/coding/性能优化/怎么进行站点内的图片性能优化？"
},
{
"text": "有些框架不用虚拟dom，但是他们的性能也不错是为什么？",
"link": "/coding/性能优化/有些框架不用虚拟dom，但是他们的性能也不错是为什么？"
},
{
"text": "浏览器为什么要请求并发数限制？",
"link": "/coding/性能优化/浏览器为什么要请求并发数限制？"
},
{
"text": "虚拟DOM一定更快吗？",
"link": "/coding/性能优化/虚拟DOM一定更快吗？"
},
{
"text": "讲一下png8、png16、png32的区别，并简单讲讲 png 的压缩原理",
"link": "/coding/性能优化/讲一下png8、png16、png32的区别，并简单讲讲 png 的压缩原理"
},
{
"text": "说说常规的前端性能优化手段",
"link": "/coding/性能优化/说说常规的前端性能优化手段"
},
{
"text": "谈谈对 window.requestAnimationFrame 的理解",
"link": "/coding/性能优化/谈谈对 window.requestAnimationFrame 的理解"
},
{
"text": "页面加载的过程中，JS 文件是不是一定会阻塞 DOM 和 CSSOM 的构建？",
"link": "/coding/性能优化/页面加载的过程中，JS 文件是不是一定会阻塞 DOM 和 CSSOM 的构建？"
}
],
"/coding/编程题/": [
{
"text": "**基于 axios 实现请求超时后，自动重试",
"link": "/coding/编程题/**基于 axios 实现请求超时后，自动重试"
},
{
"text": "**如何做 promise 缓存？上一次调用函数的 promise 没有返回， 那么下一次调用函数依然返回上一个 promise",
"link": "/coding/编程题/**如何做 promise 缓存？上一次调用函数的 promise 没有返回， 那么下一次调用函数依然返回上一个 promise"
},
{
"text": "**如何实现上拉加载，下拉刷新？",
"link": "/coding/编程题/**如何实现上拉加载，下拉刷新？"
},
{
"text": "**如何实现可过期的 localStorage 数据？",
"link": "/coding/编程题/**如何实现可过期的 localStorage 数据？"
},
{
"text": "**实现 (5).add(3).minus(2) 功能",
"link": "/coding/编程题/**实现 (5).add(3).minus(2) 功能"
},
{
"text": "**实现 isObjectEmpty 方法，判断一个对象是否为空",
"link": "/coding/编程题/**实现 isObjectEmpty 方法，判断一个对象是否为空"
},
{
"text": "**实现一个 cookies 解析函数，输出结果要求是一个对象",
"link": "/coding/编程题/**实现一个 cookies 解析函数，输出结果要求是一个对象"
},
{
"text": "**实现一个函数， 通过 id 来查找 tree 数据结构对应的节点",
"link": "/coding/编程题/**实现一个函数， 通过 id 来查找 tree 数据结构对应的节点"
},
{
"text": "**实现一个双向链表， 具备添加节点、删除节点、在特定位置插入节点、查找节点、遍历等功能",
"link": "/coding/编程题/**实现一个双向链表， 具备添加节点、删除节点、在特定位置插入节点、查找节点、遍历等功能"
},
{
"text": "**实现一个可以用 for...of 遍历的对象",
"link": "/coding/编程题/**实现一个可以用 for...of 遍历的对象"
},
{
"text": "**实现一个方法，可以对两个数组的维数进行对比",
"link": "/coding/编程题/**实现一个方法，可以对两个数组的维数进行对比"
},
{
"text": "**实现数组的flat方法，支持深度层级参数",
"link": "/coding/编程题/**实现数组的flat方法，支持深度层级参数"
},
{
"text": "**实现管道函数",
"link": "/coding/编程题/**实现管道函数"
},
{
"text": "**实现银行卡号每隔四位加一个空格， 例如：6222023100014763381 -->6222 0231 0001 4763 381",
"link": "/coding/编程题/**实现银行卡号每隔四位加一个空格， 例如：6222023100014763381 -->6222 0231 0001 4763 381"
},
{
"text": "**实现：setObjectValue(obj: object, keys: string[], value: any) 方法， 支持安全设置对象的值",
"link": "/coding/编程题/**实现：setObjectValue(obj: object, keys: string[], value: any) 方法， 支持安全设置对象的值"
},
{
"text": "**手写实现 Object.create",
"link": "/coding/编程题/**手写实现 Object.create"
},
{
"text": "**手写实现 Promise.allSettled",
"link": "/coding/编程题/**手写实现 Promise.allSettled"
},
{
"text": "**手写实现一个缓存函数 memoize",
"link": "/coding/编程题/**手写实现一个缓存函数 memoize"
},
{
"text": "**斐波拉契数列是什么，用 JS 实现，用尾调优化斐波拉契数列",
"link": "/coding/编程题/**斐波拉契数列是什么，用 JS 实现，用尾调优化斐波拉契数列"
},
{
"text": "**给定两个数组，写一个方法来计算它们的交集？",
"link": "/coding/编程题/**给定两个数组，写一个方法来计算它们的交集？"
},
{
"text": "**虚拟 dom 原理是什么，手写一个简单的虚拟 dom 实现",
"link": "/coding/编程题/**虚拟 dom 原理是什么，手写一个简单的虚拟 dom 实现"
},
{
"text": "**请仅使用 css，实现类似 ChatGPT 中，文案一个个输出的打字机效果",
"link": "/coding/编程题/**请仅使用 css，实现类似 ChatGPT 中，文案一个个输出的打字机效果"
},
{
"text": "**请使用 js 实现 isEmpty 方法",
"link": "/coding/编程题/**请使用 js 实现 isEmpty 方法"
},
{
"text": "**请在不使用 setTimeout 的前提下，实现 setInterval",
"link": "/coding/编程题/**请在不使用 setTimeout 的前提下，实现 setInterval"
},
{
"text": "**请实现一个 add 函数",
"link": "/coding/编程题/**请实现一个 add 函数"
},
{
"text": "Promise 的 finally 怎么实现的？",
"link": "/coding/编程题/Promise 的 finally 怎么实现的？"
},
{
"text": "a == 1 && a == 2 && a == 3 可能为 true 吗？",
"link": "/coding/编程题/a == 1 && a == 2 && a == 3 可能为 true 吗？"
},
{
"text": "bind、call、apply 有什么区别？如何实现一个bind？",
"link": "/coding/编程题/bind、call、apply 有什么区别？如何实现一个bind？"
},
{
"text": "不定长二维数组的全排列",
"link": "/coding/编程题/不定长二维数组的全排列"
},
{
"text": "两个字符串对比, 得出结论都做了什么操作, 比如插入或者删除",
"link": "/coding/编程题/两个字符串对比, 得出结论都做了什么操作, 比如插入或者删除"
},
{
"text": "使用 js 实现有序数组原地去重",
"link": "/coding/编程题/使用 js 实现有序数组原地去重"
},
{
"text": "使用Promise实现每隔1秒输出1,2,3",
"link": "/coding/编程题/使用Promise实现每隔1秒输出1,2,3"
},
{
"text": "使用Promise实现红绿灯交替重复亮",
"link": "/coding/编程题/使用Promise实现红绿灯交替重复亮"
},
{
"text": "使用Promise实现：限制异步操作的并发个数，并尽可能快的完成全部",
"link": "/coding/编程题/使用Promise实现：限制异步操作的并发个数，并尽可能快的完成全部"
},
{
"text": "使用Promise封装一个异步加载图片的方法",
"link": "/coding/编程题/使用Promise封装一个异步加载图片的方法"
},
{
"text": "使用TS实现一个判断传入参数是否是数组类型的方法",
"link": "/coding/编程题/使用TS实现一个判断传入参数是否是数组类型的方法"
},
{
"text": "使用css实现一个无限循环动画",
"link": "/coding/编程题/使用css实现一个无限循环动画"
},
{
"text": "使用js实现二分查找",
"link": "/coding/编程题/使用js实现二分查找"
},
{
"text": "使用js生成1-10000的数组",
"link": "/coding/编程题/使用js生成1-10000的数组"
},
{
"text": "使用原生js给一个按钮绑定两个onclick事件",
"link": "/coding/编程题/使用原生js给一个按钮绑定两个onclick事件"
},
{
"text": "使用正则表达式实现以下需求：筛选出数组中只包含大小写字母的字符串，并将结果转换成大写",
"link": "/coding/编程题/使用正则表达式实现以下需求：筛选出数组中只包含大小写字母的字符串，并将结果转换成大写"
},
{
"text": "写一个 LRU 缓存函数",
"link": "/coding/编程题/写一个 LRU 缓存函数"
},
{
"text": "写一个 repeat 方法，实现字符串的复制拼接",
"link": "/coding/编程题/写一个 repeat 方法，实现字符串的复制拼接"
},
{
"text": "写一个返回数据类型的函数，要求自定义的类实例化的对象返回定义的类名",
"link": "/coding/编程题/写一个返回数据类型的函数，要求自定义的类实例化的对象返回定义的类名"
},
{
"text": "写出一个函数trans，将数字转换成汉语的输出，输入为不超过10000亿的数字。",
"link": "/coding/编程题/写出一个函数trans，将数字转换成汉语的输出，输入为不超过10000亿的数字。"
},
{
"text": "函数珂里化",
"link": "/coding/编程题/函数珂里化"
},
{
"text": "删除链表的一个节点",
"link": "/coding/编程题/删除链表的一个节点"
},
{
"text": "利用字符重复出现的次数，编写一种方法，实现基本的字符串压缩功能。比如，字符串aabcccccaaa会变为a2b1c5a3",
"link": "/coding/编程题/利用字符重复出现的次数，编写一种方法，实现基本的字符串压缩功能。比如，字符串aabcccccaaa会变为a2b1c5a3"
},
{
"text": "去除字符串中出现次数最少的字符，不改变原字符串的顺序。",
"link": "/coding/编程题/去除字符串中出现次数最少的字符，不改变原字符串的顺序。"
},
{
"text": "反转链表",
"link": "/coding/编程题/反转链表"
},
{
"text": "回文链表",
"link": "/coding/编程题/回文链表"
},
{
"text": "多叉树指定层节点的个数",
"link": "/coding/编程题/多叉树指定层节点的个数"
},
{
"text": "大数相加",
"link": "/coding/编程题/大数相加"
},
{
"text": "如何判断一个对象是否为空对象？",
"link": "/coding/编程题/如何判断一个对象是否为空对象？"
},
{
"text": "如何实现一个轮播图组件？",
"link": "/coding/编程题/如何实现一个轮播图组件？"
},
{
"text": "如何查找一篇英文文章中出现频率最高的单词？",
"link": "/coding/编程题/如何查找一篇英文文章中出现频率最高的单词？"
},
{
"text": "字符串解析问题",
"link": "/coding/编程题/字符串解析问题"
},
{
"text": "实现 Array.prototype.forEach()",
"link": "/coding/编程题/实现 Array.prototype.forEach()"
},
{
"text": "实现 Array.prototype.map()",
"link": "/coding/编程题/实现 Array.prototype.map()"
},
{
"text": "实现 Array.prototype.reduce()",
"link": "/coding/编程题/实现 Array.prototype.reduce()"
},
{
"text": "实现 Function.prototype.apply()",
"link": "/coding/编程题/实现 Function.prototype.apply()"
},
{
"text": "实现 Function.prototype.bind",
"link": "/coding/编程题/实现 Function.prototype.bind"
},
{
"text": "实现 Function.prototype.call",
"link": "/coding/编程题/实现 Function.prototype.call"
},
{
"text": "实现 Promise.all",
"link": "/coding/编程题/实现 Promise.all"
},
{
"text": "实现 Promise",
"link": "/coding/编程题/实现 Promise"
},
{
"text": "实现 Promise.race 函数",
"link": "/coding/编程题/实现 Promise.race 函数"
},
{
"text": "实现 compose 函数, 类似于 koa 的中间件洋葱模型",
"link": "/coding/编程题/实现 compose 函数, 类似于 koa 的中间件洋葱模型"
},
{
"text": "实现 debounce（防抖）函数",
"link": "/coding/编程题/实现 debounce（防抖）函数"
},
{
"text": "实现 event模块",
"link": "/coding/编程题/实现 event模块"
},
{
"text": "实现 instanceof",
"link": "/coding/编程题/实现 instanceof"
},
{
"text": "实现 throttle（节流）函数",
"link": "/coding/编程题/实现 throttle（节流）函数"
},
{
"text": "实现AJAX",
"link": "/coding/编程题/实现AJAX"
},
{
"text": "实现JSONP",
"link": "/coding/编程题/实现JSONP"
},
{
"text": "实现Object.assign",
"link": "/coding/编程题/实现Object.assign"
},
{
"text": "实现lodash中的get方法",
"link": "/coding/编程题/实现lodash中的get方法"
},
{
"text": "实现lodash的set和get方法",
"link": "/coding/编程题/实现lodash的set和get方法"
},
{
"text": "实现mergePromise函数",
"link": "/coding/编程题/实现mergePromise函数"
},
{
"text": "实现一个函数, 可以间隔输出",
"link": "/coding/编程题/实现一个函数, 可以间隔输出"
},
{
"text": "实现一个对象的 flatten 方法",
"link": "/coding/编程题/实现一个对象的 flatten 方法"
},
{
"text": "实现一个将多维数组展示的方法",
"link": "/coding/编程题/实现一个将多维数组展示的方法"
},
{
"text": "实现一个批量请求函数，要求能够限制并发量",
"link": "/coding/编程题/实现一个批量请求函数，要求能够限制并发量"
},
{
"text": "实现一个数字转中文的方法",
"link": "/coding/编程题/实现一个数字转中文的方法"
},
{
"text": "实现一个方法，从某个数值数组中，获取最小正数（非零非负数）的索引值",
"link": "/coding/编程题/实现一个方法，从某个数值数组中，获取最小正数（非零非负数）的索引值"
},
{
"text": "实现一个方法，清除字符串前后的空格。",
"link": "/coding/编程题/实现一个方法，清除字符串前后的空格。"
},
{
"text": "实现一个等待函数，支持让 async 函数在执行时暂停一段时间，函数的入参为暂停的时间",
"link": "/coding/编程题/实现一个等待函数，支持让 async 函数在执行时暂停一段时间，函数的入参为暂停的时间"
},
{
"text": "实现一个类，其实例可以链式调用，它有一个 sleep 方法，可以 sleep 一段时间后再后续调用",
"link": "/coding/编程题/实现一个类，其实例可以链式调用，它有一个 sleep 方法，可以 sleep 一段时间后再后续调用"
},
{
"text": "实现一个请求函数：fetchWithRetry，要求会最多自动重试 3 次，任意一次成功就直接返回",
"link": "/coding/编程题/实现一个请求函数：fetchWithRetry，要求会最多自动重试 3 次，任意一次成功就直接返回"
},
{
"text": "实现以下转换，合并连续的数字",
"link": "/coding/编程题/实现以下转换，合并连续的数字"
},
{
"text": "实现数字的千分位逗号分割",
"link": "/coding/编程题/实现数字的千分位逗号分割"
},
{
"text": "实现斐波那契数列",
"link": "/coding/编程题/实现斐波那契数列"
},
{
"text": "实现有并行限制的Promise调度器",
"link": "/coding/编程题/实现有并行限制的Promise调度器"
},
{
"text": "实现柯里化",
"link": "/coding/编程题/实现柯里化"
},
{
"text": "实现深拷贝",
"link": "/coding/编程题/实现深拷贝"
},
{
"text": "封装一个 javascript 的类型判断函数",
"link": "/coding/编程题/封装一个 javascript 的类型判断函数"
},
{
"text": "将下面的数组转成树状结构",
"link": "/coding/编程题/将下面的数组转成树状结构"
},
{
"text": "怎么使用 setTimeout 实现 setInterval？",
"link": "/coding/编程题/怎么使用 setTimeout 实现 setInterval？"
},
{
"text": "手写一个 jsonp",
"link": "/coding/编程题/手写一个 jsonp"
},
{
"text": "改造下面的代码，让它输出1，2，3，4，5",
"link": "/coding/编程题/改造下面的代码，让它输出1，2，3，4，5"
},
{
"text": "数组去重",
"link": "/coding/编程题/数组去重"
},
{
"text": "数组转树",
"link": "/coding/编程题/数组转树"
},
{
"text": "树转数组",
"link": "/coding/编程题/树转数组"
},
{
"text": "根据运算优先级添加括号",
"link": "/coding/编程题/根据运算优先级添加括号"
},
{
"text": "深拷贝浅拷贝有什么区别？怎么实现深拷贝？",
"link": "/coding/编程题/深拷贝浅拷贝有什么区别？怎么实现深拷贝？"
},
{
"text": "版本号排序",
"link": "/coding/编程题/版本号排序"
},
{
"text": "用es5如何实现 let 和 const ？",
"link": "/coding/编程题/用es5如何实现 let 和 const ？"
},
{
"text": "用js实现二叉树的定义和基本操作",
"link": "/coding/编程题/用js实现二叉树的定义和基本操作"
},
{
"text": "类数组转化为数组",
"link": "/coding/编程题/类数组转化为数组"
},
{
"text": "给某个资源的链接，如 https:--www.baidu.com-index.html ，请实现一个方法，获取该资源的后缀，如 html",
"link": "/coding/编程题/给某个资源的链接，如 https:--www.baidu.com-index.html ，请实现一个方法，获取该资源的后缀，如 html"
},
{
"text": "编写一个vue组件，组件内部使用插槽接收外部内容，v-model双向绑定，实现折叠展开的功能",
"link": "/coding/编程题/编写一个vue组件，组件内部使用插槽接收外部内容，v-model双向绑定，实现折叠展开的功能"
},
{
"text": "编程实现温度转换，已知温度转换的关系式是：华氏度＝32＋摄氏度×1.8，现在要求输入摄氏度，输出对应的华氏度，小数保留两位",
"link": "/coding/编程题/编程实现温度转换，已知温度转换的关系式是：华氏度＝32＋摄氏度×1.8，现在要求输入摄氏度，输出对应的华氏度，小数保留两位"
},
{
"text": "解析url",
"link": "/coding/编程题/解析url"
},
{
"text": "计算出下面数组中的平均时间",
"link": "/coding/编程题/计算出下面数组中的平均时间"
},
{
"text": "说说ajax的原理，以及如何实现？",
"link": "/coding/编程题/说说ajax的原理，以及如何实现？"
},
{
"text": "说说new操作符具体干了什么？",
"link": "/coding/编程题/说说new操作符具体干了什么？"
},
{
"text": "请实现一个函数，要求能在页面请求很多时，尽可能快地按照顺序输出返回的结果。",
"link": "/coding/编程题/请实现一个函数，要求能在页面请求很多时，尽可能快地按照顺序输出返回的结果。"
},
{
"text": "请对以下数组，根据 `born` 的值降序排列",
"link": "/coding/编程题/请对以下数组，根据 `born` 的值降序排列"
},
{
"text": "请手写“冒泡排序”",
"link": "/coding/编程题/请手写“冒泡排序”"
},
{
"text": "请手写“基数排序”",
"link": "/coding/编程题/请手写“基数排序”"
},
{
"text": "请手写“堆排序”",
"link": "/coding/编程题/请手写“堆排序”"
},
{
"text": "请手写“希尔排序”",
"link": "/coding/编程题/请手写“希尔排序”"
},
{
"text": "请手写“归并排序”",
"link": "/coding/编程题/请手写“归并排序”"
},
{
"text": "请手写“快速排序”",
"link": "/coding/编程题/请手写“快速排序”"
},
{
"text": "请手写“插入排序”",
"link": "/coding/编程题/请手写“插入排序”"
},
{
"text": "请手写“桶排序”",
"link": "/coding/编程题/请手写“桶排序”"
},
{
"text": "请手写“计数排序”",
"link": "/coding/编程题/请手写“计数排序”"
},
{
"text": "请手写“选择排序”",
"link": "/coding/编程题/请手写“选择排序”"
},
{
"text": "请按以下要求实现 compose 方法",
"link": "/coding/编程题/请按以下要求实现 compose 方法"
},
{
"text": "请按以下要求实现方法 fn ：遇到退格字符就删除前面的字符，遇到两个退格就删除两个字符",
"link": "/coding/编程题/请按以下要求实现方法 fn ：遇到退格字符就删除前面的字符，遇到两个退格就删除两个字符"
},
{
"text": "请补充 objToArray 函数",
"link": "/coding/编程题/请补充 objToArray 函数"
},
{
"text": "链表中，环的入口节点",
"link": "/coding/编程题/链表中，环的入口节点"
}
],
"/coding/跨端技术/": [
{
"text": "**react native 工作原理是什么？",
"link": "/coding/跨端技术/**react native 工作原理是什么？"
},
{
"text": "Electron 中的主进程和渲染进程分别是什么？",
"link": "/coding/跨端技术/Electron 中的主进程和渲染进程分别是什么？"
},
{
"text": "Electron 有哪些特点和优势？",
"link": "/coding/跨端技术/Electron 有哪些特点和优势？"
},
{
"text": "taro 的实现原理是怎么样的？",
"link": "/coding/跨端技术/taro 的实现原理是怎么样的？"
},
{
"text": "前端领域有哪些跨端方案？",
"link": "/coding/跨端技术/前端领域有哪些跨端方案？"
},
{
"text": "简单说下你对 Electron 架构的理解",
"link": "/coding/跨端技术/简单说下你对 Electron 架构的理解"
},
{
"text": "说说 jsBridge 的原理",
"link": "/coding/跨端技术/说说 jsBridge 的原理"
},
{
"text": "说说你对 Electron 的了解",
"link": "/coding/跨端技术/说说你对 Electron 的了解"
},
{
"text": "说说你对React Native的了解？",
"link": "/coding/跨端技术/说说你对React Native的了解？"
},
{
"text": "说说你对flutter的了解",
"link": "/coding/跨端技术/说说你对flutter的了解"
},
{
"text": "说说你对跨平台的理解",
"link": "/coding/跨端技术/说说你对跨平台的理解"
}
],
"/framework/Node/": [
{
"text": "**ESM 与 CJS 的差异有哪些？",
"link": "/framework/Node/**ESM 与 CJS 的差异有哪些？"
},
{
"text": "**Node.js 是单线程的，那该如何充分利用多核 CPU 呢？",
"link": "/framework/Node/**Node.js 是单线程的，那该如何充分利用多核 CPU 呢？"
},
{
"text": "**PM2 部署 nodejs 有哪些优势？",
"link": "/framework/Node/**PM2 部署 nodejs 有哪些优势？"
},
{
"text": "**express 里面的\"中间件\"和\"插件\"是同一个东西吗？",
"link": "/framework/Node/**express 里面的\"中间件\"和\"插件\"是同一个东西吗？"
},
{
"text": "**process.nextTick, setTimeout 以及 setImmediate 三者的执行顺序？",
"link": "/framework/Node/**process.nextTick, setTimeout 以及 setImmediate 三者的执行顺序？"
},
{
"text": "**单线程的 nodejs 是如何充分利用计算机 CPU 资源的呢？",
"link": "/framework/Node/**单线程的 nodejs 是如何充分利用计算机 CPU 资源的呢？"
},
{
"text": "**在没有async-await 的时候, koa是怎么实现的洋葱模型？",
"link": "/framework/Node/**在没有async-await 的时候, koa是怎么实现的洋葱模型？"
},
{
"text": "**怎么在 koa 中，进行中间件的异常处理？",
"link": "/framework/Node/**怎么在 koa 中，进行中间件的异常处理？"
},
{
"text": "**怎么进行 Node 服务的内存优化？",
"link": "/framework/Node/**怎么进行 Node 服务的内存优化？"
},
{
"text": "**说说 express middleware(中间件) 的工作原理",
"link": "/framework/Node/**说说 express middleware(中间件) 的工作原理"
},
{
"text": "**说说你对 npm 包管理的了解",
"link": "/framework/Node/**说说你对 npm 包管理的了解"
},
{
"text": "**说说对 node 子进程的了解",
"link": "/framework/Node/**说说对 node 子进程的了解"
},
{
"text": "Koa 中，如果一个中间件没有调用 await next()，后续的中间件还会执行吗？",
"link": "/framework/Node/Koa 中，如果一个中间件没有调用 await next()，后续的中间件还会执行吗？"
},
{
"text": "Node. js 有哪些全局对象？",
"link": "/framework/Node/Node. js 有哪些全局对象？"
},
{
"text": "Node.js 如何调试？",
"link": "/framework/Node/Node.js 如何调试？"
},
{
"text": "Node性能如何进行监控以及优化？",
"link": "/framework/Node/Node性能如何进行监控以及优化？"
},
{
"text": "body-parser 这个中间件是做什么用的？",
"link": "/framework/Node/body-parser 这个中间件是做什么用的？"
},
{
"text": "common.js和es6中模块引入的区别？",
"link": "/framework/Node/common.js和es6中模块引入的区别？"
},
{
"text": "koa 框架中，该怎么处理中间件的异常？",
"link": "/framework/Node/koa 框架中，该怎么处理中间件的异常？"
},
{
"text": "koa和express有哪些不同？",
"link": "/framework/Node/koa和express有哪些不同？"
},
{
"text": "npm 是什么？",
"link": "/framework/Node/npm 是什么？"
},
{
"text": "pm2守护进程的原理是什么？",
"link": "/framework/Node/pm2守护进程的原理是什么？"
},
{
"text": "两个 Node.js 进程如何通信？",
"link": "/framework/Node/两个 Node.js 进程如何通信？"
},
{
"text": "为什么Node在使用es module时必须加上文件扩展名？",
"link": "/framework/Node/为什么Node在使用es module时必须加上文件扩展名？"
},
{
"text": "在没有async await 的时候，koa是怎么实现的洋葱模型？",
"link": "/framework/Node/在没有async await 的时候，koa是怎么实现的洋葱模型？"
},
{
"text": "如何实现jwt鉴权机制？说说你的思路",
"link": "/framework/Node/如何实现jwt鉴权机制？说说你的思路"
},
{
"text": "如何实现文件上传？说说你的思路",
"link": "/framework/Node/如何实现文件上传？说说你的思路"
},
{
"text": "如果让你来设计一个分页功能, 你会怎么设计？ 前后端如何交互？",
"link": "/framework/Node/如果让你来设计一个分页功能, 你会怎么设计？ 前后端如何交互？"
},
{
"text": "浏览器和 Node 中的事件循环有什么区别？",
"link": "/framework/Node/浏览器和 Node 中的事件循环有什么区别？"
},
{
"text": "说说 Node 文件查找的优先级以及 Require 方法的文件查找策略？",
"link": "/framework/Node/说说 Node 文件查找的优先级以及 Require 方法的文件查找策略？"
},
{
"text": "说说Node中的EventEmitter？ 如何实现一个EventEmitter？",
"link": "/framework/Node/说说Node中的EventEmitter？ 如何实现一个EventEmitter？"
},
{
"text": "说说你对 koa 洋葱模型的理解",
"link": "/framework/Node/说说你对 koa 洋葱模型的理解"
},
{
"text": "说说你对Node.js 的理解？优缺点？应用场景？",
"link": "/framework/Node/说说你对Node.js 的理解？优缺点？应用场景？"
},
{
"text": "说说对 Node 中的 Buffer 的理解？应用场景？",
"link": "/framework/Node/说说对 Node 中的 Buffer 的理解？应用场景？"
},
{
"text": "说说对 Node 中的 Stream 的理解？应用场景？",
"link": "/framework/Node/说说对 Node 中的 Stream 的理解？应用场景？"
},
{
"text": "说说对 Node 中的 fs模块的理解？ 有哪些常用方法",
"link": "/framework/Node/说说对 Node 中的 fs模块的理解？ 有哪些常用方法"
},
{
"text": "说说对 Node 中的 process 的理解？有哪些常用方法？",
"link": "/framework/Node/说说对 Node 中的 process 的理解？有哪些常用方法？"
},
{
"text": "说说对Nodejs中的事件循环机制理解？",
"link": "/framework/Node/说说对Nodejs中的事件循环机制理解？"
},
{
"text": "说说对中间件概念的理解，如何封装 node 中间件？",
"link": "/framework/Node/说说对中间件概念的理解，如何封装 node 中间件？"
}
],
"/framework/React/": [
{
"text": "**Next.js 中的 AppRouter 和 PageRouter 有什么区别？",
"link": "/framework/React/**Next.js 中的 AppRouter 和 PageRouter 有什么区别？"
},
{
"text": "**React 19 有哪些新特性？",
"link": "/framework/React/**React 19 有哪些新特性？"
},
{
"text": "**React Reconciler 为何要采用 fiber 架构？",
"link": "/framework/React/**React Reconciler 为何要采用 fiber 架构？"
},
{
"text": "**React Router 中，HashRouter 和 BrowserRouter 的区别和原理？",
"link": "/framework/React/**React Router 中，HashRouter 和 BrowserRouter 的区别和原理？"
},
{
"text": "**React 中怎么实现状态自动保存（KeepAlive）？",
"link": "/framework/React/**React 中怎么实现状态自动保存（KeepAlive）？"
},
{
"text": "**React 中的 createContext 和 useContext 分别有什么用？",
"link": "/framework/React/**React 中的 createContext 和 useContext 分别有什么用？"
},
{
"text": "**React 中的 forwardsRef，作用是什么， 有哪些使用场景？",
"link": "/framework/React/**React 中的 forwardsRef，作用是什么， 有哪些使用场景？"
},
{
"text": "**React 中的 hooks 和 memorizedState 是什么关系？",
"link": "/framework/React/**React 中的 hooks 和 memorizedState 是什么关系？"
},
{
"text": "**React 中的 useRef 是如何实现的？",
"link": "/framework/React/**React 中的 useRef 是如何实现的？"
},
{
"text": "**React 中，fiber 是如何实现时间切片的？",
"link": "/framework/React/**React 中，fiber 是如何实现时间切片的？"
},
{
"text": "**React 中，如何实现类似于 Vue-router 提供的路由守卫？",
"link": "/framework/React/**React 中，如何实现类似于 Vue-router 提供的路由守卫？"
},
{
"text": "**React 中，如何避免使用 context 时， 引起整个挂载节点树的重新渲染",
"link": "/framework/React/**React 中，如何避免使用 context 时， 引起整个挂载节点树的重新渲染"
},
{
"text": "**React 中，怎么给 children 添加额外的属性？",
"link": "/framework/React/**React 中，怎么给 children 添加额外的属性？"
},
{
"text": "**React 中，构建组件的方式有哪些？",
"link": "/framework/React/**React 中，构建组件的方式有哪些？"
},
{
"text": "**React 为什么要自己实现调度器， 而不是直接使用 requestIdleCallback ？",
"link": "/framework/React/**React 为什么要自己实现调度器， 而不是直接使用 requestIdleCallback ？"
},
{
"text": "**React 是怎么渲染出页面的？",
"link": "/framework/React/**React 是怎么渲染出页面的？"
},
{
"text": "**React 的循环渲染中，为什么不推荐使用 index 作为元素的 key？",
"link": "/framework/React/**React 的循环渲染中，为什么不推荐使用 index 作为元素的 key？"
},
{
"text": "**React中，useRef、ref、forwardsRef 的区别是什么？",
"link": "/framework/React/**React中，useRef、ref、forwardsRef 的区别是什么？"
},
{
"text": "**fiber 架构的工作原理？",
"link": "/framework/React/**fiber 架构的工作原理？"
},
{
"text": "**forwardRef 作用是什么？",
"link": "/framework/React/**forwardRef 作用是什么？"
},
{
"text": "**mobx 和 redux 有什么区别？",
"link": "/framework/React/**mobx 和 redux 有什么区别？"
},
{
"text": "**react 中，在什么场景下需要使用 useContext？",
"link": "/framework/React/**react 中，在什么场景下需要使用 useContext？"
},
{
"text": "**react 中，数组用useState做状态管理的时候，使用push，pop，splice等直接更改数组对象，会引起页面渲染吗？",
"link": "/framework/React/**react 中，数组用useState做状态管理的时候，使用push，pop，splice等直接更改数组对象，会引起页面渲染吗？"
},
{
"text": "**react-router 和原生路由有什么区别？",
"link": "/framework/React/**react-router 和原生路由有什么区别？"
},
{
"text": "**react中，父子组件的生命周期执行顺序是怎么样的？",
"link": "/framework/React/**react中，父子组件的生命周期执行顺序是怎么样的？"
},
{
"text": "**redux-thunk 和 redux 是什么关系？",
"link": "/framework/React/**redux-thunk 和 redux 是什么关系？"
},
{
"text": "**useEffect的第二个参数，是如何判断实现依赖是否发生变化的？",
"link": "/framework/React/**useEffect的第二个参数，是如何判断实现依赖是否发生变化的？"
},
{
"text": "**useState 是如何实现的？",
"link": "/framework/React/**useState 是如何实现的？"
},
{
"text": "**为什么 react 组件中， 都需要声明 `import React from 'react';`",
"link": "/framework/React/**为什么 react 组件中， 都需要声明 `import React from 'react';`"
},
{
"text": "**为什么 useState 返回的是数组而不是对象？",
"link": "/framework/React/**为什么 useState 返回的是数组而不是对象？"
},
{
"text": "**为什么不能在循环、条件或嵌套函数中调用 Hooks？",
"link": "/framework/React/**为什么不能在循环、条件或嵌套函数中调用 Hooks？"
},
{
"text": "**使用 react-router 跳转时，如何将参数传递给下一个页面？",
"link": "/framework/React/**使用 react-router 跳转时，如何将参数传递给下一个页面？"
},
{
"text": "**在 React 中如何实现代码分割？有哪些常见方式？",
"link": "/framework/React/**在 React 中如何实现代码分割？有哪些常见方式？"
},
{
"text": "**在 React 中，useEffect 钩子的作用是什么？它的参数有哪些？如何使用 useEffect 实现组件的副作用处理？",
"link": "/framework/React/**在 React 中，useEffect 钩子的作用是什么？它的参数有哪些？如何使用 useEffect 实现组件的副作用处理？"
},
{
"text": "**在 React 项目中， 是否可以不用 react-router， 使用浏览器原生 history 路由来组织页面路由？",
"link": "/framework/React/**在 React 项目中， 是否可以不用 react-router， 使用浏览器原生 history 路由来组织页面路由？"
},
{
"text": "**在 React 项目中，一般怎么处理错误？",
"link": "/framework/React/**在 React 项目中，一般怎么处理错误？"
},
{
"text": "**如何实现一个可以监听任何事件的React Hooks？",
"link": "/framework/React/**如何实现一个可以监听任何事件的React Hooks？"
},
{
"text": "**如何通过 React.memo 优化条件渲染？",
"link": "/framework/React/**如何通过 React.memo 优化条件渲染？"
},
{
"text": "**怎么获取函数组件的实例？",
"link": "/framework/React/**怎么获取函数组件的实例？"
},
{
"text": "**讲讲 React.memo 和 JS 的 memorize 函数的区别",
"link": "/framework/React/**讲讲 React.memo 和 JS 的 memorize 函数的区别"
},
{
"text": "**说说 React commit 阶段的执行过程",
"link": "/framework/React/**说说 React commit 阶段的执行过程"
},
{
"text": "**说说 React render 阶段的执行过程",
"link": "/framework/React/**说说 React render 阶段的执行过程"
},
{
"text": "**说说 React 中，scheduler 的调度机制原理",
"link": "/framework/React/**说说 React 中，scheduler 的调度机制原理"
},
{
"text": "**说说Fiber的含义与数据结构",
"link": "/framework/React/**说说Fiber的含义与数据结构"
},
{
"text": "**说说React render方法的原理？在什么时候会被触发？",
"link": "/framework/React/**说说React render方法的原理？在什么时候会被触发？"
},
{
"text": "**说说React事件和原生事件的执行顺序",
"link": "/framework/React/**说说React事件和原生事件的执行顺序"
},
{
"text": "**说说你对 React 生态的了解",
"link": "/framework/React/**说说你对 React 生态的了解"
},
{
"text": "**说说你对 createPortal 的了解",
"link": "/framework/React/**说说你对 createPortal 的了解"
},
{
"text": "**说说你对 useReducer 的理解",
"link": "/framework/React/**说说你对 useReducer 的理解"
},
{
"text": "Fiber 为什么是 React 性能的一个飞跃？",
"link": "/framework/React/Fiber 为什么是 React 性能的一个飞跃？"
},
{
"text": "React Fiber 是如何实现更新过程可控？",
"link": "/framework/React/React Fiber 是如何实现更新过程可控？"
},
{
"text": "React Fiber是什么？",
"link": "/framework/React/React Fiber是什么？"
},
{
"text": "React Hooks 在使用上有哪些限制？",
"link": "/framework/React/React Hooks 在使用上有哪些限制？"
},
{
"text": "React Hooks带来了什么便利？",
"link": "/framework/React/React Hooks带来了什么便利？"
},
{
"text": "React Hooks当中的useEffect是如何区分生命周期钩子的",
"link": "/framework/React/React Hooks当中的useEffect是如何区分生命周期钩子的"
},
{
"text": "React Portals 有什么用？",
"link": "/framework/React/React Portals 有什么用？"
},
{
"text": "React 中为什么不直接使用 requestIdleCallback？",
"link": "/framework/React/React 中为什么不直接使用 requestIdleCallback？"
},
{
"text": "React 中如果绑定事件使用匿名函数有什么影响？",
"link": "/framework/React/React 中如果绑定事件使用匿名函数有什么影响？"
},
{
"text": "React 中的 ref 有什么用？",
"link": "/framework/React/React 中的 ref 有什么用？"
},
{
"text": "React 中，怎么实现父组件调用子组件中的方法？",
"link": "/framework/React/React 中，怎么实现父组件调用子组件中的方法？"
},
{
"text": "React 为什么要废弃 componentWillMount、componentWillReceiveProps、componentWillUpdate 这三个生命周期钩子？它们有哪些问题呢？React 又是如何解决的呢？",
"link": "/framework/React/React 为什么要废弃 componentWillMount、componentWillReceiveProps、componentWillUpdate 这三个生命周期钩子？它们有哪些问题呢？React 又是如何解决的呢？"
},
{
"text": "React 和 Vue 在技术层面有哪些区别？",
"link": "/framework/React/React 和 Vue 在技术层面有哪些区别？"
},
{
"text": "React 的事件代理机制和原生事件绑定有什么区别？",
"link": "/framework/React/React 的事件代理机制和原生事件绑定有什么区别？"
},
{
"text": "React 的事件代理机制和原生事件绑定混用会有什么问题？",
"link": "/framework/React/React 的事件代理机制和原生事件绑定混用会有什么问题？"
},
{
"text": "React 组件间怎么进行通信？",
"link": "/framework/React/React 组件间怎么进行通信？"
},
{
"text": "React.PureComponent 和 React.Component 有什么区别？",
"link": "/framework/React/React.PureComponent 和 React.Component 有什么区别？"
},
{
"text": "React.memo() 和 useMemo() 的用法是什么，有哪些区别？",
"link": "/framework/React/React.memo() 和 useMemo() 的用法是什么，有哪些区别？"
},
{
"text": "React18新特性",
"link": "/framework/React/React18新特性"
},
{
"text": "React中为什么要给组件设置 key？",
"link": "/framework/React/React中为什么要给组件设置 key？"
},
{
"text": "React中的VM 一定会提高性能吗？",
"link": "/framework/React/React中的VM 一定会提高性能吗？"
},
{
"text": "React中的类组件和函数组件之间有什么区别？",
"link": "/framework/React/React中的类组件和函数组件之间有什么区别？"
},
{
"text": "React中的路由懒加载是什么？原理是什么？",
"link": "/framework/React/React中的路由懒加载是什么？原理是什么？"
},
{
"text": "React中，能否直接将 props 的值复制给 state？",
"link": "/framework/React/React中，能否直接将 props 的值复制给 state？"
},
{
"text": "React有哪些性能优化的方法？",
"link": "/framework/React/React有哪些性能优化的方法？"
},
{
"text": "React构建组件的方式有哪些？有什么区别？",
"link": "/framework/React/React构建组件的方式有哪些？有什么区别？"
},
{
"text": "Redux 中异步的请求怎么处理",
"link": "/framework/React/Redux 中异步的请求怎么处理"
},
{
"text": "Redux 和 Vuex 有什么区别，它们有什么共同思想吗？",
"link": "/framework/React/Redux 和 Vuex 有什么区别，它们有什么共同思想吗？"
},
{
"text": "Redux 状态管理器和变量挂载到 window 中有什么区别？",
"link": "/framework/React/Redux 状态管理器和变量挂载到 window 中有什么区别？"
},
{
"text": "Redux中的connect有什么作用？",
"link": "/framework/React/Redux中的connect有什么作用？"
},
{
"text": "constructor中super与props参数一起使用的目的是什么？",
"link": "/framework/React/constructor中super与props参数一起使用的目的是什么？"
},
{
"text": "react 和 react-dom 是什么关系？",
"link": "/framework/React/react 和 react-dom 是什么关系？"
},
{
"text": "react 中怎么捕获异常？",
"link": "/framework/React/react 中怎么捕获异常？"
},
{
"text": "react 和 vue 有什么区别？",
"link": "/framework/React/react 和 vue 有什么区别？"
},
{
"text": "react 的虚拟dom是怎么实现的？",
"link": "/framework/React/react 的虚拟dom是怎么实现的？"
},
{
"text": "react-router 里的 <Link> 标签和 <a> 标签有什么区别？",
"link": "/framework/React/react-router 里的 <Link> 标签和 <a> 标签有什么区别？"
},
{
"text": "react中懒加载的实现原理是什么？",
"link": "/framework/React/react中懒加载的实现原理是什么？"
},
{
"text": "react是否支持给标签设置自定义的属性，比如给video标签设置webkit-playsinline？",
"link": "/framework/React/react是否支持给标签设置自定义的属性，比如给video标签设置webkit-playsinline？"
},
{
"text": "setState 之后发生了什么",
"link": "/framework/React/setState 之后发生了什么"
},
{
"text": "setState 是同步，还是异步的？",
"link": "/framework/React/setState 是同步，还是异步的？"
},
{
"text": "state 和 props有什么区别？",
"link": "/framework/React/state 和 props有什么区别？"
},
{
"text": "taro 2.x 和 taro 3 最大区别是什么？",
"link": "/framework/React/taro 2.x 和 taro 3 最大区别是什么？"
},
{
"text": "taro 的实现原理是怎么样的？",
"link": "/framework/React/taro 的实现原理是怎么样的？"
},
{
"text": "useEffect 与 useLayoutEffect 有什么区别？",
"link": "/framework/React/useEffect 与 useLayoutEffect 有什么区别？"
},
{
"text": "useEffect 的第二个参数, 传空数组和传依赖数组有什么区别？",
"link": "/framework/React/useEffect 的第二个参数, 传空数组和传依赖数组有什么区别？"
},
{
"text": "useMemo 和 useCallback 有什么区别？",
"link": "/framework/React/useMemo 和 useCallback 有什么区别？"
},
{
"text": "下面代码中，点击 “+3” 按钮后，age 的值是什么？",
"link": "/framework/React/下面代码中，点击 “+3” 按钮后，age 的值是什么？"
},
{
"text": "下面函数组件的输出分别是什么？",
"link": "/framework/React/下面函数组件的输出分别是什么？"
},
{
"text": "不同版本的 React 都做过哪些优化？",
"link": "/framework/React/不同版本的 React 都做过哪些优化？"
},
{
"text": "为什么 react 需要 fiber 架构，而 Vue 却不需要？",
"link": "/framework/React/为什么 react 需要 fiber 架构，而 Vue 却不需要？"
},
{
"text": "为什么React的 VM 可以提高性能？",
"link": "/framework/React/为什么React的 VM 可以提高性能？"
},
{
"text": "为什么不能用数组下标来作为react组件中的key？",
"link": "/framework/React/为什么不能用数组下标来作为react组件中的key？"
},
{
"text": "为什么不能直接使用 this.state 改变数据？",
"link": "/framework/React/为什么不能直接使用 this.state 改变数据？"
},
{
"text": "什么是 React？",
"link": "/framework/React/什么是 React？"
},
{
"text": "什么是JSX？",
"link": "/framework/React/什么是JSX？"
},
{
"text": "什么是受控组件？",
"link": "/framework/React/什么是受控组件？"
},
{
"text": "什么是虚拟DOM？",
"link": "/framework/React/什么是虚拟DOM？"
},
{
"text": "什么是高阶组件？",
"link": "/framework/React/什么是高阶组件？"
},
{
"text": "你在React项目中是如何使用Redux的？ 项目结构是如何划分的？",
"link": "/framework/React/你在React项目中是如何使用Redux的？ 项目结构是如何划分的？"
},
{
"text": "你常用的 React Hooks 有哪些？",
"link": "/framework/React/你常用的 React Hooks 有哪些？"
},
{
"text": "使用 React hooks 怎么实现类里面的所有生命周期？",
"link": "/framework/React/使用 React hooks 怎么实现类里面的所有生命周期？"
},
{
"text": "使用 redux 有哪些原则？",
"link": "/framework/React/使用 redux 有哪些原则？"
},
{
"text": "使用 useState （const [test, setTest] = useState([])）时，为什么连续调用 setTest({...test, newValue}) 会出现值的丢失？",
"link": "/framework/React/使用 useState （const [test, setTest] = useState([])）时，为什么连续调用 setTest({...test, newValue}) 会出现值的丢失？"
},
{
"text": "使用React Hooks有什么优势？",
"link": "/framework/React/使用React Hooks有什么优势？"
},
{
"text": "列举几个常见的 Hook？",
"link": "/framework/React/列举几个常见的 Hook？"
},
{
"text": "单页应用如何提高加载速度？",
"link": "/framework/React/单页应用如何提高加载速度？"
},
{
"text": "在 React 中可以做哪些性能优化？",
"link": "/framework/React/在 React 中可以做哪些性能优化？"
},
{
"text": "在 shouldComponentUpdate 或 componentWillUpdate 中使用 setState 会发生什么？",
"link": "/framework/React/在 shouldComponentUpdate 或 componentWillUpdate 中使用 setState 会发生什么？"
},
{
"text": "在react中怎么实现组件间的过渡动画？",
"link": "/framework/React/在react中怎么实现组件间的过渡动画？"
},
{
"text": "如何在React中应用样式？",
"link": "/framework/React/如何在React中应用样式？"
},
{
"text": "如何让 useEffect 支持 async-await？",
"link": "/framework/React/如何让 useEffect 支持 async-await？"
},
{
"text": "如果在 useEffect 的第一个参数中 return 了一个函数，那么第二个参数分别传空数组和传依赖数组，该函数分别是在什么时候执行？",
"link": "/framework/React/如果在 useEffect 的第一个参数中 return 了一个函数，那么第二个参数分别传空数组和传依赖数组，该函数分别是在什么时候执行？"
},
{
"text": "子组件是一个 Portal，发生点击事件能冒泡到父组件吗？",
"link": "/framework/React/子组件是一个 Portal，发生点击事件能冒泡到父组件吗？"
},
{
"text": "实现 useUpdate 方法，调用时强制组件重新渲染",
"link": "/framework/React/实现 useUpdate 方法，调用时强制组件重新渲染"
},
{
"text": "实现一个 useTimeout Hook",
"link": "/framework/React/实现一个 useTimeout Hook"
},
{
"text": "怎么判断一个对象是否是 React 元素？",
"link": "/framework/React/怎么判断一个对象是否是 React 元素？"
},
{
"text": "怎么在代码中判断一个 React 组件是 class component 还是 function component？",
"link": "/framework/React/怎么在代码中判断一个 React 组件是 class component 还是 function component？"
},
{
"text": "我们应该在什么场景下使用 useMemo 和 useCallback ？",
"link": "/framework/React/我们应该在什么场景下使用 useMemo 和 useCallback ？"
},
{
"text": "简单介绍下React中的 diff 算法",
"link": "/framework/React/简单介绍下React中的 diff 算法"
},
{
"text": "简述下 React 的事件代理机制？",
"link": "/framework/React/简述下 React 的事件代理机制？"
},
{
"text": "简述下 React 的生命周期？每个生命周期都做了什么？",
"link": "/framework/React/简述下 React 的生命周期？每个生命周期都做了什么？"
},
{
"text": "说说React Jsx转换成真实DOM过程？",
"link": "/framework/React/说说React Jsx转换成真实DOM过程？"
},
{
"text": "说说React Router有几种模式，以及实现原理？",
"link": "/framework/React/说说React Router有几种模式，以及实现原理？"
},
{
"text": "说说React服务端渲染怎么做？原理是什么？",
"link": "/framework/React/说说React服务端渲染怎么做？原理是什么？"
},
{
"text": "说说react中引入css的方式有哪几种？区别？",
"link": "/framework/React/说说react中引入css的方式有哪几种？区别？"
},
{
"text": "说说你在React项目是如何捕获错误的？",
"link": "/framework/React/说说你在React项目是如何捕获错误的？"
},
{
"text": "说说你对 React Hook的闭包陷阱的理解，有哪些解决方案？",
"link": "/framework/React/说说你对 React Hook的闭包陷阱的理解，有哪些解决方案？"
},
{
"text": "说说你对 dangerouslySetInnerHTML 的理解",
"link": "/framework/React/说说你对 dangerouslySetInnerHTML 的理解"
},
{
"text": "说说你对 useContext 的理解",
"link": "/framework/React/说说你对 useContext 的理解"
},
{
"text": "说说你对 useMemo 的理解",
"link": "/framework/React/说说你对 useMemo 的理解"
},
{
"text": "说说你对React Router的理解？常用的Router组件有哪些？",
"link": "/framework/React/说说你对React Router的理解？常用的Router组件有哪些？"
},
{
"text": "说说你对Redux的理解？其工作原理？",
"link": "/framework/React/说说你对Redux的理解？其工作原理？"
},
{
"text": "说说你对immutable的理解？如何应用在react项目中？",
"link": "/framework/React/说说你对immutable的理解？如何应用在react项目中？"
},
{
"text": "说说你对自定义hook的理解",
"link": "/framework/React/说说你对自定义hook的理解"
},
{
"text": "说说对 React 中Element、Component、Node、Instance 四个概念的理解",
"link": "/framework/React/说说对 React 中Element、Component、Node、Instance 四个概念的理解"
},
{
"text": "说说对Redux中间件的理解？常用的中间件有哪些？实现原理？",
"link": "/framework/React/说说对Redux中间件的理解？常用的中间件有哪些？实现原理？"
},
{
"text": "说说对受控组件和非受控组件的理解，以及应用场景？",
"link": "/framework/React/说说对受控组件和非受控组件的理解，以及应用场景？"
}
],
"/framework/TypeScript/": [
{
"text": "**Boolean 和 boolean 有什么区别？",
"link": "/framework/TypeScript/**Boolean 和 boolean 有什么区别？"
},
{
"text": "**extends 条件类型怎么定义？",
"link": "/framework/TypeScript/**extends 条件类型怎么定义？"
},
{
"text": "**in 运算符作用是什么？",
"link": "/framework/TypeScript/**in 运算符作用是什么？"
},
{
"text": "**infer 关键字是什么？",
"link": "/framework/TypeScript/**infer 关键字是什么？"
},
{
"text": "**never 是什么类型，详细讲一下",
"link": "/framework/TypeScript/**never 是什么类型，详细讲一下"
},
{
"text": "**unknown 是什么类型？",
"link": "/framework/TypeScript/**unknown 是什么类型？"
},
{
"text": "**你了解 ts 工具类型 Exclude 与 Omit 的使用吗？及它们两个的区别？",
"link": "/framework/TypeScript/**你了解 ts 工具类型 Exclude 与 Omit 的使用吗？及它们两个的区别？"
},
{
"text": "**在开发过程中， 使用过哪些 TS 的特性或者能力？",
"link": "/framework/TypeScript/**在开发过程中， 使用过哪些 TS 的特性或者能力？"
},
{
"text": "**枚举和常量枚举的区别",
"link": "/framework/TypeScript/**枚举和常量枚举的区别"
},
{
"text": "**纯 TS 项目工程中, 如何使用 alias path？",
"link": "/framework/TypeScript/**纯 TS 项目工程中, 如何使用 alias path？"
},
{
"text": "**联合类型是什么？",
"link": "/framework/TypeScript/**联合类型是什么？"
},
{
"text": "**说说 TypeScript 中，有哪些内置的类型方法和工具类型",
"link": "/framework/TypeScript/**说说 TypeScript 中，有哪些内置的类型方法和工具类型"
},
{
"text": "**说说 Typscript 的 extends 关键字会在哪些场景下使用？",
"link": "/framework/TypeScript/**说说 Typscript 的 extends 关键字会在哪些场景下使用？"
},
{
"text": "**说说 const 和 readonly 的区别",
"link": "/framework/TypeScript/**说说 const 和 readonly 的区别"
},
{
"text": "TypeScript 中的 getter-setter 是什么？你如何使用它们？",
"link": "/framework/TypeScript/TypeScript 中的 getter-setter 是什么？你如何使用它们？"
},
{
"text": "TypeScript 中的模块是什么？",
"link": "/framework/TypeScript/TypeScript 中的模块是什么？"
},
{
"text": "TypeScript 中的类型断言是什么？",
"link": "/framework/TypeScript/TypeScript 中的类型断言是什么？"
},
{
"text": "TypeScript 中的类是什么？你如何定义它们？",
"link": "/framework/TypeScript/TypeScript 中的类是什么？你如何定义它们？"
},
{
"text": "TypeScript 和 JavaScript 的区别是什么？",
"link": "/framework/TypeScript/TypeScript 和 JavaScript 的区别是什么？"
},
{
"text": "TypeScript 的主要特点是什么？",
"link": "/framework/TypeScript/TypeScript 的主要特点是什么？"
},
{
"text": "TypeScript 的内置数据类型有哪些？",
"link": "/framework/TypeScript/TypeScript 的内置数据类型有哪些？"
},
{
"text": "TypeScript中有哪些声明变量的方式？",
"link": "/framework/TypeScript/TypeScript中有哪些声明变量的方式？"
},
{
"text": "TypeScript中的 Declare 关键字有什么用？",
"link": "/framework/TypeScript/TypeScript中的 Declare 关键字有什么用？"
},
{
"text": "TypeScript中的变量以及如何声明？",
"link": "/framework/TypeScript/TypeScript中的变量以及如何声明？"
},
{
"text": "TypeScript中的方法重写是什么？",
"link": "/framework/TypeScript/TypeScript中的方法重写是什么？"
},
{
"text": "TypeScript中的类型有哪些？",
"link": "/framework/TypeScript/TypeScript中的类型有哪些？"
},
{
"text": "TypeScript支持的访问修饰符有哪些？",
"link": "/framework/TypeScript/TypeScript支持的访问修饰符有哪些？"
},
{
"text": "Typescript中 interface 和 type 的差别是什么？",
"link": "/framework/TypeScript/Typescript中 interface 和 type 的差别是什么？"
},
{
"text": "Typescript中never 和 void 的区别？",
"link": "/framework/TypeScript/Typescript中never 和 void 的区别？"
},
{
"text": "Typescript中什么是类类型接口？",
"link": "/framework/TypeScript/Typescript中什么是类类型接口？"
},
{
"text": "Typescript中什么是装饰器，它们可以应用于什么？",
"link": "/framework/TypeScript/Typescript中什么是装饰器，它们可以应用于什么？"
},
{
"text": "Typescript中泛型是什么？",
"link": "/framework/TypeScript/Typescript中泛型是什么？"
},
{
"text": "tsconfig.json文件有什么用？",
"link": "/framework/TypeScript/tsconfig.json文件有什么用？"
},
{
"text": "ts中any和unknown有什么区别？",
"link": "/framework/TypeScript/ts中any和unknown有什么区别？"
},
{
"text": "typescript 中的 is 关键字有什么用？",
"link": "/framework/TypeScript/typescript 中的 is 关键字有什么用？"
},
{
"text": "为什么推荐使用 TypeScript ？",
"link": "/framework/TypeScript/为什么推荐使用 TypeScript ？"
},
{
"text": "什么是TypeScript Declare关键字？",
"link": "/framework/TypeScript/什么是TypeScript Declare关键字？"
},
{
"text": "什么是TypeScript映射文件？",
"link": "/framework/TypeScript/什么是TypeScript映射文件？"
},
{
"text": "什么是Typescript的方法重载？",
"link": "/framework/TypeScript/什么是Typescript的方法重载？"
},
{
"text": "使用TS实现一个判断传入参数是否是数组类型的方法",
"link": "/framework/TypeScript/使用TS实现一个判断传入参数是否是数组类型的方法"
},
{
"text": "使用ts实现一个判断入参是否是数组类型的方法？",
"link": "/framework/TypeScript/使用ts实现一个判断入参是否是数组类型的方法？"
},
{
"text": "如何在TypeScript中实现继承？",
"link": "/framework/TypeScript/如何在TypeScript中实现继承？"
},
{
"text": "如何定义一个数组，它的元素可能是字符串类型，也可能是数值类型？",
"link": "/framework/TypeScript/如何定义一个数组，它的元素可能是字符串类型，也可能是数值类型？"
},
{
"text": "如何将 unknown 类型指定为一个更具体的类型？",
"link": "/framework/TypeScript/如何将 unknown 类型指定为一个更具体的类型？"
},
{
"text": "如何检查TypeScript中的null和undefined ？",
"link": "/framework/TypeScript/如何检查TypeScript中的null和undefined ？"
},
{
"text": "实现下面的 firstSingleChar 方法",
"link": "/framework/TypeScript/实现下面的 firstSingleChar 方法"
},
{
"text": "实现下面的 reverseWord 方法",
"link": "/framework/TypeScript/实现下面的 reverseWord 方法"
},
{
"text": "解释一下TypeScript中的枚举。",
"link": "/framework/TypeScript/解释一下TypeScript中的枚举。"
},
{
"text": "解释如何使用 TypeScript mixin。",
"link": "/framework/TypeScript/解释如何使用 TypeScript mixin。"
},
{
"text": "说一说TypeScript中的类及其特性。",
"link": "/framework/TypeScript/说一说TypeScript中的类及其特性。"
},
{
"text": "说说你对 typescript 的理解？与 javascript 的区别？",
"link": "/framework/TypeScript/说说你对 typescript 的理解？与 javascript 的区别？"
},
{
"text": "说说对 TypeScript 中命名空间与模块的理解？区别？",
"link": "/framework/TypeScript/说说对 TypeScript 中命名空间与模块的理解？区别？"
},
{
"text": "请实现下面的 mergeArray 方法",
"link": "/framework/TypeScript/请实现下面的 mergeArray 方法"
},
{
"text": "请实现下面的 myAll 方法",
"link": "/framework/TypeScript/请实现下面的 myAll 方法"
},
{
"text": "请实现下面的 myMap 方法",
"link": "/framework/TypeScript/请实现下面的 myMap 方法"
},
{
"text": "请实现下面的 product 方法",
"link": "/framework/TypeScript/请实现下面的 product 方法"
},
{
"text": "请实现下面的 sleep 方法",
"link": "/framework/TypeScript/请实现下面的 sleep 方法"
},
{
"text": "请实现下面的 sum 方法",
"link": "/framework/TypeScript/请实现下面的 sum 方法"
},
{
"text": "请实现下面的 treePath 方法",
"link": "/framework/TypeScript/请实现下面的 treePath 方法"
},
{
"text": "请补充 objToArray 函数",
"link": "/framework/TypeScript/请补充 objToArray 函数"
}
],
"/framework/Vue/": [
{
"text": "**Pinia 有哪些使用场景？",
"link": "/framework/Vue/**Pinia 有哪些使用场景？"
},
{
"text": "**Proxy 和 Object.defineProperty 的区别是啥？",
"link": "/framework/Vue/**Proxy 和 Object.defineProperty 的区别是啥？"
},
{
"text": "**Vue 2 的响应式原理中 Object.defineProperty 有什么缺陷",
"link": "/framework/Vue/**Vue 2 的响应式原理中 Object.defineProperty 有什么缺陷"
},
{
"text": "**Vue 中的 h 函数有什么用？",
"link": "/framework/Vue/**Vue 中的 h 函数有什么用？"
},
{
"text": "**Vue 中的双向绑定和单向数据流原则是否冲突？",
"link": "/framework/Vue/**Vue 中的双向绑定和单向数据流原则是否冲突？"
},
{
"text": "**Vue 中的路由守卫是什么，可以在什么场景下使用？",
"link": "/framework/Vue/**Vue 中的路由守卫是什么，可以在什么场景下使用？"
},
{
"text": "**Vue 是如何实现 MVVM 的？",
"link": "/framework/Vue/**Vue 是如何实现 MVVM 的？"
},
{
"text": "**Vue 的响应式数据流驱动页面和传统的事件绑定命令式驱动页面，分别有什么优缺点？",
"link": "/framework/Vue/**Vue 的响应式数据流驱动页面和传统的事件绑定命令式驱动页面，分别有什么优缺点？"
},
{
"text": "**Vue 项目中，你做过哪些性能优化？",
"link": "/framework/Vue/**Vue 项目中，你做过哪些性能优化？"
},
{
"text": "**Vue2 动态给 data 添加一个新的属性时会发生什么",
"link": "/framework/Vue/**Vue2 动态给 data 添加一个新的属性时会发生什么"
},
{
"text": "**Vue2中v-model的实现原理",
"link": "/framework/Vue/**Vue2中v-model的实现原理"
},
{
"text": "**Vue2中为什么需要$set方法？如何用它解决对象新增属性的响应性问题？",
"link": "/framework/Vue/**Vue2中为什么需要$set方法？如何用它解决对象新增属性的响应性问题？"
},
{
"text": "**Vue3 中的 Teleport 是什么，有哪些应用场景？",
"link": "/framework/Vue/**Vue3 中的 Teleport 是什么，有哪些应用场景？"
},
{
"text": "**Vue3中v-model的改进是什么？如何用defineModel简化代码？",
"link": "/framework/Vue/**Vue3中v-model的改进是什么？如何用defineModel简化代码？"
},
{
"text": "**Vue3的addRoute与React Router的动态useRoutes有何区别？如何解决动态路由刷新后失效的问题？",
"link": "/framework/Vue/**Vue3的addRoute与React Router的动态useRoutes有何区别？如何解决动态路由刷新后失效的问题？"
},
{
"text": "**Vue中的 ref、toRef 和 toRefs 有什么区别？",
"link": "/framework/Vue/**Vue中的 ref、toRef 和 toRefs 有什么区别？"
},
{
"text": "**template 标签为什么不可以使用 v-show？",
"link": "/framework/Vue/**template 标签为什么不可以使用 v-show？"
},
{
"text": "**vue 中 Scoped Styles 是如何实现样式隔离的？说说具体的原理",
"link": "/framework/Vue/**vue 中 Scoped Styles 是如何实现样式隔离的？说说具体的原理"
},
{
"text": "**vue 文件中，在 v-for 时给每项元素绑定事件需要用事件代理吗，为什么？",
"link": "/framework/Vue/**vue 文件中，在 v-for 时给每项元素绑定事件需要用事件代理吗，为什么？"
},
{
"text": "**vue 是如何识别和解析指令的？",
"link": "/framework/Vue/**vue 是如何识别和解析指令的？"
},
{
"text": "**vue-cli 有哪些功能？",
"link": "/framework/Vue/**vue-cli 有哪些功能？"
},
{
"text": "**vue2 中的虚拟 dom 是怎么实现的？",
"link": "/framework/Vue/**vue2 中的虚拟 dom 是怎么实现的？"
},
{
"text": "**vue3 的响应式库是独立出来的，如果单独使用是什么样的效果？",
"link": "/framework/Vue/**vue3 的响应式库是独立出来的，如果单独使用是什么样的效果？"
},
{
"text": "**vue3 相比较于 vue2，在编译阶段有哪些改进？",
"link": "/framework/Vue/**vue3 相比较于 vue2，在编译阶段有哪些改进？"
},
{
"text": "**watch与watchEffect 有什么区别，分别在什么场景下使用？",
"link": "/framework/Vue/**watch与watchEffect 有什么区别，分别在什么场景下使用？"
},
{
"text": "**为什么需要Pinia或Vuex？如果不使用状态管理工具，如何实现跨组件通信？替代方案有哪些？",
"link": "/framework/Vue/**为什么需要Pinia或Vuex？如果不使用状态管理工具，如何实现跨组件通信？替代方案有哪些？"
},
{
"text": "**在Vue中，为什么推荐使用ref而非直接操作DOM？",
"link": "/framework/Vue/**在Vue中，为什么推荐使用ref而非直接操作DOM？"
},
{
"text": "**怎么理解 Vue3 提供的 markRaw ？",
"link": "/framework/Vue/**怎么理解 Vue3 提供的 markRaw ？"
},
{
"text": "**手写 vue 的双向绑定",
"link": "/framework/Vue/**手写 vue 的双向绑定"
},
{
"text": "**说说 Pinia 与 Vuex 的区别",
"link": "/framework/Vue/**说说 Pinia 与 Vuex 的区别"
},
{
"text": "React 和 Vue 在技术层面有哪些区别？",
"link": "/framework/Vue/React 和 Vue 在技术层面有哪些区别？"
},
{
"text": "SPA（单页应用）首屏加载速度慢怎么解决？",
"link": "/framework/Vue/SPA（单页应用）首屏加载速度慢怎么解决？"
},
{
"text": "SSR是什么？Vue中怎么实现？",
"link": "/framework/Vue/SSR是什么？Vue中怎么实现？"
},
{
"text": "Scoped Styles 为什么可以实现样式隔离？",
"link": "/framework/Vue/Scoped Styles 为什么可以实现样式隔离？"
},
{
"text": "VNode 有哪些属性？",
"link": "/framework/Vue/VNode 有哪些属性？"
},
{
"text": "Vue 3.0中Treeshaking特性是什么，并举例进行说明？",
"link": "/framework/Vue/Vue 3.0中Treeshaking特性是什么，并举例进行说明？"
},
{
"text": "Vue 中父组件怎么监听到子组件的生命周期？",
"link": "/framework/Vue/Vue 中父组件怎么监听到子组件的生命周期？"
},
{
"text": "Vue 中，假设 data 中有一个数组对象，修改数组元素时，是否会触发视图更新？",
"link": "/framework/Vue/Vue 中，假设 data 中有一个数组对象，修改数组元素时，是否会触发视图更新？"
},
{
"text": "Vue 有了数据响应式，为何还要 diff ？",
"link": "/framework/Vue/Vue 有了数据响应式，为何还要 diff ？"
},
{
"text": "Vue 模板是如何编译的",
"link": "/framework/Vue/Vue 模板是如何编译的"
},
{
"text": "Vue.observable是什么？",
"link": "/framework/Vue/Vue.observable是什么？"
},
{
"text": "Vue2.0为什么不能检查数组的变化，该怎么解决？",
"link": "/framework/Vue/Vue2.0为什么不能检查数组的变化，该怎么解决？"
},
{
"text": "Vue3.0 性能提升主要是通过哪几方面体现的？",
"link": "/framework/Vue/Vue3.0 性能提升主要是通过哪几方面体现的？"
},
{
"text": "Vue3.0 所采用的 Composition Api 与 Vue2.x 使用的 Options Api 有什么不同？",
"link": "/framework/Vue/Vue3.0 所采用的 Composition Api 与 Vue2.x 使用的 Options Api 有什么不同？"
},
{
"text": "Vue3.0的设计目标是什么？做了哪些优化？",
"link": "/framework/Vue/Vue3.0的设计目标是什么？做了哪些优化？"
},
{
"text": "Vue3.0里为什么要用 Proxy API 替代 defineProperty API ？",
"link": "/framework/Vue/Vue3.0里为什么要用 Proxy API 替代 defineProperty API ？"
},
{
"text": "Vue3有了解过吗？能说说跟Vue2的区别吗？",
"link": "/framework/Vue/Vue3有了解过吗？能说说跟Vue2的区别吗？"
},
{
"text": "Vuex 是什么？",
"link": "/framework/Vue/Vuex 是什么？"
},
{
"text": "Vuex有几种属性，它们存在的意义分别是什么？",
"link": "/framework/Vue/Vuex有几种属性，它们存在的意义分别是什么？"
},
{
"text": "Vue中的 v-show 和 v-if 有什么区别",
"link": "/framework/Vue/Vue中的 v-show 和 v-if 有什么区别"
},
{
"text": "Vue中的$nextTick有什么作用？",
"link": "/framework/Vue/Vue中的$nextTick有什么作用？"
},
{
"text": "Vue中组件和插件有什么区别？",
"link": "/framework/Vue/Vue中组件和插件有什么区别？"
},
{
"text": "Vue中给对象添加新属性时，界面不刷新怎么办？",
"link": "/framework/Vue/Vue中给对象添加新属性时，界面不刷新怎么办？"
},
{
"text": "Vue中，created和mounted两个钩子之间调用时间差值受什么影响？",
"link": "/framework/Vue/Vue中，created和mounted两个钩子之间调用时间差值受什么影响？"
},
{
"text": "Vue实例挂载的过程中发生了什么？",
"link": "/framework/Vue/Vue实例挂载的过程中发生了什么？"
},
{
"text": "Vue常用的修饰符有哪些？分别有什么应用场景？",
"link": "/framework/Vue/Vue常用的修饰符有哪些？分别有什么应用场景？"
},
{
"text": "Vue怎么实现权限管理？控制到按钮级别的权限怎么做？",
"link": "/framework/Vue/Vue怎么实现权限管理？控制到按钮级别的权限怎么做？"
},
{
"text": "Vue是怎么把template模版编译成render函数的？",
"link": "/framework/Vue/Vue是怎么把template模版编译成render函数的？"
},
{
"text": "Vue组件间通信方式都有哪些？",
"link": "/framework/Vue/Vue组件间通信方式都有哪些？"
},
{
"text": "Vue项目中如何解决跨域问题？",
"link": "/framework/Vue/Vue项目中如何解决跨域问题？"
},
{
"text": "Vue项目中有封装过axios吗？怎么封装的？",
"link": "/framework/Vue/Vue项目中有封装过axios吗？怎么封装的？"
},
{
"text": "Vue项目如何进行部署？是否有遇到部署服务器后刷新404问题？",
"link": "/framework/Vue/Vue项目如何进行部署？是否有遇到部署服务器后刷新404问题？"
},
{
"text": "computed 计算值为什么还可以依赖另外一个 computed 计算值？",
"link": "/framework/Vue/computed 计算值为什么还可以依赖另外一个 computed 计算值？"
},
{
"text": "computed怎么实现的缓存",
"link": "/framework/Vue/computed怎么实现的缓存"
},
{
"text": "created 和 mounted 有什么区别？",
"link": "/framework/Vue/created 和 mounted 有什么区别？"
},
{
"text": "react 和 vue 有什么区别？",
"link": "/framework/Vue/react 和 vue 有什么区别？"
},
{
"text": "v-model 的原理是什么样的？",
"link": "/framework/Vue/v-model 的原理是什么样的？"
},
{
"text": "vue 中 $route 和 $router 有什么区别？",
"link": "/framework/Vue/vue 中 $route 和 $router 有什么区别？"
},
{
"text": "vue 中怎么实现样式隔离？",
"link": "/framework/Vue/vue 中怎么实现样式隔离？"
},
{
"text": "vue 的响应式开发比命令式有哪些优势？",
"link": "/framework/Vue/vue 的响应式开发比命令式有哪些优势？"
},
{
"text": "vue-loader做了哪些事情？",
"link": "/framework/Vue/vue-loader做了哪些事情？"
},
{
"text": "vue3 中 ref 和 reactive 有什么区别？",
"link": "/framework/Vue/vue3 中 ref 和 reactive 有什么区别？"
},
{
"text": "vue3 为什么不需要时间分片？",
"link": "/framework/Vue/vue3 为什么不需要时间分片？"
},
{
"text": "vue3 为什么要引入 Composition API ？",
"link": "/framework/Vue/vue3 为什么要引入 Composition API ？"
},
{
"text": "vue3中怎么设置全局变量？",
"link": "/framework/Vue/vue3中怎么设置全局变量？"
},
{
"text": "vuex中的辅助函数怎么使用？",
"link": "/framework/Vue/vuex中的辅助函数怎么使用？"
},
{
"text": "vue中，推荐在哪个生命周期发起请求？",
"link": "/framework/Vue/vue中，推荐在哪个生命周期发起请求？"
},
{
"text": "vue的祖孙组件的通信方案有哪些？",
"link": "/framework/Vue/vue的祖孙组件的通信方案有哪些？"
},
{
"text": "vue组件里写的原生addEventListeners监听事件，要手动去销毁吗？为什么？",
"link": "/framework/Vue/vue组件里写的原生addEventListeners监听事件，要手动去销毁吗？为什么？"
},
{
"text": "vue路由中，history和hash两种模式有什么区别？",
"link": "/framework/Vue/vue路由中，history和hash两种模式有什么区别？"
},
{
"text": "vue中computed和watch区别",
"link": "/framework/Vue/vue中computed和watch区别"
},
{
"text": "为什么 react 需要 fiber 架构，而 Vue 却不需要？",
"link": "/framework/Vue/为什么 react 需要 fiber 架构，而 Vue 却不需要？"
},
{
"text": "为什么Vue中的data属性是一个函数而不是一个对象？",
"link": "/framework/Vue/为什么Vue中的data属性是一个函数而不是一个对象？"
},
{
"text": "为什么Vue中的v-if和v-for不建议一起用？",
"link": "/framework/Vue/为什么Vue中的v-if和v-for不建议一起用？"
},
{
"text": "什么是虚拟DOM？",
"link": "/framework/Vue/什么是虚拟DOM？"
},
{
"text": "什么是虚拟DOM？如何实现一个虚拟DOM？说说你的思路",
"link": "/framework/Vue/什么是虚拟DOM？如何实现一个虚拟DOM？说说你的思路"
},
{
"text": "你是怎么处理vue项目中的错误的？",
"link": "/framework/Vue/你是怎么处理vue项目中的错误的？"
},
{
"text": "刷新浏览器后，Vuex的数据是否存在？如何解决？",
"link": "/framework/Vue/刷新浏览器后，Vuex的数据是否存在？如何解决？"
},
{
"text": "单页应用如何提高加载速度？",
"link": "/framework/Vue/单页应用如何提高加载速度？"
},
{
"text": "大型项目中，Vue项目怎么划分结构和划分组件比较合理呢？",
"link": "/framework/Vue/大型项目中，Vue项目怎么划分结构和划分组件比较合理呢？"
},
{
"text": "如何打破 scope 对样式隔离的限制？",
"link": "/framework/Vue/如何打破 scope 对样式隔离的限制？"
},
{
"text": "如果使用Vue3.0实现一个 Modal，你会怎么进行设计？",
"link": "/framework/Vue/如果使用Vue3.0实现一个 Modal，你会怎么进行设计？"
},
{
"text": "怎么在 Vue 中定义全局方法？",
"link": "/framework/Vue/怎么在 Vue 中定义全局方法？"
},
{
"text": "自定义指令是什么？有哪些应用场景？",
"link": "/framework/Vue/自定义指令是什么？有哪些应用场景？"
},
{
"text": "说一下 vm.$set 原理",
"link": "/framework/Vue/说一下 vm.$set 原理"
},
{
"text": "说下Vite的原理",
"link": "/framework/Vue/说下Vite的原理"
},
{
"text": "说说 Vue 中 CSS scoped 的原理",
"link": "/framework/Vue/说说 Vue 中 CSS scoped 的原理"
},
{
"text": "说说 Vuex 的原理",
"link": "/framework/Vue/说说 Vuex 的原理"
},
{
"text": "说说 vue3 中的响应式设计原理",
"link": "/framework/Vue/说说 vue3 中的响应式设计原理"
},
{
"text": "说说Vue 页面渲染流程",
"link": "/framework/Vue/说说Vue 页面渲染流程"
},
{
"text": "说说vue中的diff算法",
"link": "/framework/Vue/说说vue中的diff算法"
},
{
"text": "说说vue中，key的原理",
"link": "/framework/Vue/说说vue中，key的原理"
},
{
"text": "说说你对 Vue 中异步组件的理解",
"link": "/framework/Vue/说说你对 Vue 中异步组件的理解"
},
{
"text": "说说你对Vue中 keep-alive 的理解",
"link": "/framework/Vue/说说你对Vue中 keep-alive 的理解"
},
{
"text": "说说你对Vue生命周期的理解",
"link": "/framework/Vue/说说你对Vue生命周期的理解"
},
{
"text": "说说你对slot的理解？slot使用场景有哪些？",
"link": "/framework/Vue/说说你对slot的理解？slot使用场景有哪些？"
},
{
"text": "说说你对vue的mixin的理解，以及有哪些应用场景？",
"link": "/framework/Vue/说说你对vue的mixin的理解，以及有哪些应用场景？"
},
{
"text": "说说你对vue的理解？",
"link": "/framework/Vue/说说你对vue的理解？"
},
{
"text": "说说你对渐进式框架的理解",
"link": "/framework/Vue/说说你对渐进式框架的理解"
},
{
"text": "谈谈 Vue 事件机制，并手写$on、$off、$emit、$once",
"link": "/framework/Vue/谈谈 Vue 事件机制，并手写$on、$off、$emit、$once"
},
{
"text": "谈谈你对Vue中keep-alive的理解",
"link": "/framework/Vue/谈谈你对Vue中keep-alive的理解"
},
{
"text": "谈谈对Vue中双向绑定的理解",
"link": "/framework/Vue/谈谈对Vue中双向绑定的理解"
}
],
"/framework/小程序/": [
{
"text": "**为什么小程序中无法使用 dom 相关的 api？",
"link": "/framework/小程序/**为什么小程序中无法使用 dom 相关的 api？"
},
{
"text": "**小程序如何实现rpx到px的转换？如何适配不同屏幕密度的设备（如Retina屏）？",
"link": "/framework/小程序/**小程序如何实现rpx到px的转换？如何适配不同屏幕密度的设备（如Retina屏）？"
},
{
"text": "**怎么处理微信小程序里的静默授权异步问题？",
"link": "/framework/小程序/**怎么处理微信小程序里的静默授权异步问题？"
},
{
"text": "为什么小程序里拿不到dom相关的api？",
"link": "/framework/小程序/为什么小程序里拿不到dom相关的api？"
},
{
"text": "小程序 WXSS 与 CSS 的区别？",
"link": "/framework/小程序/小程序 WXSS 与 CSS 的区别？"
},
{
"text": "小程序的双线程分别做的什么事情？",
"link": "/framework/小程序/小程序的双线程分别做的什么事情？"
},
{
"text": "小程序页面间有哪些传递数据的方法？",
"link": "/framework/小程序/小程序页面间有哪些传递数据的方法？"
},
{
"text": "微信小程序bindtap 和 catchtap 区别？",
"link": "/framework/小程序/微信小程序bindtap 和 catchtap 区别？"
},
{
"text": "微信小程序的优劣势？",
"link": "/framework/小程序/微信小程序的优劣势？"
},
{
"text": "简述一下微信小程序的主要文件有哪些？",
"link": "/framework/小程序/简述一下微信小程序的主要文件有哪些？"
},
{
"text": "简述微信小程序原理？",
"link": "/framework/小程序/简述微信小程序原理？"
},
{
"text": "说说微信小程序的架构？",
"link": "/framework/小程序/说说微信小程序的架构？"
}
],
"/framework/计算机网络/": [
{
"text": "**304 状态码用于什么场景， 好处和坏处分别是什么？",
"link": "/framework/计算机网络/**304 状态码用于什么场景， 好处和坏处分别是什么？"
},
{
"text": "**CORS 是如何实现跨域的？",
"link": "/framework/计算机网络/**CORS 是如何实现跨域的？"
},
{
"text": "**CORS 请求中，什么情况下会触发预检请求？",
"link": "/framework/计算机网络/**CORS 请求中，什么情况下会触发预检请求？"
},
{
"text": "**DNS 协议了解多少？",
"link": "/framework/计算机网络/**DNS 协议了解多少？"
},
{
"text": "**HTTP Header 中有哪些信息？",
"link": "/framework/计算机网络/**HTTP Header 中有哪些信息？"
},
{
"text": "**HTTP-3 是基于 UDP 的协议， 那么他是如何保障安全性的？",
"link": "/framework/计算机网络/**HTTP-3 是基于 UDP 的协议， 那么他是如何保障安全性的？"
},
{
"text": "**HTTPS 中的 SSL-TLS 是什么？",
"link": "/framework/计算机网络/**HTTPS 中的 SSL-TLS 是什么？"
},
{
"text": "**HTTPS 加密算法和加解密过程是啥？",
"link": "/framework/计算机网络/**HTTPS 加密算法和加解密过程是啥？"
},
{
"text": "**HTTP协议的不同版本的主要特点有哪些？",
"link": "/framework/计算机网络/**HTTP协议的不同版本的主要特点有哪些？"
},
{
"text": "**HTTP建立连接的过程？",
"link": "/framework/计算机网络/**HTTP建立连接的过程？"
},
{
"text": "**JSONP 是如何实现跨域的？",
"link": "/framework/计算机网络/**JSONP 是如何实现跨域的？"
},
{
"text": "**TCP 传输过程？",
"link": "/framework/计算机网络/**TCP 传输过程？"
},
{
"text": "**TCP 粘包（TCP packet sticking）是什么？",
"link": "/framework/计算机网络/**TCP 粘包（TCP packet sticking）是什么？"
},
{
"text": "**TCP-IP 是如何保证数据包传输有序可靠的？",
"link": "/framework/计算机网络/**TCP-IP 是如何保证数据包传输有序可靠的？"
},
{
"text": "**ajax如何获取下载进度？",
"link": "/framework/计算机网络/**ajax如何获取下载进度？"
},
{
"text": "**http 协议中的 CSP 是什么？",
"link": "/framework/计算机网络/**http 协议中的 CSP 是什么？"
},
{
"text": "**http1.1 的 keep-alive 和 http2 的多路复用有什么区别？",
"link": "/framework/计算机网络/**http1.1 的 keep-alive 和 http2 的多路复用有什么区别？"
},
{
"text": "**http1.1 的持久连接和 http2 的多路复用有什么区别？",
"link": "/framework/计算机网络/**http1.1 的持久连接和 http2 的多路复用有什么区别？"
},
{
"text": "**http3 中的 QUIC 是什么协议？",
"link": "/framework/计算机网络/**http3 中的 QUIC 是什么协议？"
},
{
"text": "**https 的证书验证过程是什么样的",
"link": "/framework/计算机网络/**https 的证书验证过程是什么样的"
},
{
"text": "**一个 tcp 连接能发几个 http 请求？",
"link": "/framework/计算机网络/**一个 tcp 连接能发几个 http 请求？"
},
{
"text": "**为什么 http2 能非常快速的过渡到 HTTP3 ？",
"link": "/framework/计算机网络/**为什么 http2 能非常快速的过渡到 HTTP3 ？"
},
{
"text": "**你知道哪些常见的网络协议？",
"link": "/framework/计算机网络/**你知道哪些常见的网络协议？"
},
{
"text": "**如何实现WebSocket的断线重连机制？",
"link": "/framework/计算机网络/**如何实现WebSocket的断线重连机制？"
},
{
"text": "**浏览器对“队头阻塞”有什么优化？",
"link": "/framework/计算机网络/**浏览器对“队头阻塞”有什么优化？"
},
{
"text": "**网络模型分层大概有哪些层级？",
"link": "/framework/计算机网络/**网络模型分层大概有哪些层级？"
},
{
"text": "**说说你对 Server-sent events(SSE，服务端推送) 的了解",
"link": "/framework/计算机网络/**说说你对 Server-sent events(SSE，服务端推送) 的了解"
},
{
"text": "**说说你对 http 协议中 HSTS 的理解",
"link": "/framework/计算机网络/**说说你对 http 协议中 HSTS 的理解"
},
{
"text": "**请求 Header 中的 Content-Type ，有哪些常见的值？",
"link": "/framework/计算机网络/**请求 Header 中的 Content-Type ，有哪些常见的值？"
},
{
"text": "**请简述 HTTP 请求的过程",
"link": "/framework/计算机网络/**请简述 HTTP 请求的过程"
},
{
"text": "301、302、303、307、308 这些状态码有什么区别？",
"link": "/framework/计算机网络/301、302、303、307、308 这些状态码有什么区别？"
},
{
"text": "Axios的原理是什么？",
"link": "/framework/计算机网络/Axios的原理是什么？"
},
{
"text": "Blob，ArrayBuffer，Base64 分别有哪些使用场景？",
"link": "/framework/计算机网络/Blob，ArrayBuffer，Base64 分别有哪些使用场景？"
},
{
"text": "Blob，ArrayBuffer，Base64 有什么区别？",
"link": "/framework/计算机网络/Blob，ArrayBuffer，Base64 有什么区别？"
},
{
"text": "Cache-Control 有哪些常见配置值？",
"link": "/framework/计算机网络/Cache-Control 有哪些常见配置值？"
},
{
"text": "DNS 预解析是什么？怎么实现？",
"link": "/framework/计算机网络/DNS 预解析是什么？怎么实现？"
},
{
"text": "DNS协议介绍",
"link": "/framework/计算机网络/DNS协议介绍"
},
{
"text": "GET和POST的请求的区别",
"link": "/framework/计算机网络/GET和POST的请求的区别"
},
{
"text": "HTTP 1.0和 HTTP 1.1 之间有哪些区别？",
"link": "/framework/计算机网络/HTTP 1.0和 HTTP 1.1 之间有哪些区别？"
},
{
"text": "HTTP 1.1和 HTTP 2.0 的区别",
"link": "/framework/计算机网络/HTTP 1.1和 HTTP 2.0 的区别"
},
{
"text": "HTTP Request Header和Response Header里面分别都有哪些比较重要的字段",
"link": "/framework/计算机网络/HTTP Request Header和Response Header里面分别都有哪些比较重要的字段"
},
{
"text": "HTTP 中如何处理表单数据的提交？",
"link": "/framework/计算机网络/HTTP 中如何处理表单数据的提交？"
},
{
"text": "HTTP 报文结构是怎样的？",
"link": "/framework/计算机网络/HTTP 报文结构是怎样的？"
},
{
"text": "HTTP1.0，HTTP1.1，HTTP2.0之间有什么区别？",
"link": "/framework/计算机网络/HTTP1.0，HTTP1.1，HTTP2.0之间有什么区别？"
},
{
"text": "HTTP1.1 中如何解决 HTTP 的队头阻塞问题？",
"link": "/framework/计算机网络/HTTP1.1 中如何解决 HTTP 的队头阻塞问题？"
},
{
"text": "HTTP2中，多路复用的原理是什么？",
"link": "/framework/计算机网络/HTTP2中，多路复用的原理是什么？"
},
{
"text": "HTTPS 为什么是安全的？",
"link": "/framework/计算机网络/HTTPS 为什么是安全的？"
},
{
"text": "HTTP协议的优点和缺点",
"link": "/framework/计算机网络/HTTP协议的优点和缺点"
},
{
"text": "HTTP和HTTPS的区别",
"link": "/framework/计算机网络/HTTP和HTTPS的区别"
},
{
"text": "HTTP状态码",
"link": "/framework/计算机网络/HTTP状态码"
},
{
"text": "HTTP的长连接和短连接分别是什么？keep-alive是干什么的",
"link": "/framework/计算机网络/HTTP的长连接和短连接分别是什么？keep-alive是干什么的"
},
{
"text": "Http 3.0 是基于 udp 的，那么它是如何保证传输可靠性的？",
"link": "/framework/计算机网络/Http 3.0 是基于 udp 的，那么它是如何保证传输可靠性的？"
},
{
"text": "Http 缓存策略，有什么区别，分别解决了什么问题",
"link": "/framework/计算机网络/Http 缓存策略，有什么区别，分别解决了什么问题"
},
{
"text": "Nginx支持哪些负载均衡调度算法？",
"link": "/framework/计算机网络/Nginx支持哪些负载均衡调度算法？"
},
{
"text": "POST请求的 Content-Type 常见的有哪几种？",
"link": "/framework/计算机网络/POST请求的 Content-Type 常见的有哪几种？"
},
{
"text": "TCP 和 UDP的区别是什么？",
"link": "/framework/计算机网络/TCP 和 UDP的区别是什么？"
},
{
"text": "TCP和HTTP请求之间有什么关系？",
"link": "/framework/计算机网络/TCP和HTTP请求之间有什么关系？"
},
{
"text": "TCP是怎么判断丢包的？",
"link": "/framework/计算机网络/TCP是怎么判断丢包的？"
},
{
"text": "TCP链接为什么会采用三次握手，而不是两次或者四次呢？",
"link": "/framework/计算机网络/TCP链接为什么会采用三次握手，而不是两次或者四次呢？"
},
{
"text": "TLS 1.3 做了哪些改进？",
"link": "/framework/计算机网络/TLS 1.3 做了哪些改进？"
},
{
"text": "TLS1.2 握手的过程是怎样的？",
"link": "/framework/计算机网络/TLS1.2 握手的过程是怎样的？"
},
{
"text": "URI、URL、URN分别是什么？",
"link": "/framework/计算机网络/URI、URL、URN分别是什么？"
},
{
"text": "WebSocket 中的心跳是为了解决什么问题？",
"link": "/framework/计算机网络/WebSocket 中的心跳是为了解决什么问题？"
},
{
"text": "cookie 怎么设置只在 https 时携带？",
"link": "/framework/计算机网络/cookie 怎么设置只在 https 时携带？"
},
{
"text": "get 和 post 请求在缓存方面有什么区别？",
"link": "/framework/计算机网络/get 和 post 请求在缓存方面有什么区别？"
},
{
"text": "get 请求是否限制了传参长度？",
"link": "/framework/计算机网络/get 请求是否限制了传参长度？"
},
{
"text": "https是如何保证安全的，又是如何保证不被中间人攻击的？",
"link": "/framework/计算机网络/https是如何保证安全的，又是如何保证不被中间人攻击的？"
},
{
"text": "nginx是什么？",
"link": "/framework/计算机网络/nginx是什么？"
},
{
"text": "options请求方法及使用场景",
"link": "/framework/计算机网络/options请求方法及使用场景"
},
{
"text": "webSocket 有哪些安全问题，应该如何应对？",
"link": "/framework/计算机网络/webSocket 有哪些安全问题，应该如何应对？"
},
{
"text": "websocket 中的 Handshaking 是什么？",
"link": "/framework/计算机网络/websocket 中的 Handshaking 是什么？"
},
{
"text": "为什么推荐将静态资源放到cdn上？",
"link": "/framework/计算机网络/为什么推荐将静态资源放到cdn上？"
},
{
"text": "为什么说HTTP是无状态的协议？",
"link": "/framework/计算机网络/为什么说HTTP是无状态的协议？"
},
{
"text": "为什么部分请求中，参数需要使用 encodeURIComponent 进行转码？",
"link": "/framework/计算机网络/为什么部分请求中，参数需要使用 encodeURIComponent 进行转码？"
},
{
"text": "什么是CDN？",
"link": "/framework/计算机网络/什么是CDN？"
},
{
"text": "什么是DNS劫持？",
"link": "/framework/计算机网络/什么是DNS劫持？"
},
{
"text": "什么是对象存储OSS？",
"link": "/framework/计算机网络/什么是对象存储OSS？"
},
{
"text": "什么是负载均衡？",
"link": "/framework/计算机网络/什么是负载均衡？"
},
{
"text": "什么是跨域？",
"link": "/framework/计算机网络/什么是跨域？"
},
{
"text": "介绍下304过程",
"link": "/framework/计算机网络/介绍下304过程"
},
{
"text": "介绍下WebSocket",
"link": "/framework/计算机网络/介绍下WebSocket"
},
{
"text": "从存储位置看，浏览器缓存分为哪几种？",
"link": "/framework/计算机网络/从存储位置看，浏览器缓存分为哪几种？"
},
{
"text": "你知道哪些应用层协议？",
"link": "/framework/计算机网络/你知道哪些应用层协议？"
},
{
"text": "协商缓存中，有了 Last-Modified，为什么还会出现 ETag？",
"link": "/framework/计算机网络/协商缓存中，有了 Last-Modified，为什么还会出现 ETag？"
},
{
"text": "即时通讯的实现：短轮询、长轮询、SSE 和 WebSocket 间的区别？",
"link": "/framework/计算机网络/即时通讯的实现：短轮询、长轮询、SSE 和 WebSocket 间的区别？"
},
{
"text": "如何理解 HTTP 代理？",
"link": "/framework/计算机网络/如何理解 HTTP 代理？"
},
{
"text": "对于定长和不定长的数据，HTTP 是怎么传输的？",
"link": "/framework/计算机网络/对于定长和不定长的数据，HTTP 是怎么传输的？"
},
{
"text": "常见的HTTP请求方法",
"link": "/framework/计算机网络/常见的HTTP请求方法"
},
{
"text": "强缓存和协商缓存分别是什么？",
"link": "/framework/计算机网络/强缓存和协商缓存分别是什么？"
},
{
"text": "正向代理和反向代理分别是什么？",
"link": "/framework/计算机网络/正向代理和反向代理分别是什么？"
},
{
"text": "简单描述从输入网址到页面显示的过程",
"link": "/framework/计算机网络/简单描述从输入网址到页面显示的过程"
},
{
"text": "简单说下你对 HTTP2 的理解",
"link": "/framework/计算机网络/简单说下你对 HTTP2 的理解"
},
{
"text": "说下 websocket 的连接原理",
"link": "/framework/计算机网络/说下 websocket 的连接原理"
},
{
"text": "说说 https 的握手过程",
"link": "/framework/计算机网络/说说 https 的握手过程"
},
{
"text": "说说WebSocket和HTTP的区别",
"link": "/framework/计算机网络/说说WebSocket和HTTP的区别"
},
{
"text": "说说你对cookie的理解",
"link": "/framework/计算机网络/说说你对cookie的理解"
},
{
"text": "说说你对“三次握手”、“四次挥手”的理解",
"link": "/framework/计算机网络/说说你对“三次握手”、“四次挥手”的理解"
},
{
"text": "说说对 HTTP3 的了解",
"link": "/framework/计算机网络/说说对 HTTP3 的了解"
},
{
"text": "说说对 WebSocket 的了解",
"link": "/framework/计算机网络/说说对 WebSocket 的了解"
},
{
"text": "说说对TCP-IP协议的了解",
"link": "/framework/计算机网络/说说对TCP-IP协议的了解"
},
{
"text": "请说说cookie与session有什么区别？",
"link": "/framework/计算机网络/请说说cookie与session有什么区别？"
},
{
"text": "跨域时怎么处理 cookie？",
"link": "/framework/计算机网络/跨域时怎么处理 cookie？"
}
],
"/others/AI相关/": [
{
"text": "**AI 工具中，经常提到的 mcp 是什么，有哪些与前端方向结合的场景？",
"link": "/others/AI相关/**AI 工具中，经常提到的 mcp 是什么，有哪些与前端方向结合的场景？"
},
{
"text": "**你了解哪些 AI 前端工具或库？",
"link": "/others/AI相关/**你了解哪些 AI 前端工具或库？"
},
{
"text": "**你知道什么是 AIGC 吗，是否有参与过相关工具的研发？",
"link": "/others/AI相关/**你知道什么是 AIGC 吗，是否有参与过相关工具的研发？"
},
{
"text": "**假如要做一个类似 ChatGPT 的聊天 UI，前端如何处理流式响应？",
"link": "/others/AI相关/**假如要做一个类似 ChatGPT 的聊天 UI，前端如何处理流式响应？"
},
{
"text": "**假设要做一个 AI 语音生成工具（TTS），如何处理音频播放、缓存与断点续播？",
"link": "/others/AI相关/**假设要做一个 AI 语音生成工具（TTS），如何处理音频播放、缓存与断点续播？"
},
{
"text": "**如何保障前端调用 AI 接口时的安全性与权限控制？你是否考虑过代理服务或签名机制？",
"link": "/others/AI相关/**如何保障前端调用 AI 接口时的安全性与权限控制？你是否考虑过代理服务或签名机制？"
},
{
"text": "**如何在前端安全地使用大语言模型 API，比如调用 OpenAI 接口进行文本生成？",
"link": "/others/AI相关/**如何在前端安全地使用大语言模型 API，比如调用 OpenAI 接口进行文本生成？"
},
{
"text": "**如何在前端项目中集成 AI 能力，例如实现智能对话、图像识别或推荐系统？",
"link": "/others/AI相关/**如何在前端项目中集成 AI 能力，例如实现智能对话、图像识别或推荐系统？"
},
{
"text": "**如何在富文本中插入可控组件，如“可编辑 AI 卡片”、“模型输入块”等？会有哪些技术难点？",
"link": "/others/AI相关/**如何在富文本中插入可控组件，如“可编辑 AI 卡片”、“模型输入块”等？会有哪些技术难点？"
},
{
"text": "**如何基于现有富文本编辑器（如 Slate、TipTap、Monaco）扩展支持 AIGC 插件？比如一键生成段落或续写？",
"link": "/others/AI相关/**如何基于现有富文本编辑器（如 Slate、TipTap、Monaco）扩展支持 AIGC 插件？比如一键生成段落或续写？"
},
{
"text": "**如何封装一个 AI 图片生成组件，支持选择模型、输入 prompt、展示图像并支持本地保存？",
"link": "/others/AI相关/**如何封装一个 AI 图片生成组件，支持选择模型、输入 prompt、展示图像并支持本地保存？"
},
{
"text": "**当前主流大模型 API（如 OpenAI、Claude、文心一言）在前端调用时需要注意哪些问题？如何做统一封装？",
"link": "/others/AI相关/**当前主流大模型 API（如 OpenAI、Claude、文心一言）在前端调用时需要注意哪些问题？如何做统一封装？"
},
{
"text": "**请设计一个能自动生成产品文案的前端小工具，简述如何设计 UI ，以及与后端 AI 服务的交互流程。",
"link": "/others/AI相关/**请设计一个能自动生成产品文案的前端小工具，简述如何设计 UI ，以及与后端 AI 服务的交互流程。"
},
{
"text": "**请设计一个面向设计师的“AI 助手”前端界面，可以生成文本、图像并自动插入到设计稿中",
"link": "/others/AI相关/**请设计一个面向设计师的“AI 助手”前端界面，可以生成文本、图像并自动插入到设计稿中"
}
],
"/others/leetcode/": [
{
"text": "Z 字形变换",
"link": "/others/leetcode/Z 字形变换"
},
{
"text": "x 的平方根",
"link": "/others/leetcode/x 的平方根"
},
{
"text": "两个字符串的删除操作",
"link": "/others/leetcode/两个字符串的删除操作"
},
{
"text": "两数之和",
"link": "/others/leetcode/两数之和"
},
{
"text": "两数相加",
"link": "/others/leetcode/两数相加"
},
{
"text": "二叉树中和为某一值的路径",
"link": "/others/leetcode/二叉树中和为某一值的路径"
},
{
"text": "二叉树的层序遍历",
"link": "/others/leetcode/二叉树的层序遍历"
},
{
"text": "二叉树的最近公共祖先",
"link": "/others/leetcode/二叉树的最近公共祖先"
},
{
"text": "全排列",
"link": "/others/leetcode/全排列"
},
{
"text": "删除排序链表中的重复元素",
"link": "/others/leetcode/删除排序链表中的重复元素"
},
{
"text": "反转链表",
"link": "/others/leetcode/反转链表"
},
{
"text": "只出现一次的数字",
"link": "/others/leetcode/只出现一次的数字"
},
{
"text": "合并两个有序数组",
"link": "/others/leetcode/合并两个有序数组"
},
{
"text": "回文子串",
"link": "/others/leetcode/回文子串"
},
{
"text": "回文链表",
"link": "/others/leetcode/回文链表"
},
{
"text": "字符串相加",
"link": "/others/leetcode/字符串相加"
},
{
"text": "寻找两个正序数组的中位数",
"link": "/others/leetcode/寻找两个正序数组的中位数"
},
{
"text": "找出数组中重复的数字",
"link": "/others/leetcode/找出数组中重复的数字"
},
{
"text": "搜索二维矩阵",
"link": "/others/leetcode/搜索二维矩阵"
},
{
"text": "数据流中的中位数",
"link": "/others/leetcode/数据流中的中位数"
},
{
"text": "数组中的第 k 大的数字",
"link": "/others/leetcode/数组中的第 k 大的数字"
},
{
"text": "无重复字符的最长子串",
"link": "/others/leetcode/无重复字符的最长子串"
},
{
"text": "时钟指针的夹角",
"link": "/others/leetcode/时钟指针的夹角"
},
{
"text": "最大子序和",
"link": "/others/leetcode/最大子序和"
},
{
"text": "最小的k个数",
"link": "/others/leetcode/最小的k个数"
},
{
"text": "最长回文子串",
"link": "/others/leetcode/最长回文子串"
},
{
"text": "有效的变位词",
"link": "/others/leetcode/有效的变位词"
},
{
"text": "有效的括号",
"link": "/others/leetcode/有效的括号"
},
{
"text": "爬楼梯",
"link": "/others/leetcode/爬楼梯"
},
{
"text": "爱吃香蕉的珂珂",
"link": "/others/leetcode/爱吃香蕉的珂珂"
},
{
"text": "环形链表",
"link": "/others/leetcode/环形链表"
},
{
"text": "编辑距离",
"link": "/others/leetcode/编辑距离"
},
{
"text": "翻转二叉树",
"link": "/others/leetcode/翻转二叉树"
},
{
"text": "背包问题",
"link": "/others/leetcode/背包问题"
},
{
"text": "路径总和",
"link": "/others/leetcode/路径总和"
}
],
"/others/工具/": [
{
"text": "**Webpack 中的 chunk 是什么？",
"link": "/others/工具/**Webpack 中的 chunk 是什么？"
},
{
"text": "**git merge master 与 git merge origin master 有什么区别？",
"link": "/others/工具/**git merge master 与 git merge origin master 有什么区别？"
},
{
"text": "**git pull 命令实际上是哪两个操作的融合？",
"link": "/others/工具/**git pull 命令实际上是哪两个操作的融合？"
},
{
"text": "**了解语义化版本 SemVer（Semantic Versioning）吗？",
"link": "/others/工具/**了解语义化版本 SemVer（Semantic Versioning）吗？"
},
{
"text": "**如果有 git 仓库需要迁移，应该怎么操作？",
"link": "/others/工具/**如果有 git 仓库需要迁移，应该怎么操作？"
},
{
"text": "**怎么实现 commit lint？",
"link": "/others/工具/**怎么实现 commit lint？"
},
{
"text": "**有了解过 Protobuf 吗？",
"link": "/others/工具/**有了解过 Protobuf 吗？"
},
{
"text": "**说说 Eslint 进行代码检查的原理",
"link": "/others/工具/**说说 Eslint 进行代码检查的原理"
},
{
"text": "**说说你对 V8 引擎的了解",
"link": "/others/工具/**说说你对 V8 引擎的了解"
},
{
"text": "**说说你对 npx 的了解？",
"link": "/others/工具/**说说你对 npx 的了解？"
},
{
"text": "ESLint 是什么？",
"link": "/others/工具/ESLint 是什么？"
},
{
"text": "Git，GitHub与GitLab分别是什么？有什么区别？",
"link": "/others/工具/Git，GitHub与GitLab分别是什么？有什么区别？"
},
{
"text": "babel 和 babel ployfill 有什么关系？",
"link": "/others/工具/babel 和 babel ployfill 有什么关系？"
},
{
"text": "babel-polyfill 有什么用？",
"link": "/others/工具/babel-polyfill 有什么用？"
},
{
"text": "git pull 和 git fetch 有什么区别？",
"link": "/others/工具/git pull 和 git fetch 有什么区别？"
},
{
"text": "git 中 rebase、reset、revert 有什么区别？",
"link": "/others/工具/git 中 rebase、reset、revert 有什么区别？"
},
{
"text": "npm 和 yarn有哪些不一样的地方？",
"link": "/others/工具/npm 和 yarn有哪些不一样的地方？"
},
{
"text": "为什么推荐将静态资源放到cdn上？",
"link": "/others/工具/为什么推荐将静态资源放到cdn上？"
},
{
"text": "什么是 git stash？",
"link": "/others/工具/什么是 git stash？"
},
{
"text": "前端领域有哪些跨端方案？",
"link": "/others/工具/前端领域有哪些跨端方案？"
},
{
"text": "如何检查Javascript中的内存泄漏？",
"link": "/others/工具/如何检查Javascript中的内存泄漏？"
},
{
"text": "如何迁移仓库，同时保留原有的提交记录和分支？",
"link": "/others/工具/如何迁移仓库，同时保留原有的提交记录和分支？"
},
{
"text": "怎么使用 git 将多次提交压缩成一次提交？",
"link": "/others/工具/怎么使用 git 将多次提交压缩成一次提交？"
},
{
"text": "怎么进行移动端的调试？",
"link": "/others/工具/怎么进行移动端的调试？"
},
{
"text": "数据Mock是什么？",
"link": "/others/工具/数据Mock是什么？"
},
{
"text": "说一下 vite 的构建流程",
"link": "/others/工具/说一下 vite 的构建流程"
},
{
"text": "说说 git 发生冲突的场景？如何解决？",
"link": "/others/工具/说说 git 发生冲突的场景？如何解决？"
},
{
"text": "说说Git 中 HEAD、工作树和索引之间的区别？",
"link": "/others/工具/说说Git 中 HEAD、工作树和索引之间的区别？"
},
{
"text": "说说Git中 fork, clone,branch这三个概念，有什么区别？",
"link": "/others/工具/说说Git中 fork, clone,branch这三个概念，有什么区别？"
},
{
"text": "说说Git常用的命令有哪些？",
"link": "/others/工具/说说Git常用的命令有哪些？"
},
{
"text": "说说你对Git的理解？",
"link": "/others/工具/说说你对Git的理解？"
},
{
"text": "说说你对git rebase 和 git merge的理解？以及它们的区别？",
"link": "/others/工具/说说你对git rebase 和 git merge的理解？以及它们的区别？"
},
{
"text": "说说你对git reset 和 git revert 的理解？区别？",
"link": "/others/工具/说说你对git reset 和 git revert 的理解？区别？"
},
{
"text": "说说你对git stash 的理解？应用场景？",
"link": "/others/工具/说说你对git stash 的理解？应用场景？"
},
{
"text": "说说你对低代码的了解",
"link": "/others/工具/说说你对低代码的了解"
},
{
"text": "说说你对版本管理的理解？",
"link": "/others/工具/说说你对版本管理的理解？"
},
{
"text": "说说你对跨平台的理解",
"link": "/others/工具/说说你对跨平台的理解"
},
{
"text": "说说对git pull 和 git fetch 的理解？有什么区别？",
"link": "/others/工具/说说对git pull 和 git fetch 的理解？有什么区别？"
},
{
"text": "谈谈对 babel-polyfill 的了解",
"link": "/others/工具/谈谈对 babel-polyfill 的了解"
}
],
"/others/算法/": [
{
"text": "**base64 的编码原理是什么？",
"link": "/others/算法/**base64 的编码原理是什么？"
},
{
"text": "**不重复最大子串",
"link": "/others/算法/**不重复最大子串"
},
{
"text": "**介绍下深度优先遍历和广度优先遍历，如何实现？",
"link": "/others/算法/**介绍下深度优先遍历和广度优先遍历，如何实现？"
},
{
"text": "**如何判断一个单向链表是否是循环链表？",
"link": "/others/算法/**如何判断一个单向链表是否是循环链表？"
},
{
"text": "**常见数组排序算法有哪些？",
"link": "/others/算法/**常见数组排序算法有哪些？"
},
{
"text": "**深度遍历与广度遍历有什么区别？",
"link": "/others/算法/**深度遍历与广度遍历有什么区别？"
},
{
"text": "**移动零",
"link": "/others/算法/**移动零"
},
{
"text": "什么是尾调用优化和尾递归？",
"link": "/others/算法/什么是尾调用优化和尾递归？"
},
{
"text": "什么是时间复杂度？",
"link": "/others/算法/什么是时间复杂度？"
},
{
"text": "写一个 LRU 缓存函数",
"link": "/others/算法/写一个 LRU 缓存函数"
},
{
"text": "去除字符串中出现次数最少的字符，不改变原字符串的顺序。",
"link": "/others/算法/去除字符串中出现次数最少的字符，不改变原字符串的顺序。"
},
{
"text": "合并K个升序链表",
"link": "/others/算法/合并K个升序链表"
},
{
"text": "实现一个函数，判断输入是不是回文字符串。",
"link": "/others/算法/实现一个函数，判断输入是不是回文字符串。"
},
{
"text": "怎么实现洗牌算法？",
"link": "/others/算法/怎么实现洗牌算法？"
},
{
"text": "最大的钻石",
"link": "/others/算法/最大的钻石"
},
{
"text": "请手写“冒泡排序”",
"link": "/others/算法/请手写“冒泡排序”"
},
{
"text": "请手写“堆排序”",
"link": "/others/算法/请手写“堆排序”"
},
{
"text": "请手写“希尔排序”",
"link": "/others/算法/请手写“希尔排序”"
},
{
"text": "请手写“归并排序”",
"link": "/others/算法/请手写“归并排序”"
},
{
"text": "请手写“快速排序”",
"link": "/others/算法/请手写“快速排序”"
},
{
"text": "请手写“插入排序”",
"link": "/others/算法/请手写“插入排序”"
},
{
"text": "请手写“选择排序”",
"link": "/others/算法/请手写“选择排序”"
}
],
"/others/计算机基础/": [
{
"text": "**V8 里面的 JIT 是什么？",
"link": "/others/计算机基础/**V8 里面的 JIT 是什么？"
},
{
"text": "**解释性语言和编译型语言有什么区别？",
"link": "/others/计算机基础/**解释性语言和编译型语言有什么区别？"
},
{
"text": "**进程、线程、协程分别是什么概念？",
"link": "/others/计算机基础/**进程、线程、协程分别是什么概念？"
},
{
"text": "Unicode 和 UTF-8 之间有什么关系？",
"link": "/others/计算机基础/Unicode 和 UTF-8 之间有什么关系？"
},
{
"text": "app中常提到的webview是什么？",
"link": "/others/计算机基础/app中常提到的webview是什么？"
},
{
"text": "为什么部分请求中，参数需要使用 encodeURIComponent 进行转码？",
"link": "/others/计算机基础/为什么部分请求中，参数需要使用 encodeURIComponent 进行转码？"
},
{
"text": "什么是内存泄漏？",
"link": "/others/计算机基础/什么是内存泄漏？"
},
{
"text": "什么是空间复杂度？",
"link": "/others/计算机基础/什么是空间复杂度？"
},
{
"text": "介绍你知道的一些数据结构",
"link": "/others/计算机基础/介绍你知道的一些数据结构"
},
{
"text": "使用cookie、session维持登录状态的原理是什么？",
"link": "/others/计算机基础/使用cookie、session维持登录状态的原理是什么？"
},
{
"text": "原码、反码和补码分别是什么？",
"link": "/others/计算机基础/原码、反码和补码分别是什么？"
},
{
"text": "堆与栈有什么区别？",
"link": "/others/计算机基础/堆与栈有什么区别？"
},
{
"text": "浏览器的同源策略是什么？",
"link": "/others/计算机基础/浏览器的同源策略是什么？"
},
{
"text": "说说DOS及DDOS的原理及防御方式",
"link": "/others/计算机基础/说说DOS及DDOS的原理及防御方式"
},
{
"text": "说说你对操作系统的理解？核心概念有哪些？",
"link": "/others/计算机基础/说说你对操作系统的理解？核心概念有哪些？"
},
{
"text": "说说你对计算机网络模型的理解",
"link": "/others/计算机基础/说说你对计算机网络模型的理解"
},
{
"text": "请说说cookie与session有什么区别？",
"link": "/others/计算机基础/请说说cookie与session有什么区别？"
},
{
"text": "进程与线程有什么区别？",
"link": "/others/计算机基础/进程与线程有什么区别？"
},
{
"text": "进程间有哪些通信方式？",
"link": "/others/计算机基础/进程间有哪些通信方式？"
}
],
"/others/趣味题/": [
{
"text": "**白帽子问题",
"link": "/others/趣味题/**白帽子问题"
},
{
"text": "64匹马，8个赛道，找出最快的4匹马，要比赛多少轮？",
"link": "/others/趣味题/64匹马，8个赛道，找出最快的4匹马，要比赛多少轮？"
},
{
"text": "一百个囚犯和一盏灯",
"link": "/others/趣味题/一百个囚犯和一盏灯"
},
{
"text": "修改水果框标签问题",
"link": "/others/趣味题/修改水果框标签问题"
},
{
"text": "囚犯抓绿豆问题",
"link": "/others/趣味题/囚犯抓绿豆问题"
},
{
"text": "圆桌射击游戏",
"link": "/others/趣味题/圆桌射击游戏"
},
{
"text": "圆环转圈问题",
"link": "/others/趣味题/圆环转圈问题"
},
{
"text": "如何使用js计算一个html页面有多少种标签？",
"link": "/others/趣味题/如何使用js计算一个html页面有多少种标签？"
},
{
"text": "小白鼠试毒问题",
"link": "/others/趣味题/小白鼠试毒问题"
},
{
"text": "小白鼠试毒问题进阶",
"link": "/others/趣味题/小白鼠试毒问题进阶"
},
{
"text": "干脆面抽卡问题",
"link": "/others/趣味题/干脆面抽卡问题"
},
{
"text": "怎么用3升和5升的桶量出4升的水？",
"link": "/others/趣味题/怎么用3升和5升的桶量出4升的水？"
},
{
"text": "拿苹果问题",
"link": "/others/趣味题/拿苹果问题"
},
{
"text": "推理问题（一）",
"link": "/others/趣味题/推理问题（一）"
},
{
"text": "推理问题（二）",
"link": "/others/趣味题/推理问题（二）"
},
{
"text": "握手问题",
"link": "/others/趣味题/握手问题"
},
{
"text": "最后剩下谁？",
"link": "/others/趣味题/最后剩下谁？"
},
{
"text": "最大的钻石",
"link": "/others/趣味题/最大的钻石"
},
{
"text": "汽车所停车位的编号是多少？",
"link": "/others/趣味题/汽车所停车位的编号是多少？"
},
{
"text": "沙漠尸体",
"link": "/others/趣味题/沙漠尸体"
},
{
"text": "海盗博弈问题",
"link": "/others/趣味题/海盗博弈问题"
},
{
"text": "猴子搬香蕉问题",
"link": "/others/趣味题/猴子搬香蕉问题"
},
{
"text": "球的重量",
"link": "/others/趣味题/球的重量"
},
{
"text": "盲人分袜子",
"link": "/others/趣味题/盲人分袜子"
},
{
"text": "盲人翻牌",
"link": "/others/趣味题/盲人翻牌"
},
{
"text": "砝码称重问题（一）",
"link": "/others/趣味题/砝码称重问题（一）"
},
{
"text": "砝码称重问题（三）",
"link": "/others/趣味题/砝码称重问题（三）"
},
{
"text": "砝码称重问题（二）",
"link": "/others/趣味题/砝码称重问题（二）"
},
{
"text": "绳子计时问题",
"link": "/others/趣味题/绳子计时问题"
},
{
"text": "药丸难题",
"link": "/others/趣味题/药丸难题"
},
{
"text": "计算聚会人数",
"link": "/others/趣味题/计算聚会人数"
},
{
"text": "过桥问题",
"link": "/others/趣味题/过桥问题"
},
{
"text": "连续自然数之和为1000的共有几组？（m，n都为自然数，单独1个数也算作“连续自然数”）",
"link": "/others/趣味题/连续自然数之和为1000的共有几组？（m，n都为自然数，单独1个数也算作“连续自然数”）"
},
{
"text": "问路问题",
"link": "/others/趣味题/问路问题"
},
{
"text": "高楼逃生问题",
"link": "/others/趣味题/高楼逃生问题"
}
],
"/others/选择题/": [
{
"text": "**1-对以下代码说法正确的是？",
"link": "/others/选择题/**1-对以下代码说法正确的是？"
},
{
"text": "**2-下列哪些不可以实现浏览器存储数据？",
"link": "/others/选择题/**2-下列哪些不可以实现浏览器存储数据？"
},
{
"text": "**3-下面不可以继承的属性有哪些？",
"link": "/others/选择题/**3-下面不可以继承的属性有哪些？"
},
{
"text": "10-输出什么？",
"link": "/others/选择题/10-输出什么？"
},
{
"text": "100-输出是什么？",
"link": "/others/选择题/100-输出是什么？"
},
{
"text": "101-输出是什么？",
"link": "/others/选择题/101-输出是什么？"
},
{
"text": "102-输出是什么？",
"link": "/others/选择题/102-输出是什么？"
},
{
"text": "103-输出是什么？",
"link": "/others/选择题/103-输出是什么？"
},
{
"text": "104-输出是什么？",
"link": "/others/选择题/104-输出是什么？"
},
{
"text": "105-输出是什么？",
"link": "/others/选择题/105-输出是什么？"
},
{
"text": "106-下面代码的输出是什么？",
"link": "/others/选择题/106-下面代码的输出是什么？"
},
{
"text": "107-输出是什么？",
"link": "/others/选择题/107-输出是什么？"
},
{
"text": "108-输出是什么？",
"link": "/others/选择题/108-输出是什么？"
},
{
"text": "109-输出是什么？",
"link": "/others/选择题/109-输出是什么？"
},
{
"text": "11-输出什么？",
"link": "/others/选择题/11-输出什么？"
},
{
"text": "110-输出的是什么？",
"link": "/others/选择题/110-输出的是什么？"
},
{
"text": "111-输出是什么？",
"link": "/others/选择题/111-输出是什么？"
},
{
"text": "112-num的值是什么？",
"link": "/others/选择题/112-num的值是什么？"
},
{
"text": "113-输出是什么？",
"link": "/others/选择题/113-输出是什么？"
},
{
"text": "114-输出是什么？",
"link": "/others/选择题/114-输出是什么？"
},
{
"text": "115-输出是什么？",
"link": "/others/选择题/115-输出是什么？"
},
{
"text": "116-返回值是什么？",
"link": "/others/选择题/116-返回值是什么？"
},
{
"text": "117-输出是什么？",
"link": "/others/选择题/117-输出是什么？"
},
{
"text": "118-输出是什么？",
"link": "/others/选择题/118-输出是什么？"
},
{
"text": "119-setInterval 方法的返回值是什么？",
"link": "/others/选择题/119-setInterval 方法的返回值是什么？"
},
{
"text": "12-输出什么？",
"link": "/others/选择题/12-输出什么？"
},
{
"text": "120-输出是什么？",
"link": "/others/选择题/120-输出是什么？"
},
{
"text": "121-下面代码的输出是什么？",
"link": "/others/选择题/121-下面代码的输出是什么？"
},
{
"text": "122-输出是什么？",
"link": "/others/选择题/122-输出是什么？"
},
{
"text": "123-输出是什么？",
"link": "/others/选择题/123-输出是什么？"
},
{
"text": "124-输出是什么？",
"link": "/others/选择题/124-输出是什么？"
},
{
"text": "125-下面哪些值是 falsy？",
"link": "/others/选择题/125-下面哪些值是 falsy？"
},
{
"text": "126-输出是什么？",
"link": "/others/选择题/126-输出是什么？"
},
{
"text": "127-下面会输出什么？",
"link": "/others/选择题/127-下面会输出什么？"
},
{
"text": "128-输出是什么？",
"link": "/others/选择题/128-输出是什么？"
},
{
"text": "129-输出是什么？",
"link": "/others/选择题/129-输出是什么？"
},
{
"text": "13-输出什么？",
"link": "/others/选择题/13-输出什么？"
},
{
"text": "130-输出是什么？",
"link": "/others/选择题/130-输出是什么？"
},
{
"text": "131-下面的输出是什么？",
"link": "/others/选择题/131-下面的输出是什么？"
},
{
"text": "132-输出是什么？",
"link": "/others/选择题/132-输出是什么？"
},
{
"text": "133-输出是什么？",
"link": "/others/选择题/133-输出是什么？"
},
{
"text": "134-输出是什么？",
"link": "/others/选择题/134-输出是什么？"
},
{
"text": "135-cool_secret 可访问多长时间？",
"link": "/others/选择题/135-cool_secret 可访问多长时间？"
},
{
"text": "136-下面代码中，sum 的值是什么？",
"link": "/others/选择题/136-下面代码中，sum 的值是什么？"
},
{
"text": "137-输出是什么？",
"link": "/others/选择题/137-输出是什么？"
},
{
"text": "138-输出是什么？",
"link": "/others/选择题/138-输出是什么？"
},
{
"text": "139-输出是什么？",
"link": "/others/选择题/139-输出是什么？"
},
{
"text": "14-输出什么？",
"link": "/others/选择题/14-输出什么？"
},
{
"text": "140-输出是什么？",
"link": "/others/选择题/140-输出是什么？"
},
{
"text": "141-输出是什么？",
"link": "/others/选择题/141-输出是什么？"
},
{
"text": "142-以下代码的输出是什么？",
"link": "/others/选择题/142-以下代码的输出是什么？"
},
{
"text": "143-输出是什么？",
"link": "/others/选择题/143-输出是什么？"
},
{
"text": "144-输出是什么？",
"link": "/others/选择题/144-输出是什么？"
},
{
"text": "145-当我们这么做时，会发生什么？",
"link": "/others/选择题/145-当我们这么做时，会发生什么？"
},
{
"text": "146-输出是什么？",
"link": "/others/选择题/146-输出是什么？"
},
{
"text": "147-输出是什么？",
"link": "/others/选择题/147-输出是什么？"
},
{
"text": "148-输出是什么？",
"link": "/others/选择题/148-输出是什么？"
},
{
"text": "149-输出是什么？",
"link": "/others/选择题/149-输出是什么？"
},
{
"text": "15-输出是什么？",
"link": "/others/选择题/15-输出是什么？"
},
{
"text": "150-哪一个是正确的？",
"link": "/others/选择题/150-哪一个是正确的？"
},
{
"text": "151-输出是什么？",
"link": "/others/选择题/151-输出是什么？"
},
{
"text": "152-输出是什么？",
"link": "/others/选择题/152-输出是什么？"
},
{
"text": "153-输出是什么？",
"link": "/others/选择题/153-输出是什么？"
},
{
"text": "154-输出是什么？",
"link": "/others/选择题/154-输出是什么？"
},
{
"text": "16-输出什么？",
"link": "/others/选择题/16-输出什么？"
},
{
"text": "17-向对象 person 添加什么时，可以通过执行 [...person] 获得类似 [\"Lydia Hallie\", 21] 的输出？",
"link": "/others/选择题/17-向对象 person 添加什么时，可以通过执行 [...person] 获得类似 [\"Lydia Hallie\", 21] 的输出？"
},
{
"text": "18-哪一个选项会导致报错？",
"link": "/others/选择题/18-哪一个选项会导致报错？"
},
{
"text": "19-输出什么？",
"link": "/others/选择题/19-输出什么？"
},
{
"text": "20-输出什么？",
"link": "/others/选择题/20-输出什么？"
},
{
"text": "21-选择哪一个？",
"link": "/others/选择题/21-选择哪一个？"
},
{
"text": "22-输出是什么？",
"link": "/others/选择题/22-输出是什么？"
},
{
"text": "23-输出什么？",
"link": "/others/选择题/23-输出什么？"
},
{
"text": "24-以下哪一项会对对象 `person` 有副作用？",
"link": "/others/选择题/24-以下哪一项会对对象 `person` 有副作用？"
},
{
"text": "25-以下哪一项会对对象 `person` 有副作用？",
"link": "/others/选择题/25-以下哪一项会对对象 `person` 有副作用？"
},
{
"text": "26-输出什么？",
"link": "/others/选择题/26-输出什么？"
},
{
"text": "27-怎样能在 index.js 中调用 sum.js 中的 sum 方法？",
"link": "/others/选择题/27-怎样能在 index.js 中调用 sum.js 中的 sum 方法？"
},
{
"text": "28-输出什么？",
"link": "/others/选择题/28-输出什么？"
},
{
"text": "29-输出什么？",
"link": "/others/选择题/29-输出什么？"
},
{
"text": "30-输出什么？",
"link": "/others/选择题/30-输出什么？"
},
{
"text": "31-输出什么？",
"link": "/others/选择题/31-输出什么？"
},
{
"text": "32-输出什么？",
"link": "/others/选择题/32-输出什么？"
},
{
"text": "33-输出什么？",
"link": "/others/选择题/33-输出什么？"
},
{
"text": "34-输出什么？",
"link": "/others/选择题/34-输出什么？"
},
{
"text": "35-输出什么？",
"link": "/others/选择题/35-输出什么？"
},
{
"text": "36-输出什么？",
"link": "/others/选择题/36-输出什么？"
},
{
"text": "37-输出什么？",
"link": "/others/选择题/37-输出什么？"
},
{
"text": "38-输出什么？",
"link": "/others/选择题/38-输出什么？"
},
{
"text": "39-输出什么？",
"link": "/others/选择题/39-输出什么？"
},
{
"text": "4-在点击p标签时，会输出什么？",
"link": "/others/选择题/4-在点击p标签时，会输出什么？"
},
{
"text": "40-输出什么？",
"link": "/others/选择题/40-输出什么？"
},
{
"text": "41-输出什么？",
"link": "/others/选择题/41-输出什么？"
},
{
"text": "42-下面的输出是什么？",
"link": "/others/选择题/42-下面的输出是什么？"
},
{
"text": "43-输出什么？",
"link": "/others/选择题/43-输出什么？"
},
{
"text": "44-下面那个选项将会返回 '6' ？",
"link": "/others/选择题/44-下面那个选项将会返回 '6' ？"
},
{
"text": "45-输出什么？",
"link": "/others/选择题/45-输出什么？"
},
{
"text": "46-哪一个方法会返回 'Hello world!' ？",
"link": "/others/选择题/46-哪一个方法会返回 'Hello world!' ？"
},
{
"text": "47-将会发生什么？",
"link": "/others/选择题/47-将会发生什么？"
},
{
"text": "48-输出什么？",
"link": "/others/选择题/48-输出什么？"
},
{
"text": "49-输出什么？",
"link": "/others/选择题/49-输出什么？"
},
{
"text": "5-在点击 button 时，触发的 event.target 是哪个？",
"link": "/others/选择题/5-在点击 button 时，触发的 event.target 是哪个？"
},
{
"text": "50-输出什么？",
"link": "/others/选择题/50-输出什么？"
},
{
"text": "51-这个函数干了什么？",
"link": "/others/选择题/51-这个函数干了什么？"
},
{
"text": "52-下面代码输出什么？",
"link": "/others/选择题/52-下面代码输出什么？"
},
{
"text": "53-哪些方法修改了原数组？",
"link": "/others/选择题/53-哪些方法修改了原数组？"
},
{
"text": "54-输出什么？",
"link": "/others/选择题/54-输出什么？"
},
{
"text": "55-输出什么？",
"link": "/others/选择题/55-输出什么？"
},
{
"text": "56-输出什么？",
"link": "/others/选择题/56-输出什么？"
},
{
"text": "57-结果是什么？",
"link": "/others/选择题/57-结果是什么？"
},
{
"text": "58-输出什么？",
"link": "/others/选择题/58-输出什么？"
},
{
"text": "59-依次输出什么？",
"link": "/others/选择题/59-依次输出什么？"
},
{
"text": "6-输出什么？",
"link": "/others/选择题/6-输出什么？"
},
{
"text": "60-输出什么？",
"link": "/others/选择题/60-输出什么？"
},
{
"text": "61-输出什么？",
"link": "/others/选择题/61-输出什么？"
},
{
"text": "62-输出什么？",
"link": "/others/选择题/62-输出什么？"
},
{
"text": "63-输出什么？",
"link": "/others/选择题/63-输出什么？"
},
{
"text": "64-输出什么？",
"link": "/others/选择题/64-输出什么？"
},
{
"text": "65-输出什么？",
"link": "/others/选择题/65-输出什么？"
},
{
"text": "66-输出是什么？",
"link": "/others/选择题/66-输出是什么？"
},
{
"text": "67-输出什么？",
"link": "/others/选择题/67-输出什么？"
},
{
"text": "68-输出什么？",
"link": "/others/选择题/68-输出什么？"
},
{
"text": "69-输出什么？",
"link": "/others/选择题/69-输出什么？"
},
{
"text": "7-输出什么？",
"link": "/others/选择题/7-输出什么？"
},
{
"text": "70-输出什么？",
"link": "/others/选择题/70-输出什么？"
},
{
"text": "71-输出什么？",
"link": "/others/选择题/71-输出什么？"
},
{
"text": "72-输出什么？",
"link": "/others/选择题/72-输出什么？"
},
{
"text": "73-输出什么？",
"link": "/others/选择题/73-输出什么？"
},
{
"text": "74-输出什么？",
"link": "/others/选择题/74-输出什么？"
},
{
"text": "75-哪个选项是将 hasName 设置为 true 的方法（不能将true作为参数传递）？",
"link": "/others/选择题/75-哪个选项是将 hasName 设置为 true 的方法（不能将true作为参数传递）？"
},
{
"text": "76-下面代码的输出是什么？",
"link": "/others/选择题/76-下面代码的输出是什么？"
},
{
"text": "77-输出什么？",
"link": "/others/选择题/77-输出什么？"
},
{
"text": "78-输出什么？",
"link": "/others/选择题/78-输出什么？"
},
{
"text": "79-输出什么？",
"link": "/others/选择题/79-输出什么？"
},
{
"text": "8-method 的值选择哪个时，会输出 { name: \"Lydia\", age: 22 } ？",
"link": "/others/选择题/8-method 的值选择哪个时，会输出 { name: \"Lydia\", age: 22 } ？"
},
{
"text": "80-输出什么？",
"link": "/others/选择题/80-输出什么？"
},
{
"text": "81-输出什么？",
"link": "/others/选择题/81-输出什么？"
},
{
"text": "82-输出什么？",
"link": "/others/选择题/82-输出什么？"
},
{
"text": "83-输出什么？",
"link": "/others/选择题/83-输出什么？"
},
{
"text": "84-以下是个纯函数么？",
"link": "/others/选择题/84-以下是个纯函数么？"
},
{
"text": "85-输出什么？",
"link": "/others/选择题/85-输出什么？"
},
{
"text": "86-输出什么？",
"link": "/others/选择题/86-输出什么？"
},
{
"text": "87-输出什么？",
"link": "/others/选择题/87-输出什么？"
},
{
"text": "88-输出什么？",
"link": "/others/选择题/88-输出什么？"
},
{
"text": "89-输出什么？",
"link": "/others/选择题/89-输出什么？"
},
{
"text": "9-输出什么？",
"link": "/others/选择题/9-输出什么？"
},
{
"text": "90-如何能打印出 console.log 语句后注释掉的值？",
"link": "/others/选择题/90-如何能打印出 console.log 语句后注释掉的值？"
},
{
"text": "91-输出什么？",
"link": "/others/选择题/91-输出什么？"
},
{
"text": "92-输出什么？",
"link": "/others/选择题/92-输出什么？"
},
{
"text": "93-输出什么？",
"link": "/others/选择题/93-输出什么？"
},
{
"text": "94-输出什么？",
"link": "/others/选择题/94-输出什么？"
},
{
"text": "95-使用哪个构造函数可以成功继承 Dog 类？",
"link": "/others/选择题/95-使用哪个构造函数可以成功继承 Dog 类？"
},
{
"text": "96-输出什么？",
"link": "/others/选择题/96-输出什么？"
},
{
"text": "97-输出什么？",
"link": "/others/选择题/97-输出什么？"
},
{
"text": "98-输出是什么？",
"link": "/others/选择题/98-输出是什么？"
},
{
"text": "99-输出是什么？",
"link": "/others/选择题/99-输出是什么？"
}
],
"/": [
{
"text": "Examples",
"items": [
{
"text": "Markdown Examples",
"link": "/markdown-examples"
},
{
"text": "Runtime API Examples",
"link": "/api-examples"
},
{
"text": "响应式原理",
"link": "/响应式原理"
}
]
}
]
},
"socialLinks": [
{
"icon": "github",
"link": "https://github.com/vuejs/vitepress"
}
]
}Page Data
{
"title": "Runtime API Examples",
"description": "",
"frontmatter": {
"outline": "deep"
},
"headers": [],
"relativePath": "api-examples.md",
"filePath": "api-examples.md"
}Page Frontmatter
{
"outline": "deep"
}More
Check out the documentation for the full list of runtime APIs.