开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> JavaScript知识库 -> 面试题（温习一下） -> 正文阅读

[JavaScript知识库]面试题（温习一下）

*vue中的面试题*

https://segmentfault.com/a/1190000016344599

在这里插入图片描述

*输入url浏览器发生了什么三次握手，四次挥手*

client想结束的时候, server得先确保手中的数据发送完才能够结束

https://blog.csdn.net/baiqiangdoudou/article/details/88548288

*首屏优化*

****https://zhuanlan.zhihu.com/p/88639980?utm_source=wechat_session****

****async和defer****

https://www.cnblogs.com/jiasm/p/7683930.html

*Vue********2********和vue********3********的区别*

****https://blog.csdn.net/weixin_44475093/article/details/112386778****

*Let* *var* *和const的区别*

****https://www.jb51.net/article/94495.htm****

*深度优先遍历和广度优先遍历*

https://developer.51cto.com/art/202004/614590.htm

*Fiter，forsmoe和forevery*

https://blog.csdn.net/Flowering_Vivian/article/details/108756964

*原型和原型链*

原型：

每一个javascript对象(除null外)创建的时候，都会与之关联另一个对象，这个对象就是我们所说的原型，每一个对象都会从原型中“继承”属性。通过这个原型属性我们就可以访问另一个对象所有的属性和方法。

原型链：

在Javascript中如果访问一个对象本身不存在的属性或是方法，就首先在它的原型对象上去寻找，如果原型对象上也不存在，就继续在原型对象的原型对象上去寻找，直到返回null为止。

*防抖和节流*

防抖：

在规定的时间（wait）内执行被调函数（fn），当高速被调用时（小与规定时间），重新开始计算时间（wait），直至在规定时间（wait）内没有再次被调用时，或者最后一次调用时，才真正的执行被调函数。

防抖函数：

function debounce(fn,delay){

let timer = null //借助闭包

return function() {

? if(timer){

? clearTimeout(timer)

? }

? timer = setTimeout(fn,delay) // 简化写法

}

节流：

在规定的时间（wait）内执行被调函数（fn），当高速被调用时（小与规定时间），在规定的时间（wait）后开始第一次执行被调函数（fn），直至结束，再次在规定的时间（wait）后执行被调函数（fn），如此循环

节流函数：

function throttle(fn,delay){

let valid = true

return function() {

? if(!valid){

? //休息时间暂不接客

? return false

? }

? // 工作时间，执行函数并且在间隔期内把状态位设为无效

? valid = false

? setTimeout(() => {

? fn()

? valid = true;

? }, delay)

}

*vue********传参*

https://www.cnblogs.com/barryzhang/p/10566515.html

1.父向子传参：props

子向父传参：emit

2.父向孙子传参： $a t t r s 和$ listeners

3.兄弟组件传参：中央事件bus.$on监听触发的事件。

4.父向子传参：父组件中通过provider来提供变量，然后在子组件中通过inject来注入变量

5.父向子的子传参： $p a r e n t 和$ children

6.vuex处理组件之间的数据交互

*vue–同步父子组件和异步父子组件的生命周期顺序*

https://blog.csdn.net/weixin_39147099/article/details/82956439

同步引入：例子： import Page from ‘@/components/page’

同步引入时生命周期顺序为：父组件的beforeCreate、created、beforeMount --> 所有子组件的beforeCreate、created、beforeMount --> 所有子组件的mounted --> 父组件的mounted

异步引入：例子：const Page = () => import(’@/components/page’)

? 或者： const Page = resolve => require([’@/components/page’], page)

异步引入时生命周期顺序：父组件的beforeCreate、created、beforeMount、mounted --> 子组件的beforeCreate、created、beforeMount、mounted

****Promise****：

https://www.cnblogs.com/whybxy/p/7645578.html

Promise 是异步编程的一种解决方案，其实是一个构造函数，自己身上有all、reject、resolve这几个方法，原型上有then、catch等方法。

Promise对象有以下两个特点。

（1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是Promise这个名字的由来，它的英语意思就是“承诺”，表示其他手段无法改变。

（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的

*Promise.all方法，Promise.race方法*

https://www.cnblogs.com/jianghaijun4031/p/13231891.html

Promise.all 方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。该promise对象在所有的promise对象都成功的时候才会触发成功，一旦有任何一个里面的promise对象失败则立即触发该promise对象的失败。

Promise.race([p1, p2, p3])里面哪个结果获得的快，就返回那个结果，不管结果本身是成功状态还是失败状态

*虚拟dom*

*https://www.jianshu.com/p/616999666920*

当用原生js或jquery等库去操作DOM时，浏览器会从构建DOM树开始将整个流程执行一遍，所以频繁操作DOM会引起不需要的计算，导致页面卡顿，影响用户体验，而Virtual DOM能很好的解决这个问题。

第一步，用HTML分析器，分析HTML元素，构建一颗DOM树。

第二步：用CSS分析器，分析CSS文件和元素上的inline样式，生成页面的样式表。

第三步：将上面的DOM树和样式表，关联起来，构建一颗Render树。这一过程又称为Attachment。每个DOM节点都有attach方法，接受样式信息，返回一个render对象（又名renderer）。这些render对象最终会被构建成一颗Render树。

第四步：有了Render树后，浏览器开始布局，会为每个Render树上的节点确定一个在显示屏上出现的精确坐标值。

第五步：Render数有了，节点显示的位置坐标也有了，最后就是调用每个节点的paint方法，让它们显示出来

*vue diff和 react diff*

https://www.jianshu.com/p/fac3d2b112a6

相同点：

Vue和react的diff算法，都是不进行跨层级比较，只做同级比较。

不同点：

1.Vue进行diff时，调用patch打补丁函数，一边比较一边给真实的DOM打补丁

2.Vue对比节点，当节点元素类型相同，但是className不同时，认为是不同类型的元素，删除重新创建，而react则认为是同类型节点，进行修改操作

3.① Vue的列表比对，采用从两端到中间的方式，旧集合和新集合两端各存在两个指针，两两进行比较，如果匹配上了就按照新集合去调整旧集合，每次对比结束后，指针向队列中间移动；

②而react则是从左往右依次对比，利用元素的index和标识lastIndex进行比较，如果满足index < lastIndex就移动元素，删除和添加则各自按照规则调整；

③当一个集合把最后一个节点移动到最前面，react会把前面的节点依次向后移动，而Vue只会把最后一个节点放在最前面，这样的操作来看，Vue的diff性能是高于react的

*为什么不能用index作为key*

这个时候，除了 Person1 之外，剩下的 Person3、Person4，因为被发现与相应 key 的绑定关系有变化，所以被重新渲染，这会影响性能。

如果此时 list 的 item 是 select 的选项，其中 Person3 是选中的，这个时候 Person2 被删除了，用 index 作为 key 就会变成是 Person4 选中的了，这就产生了bug。

如果使用唯一id作为key，删除 Person2 后，剩下的元素因为与 key 的关系没有发生变化，都不会被重新渲染，从而达到提升性能的目的。此时，list 的 item 作为 select 的选项，也不会出现上面所描述的bug

*Vue的双向数据绑定*

实现mvvm的双向绑定，是采用数据劫持结合发布者-订阅者模式的方式，通过Object.defineProperty()来劫持各个属性的setter，getter，在数据变动时发布消息给订阅者，触发相应的监听回调。就必须要实现以下几点：
1、实现一个数据监听器Observer，能够对数据对象的所有属性进行监听，如有变动可拿到最新值并通知订阅者
2、实现一个指令解析器Compile，对每个元素节点的指令进行扫描和解析，根据指令模板替换数据，以及绑定相应的更新函数
3、实现一个Watcher，作为连接Observer和Compile的桥梁，能够订阅并收到每个属性变动的通知，执行指令绑定的相应回调函数，从而更新视图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6JLvTlqL-1632325512328)(file:///C:\Users\Mint\AppData\Local\Temp\ksohtml\wpsD4EF.tmp.png)]

*双边距问题和内容塌陷：*

https://www.cnblogs.com/niuyaomin/p/11618296.html

BFC

内容塌陷：

1.空标签 clear: both;

.parent::after{

clear: both;

content: “”;

height: 0;

width: 0;

display: block;

overflow: hidden;

}

*盒模型：*

https://blog.csdn.net/qq_37016928/article/details/79489293

IE：IE盒模型的content包括border、padding

标准：content的宽高不包括border和padding

border-box：ie盒模型

content-box：标准盒模型

箭头函数和普通函数的区别

https://www.jianshu.com/p/231a6f58e00b

箭头函数是匿名函数，不能作为构造函数，不能使用new

箭头函数不能绑定arguments，取而代之用rest参数…解决

箭头函数没有原型属性

箭头函数的this永远指向其上下文的this，没有办改变其指向，普通函数的this指向调用它的对象

箭头函数不绑定this，会捕获其所在的上下文的this值，作为自己的this值

基本数据类型和引用的数据类型

https://blog.csdn.net/weixin_42878211/article/details/108037109

null和undefined区别 https://www.cnblogs.com/shengmo/p/8671803.html

基本的数据类型：number、undefined、string、null、boolean 存在栈中

引用的数据类型：object 存在栈和堆

*JSON********.********stringify的优缺点*

https://blog.csdn.net/u013565133/article/details/102819929

1、如果obj里面有时间对象，则JSON.stringify后再JSON.parse的结果，时间将只是字符串的形式。而不是时间对象

2、如果obj里有RegExp、Error对象，则序列化的结果将只得到空对象；

3、如果obj里有函数，undefined，则序列化的结果会把函数或 undefined丢失；

4、如果obj里有NaN、Infinity和-Infinity，则序列化的结果会变成null

5、JSON.stringify()只能序列化对象的可枚举的自有属性，例如如果obj中的对象是有构造函数生成的，则使用JSON.parse(JSON.stringify(obj))深拷贝后，会丢弃对象的constructor

6、如果对象中存在循环引用的情况也无法正确实现深拷贝；以上，如果拷贝的对象不涉及上面讲的情况，可以使用JSON.parse(JSON.stringify(obj))实现深拷贝

*watch，computed和methods*

****https://www.cnblogs.com/jiajialove/p/11327945.html****

computed :

\1. 支持缓存，只有依赖数据发生改变，才会重新进行计算

\2. 不支持异步，当computed内有异步操作时无效，无法监听数据的变化

3.computed 属性值会默认走缓存，计算属性是基于它们的响应式依赖进行缓存的，也就是基于data中声明过或者父组件传递的props中的数据通过计算得到的值

\4. 如果一个属性是由其他属性计算而来的，这个属性依赖其他属性，是多对一或者一对一，一般用computed

5.如果computed属性属性值是函数，那么默认会走get方法；函数的返回值就是属性的属性值；在computed中的，属性都有一个get和一个set方法，当数据变化时，调用set方法。

Watch：

\1. 不支持缓存，数据变，直接会触发相应的操作；

2.watch支持异步；

3.监听的函数接收两个参数，第一个参数是最新的值；第二个参数是输入之前的值；

\4. 当一个属性发生变化时，需要执行对应的操作；一对多；

\5. 监听数据必须是data中声明过或者父组件传递过来的props中的数据，当数据变化时，触发其他操作，函数有两个参数，

immediate：组件加载立即触发回调函数执行，

deep: 深度监听，为了发现对象内部值的变化，复杂类型的数据时使用，例如数组中的对象内容的改变，注意监听数组的变动不需要这么做。注意：deep无法监听到数组的变动和对象的新增，参考vue数组变异,只有以响应式的方式触发才会被监听到。

*路由实现的方式* *hash和history模式*

****https://www.cnblogs.com/zzz-knight/p/12694627.html****

*原理：********https://blog.csdn.net/weixin_44385241/article/details/109245740*

**区别:**hash模式url带#号，history模式不带#号

**hash模式：**在浏览器中符号“#”，#以及#后面的字符称之为hash，用window.location.hash读取；
**特点：**hash虽然在URL中，但不被包括在HTTP请求中；用来指导浏览器动作，对服务端安全无用，hash不会重加载页面。hash 模式下，仅 hash 符号之前的内容会被包含在请求中，如 http://www.xxx.com，因此对于后端来说，即使没有做到对路由的全覆盖，也不会返回 404 错误。

**history模式：**history采用HTML5的新特性；且提供了两个新方法：pushState()，replaceState()可以对浏览器历史记录栈进行修改，以及popState事件的监听到状态变更。
history 模式下，前端的 URL 必须和实际向后端发起请求的 URL 一致，如 http://www.xxx.com/items/id。后端如果缺少对 /items/id 的路由处理，将返回 404 错误。Vue-Router 官网里如此描述：“不过这种模式要玩好，还需要后台配置支持……所以呢，你要在服务端增加一个覆盖所有情况的候选资源：如果 URL 匹配不到任何静态资源，则应该返回同一个 index.html 页面，这个页面就是你 app 依赖的页面。”

*V********ue中********keep-alive*

****https://www.cnblogs.com/goloving/p/9256212.html****

1.是Vue的内置组件，能在组件切换过程中将状态保留在内存中，防止重复渲染DOM。

2. 包裹动态组件时，会缓存不活动的组件实例，而不是销毁它们。 3. 与相似，只是一个抽象组件，它不会在DOM树中渲染(真实或者虚拟都不会)，也不在父组件链中

vue的实现原理：

https://www.jianshu.com/p/9523bb439950

*Vuex* *,********vuex使用哪种设计模式*

****https://www.jianshu.com/p/2e5973fe1223****

*https://blog.csdn.net/saucxs/article/details/91967620*

*成员列表：*

*state 存放状态*

*mutations state成员操作*

*Actions* *异步提交*

*getters 加工state成员给外界actions 异步操作*

*modules 模块化状态管理*

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-apsLaNfG-1632325512331)(file:///C:\Users\Mint\AppData\Local\Temp\ksohtml\wpsD4FF.tmp.png)]

Vue中组件中v-model语法糖

https://www.cnblogs.com/wangchangli/p/11328781.html

//在组件中等价于

<p-input :value=“value” @input="value= $e v e n t . t a r g e t . v a l u e " > < / p ? i n p u t > / / 这里的 i n p u t 事件并不是 i n p u t 的监听输入的事件，而是自己自定义组件中发布的事件，$ event是自己自定义组件中发布的事件

*Vue* *的生命周期*

****https://www.mk2048.com/blog/blog_j0i0abc2ak2j.html****

**beforeCreated:**组件实例刚刚被创建，组件属性计算之前，如data属性等。

**created：**组件实例创建完成，属性已绑定，但DOM还未生成，$el属性还不存在

**beforeMount：**模板挂载之前调用，$el的值为“虚拟”的元素节点

mounted：模板挂载之后调用,虚拟dom节点被真实的dom节点替换,于是在触发mounted时，可以获取到$el为真实的dom元素

**beforUpdate:**组件更新之前调用

**updated：**组件更新之后调用

**beforeDestroy：**组件销毁之前调用

**destroyed：**组件销毁之后调用

*post与get*

https://zhidao.baidu.com/question/87535798.html

相同点：

POST和GET都是向服务器提交数据，并且都会从服务器获取数据

区别：

1、传送方式：get通过地址栏传输，post通过报文传输。

2、传送长度：get参数有长度限制（受限于url长度），而post无限制

3、GET和POST还有一个重大区别，

简单的说：

GET产生一个TCP数据包；POST产生两个TCP数据包

长的说：

对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；

而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

也就是说，GET只需要汽车跑一趟就把货送到了，而POST得跑两趟，第一趟，先去和服务器打个招呼“嗨，我等下要送一批货来，你们打开门迎接我”，然后再回头把货送过去。

因为POST需要两步，时间上消耗的要多一点，看起来GET比POST更有效。因此Yahoo团队有推荐用GET替换POST来优化网站性能。但这是一个坑！跳入需谨慎。为什么？

\1. GET与POST都有自己的语义，不能随便混用。

\2. 据研究，在网络环境好的情况下，发一次包的时间和发两次包的时间差别基本可以无视。而在网络环境差的情况下，两次包的TCP在验证数据包完整性上，有非常大的优点。

\3. 并不是所有浏览器都会在POST中发送两次包，Firefox就只发送一次。

*ajax请求头有哪些？*

“Content-Type”:text/plain;

charset=UTF-8

*Event* *loop*

****https://blog.csdn.net/m0_49159526/article/details/113799276****

*script标签为啥放底部*

*https://blog.csdn.net/xc917563264/article/details/84639919*

*$route 和 $router*

****https://zhuanlan.zhihu.com/p/140775712****

*$route********：********route是路由信息对象，里面主要包含路由的一些基本信息，包括name、path、hash、query、params*

*$router********：********router是VueRouter的实例，包含了一些路由的跳转方法，钩子函数等*

*全局router.beforeEach********、********路由独享的守卫(路由内钩子)beforeEnter********和组件内部********beforeRouteEnter、* *beforeRouteUpdate、beforeRouteLeave*

*js是如何实现继承以及优缺点：*

*https://www.cnblogs.com/humin/p/4556820.html*

*$nextTick*

****https://blog.csdn.net/qq_42072086/article/details/106987202****

*js同步和异步*

*https://www.cnblogs.com/cxdong/p/11430812.html*

*$set*

*虚拟dom怎么解析成真实的dom*

*https://blog.csdn.net/simple5960/article/details/115839867*

*单页面和多页面*

****https://www.cnblogs.com/yunyea/p/8824178.html****

*单页面的优点：*

*1，用户体验好，快，内容的改变不需要重新加载整个页面，基于这一点spa对服务器压力较小*

*2，前后端分离*

*3，页面效果会比较炫酷（比如切换页面内容时的专场动画）*

*单页面缺点：*

*1，不利于seo*

*2，导航不可用，如果一定要导航需要自行实现前进、后退。（由于是单页面不能用浏览器的前进后退功能，所以需要自己建立堆栈管理）*

*3，初次加载时耗时多*

*4，页面复杂度提高很多*

*axios运用*

****https://zhuanlan.zhihu.com/p/58837269****

****https://www.cnblogs.com/qianxiaox/p/14025708.html****

****https://blog.csdn.net/weixin_43216105/article/details/98877960****

*拦截器：*

对象合并方法

https://www.cnblogs.com/houBlogs/p/12752649.html

var obj1 = {name:‘小A’,sex:‘女’};

var obj2 = {age:‘30’,job:‘程序猿’};
Object.assign(obj1,obj2);

*数组方法*

toString() 把数组转换为数组值（逗号分隔）的字符串

join() 方法也可将所有数组元素结合为一个字符串。

pop() 方法从数组中删除最后一个元素：

push() 方法（在数组结尾处）向数组添加一个新的元素

shift() 方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引。

unshift() 方法（在开头）向数组添加新元素，并“反向位移”旧元素

concat() 方法也可以将值作为参数：数组合并

字符串方法

****https://www.cnblogs.com/Yimi/p/10362214.html****

1、toLowerCase(): 把字符串转为小写，返回新的字符串。

2、toUpperCase(): 把字符串转为大写，返回新的字符串。

3、charAt(): 返回指定下标位置的字符。如果index不在0-str.length(不包含str.length)之间，返回空字符串。

4、charCodeAt(): 返回指定下标位置的字符的unicode编码,这个返回值是 0 - 65535 之间的整数。

5、indexOf(): 返回某个指定的子字符串在字符串中第一次出现的位置

6、lastIndexOf(): 返回某个指定的子字符串在字符串中最后出现的位置。

7、slice(): 返回字符串中提取的子字符串。

8、substring(): 提取字符串中介于两个指定下标之间的字符。

9、substr(): 返回从指定下标开始指定长度的的子字符串

10、split(): 把字符串分割成字符串数组。

11、replace(): 在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串

12、match(): 返回所有查找的关键字内容的数组。

*params和query*

****https://blog.csdn.net/mf_717714/article/details/81945218****

*1.********传参可以使用params和query两种方式。*

*2.********使用params传参只能用name来引入路由，即push里面只能是name:’xxxx’,不能是path:’/xxx’,因为params只能用name来引入路由，如果这里写成了path，接收参数页面会是undefined！！！。*

*3.********使用query传参使用path来引入路由。*

*4.********params是路由的一部分,必须要在路由后面添加参数名。query是拼接在url后面的参数，没有也没关系。*

*5.********二者还有点区别，直白的来说query相当于get请求，页面跳转的时候，可以在地址栏看到请求参数，而params相当于post请求，参数不会再地址栏中显示。*

*created和mounted*

****https://blog.csdn.net/xdnloveme/article/details/78035065****

created:在模板渲染成html前调用，即通常初始化某些属性值，然后再渲染成视图。

mounted:在模板渲染成html后调用，通常是初始化页面完成后，再对html的dom节点进行一些需要的操作。

*promise async await*

****https://segmentfault.com/a/1190000016788484****

*宏任务和微任务*

*https://www.jianshu.com/p/bfc3e319a96b*

*闭包冒泡*

****闭包：********https://blog.csdn.net/weixin_43586120/article/details/89456183****

****冒泡和捕获：********https://blog.csdn.net/weixin_41646716/article/details/81099880****

*Vue fliter* *封装和vue* *dilog*

Fliter封装：https://blog.csdn.net/qq_42268364/article/details/101481275

Vue dilog： https://www.jianshu.com/p/6a15ee763af4

*call apply bind*

*https://www.runoob.com/w3cnote/js-call-apply-bind.html*

*JS设计模式*

https://segmentfault.com/a/1190000017787537

*new的过程*

https://www.cnblogs.com/echolun/p/10903290.html

? 创建一个空对象，将它的引用赋给 this，继承函数的原型。
? 通过 this 将属性和方法添加至这个对象
? 最后返回 this 指向的新对象，也就是实例（如果没有手动返回其他的对象）

*Dom绑定经历了什么？什么是事件代理*

Dom绑定经历什么：https://blog.csdn.net/qq_15253407/article/details/89634619

事件捕获阶段事件捕获定义了事件首先由最外层的元素（window）接收，然后才是下级元素

处于目标阶段捕获到当前绑定的dom元素

事件冒泡阶段从当前捕获阶段线上冒泡到document元素

事件代理：https://www.cnblogs.com/lauzhishuai/p/11263210.html

事件捕获阶段：事件从最上一级标签开始往下查找，直到捕获到事件目标(target)。

事件冒泡阶段：事件从事件目标(target)开始，往上冒泡直到页面的最上一级标签。

事件冒泡：JS中当出发某些具有冒泡性质的事件是，首先在触发元素寻找是否有相应的注册事件，如果没有再继续向上级父元素寻找是否有相应的注册事件作出相应，这就是事件冒泡。

事件委托：利用事件冒泡的特性，将本应该注册在子元素上的处理事件注册在父元素上，这样点击子元素时发现其本身没有相应事件就到父元素上寻找作出相应。这样做的优势有：

1.减少DOM操作，提高性能。

2.随时可以添加子元素，添加的子元素会自动有相应的处理事件。

*css初始化*

https://cloud.tencent.com/developer/article/1158716

Render

https://www.cnblogs.com/weichen913/p/9676210.html

$e l 和$ ref

$ref：

1、ref 加在普通的元素上，用this.r e f s . （ r e f 值）获取到的是 d o m 元素

2、ref加在子组件上，用this.refs.（ref值）获取到的是组件实例

弊端：

当前dom已经渲染完成，多个ref相同的话返回一个数组

$rel:

$el获取Vue实例关联的DOM元素；比方说我这里想获取自定义组件tabControl，并获取它的OffsetTop。就需要先获取该组件。在组件内设置属性ref= 一个名称(tabControl2) ,然后this.refs.tabControl2 就拿到了该组件

https://blog.csdn.net/weixin_44866262/article/details/106328061

*js继承与构造函数*

https://www.jb51.net/article/81766.htm

https://www.cnblogs.com/humin/p/4556820.html

*虚拟dom、虚拟dom的算法*

https://blog.csdn.net/weixin_38655450/article/details/107505574

*闭包的三次调用*

http://js.zhizuobiao.com/js-18082400158/

*双边距*

加一个overflow：hidden

*js原生的怎么实现jq链式结构*

https://blog.csdn.net/sufubo/article/details/48953403

*flex* *=1*

flex-grow : 1; // 这意味着div将以与窗口大小相同的比例增长

flex-shrink : 1; // 这意味着div将以与窗口大小相同的比例缩小

flex-basis : 0; // 这意味着div没有这样的起始值，并且将根据可用的屏幕大小占用屏幕。例如： - 如果包装器中有3个div，则每个div将占用33％。

*css实现梯形，css画三角*

梯形： border-bottom: 100px solid #fb3;

border-left: 50px solid transparent;

border-right: 50px solid transparent;

height: 0;

width: 100px;

margin: 0 0 20px 0;

三角：width: 0;

height: 0;

border-left: 50px solid transparent;

border-right: 50px solid transparent;

border-bottom: 100px solid red;

*判断数据类型的方式*

https://www.cnblogs.com/yadiblogs/p/10750775.html

*Scoped实现原理*

https://segmentfault.com/a/1190000017508285

*import和export* *require*

https://blog.csdn.net/p3118601/article/details/100150075

*分片上传的怎么实现和状态码*

https://www.cnblogs.com/xiahj/archive/2018/12/05/vue-simple-uploader.html

*请求oppotion作用*

https://blog.csdn.net/weixin_34109408/article/details/94758821

*attr和data* *api的区别*

https://blog.csdn.net/cccmercy/article/details/79686577?utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control&dist_request_id=1619619964744_64501&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control

*margin********-********left：********50%* *和translation* *50%********区别*

https://blog.csdn.net/weixin_43970743/article/details/104970129

*隐式转换和强制转换的规则*

https://www.cnblogs.com/yangguoe/p/8465092.html

*预编译less和scss做了哪些操作*

****https://blog.csdn.net/qq_42958772/article/details/87777068****

****Render函数详解****

****https://www.cnblogs.com/yubin-/p/11543734.html****

*css:*

*B********fc*

*https://blog.csdn.net/sinat_36422236/article/details/88763187*

*flex*

*rem em px*

*标准的CSS的盒子模型和ie盒模型*

*实现0.5px*

*https://www.cnblogs.com/sese/p/7067961.html*

*css3*

*P********osition*

****https://blog.csdn.net/qq_39207066/article/details/79764191****

*es6新特性有哪些*

*https://blog.csdn.net/weixin_44141866/article/details/106028210*

*commonJS es6的区别*

****https://www.cnblogs.com/whm-blog/p/9750021.html****

*浏览器总有那些线程，都是用来干什么的*

浏览器的渲染进程是多线程的。js是阻塞单线程的。

\1. GUI渲染线程

\2. JS引擎线程

3.事件触发线程

**4.**定时触发器线程

5.异步http请求线程

*https://www.cnblogs.com/hustxychen/p/9412656.html*

*重排和重绘相应的首屏加载速度策略*

*https://www.cnblogs.com/soyxiaobi/p/9963019.html*

*哪些可以开启GPU*

*箭头函数的作用域 this指向 settimeout中的箭头函数的this指向*

*https://blog.csdn.net/MingleHDU/article/details/85058573*

*jsonp的工作原理，有哪些局限性*

****原理：********https://segmentfault.com/a/1190000007665361****

*1********、********首先是利用script标签的src属性来实现跨域。*

*2********、********通过将前端方法作为参数传递到服务器端，然后由服务器端注入参数之后再返回，实现服务器端向客户端通信。*

*3********、********由于使用script标签的src属性，因此只支持get方法*

function foo(){

foo.a = function(){

console.log(1)

}

this.a = function(){

console.log(2)

}

foo.prototype.a = function(){

console.log(3)

}

foo.a = function(){

console.log(4)

}

foo.a() //4

var obj = new foo()

obj.a() //2

foo.a() //1

*new的六个步骤：*

new操作符创建对象可以分为以下四个步骤：

· 创建一个空对象

· 将所创建对象的__proto__属性值设为构造函数的prototype的属性值

· 执行构造函数中的代码，构造函数中的this指向该对象

· 返回对象

****https://www.jianshu.com/p/4b4f1dde91c6#comments****

apply、call、bind的应用场景

https://www.jianshu.com/p/f577555cdce1

*vue********实现双向绑定********原理*

*https://www.cnblogs.com/chenhuichao/p/10818396.html*

*V********ue* *data为什么是函数*

****https://www.jianshu.com/p/f3e774c57356****

*v-mod********el********实现的原理*

v-model 是数据双向绑定

· 浅层理解：将触发input事件来修改value值

· 深层理解：利用Object.defineProperty()数据劫持来实现

****https://www.jianshu.com/p/2012c26b6933****

*nexttick实现原理*

*https://www.cnblogs.com/liuhao-web/p/8919623.html*

*模板编译实现流程*

****https://blog.csdn.net/wanda000/article/details/104804629****

*虚拟dom从产生到对比整体流程* *，********dom对比过程key在其中的作用*

\1. 创建虚拟节点Vnode的函数 createVNode()

\2. 2.在render中创建虚拟节点VNodes

\3. 3.在createApp中把得到的虚拟节点挂载到根节点上去

****https://blog.csdn.net/simple5960/article/details/115839867****

*https://www.jianshu.com/p/5d771cf57012*

*数组如何实现双向绑定的*

*https://blog.csdn.net/weixin_30919571/article/details/96586784*

*事件捕获和冒泡事件流*

*https://blog.csdn.net/weixin_41646716/article/details/81099880*

*为什么css放到页面上面 js放到页面下边*

*https://blog.csdn.net/qq_33505829/article/details/103419143*

*vue路由********有几种模式实现原理*

*https://blog.csdn.net/tdl081071tdy/article/details/113410501*

*vue中如何使用router中的方法的*

****https://blog.csdn.net/qq_39239110/article/details/88765354****

*路由传参的几种方式*

*https://www.cnblogs.com/tzwbk/p/12462879.html*

*两个有序链表的合并*

****https://www.cnblogs.com/ximiximi-blog/p/13230440.html****

*css实现左边宽度固定，右边宽度自适应*

****https://www.cnblogs.com/dirgo/p/10212803.html****

*css选择器是从左到右还是从右到左*

****https://www.cnblogs.com/chenshuyong/p/10052183.html****

*ES********6********中set和********reduce*

*Set:* *https://blog.csdn.net/whilewhite/article/details/82899356*

*Reduce:* *https://www.cnblogs.com/cckui/p/9267542.html*

*J********S引用地址放在哪里*

https://www.cnblogs.com/cxying93/p/6106469.html

*V********ue3* *数据劫持和Vue********2********的obj********.definepro********per********ty*

https://blog.csdn.net/weixin_42060560/article/details/113182757

*路由跳转的几种方法*

https://blog.csdn.net/a378113472/article/details/106239754

*vue的单向数据流*

从上面 v-model 的分析我们可以这么理解，双向数据绑定就是在单向绑定的基础上给可输入元素（input、textare等）添加了 change(input) 事件，来动态修改 model 和 view ，即通过触发（$emit）父组件的事件来修改mv来达到 mvvm 的效果。而 vue 组件间传递数据是单向的，即数据总是由父组件传递到子组件，子组件在其内部可以有自己维护的数据，但它无权修改父组件传递给它的数据，当开发者尝试这样做的时候，vue 将会报错。这样做是为了组件间更好的解耦，在开发中可能有多个子组件依赖于父组件的某个数据，假如子组件可以修改父组件数据的话，一个子组件变化会引发所有依赖这个数据的子组件发生变化，所以 vue 不推荐子组件修改父组件的数据，直接修改 props 会抛出警告。

https://www.jb51.net/article/127891.htm

*静态页面js的执行顺序*

https://blog.csdn.net/zwn_software/article/details/83566365

DOM和BOM

https://blog.csdn.net/qq877507054/article/details/51395830

*Script* *differ* *和* *async*

https://www.cnblogs.com/jiasm/p/7683930.html

*发布订阅这模式*

**观察者模式：**观察者（Observer）直接订阅（Subscribe）主题（Subject），而当主题被激活的时候，会触发（Fire Event）观察者里的事件。

**发布订阅模式：**订阅者（Subscriber）把自己想订阅的事件注册（Subscribe）到调度中心（Topic），当发布者（Publisher）发布该事件（Publish topic）到调度中心，也就是该事件触发时，由调度中心统一调度（Fire Event）订阅者注册到调度中心的处理代码。

观察者模式和发布订阅模式最大的区别就是发布订阅模式有个事件调度中心。

https://blog.csdn.net/weixin_46656983/article/details/107146557