常见面试题总结

admin管理员组

文章数量:1566222

参考：

https://www.nowcoder/ta/front-end-interview?query=&asc=true&order=&tagQuery=&page=1
http://bigerfe/
https://blog.csdn/keyandi/article/details/89227175
https://blog.csdn/MingL520/article/details/88549999
https://segmentfault/a/1190000016481101
https://www.jianshu/p/ff6de219f988
https://segmentfault/a/1190000016344599?utm_source=tag-newest
https://blog.csdn/wdlhao/article/details/79079660
https://segmentfault/a/1190000018426354?utm_source=tag-newest

https://wwwblogs/2050/p/3191744.html
https://www.jianshu/p/1b63a13c2701
 

 

转自：https://blog.csdn/keyandi/article/details/89227175
HTML&CSS：  对Web标准的理解、浏览器内核差异、兼容性、hack、CSS基本功：布局、盒子模型、选择器优先级及使用、HTML5、CSS3、移动端适应。
 
JavaScript：   数据类型、面向对象、继承、闭包、插件、作用域、跨域、原型链、模块化、自定义事件、内存泄漏、事件机制、异步装载回调、模板引擎、Nodejs、JSON、ajax等。
 
其他：  HTTP、安全、正则、优化、重构、响应式、移动端、团队协作、可维护、SEO、UED、架构、职业生涯 
1.请你谈谈Cookie的弊端
cookie

1.IE6或更低版本最多20个cookie
2.IE7和之后的版本最后可以有50个cookie。
3.Firefox最多50个cookie
4.chrome和Safari没有做硬性限制
Opera 会清理近期最少使用的Firefox会随机清理 4096字节，为了兼容性，一般不能超过 IE 提供了一种存储可以持久化用户数据，叫做IE5.0就开始支持。每个数据最多128K，每个域名下最多1M。这个持久化数据放在缓存中，如果缓存没有清理，那么会一直存在。

优点：极高的扩展性和可用性
1.通过良好的编程，控制保存在cookie中的session对象的大小。
2.通过加密和安全传输技术（SSL），减少cookie被破解的可能性。
3.只在cookie中存放不敏感数据，即使被盗也不会有重大损失。
4.控制cookie的生命期，使之不会永远有效。偷盗者很可能拿到一个过期的cookie。
缺点：
1.`Cookie`数量和长度的限制。每个domain最多只能有20条cookie，每个cookie长度不能超过4KB，否则会被截掉。
 
2.安全性问题。如果cookie被人拦截了，那人就可以取得所有的session信息。即使加密也与事无补，因为拦截者并不需要知道cookie的意义，他只要原样转发cookie就可以达到目的了。
 
3.有些状态不可能保存在客户端。例如，为了防止重复提交表单，我们需要在服务器端保存一个计数器。如果我们把这个计数器保存在客户端，那么它起不到任何作用。
2.浏览器本地存储
在较高版本的浏览器中，sessionStorage和HTML5中提供了globalStorage。

Web Storage包括了两种存储方式：localStorage。

sessionStorage不是一种持久化的本地存储，仅仅是会话级别的存储。

而 3.web storage和cookie的区别

cookie相似，区别是它是为了更大容量存储设计的。Cookie都会被发送过去，这样无形中浪费了带宽，另外 除此之外，setItem,getItem,removeItem,clear等方法，不像setCookie，getCookie。

但是Cookie的作用是与服务器进行交互，作为Web Storage仅仅是为了在本地“存储”数据而生

浏览器的支持除了UserData其实就是web storage。

sessionStorage都具有相同的操作方法，例如removeItem等

CSS 相关问题

display:none和visibility:hidden的区别？
display:none  隐藏对应的元素，在文档布局中不再给它分配空间，它各边的元素会合拢，
就当他从来不存在。
 
visibility:hidden  隐藏对应的元素，但是在文档布局中仍保留原来的空间。
CSS中 link 和@import 的区别是？
A：(1) link属于HTML标签，而@import是CSS提供的; (2) 页面被加载的时，link会同时被加载，而@import引用的CSS会等到页面被加载完再加载;(3) import只在IE5以上才能识别，而link是HTML标签，无兼容问题; (4) link方式的样式的权重 高于@import的权重.
position的absolute与fixed共同点与不同点
A：共同点：
1.改变行内元素的呈现方式，display被置为block；2.让元素脱离普通流，不占据空间；3.默认会覆盖到非定位元素上
 
B不同点：
absolute的”根元素“是可以设置的，而fixed的”根元素“固定为浏览器窗口。当你滚动网页，fixed元素与浏览器窗口之间的距离是不变的。  
介绍一下CSS的盒子模型？
1）有两种， IE 盒子模型、标准 W3C 盒子模型；IE的content部分包含了 border 和 pading;
 
2）盒模型： 内容(content)、填充(padding)、边界(margin)、 边框(border).

CSS 选择符有哪些？哪些属性可以继承？优先级算法如何计算？ CSS3新增伪类有那些？
   *   1.id选择器（ # myid）
        2.类选择器（.myclassname）
        3.标签选择器（div, h1, p）
        4.相邻选择器（h1 + p）
        5.子选择器（ul > li）
        6.后代选择器（li a）
        7.通配符选择器（ * ）
        8.属性选择器（a[rel = "external"]）
        9.伪类选择器（a: hover, li:nth-child）
 
    *   可继承的样式： font-size font-family color, text-indent;
 
    *   不可继承的样式：border padding margin width height ;
 
    *   优先级就近原则，同权重情况下样式定义最近者为准;
 
    *   载入样式以最后载入的定位为准;
 
优先级为:
 
 
   !important >  id > class > tag  
 
   important 比 内联优先级高,但内联比 id 要高
 
CSS3新增伪类举例：
 
 
p:first-of-type 选择属于其父元素的首个 <p> 元素的每个 <p> 元素。
p:last-of-type  选择属于其父元素的最后 <p> 元素的每个 <p> 元素。
p:only-of-type  选择属于其父元素唯一的 <p> 元素的每个 <p> 元素。
p:only-child    选择属于其父元素的唯一子元素的每个 <p> 元素。
p:nth-child(2)  选择属于其父元素的第二个子元素的每个 <p> 元素。
:enabled  :disabled 控制表单控件的禁用状态。
:checked        单选框或复选框被选中。
列出display的值，说明他们的作用。position的值， relative和absolute分别是相对于谁进行定位的？
1.   
  block 象块类型元素一样显示。
  inline 缺省值。象行内元素类型一样显示。
  inline-block 象行内元素一样显示，但其内容象块类型元素一样显示。
  list-item 象块类型元素一样显示，并添加样式列表标记。
 
  2. 
  *absolute 
        生成绝对定位的元素，相对于 static 定位以外的第一个祖先元素进行定位。 
 
  *fixed （老IE不支持）
        生成绝对定位的元素，相对于浏览器窗口进行定位。 
 
  *relative 
        生成相对定位的元素，相对于其在普通流中的位置进行定位。 
 
  * static  默认值。没有定位，元素出现在正常的流中
  *（忽略 top, bottom, left, right z-index 声明）。
 
  * inherit 规定从父元素继承 position 属性的值。
CSS3有哪些新特性？
CSS3实现圆角（border-radius），阴影（box-shadow），
对文字加特效（text-shadow、），线性渐变（gradient），旋转（transform）
transform:rotate(9deg) scale(0.85,0.90) translate(0px,-30px) skew(-9deg,0deg);//旋转,缩放,定位,倾斜
增加了更多的CSS选择器  多背景 rgba 
在CSS3中唯一引入的伪元素是::selection.
媒体查询，多栏布局
border-image
为什么要初始化CSS样式。
    因为浏览器的兼容问题，不同浏览器对有些标签的默认值是不同的，如果没对CSS初始化往往会出现浏览器之间的页面显示差异。
 
    当然，初始化样式会对SEO有一定的影响，但鱼和熊掌不可兼得，但力求影响最小的情况下初始化。
 
*最简单的初始化方法就是： * {padding: 0; margin: 0;} （不建议）
 
    淘宝的样式初始化： 
    body, h1, h2, h3, h4, h5, h6, hr, p, blockquote, dl, dt, dd, ul, ol, li, pre, form, fieldset, legend, button, input, textarea, th, td { margin:0; padding:0; }
    body, button, input, select, textarea { font:12px/1.5tahoma, arial, \5b8b\4f53; }
    h1, h2, h3, h4, h5, h6{ font-size:100%; }
    address, cite, dfn, em, var { font-style:normal; }
    code, kbd, pre, samp { font-family:couriernew, courier, monospace; }
    small{ font-size:12px; }
    ul, ol { list-style:none; }
    a { text-decoration:none; }
    a:hover { text-decoration:underline; }
    sup { vertical-align:text-top; }
    sub{ vertical-align:text-bottom; }
    legend { color:#000; }
    fieldset, img { border:0; }
    button, input, select, textarea { font-size:100%; }
    table { border-collapse:collapse; border-spacing:0; } 
对BFC规范的理解？
      BFC，块级格式化上下文，一个创建了新的BFC的盒子是独立布局的，盒子里面的子元素的样式不会影响到外面的元素。在同一个BFC中的两个毗邻的块级盒在垂直方向（和布局方向有关系）的margin会发生折叠。
    （W3C CSS 2.1 规范中的一个概念，它决定了元素如何对其内容进行布局，以及与其他元素的关系和相互作用。）
解释下 CSS sprites，以及你要如何在页面或网站中使用它。
CSS Sprites其实就是把网页中一些背景图片整合到一张图片文件中，再利用CSS的“background-image”，“background- repeat”，“background-position”的组合进行背景定位，background-position可以用数字能精确的定位出背景图片的位置。这样可以减少很多图片请求的开销，因为请求耗时比较长；请求虽然可以并发，但是也有限制，一般浏览器都是6个。对于未来而言，就不需要这样做了，因为有了`http2`。
html部分
说说你对语义化的理解？
1，去掉或者丢失样式的时候能够让页面呈现出清晰的结构
2，有利于SEO：和搜索引擎建立良好沟通，有助于爬虫抓取更多的有效信息：爬虫依赖于标签来确定上下文和各个关键字的权重；
3，方便其他设备解析（如屏幕阅读器、盲人阅读器、移动设备）以意义的方式来渲染网页；
4，便于团队开发和维护，语义化更具可读性，是下一步吧网页的重要动向，遵循W3C标准的团队都遵循这个标准，可以减少差异化。
Doctype作用? 严格模式与混杂模式如何区分？它们有何意义?
（1）、<!DOCTYPE> 声明位于文档中的最前面，处于 <html> 标签之前。告知浏览器以何种模式来渲染文档。 
 
（2）、严格模式的排版和 JS 运作模式是  以该浏览器支持的最高标准运行。
 
（3）、在混杂模式中，页面以宽松的向后兼容的方式显示。模拟老式浏览器的行为以防止站点无法工作。
 
（4）、DOCTYPE不存在或格式不正确会导致文档以混杂模式呈现。   
你知道多少种Doctype文档类型？
 该标签可声明三种 DTD 类型，分别表示严格版本、过渡版本以及基于框架的 HTML 文档。
 HTML 4.01 规定了三种文档类型：Strict、Transitional 以及 Frameset。
 XHTML 1.0 规定了三种 XML 文档类型：Strict、Transitional 以及 Frameset。
Standards （标准）模式（也就是严格呈现模式）用于呈现遵循最新标准的网页，而 Quirks
 （包容）模式（也就是松散呈现模式或者兼容模式）用于呈现为传统浏览器而设计的网页。
HTML与XHTML——二者有什么区别
区别：
1.所有的标记都必须要有一个相应的结束标记
2.所有标签的元素和属性的名字都必须使用小写
3.所有的XML标记都必须合理嵌套
4.所有的属性必须用引号""括起来
5.把所有<和&特殊符号用编码表示
6.给所有属性赋一个值
7.不要在注释内容中使“--”
8.图片必须有说明文字
常见兼容性问题？
* png24位的图片在iE6浏览器上出现背景，解决方案是做成PNG8.也可以引用一段脚本处理.
 
* 浏览器默认的margin和padding不同。解决方案是加一个全局的*{margin:0;padding:0;}来统一。
 
* IE6双边距bug:块属性标签float后，又有横行的margin情况下，在ie6显示margin比设置的大。 
 
* 浮动ie产生的双倍距离（IE6双边距问题：在IE6下，如果对元素设置了浮动，同时又设置了margin-left或margin-right，margin值会加倍。）
  #box{ float:left; width:10px; margin:0 0 0 100px;} 
 
 这种情况之下IE会产生20px的距离，解决方案是在float的标签样式控制中加入 ——_display:inline;将其转化为行内属性。(_这个符号只有ie6会识别)
 
*  渐进识别的方式，从总体中逐渐排除局部。 
 
  首先，巧妙的使用“\9”这一标记，将IE游览器从所有情况中分离出来。 
  接着，再次使用“+”将IE8和IE7、IE6分离开来，这样IE8已经独立识别。
 
  css
      .bb{
       background-color:#f1ee18;/*所有识别*/
      .background-color:#00deff\9; /*IE6、7、8识别*/
      +background-color:#a200ff;/*IE6、7识别*/
      _background-color:#1e0bd1;/*IE6识别*/ 
      } 
 
*  IE下,可以使用获取常规属性的方法来获取自定义属性,
   也可以使用getAttribute()获取自定义属性;
   Firefox下,只能使用getAttribute()获取自定义属性. 
   解决方法:统一通过getAttribute()获取自定义属性.
 
* IE下,event对象有x,y属性,但是没有pageX,pageY属性; 
  Firefox下,event对象有pageX,pageY属性,但是没有x,y属性.
 
* 解决方法：（条件注释）缺点是在IE浏览器下可能会增加额外的HTTP请求数。
 
* Chrome 中文界面下默认会将小于 12px 的文本强制按照 12px 显示, 
  可通过加入 CSS 属性 -webkit-text-size-adjust: none; 解决.
 
* 超链接访问过后hover样式就不出现了 被点击访问过的超链接样式不在具有hover和active了解决方法是改变CSS属性的排列顺序:
L-V-H-A :  a:link {} a:visited {} a:hover {} a:active {}
 
* 怪异模式问题：漏写DTD声明，Firefox仍然会按照标准模式来解析网页，但在IE中会触发怪异模式。为避免怪异模式给我们带来不必要的麻烦，最好养成书写DTD声明的好习惯。现在可以使用[html5](http://www.w3/TR/html5/single-page.html)推荐的写法：`<doctype html>`
 
* 上下margin重合问题
ie和ff都存在，相邻的两个div的margin-left和margin-right不会重合，但是margin-top和margin-bottom却会发生重合。
解决方法，养成良好的代码编写习惯，同时采用margin-top或者同时采用margin-bottom。
* ie6对png图片格式支持不好(引用一段脚本处理)
解释下浮动和它的工作原理？清除浮动的技巧
浮动元素脱离文档流，不占据空间。浮动元素碰到包含它的边框或者浮动元素的边框停留。
 
1.使用空标签清除浮动。
   这种方法是在所有浮动标签后面添加一个空标签 定义css clear:both. 弊端就是增加了无意义标签。
2.使用overflow。
   给包含浮动元素的父标签添加css属性 overflow:auto; zoom:1; zoom:1用于兼容IE6。
3.使用after伪对象清除浮动。
   该方法只适用于非IE浏览器。具体写法可参照以下示例。使用中需注意以下几点。一、该方法中必须为需要清除浮动元素的伪对象中设置 height:0，否则该元素会比实际高出若干像素；
浮动元素引起的问题和解决办法？
浮动元素引起的问题：
（1）父元素的高度无法被撑开，影响与父元素同级的元素
（2）与浮动元素同级的非浮动元素会跟随其后
（3）若非第一个元素浮动，则该元素之前的元素也需要浮动，否则会影响页面显示的结构
解决方法：
使用clear:both;属性来清除元素的浮动可解决2、3问题，对于问题1，添加如下样式，给父元素添加.clearfix:after{content: ".";display: block;height: 0;clear: both;visibility: hidden;} .clearfix{display: inline-block;} /* for IE/Mac */

清除浮动的几种方法：

1，额外标签法，<div style="clear:both;"></div>（缺点：不过这个办法会增加额外的标签使HTML结构看起来不够简洁。）
2，使用after伪类
 
#parent:after{
    content:".";
    height:0;
    visibility:hidden;
    display:block;
    clear:both;
    }
 
3,浮动外部元素
4,设置`overflow`为`hidden`或者auto
IE 8以下版本的浏览器中的盒模型有什么不同
IE8以下浏览器的盒模型中定义的元素的宽高不包括内边距和边框
DOM操作——怎样添加、移除、移动、复制、创建和查找节点。
（1）创建新节点
 
      createDocumentFragment()    //创建一个DOM片段
 
      createElement()   //创建一个具体的元素
 
      createTextNode()   //创建一个文本节点
 
（2）添加、移除、替换、插入
 
      appendChild()
 
      removeChild()
 
      replaceChild()
 
      insertBefore() //在已有的子节点前插入一个新的子节点
 
（3）查找
 
      getElementsByTagName()    //通过标签名称
 
      getElementsByName()    //通过元素的Name属性的值(IE容错能力较强，会得到一个数组，其中包括id等于name值的)
 
      getElementById()    //通过元素Id，唯一性
html5有哪些新特性、移除了那些元素？如何处理HTML5新标签的浏览器兼容问题？如何区分 HTML 和 HTML5？
* HTML5 现在已经不是 SGML 的子集，主要是关于图像，位置，存储，多任务等功能的增加。
 
* 拖拽释放(Drag and drop) API 
  语义化更好的内容标签（header,nav,footer,aside,article,section）
  音频、视频API(audio,video)
  画布(Canvas) API
  地理(Geolocation) API
  本地离线存储 localStorage 长期存储数据，浏览器关闭后数据不丢失；
  sessionStorage 的数据在浏览器关闭后自动删除
 
  表单控件，calendar、date、time、email、url、search  
  新的技术webworker, websocket, Geolocation
 
* 移除的元素
 
纯表现的元素：basefont，big，center，font, s，strike，tt，u；
 
对可用性产生负面影响的元素：frame，frameset，noframes；
 
支持HTML5新标签：
 
* IE8/IE7/IE6支持通过document.createElement方法产生的标签，
  可以利用这一特性让这些浏览器支持HTML5新标签，
 
  浏览器支持新标签后，还需要添加标签默认的样式：
 
* 当然最好的方式是直接使用成熟的框架、使用最多的是html5shim框架
   <!--[if lt IE 9]> 
   <script> src="http://html5shim.googlecode/svn/trunk/html5.js"</script> 
   <![endif]--> 
如何区分： DOCTYPE声明\新增的结构元素\功能元素
iframe的优缺点？
1.<iframe>优点：
 
    解决加载缓慢的第三方内容如图标和广告等的加载问题
    Security sandbox
    并行加载脚本
 
2.<iframe>的缺点：
 
 
    *iframe会阻塞主页面的Onload事件；
 
    *即时内容为空，加载也需要时间
    *没有语意 
如何实现浏览器内多个标签页之间的通信?
调用localstorge、cookies等本地存储方式
webSocket如何兼容低浏览器？
Adobe Flash Socket 、 ActiveX HTMLFile (IE) 、 基于 multipart 编码发送 XHR 、 基于长轮询的 XHR
线程与进程的区别
一个程序至少有一个进程,一个进程至少有一个线程. 
线程的划分尺度小于进程，使得多线程程序的并发性高。 
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
你如何对网站的文件和资源进行优化？
期待的解决方案包括：
 文件合并
 文件最小化/文件压缩
 使用 CDN 托管
 缓存的使用（多个域名来提供缓存）
 其他
请说出三种减少页面加载时间的方法。
 1.优化图片 
 2.图像格式的选择（GIF：提供的颜色较少，可用在一些对颜色要求不高的地方） 
 3.优化CSS（压缩合并css，如margin-top,margin-left...) 
 4.网址后加斜杠（如www.campr/目录，会判断这个“目录是什么文件类型，或者是目录。） 
 5.标明高度和宽度（如果浏览器没有找到这两个参数，它需要一边下载图片一边计算大小，如果图片很多，浏览器需要不断地调整页面。这不但影响速度，也影响浏览体验。 
当浏览器知道了高度和宽度参数后，即使图片暂时无法显示，页面上也会腾出图片的空位，然后继续加载后面的内容。从而加载时间快了，浏览体验也更好了。） 
 
6.减少http请求（合并文件，合并图片）。
你都使用哪些工具来测试代码的性能？
Profiler, JSPerf（http://jsperf/nexttick-vs-setzerotimeout-vs-settimeout）, Dromaeo
什么是 FOUC（无样式内容闪烁）？你如何来避免 FOUC？
 FOUC - Flash Of Unstyled Content 文档样式闪烁
 <style type="text/css" media="all">@import "../fouc.css";</style> 
而引用CSS文件的@import就是造成这个问题的罪魁祸首。IE会先加载整个HTML文档的DOM，然后再去导入外部的CSS文件，因此，在页面DOM加载完成到CSS导入完成中间会有一段时间页面上的内容是没有样式的，这段时间的长短跟网速，电脑速度都有关系。
 解决方法简单的出奇，只要在<head>之间加入一个<link>或者<script>元素就可以了。
null和undefined的区别？
undefined是一个表示"无"的原始值，转为数值时为 当声明的变量还未被初始化时，变量的默认值为null用来表示尚未存在的对象，常用来表示函数企图返回一个不存在的对象。

（1）变量被声明了，但没有赋值时，就等于undefined。 （2) 调用函数时，应该提供的参数没有提供，该参数等于undefined。 （3）对象没有赋值的属性，该属性的值为undefined。 （4）函数没有返回值时，默认返回undefined。

（1） 作为函数的参数，表示该函数的参数不是对象。 （2） 作为对象原型链的终点。

new操作符具体干了什么呢?
   1、创建一个空对象，并且 this 变量引用该对象，同时还继承了该函数的原型。
   2、属性和方法被加入到 this 引用的对象中。
   3、新创建的对象由 this 所引用，并且最后隐式的返回 this 。
 
var obj  = {};
obj.__proto__ = Base.prototype;
Base.call(obj); 
JSON 的了解？
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。
它是基于JavaScript的一个子集。数据格式简单, 易于读写, 占用带宽小
{'age':'12', 'name':'back'}
js延迟加载的方式有哪些？
defer和async、动态创建DOM方式（创建script，插入到DOM中，加载完毕后callBack）、按需异步载入js
如何解决跨域问题?
    jsonp、 document.domain+iframe、window.name、window.postMessage、服务器上设置代理页面
 
jsonp的原理是动态插入script标签
 

documen.write和 innerHTML的区别
document.write只能重绘整个页面
 
innerHTML可以重绘页面的一部分
.call() 和 .apply() 的区别和作用？
作用：动态改变某个类的某个方法的运行环境。

哪些操作会造成内存泄漏？
内存泄漏指任何对象在您不再拥有或需要它之后仍然存在。
垃圾回收器定期扫描对象，并计算引用了每个对象的其他对象的数量。如果一个对象的引用数量为 0（没有其他对象引用过该对象），或对该对象的惟一引用是循环的，那么该对象的内存即可回收。
 
setTimeout 的第一个参数使用字符串而非函数的话，会引发内存泄漏。
闭包、控制台日志、循环（在两个对象彼此引用且彼此保留时，就会产生一个循环）
 

JavaScript中的作用域与变量声明提升？
 

如何判断当前脚本运行在浏览器还是node环境中？
通过判断Global对象是否为window，如果不为window，当前脚本没有运行在浏览器中
其他问题？
你遇到过比较难的技术问题是？你是如何解决的？
常使用的库有哪些？常用的前端开发工具？开发过什么应用或组件？
列举IE 与其他浏览器不一样的特性？
99%的网站都需要被重构是那本书上写的？
* 网站重构：应用web标准进行设计（第2版）
什么叫优雅降级和渐进增强？
优雅降级：Web站点在所有新式浏览器中都能正常工作，如果用户使用的是老式浏览器，则代码会检查以确认它们是否能正常工作。由于IE独特的盒模型布局问题，针对不同版本的IE的hack实践过优雅降级了,为那些无法支持功能的浏览器增加候选方案，使之在旧式浏览器上以某种形式降级体验却不至于完全失效.
 
渐进增强：从被所有浏览器支持的基本功能开始，逐步地添加那些只有新式浏览器才支持的功能,向页面增加无害于基础浏览器的额外样式和功能的。当浏览器支持时，它们会自动地呈现出来并发挥作用。
 

WEB应用从服务器主动推送Data到客户端有那些方式？
对Node的优点和缺点提出了自己的看法？
*（优点）因为Node是基于事件驱动和无阻塞的，所以非常适合处理并发请求，
  因此构建在Node上的代理服务器相比其他技术实现（如Ruby）的服务器表现要好得多。
  此外，与Node代理服务器交互的客户端代码是由javascript语言编写的，
  因此客户端和服务器端都用同一种语言编写，这是非常美妙的事情。
 
*（缺点）Node是一个相对新的开源项目，所以不太稳定，它总是一直在变，
  而且缺少足够多的第三方库支持。看起来，就像是Ruby/Rails当年的样子。
除了前端以外还了解什么其它技术么？你最最厉害的技能是什么？
你常用的开发工具是什么，为什么？
对前端界面工程师这个职位是怎么样理解的？它的前景会怎么样？
前端是最贴近用户的程序员，比后端、数据库、产品经理、运营、安全都近。
    1、实现界面交互
    2、提升用户体验
    3、有了Node.js，前端可以实现服务端的一些事情
 
 
前端是最贴近用户的程序员，前端的能力就是能让产品从 90分进化到 100 分，甚至更好，
 
 参与项目，快速高质量完成实现效果图，精确到1px；
 
 与团队成员，UI设计，产品经理的沟通；
 
 做好的页面结构，页面重构和用户体验；
 
 处理hack，兼容、写出优美的代码格式；
 
 针对服务器的优化、拥抱最新前端技术。
你在现在的团队处于什么样的角色，起到了什么明显的作用？
你认为怎样才是全端工程师（Full Stack developer）？
介绍一个你最得意的作品吧？
项目中遇到什么问题？如何解决？
你的优点是什么？缺点是什么？
如何管理前端团队?
最近在学什么？能谈谈你未来3，5年给自己的规划吗？
你有哪些性能优化的方法？
 

  （1） 减少http请求次数：CSS Sprites, JS、CSS源码压缩、图片大小控制合适；网页Gzip，CDN托管，data缓存 ，图片服务器。
 
  （2） 前端模板 JS+数据，减少由于HTML标签导致的带宽浪费，前端用变量保存AJAX请求结果，每次操作本地变量，不用请求，减少请求次数
 
  （3） 用innerHTML代替DOM操作，减少DOM操作次数，优化javascript性能。
 
  （4） 当需要设置的样式很多时设置className而不是直接操作style。
 
  （5） 少用全局变量、缓存DOM节点查找的结果。减少IO读取操作。
 
  （6） 避免使用CSS Expression（css表达式)又称Dynamic properties(动态属性)。
 
  （7） 图片预加载，将样式表放在顶部，将脚本放在底部  加上时间戳。
http状态码有那些？分别代表是什么意思？
100-199 用于指定客户端应相应的某些动作。 
200-299 用于表示请求成功。 
300-399 用于已经移动的文件并且常被包含在定位头信息中指定新的地址信息。 
400-499 用于指出客户端的错误。400    1、语义有误，当前请求无法被服务器理解。401   当前请求需要用户验证 403  服务器已经理解请求，但是拒绝执行它。
500-599 用于支持服务器错误。 503 – 服务不可用
 

一个页面从输入 URL 到页面加载显示完成，这个过程中都发生了什么？
    分为4个步骤：
    （1），当发送一个URL请求时，不管这个URL是Web页面的URL还是Web页面上每个资源的URL，浏览器都会开启一个线程来处理这个请求，同时在远程DNS服务器上启动一个DNS查询。这能使浏览器获得请求对应的IP地址。
    （2）， 浏览器与远程Web服务器通过TCP三次握手协商来建立一个TCP/IP连接。该握手包括一个同步报文，一个同步-应答报文和一个应答报文，这三个报文在 浏览器和服务器之间传递。该握手首先由客户端尝试建立起通信，而后服务器应答并接受客户端的请求，最后由客户端发出该请求已经被接受的报文。
    （3），一旦TCP/IP连接建立，浏览器会通过该连接向远程服务器发送HTTP的GET请求。远程服务器找到资源并使用HTTP响应返回该资源，值为200的HTTP响应状态表示一个正确的响应。
    （4），此时，Web服务器提供资源服务，客户端开始下载资源。
 
请求返回后，便进入了我们关注的前端模块
简单来说，浏览器会解析HTML生成DOM Tree，其次会根据CSS生成CSS Rule Tree，而javascript又可以根据DOM API操作DOM
 

平时如何管理你的项目？
先期团队必须确定好全局样式（globe.css），编码模式(utf-8) 等；
 
        编写习惯必须一致（例如都是采用继承式的写法，单样式都写成一行）；
 
        标注样式编写人，各模块都及时标注（标注关键样式调用的地方）；
 
        页面进行标注（例如 页面 模块 开始和结束）；
 
        CSS跟HTML 分文件夹并行存放，命名都得统一（例如style.css）；
 
        JS 分文件夹存放 命名以该JS功能为准的英文翻译。
 
        图片采用整合的 images.png png8 格式文件使用 尽量整合在一起使用方便将来的管理 
说说最近最流行的一些东西吧？常去哪些网站？
Node.js、Mongodb、npm、MVVM、MEAN、three.js,React 。
网站：w3cfuns,sf,hacknews,CSDN,慕课，博客园，InfoQ,w3cplus等
javascript对象的几种创建方式
1，工厂模式
2，构造函数模式
3，原型模式
4，混合构造函数和原型模式
5，动态原型模式
6，寄生构造函数模式
7，稳妥构造函数模式
javascript继承的6种方法
1，原型链继承
2，借用构造函数继承
3，组合继承(原型+借用构造)
4，原型式继承
5，寄生式继承
6，寄生组合式继承
 

ajax过程
(1)创建XMLHttpRequest对象,也就是创建一个异步调用对象.
 
(2)创建一个新的HTTP请求,并指定该HTTP请求的方法、URL及验证信息.
 
(3)设置响应HTTP请求状态变化的函数.
 
(4)发送HTTP请求.
 
(5)获取异步调用返回的数据.
 
(6)使用JavaScript和DOM实现局部刷新.
 

异步加载和延迟加载
1.异步加载的方案： 动态插入script标签
2.通过ajax去获取js代码，然后通过eval执行
3.script标签上添加defer或者async属性
4.创建并插入iframe，让它异步执行js
5.延迟加载：有些 js 代码并不是页面初始化的时候就立刻需要的，而稍后的某些情况才需要的。
前端安全问题？
    （XSS，sql注入，CSRF）
CSRF：是跨站请求伪造，很明显根据刚刚的解释，他的核心也就是请求伪造，通过伪造身份提交POST和GET请求来进行跨域的攻击。
 
**完成CSRF需要两个步骤：**
 
1.登陆受信任的网站A，在本地生成COOKIE
 
2.在不登出A的情况下，或者本地COOKIE没有过期的情况下，访问危险网站B。
ie各版本和chrome可以并行下载多少个资源
IE6 两个并发，iE7升级之后的6个并发，之后版本也是6个
 
Firefox，chrome也是6个
javascript里面的继承怎么实现，如何避免原型链上面的对象共享
用构造函数和原型链的混合模式去实现继承，避免对象共享可以参考经典的extend()函数，很多前端框架都有封装的，就是用一个空函数当做中间变量
grunt， YUI compressor 和 google clojure用来进行代码压缩的用法。
YUI Compressor 是一个用来压缩 JS 和 CSS 文件的工具，采用Java开发。
 
使用方法：
 
//压缩JS
java -jar yuicompressor-2.4.2.jar --type js --charset utf-8 -v src.js > packed.js
//压缩CSS
java -jar yuicompressor-2.4.2.jar --type css --charset utf-8 -v src.css > packed.css
 

Flash、Ajax各自的优缺点，在使用中如何取舍？
1、Flash ajax对比
Flash适合处理多媒体、矢量图形、访问机器；对CSS、处理文本上不足，不容易被搜索。
Ajax对CSS、文本支持很好，支持搜索；多媒体、矢量图形、机器访问不足。
共同点：与服务器的无刷新传递消息、用户离线和在线状态、操作DOM
请解释一下 JavaScript 的同源策略。
概念:同源策略是客户端脚本（尤其是Netscape Navigator2.0，其目的是防止某个文档或脚本从多个不同源装载。

这里的同源策略指的是：协议，域名，端口相同，同源策略是一种安全协议。
指一段脚本只能读取来自同一来源的窗口和文档的属性。

为什么要有同源限制？
我们举例说明：比如一个黑客程序，他利用Javascript读取到你的表单中 什么是 "use strict"; ? 使用它的好处和坏处分别是什么？

Javascript在更严格的条件下运行。

设立"严格模式"的目的，主要有以下几个：

- 消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为;
- 消除代码运行的一些不安全之处，保证代码运行的安全；
- 提高编译器效率，增加运行速度；
- 为未来新版本的Javascript做好铺垫。
注：经过测试 缺点：
现在网站的merge 后，这个串就到了文件的中间，不仅没有指示严格模式，反而在压缩后浪费了字节。

GET和POST的区别，何时使用POST？
    GET：一般用于信息获取，使用URL传递参数，对所发送信息的数量也有限制，一般在2000个字符
    POST：一般用于修改服务器上的资源，对所发送的信息没有限制。
 
    GET方式需要使用Request.QueryString来取得变量的值，而POST方式通过Request.Form来获取变量的值，
    也就是说Get是通过地址栏来传值，而Post是通过提交表单来传值。
 
然而，在以下情况中，请使用 POST 请求：
无法使用缓存文件（更新服务器上的文件或数据库）
向服务器发送大量数据（POST 没有数据量限制）
发送包含未知字符的用户输入时，POST 比 GET 更稳定也更可靠
哪些地方会出现css阻塞，哪些地方会出现js阻塞？
js的阻塞特性：所有浏览器在下载JS下载、解析、执行完毕后才开始继续JS，但是 由于浏览器为了防止出现DOM树，需要重新构建 嵌入JS只会阻塞其后内容的显示，2种方式都会阻塞其后资源的下载。也就是说外部样式不会阻塞外部脚本的加载，但会阻塞外部脚本的执行。

CSS本来是可以并行下载的，在什么情况下会出现阻塞加载了(在测试观察中，CSS都是阻塞加载）

当JS的时候，该JS放到 根本原因：因为浏览器会维持css和JS会阻塞后面的资源加载，所以就会出现上面 嵌入 1、放在底部，虽然放在底部照样会阻塞所有呈现，但不会阻塞资源下载。 2、如果嵌入JS放在head中，请把嵌入JS放在CSS头部。 3、使用defer（只支持IE） 4、不要在嵌入的JS中调用运行时间较长的函数，如果一定要用，可以用`setTimeout`来调用

Javascript无阻塞加载具体方式
将脚本放在底部。head中，用以保证在<script>标签放在前。
成组脚本：由于每个<script>总数也可以改善性能。适用于内联脚本和外部脚本。

前。
非阻塞脚本：等页面完成加载后，再加载window.onload事件发出后开始下载代码。
（1）fierfox3.5更高版本浏览器
（2）动态脚本元素：文档对象模型（DOM）允许你使用js动态创建 

<script>
var script=document.createElement("script");
script.type="text/javascript";
script.src="file.js";
document.getElementsByTagName("head")[0].appendChild(script);
</script>
此技术的重点在于：无论在何处启动下载，文件额下载和运行都不会阻塞其他页面处理过程。即使在head里（除了用于下载文件的http链接）。

闭包相关问题？
js事件处理程序问题？
eval是做什么的？
它的功能是把对应的字符串解析成JS代码并运行；
应该避免使用eval，不安全，非常耗性能（2次，一次解析成js语句，一次执行）。
写一个通用的事件侦听器函数?
// event(事件)工具集，来源：github/markyun
    markyun.Event = {
        // 页面加载完成后
        readyEvent : function(fn) {
            if (fn==null) {
                fn=document;
            }
            var oldonload = window.onload;
            if (typeof window.onload != 'function') {
                window.onload = fn;
            } else {
                window.onload = function() {
                    oldonload();
                    fn();
                };
            }
        },
        // 视能力分别使用dom0||dom2||IE方式 来绑定事件
        // 参数： 操作的元素,事件名称 ,事件处理程序
        addEvent : function(element, type, handler) {
            if (element.addEventListener) {
                //事件类型、需要执行的函数、是否捕捉
                element.addEventListener(type, handler, false);
            } else if (element.attachEvent) {
                element.attachEvent('on' + type, function() {
                    handler.call(element);
                });
            } else {
                element['on' + type] = handler;
            }
        },
        // 移除事件
        removeEvent : function(element, type, handler) {
            if (element.removeEnentListener) {
                element.removeEnentListener(type, handler, false);
            } else if (element.datachEvent) {
                element.detachEvent('on' + type, handler);
            } else {
                element['on' + type] = null;
            }
        }, 
        // 阻止事件 (主要是事件冒泡，因为IE不支持事件捕获)
        stopPropagation : function(ev) {
            if (ev.stopPropagation) {
                ev.stopPropagation();
            } else {
                ev.cancelBubble = true;
            }
        },
        // 取消事件的默认行为
        preventDefault : function(event) {
            if (event.preventDefault) {
                event.preventDefault();
            } else {
                event.returnValue = false;
            }
        },
        // 获取事件目标
        getTarget : function(event) {
            return event.target || event.srcElement;
        },
        // 获取event对象的引用，取到事件的所有信息，确保随时能使用event；
        getEvent : function(e) {
            var ev = e || window.event;
            if (!ev) {
                var c = this.getEvent.caller;
                while (c) {
                    ev = c.arguments[0];
                    if (ev && Event == ev.constructor) {
                        break;
                    }
                    c = c.caller;
                }
            }
            return ev;
        }
    }; 
Node.js的适用场景？
高并发、聊天、实时消息推送   
JavaScript原型，原型链 ? 有什么特点？
*  原型对象也是普通的对象，是对象一个自带隐式的 __proto__ 属性，原型也有可能有自己的原型，如果一个原型对象的原型不为null的话，我们就称之为原型链。
*  原型链是由一些用来继承和共享属性的对象组成的（有限的）对象链。
页面重构怎么操作？
编写 CSS、让页面结构更合理化，提升用户体验，实现良好的页面效果和提升性能。
WEB应用从服务器主动推送Data到客户端有那些方式？
html5 websoket
    WebSocket通过Flash
    XHR长时间连接
    XHR Multipart Streaming
    不可见的Iframe
    <script>标签的长时间连接(可跨域)
事件、IE与火狐的事件机制有什么区别？ 如何阻止冒泡？
 1. 我们在网页中的某个操作（有的操作对应多个事件）。例如：当我们点击一个按钮就会产生一个事件。是可以被 JavaScript 侦测到的行为。  
 2. 事件处理机制：IE是事件冒泡、firefox同时支持两种事件模型，也就是：捕获型事件和冒泡型事件。；
 3.  ev.stopPropagation();注意旧ie的方法 ev.cancelBubble = true;
ajax 是什么?ajax 的交互模型?同步和异步的区别?如何解决跨域问题?
1. 通过异步模式，提升了用户体验
 
  2. 优化了浏览器和服务器之间的传输，减少不必要的数据往返，减少了带宽占用
 
  3. Ajax在客户端运行，承担了一部分本来由服务器承担的工作，减少了大用户量下的服务器负载。
 
  2. Ajax的最大的特点是什么。
 
  Ajax可以实现动态不刷新（局部刷新）
  readyState属性 状态 有5个可取值： 0=未初始化 ，1=启动 2=发送，3=接收，4=完成
 
ajax的缺点
 
  1、ajax不支持浏览器back按钮。
 
  2、安全问题 AJAX暴露了与服务器交互的细节。
 
  3、对搜索引擎的支持比较弱。
 
  4、破坏了程序的异常机制。
 
  5、不容易调试。
 
跨域： jsonp、 iframe、window.name、window.postMessage、服务器上设置代理页面
js对象的深度克隆
  function clone(Obj) {   
        var buf;   
        if (Obj instanceof Array) {   
            buf = [];  //创建一个空的数组 
            var i = Obj.length;   
            while (i--) {   
                buf[i] = clone(Obj[i]);   
            }   
            return buf;   
        }else if (Obj instanceof Object){   
            buf = {};  //创建一个空对象 
            for (var k in Obj) {  //为这个对象添加新的属性 
                buf[k] = clone(Obj[k]);   
            }   
            return buf;   
        }else{   
            return Obj;   
        }   
    }  
AMD和CMD 规范的区别？
 

网站重构的理解？
网站重构：在不改变外部行为的前提下，简化结构、添加可读性，而在网站前端保持一致的行为。也就是说是在不改变UI的情况下，对网站进行优化，在扩展的同时保持一致的UI。
 
对于传统的网站来说重构通常是：
 
表格(table)布局改为DIV+CSS
使网站前端兼容于现代浏览器(针对于不合规范的CSS、如对IE6有效的)
对于移动平台的优化
针对于SEO进行优化
深层次的网站重构应该考虑的方面
 
减少代码间的耦合
让代码保持弹性
严格按规范编写代码
设计可扩展的API
代替旧有的框架、语言(如VB)
增强用户体验
通常来说对于速度的优化也包含在重构中
 
压缩JS、CSS、image等前端资源(通常是由服务器来解决)
程序的性能优化(如数据读写)
采用CDN来加速资源加载
对于JS DOM的优化
HTTP服务器的文件缓存
如何获取UA？
<script> 
    function whatBrowser() {  
        document.Browser.Name.value=navigator.appName;  
        document.Browser.Version.value=navigator.appVersion;  
        document.Browser.Code.value=navigator.appCodeName;  
        document.Browser.Agent.value=navigator.userAgent;  
    }  
</script>
js数组去重
以下是数组去重的三种方法：

Array.prototype.unique1 = function () {
  var n = []; //一个新的临时数组
  for (var i = 0; i < this.length; i++) //遍历当前数组
  {
    //如果当前数组的第i已经保存进了临时数组，那么跳过，
    //否则把当前项push到临时数组里面
    if (n.indexOf(this[i]) == -1) n.push(this[i]);
  }
  return n;
}
 
Array.prototype.unique2 = function()
{
    var n = {},r=[]; //n为hash表，r为临时数组
    for(var i = 0; i < this.length; i++) //遍历当前数组
    {
        if (!n[this[i]]) //如果hash表中没有当前项
        {
            n[this[i]] = true; //存入hash表
            r.push(this[i]); //把当前数组的当前项push到临时数组里面
        }
    }
    return r;
}
 
Array.prototype.unique3 = function()
{
    var n = [this[0]]; //结果数组
    for(var i = 1; i < this.length; i++) //从第二项开始遍历
    {
        //如果当前数组的第i项在当前数组中第一次出现的位置不是i，
        //那么表示第i项是重复的，忽略掉。否则存入结果数组
        if (this.indexOf(this[i]) == i) n.push(this[i]);
    }
    return n;
}
HTTP状态码
100  Continue  继续，一般在发送post请求时，已发送了http header之后服务端将返回此信息，表示确认，之后发送具体参数信息
200  OK   正常返回信息
201  Created  请求成功并且服务器创建了新的资源
202  Accepted  服务器已接受请求，但尚未处理
301  Moved Permanently  请求的网页已永久移动到新位置。
302 Found  临时性重定向。
303 See Other  临时性重定向，且总是使用 GET 请求新的 URI。
304  Not Modified  自从上次请求后，请求的网页未修改过。
 
400 Bad Request  服务器无法理解请求的格式，客户端不应当尝试再次使用相同的内容发起请求。
401 Unauthorized  请求未授权。
403 Forbidden  禁止访问。
404 Not Found  找不到如何与 URI 相匹配的资源。
 
500 Internal Server Error  最常见的服务器端错误。
503 Service Unavailable 服务器端暂时无法处理请求（可能是过载或维护）。
cache-control
网页的缓存是由HTTP消息头中的private、no-cache、max-age、must-revalidate等，默认为 max-age的效果。但是如果同时存在，则被max-age覆盖。

Expires = "Expires" ":" HTTP-date
例如

Expires: Thu, 01 Dec 1994 16:00:00 GMT （必须是GMT格式）
如果把它设置为 max-age都可以用来指定文档的过期时间，但是二者有一些细微差别

1.Expires在HTTP/1.0中已经定义，Cache-Control:max-age在HTTP/1.1中才有定义，为了向下兼容，仅使用max-age不够；
2.Expires指定一个绝对的过期时间(GMT格式),这么做会导致至少2个问题：1)客户端和服务器时间不同步导致Expires的配置出现问题。 2）很容易在配置后忘记具体的过期时间，导致过期来临出现浪涌现象；
 
3.max-age 指定的是从文档被访问后的存活时间，这个时间是个相对值(比如:3600s),相对的是文档第一次被请求时服务器记录的Request_time(请求时间)
 
4.Expires指定的时间可以是相对文件的最后访问时间(Atime)或者修改时间(MTime),而max-age相对对的是文档的请求时间(Atime)
 
如果值为no-cache,那么每次都会访问服务器。如果值为max-age,则在过期之前不会重复访问服务器。
js操作获取和设置cookie
//创建cookie
function setCookie(name, value, expires, path, domain, secure) {
    var cookieText = encodeURIComponent(name) + '=' + encodeURIComponent(value);
    if (expires instanceof Date) {
        cookieText += '; expires=' + expires;
    }
    if (path) {
        cookieText += '; expires=' + expires;
    }
    if (domain) {
        cookieText += '; domain=' + domain;
    }
    if (secure) {
        cookieText += '; secure';
    }
    document.cookie = cookieText;
}
 
//获取cookie
function getCookie(name) {
    var cookieName = encodeURIComponent(name) + '=';
    var cookieStart = document.cookie.indexOf(cookieName);
    var cookieValue = null;
    if (cookieStart > -1) {
        var cookieEnd = document.cookie.indexOf(';', cookieStart);
        if (cookieEnd == -1) {
            cookieEnd = document.cookie.length;
        }
 

 

 

Vue面试中，经常会被问到的面试题/Vue知识点整理

一、对于MVVM的理解？

MVVM 是 Model-View-ViewModel 的缩写。
Model代表数据模型，也可以在Model中定义数据修改和操作的业务逻辑。
View 代表UI 组件，它负责将数据模型转化成UI 展现出来。
ViewModel 监听模型数据的改变和控制视图行为、处理用户交互，简单理解就是一个同步View 和 Model的对象，连接Model和View。
在MVVM架构下，View 和 Model 之间并没有直接的联系，而是通过ViewModel进行交互，Model 和 ViewModel 之间的交互是双向的， 因此View 数据的变化会同步到Model中，而Model 数据的变化也会立即反应到View 上。
ViewModel 通过双向数据绑定把 View 层和 Model 层连接了起来，而View 和 Model 之间的同步工作完全是自动的，无需人为干涉，因此开发者只需关注业务逻辑，不需要手动操作DOM, 不需要关注数据状态的同步问题，复杂的数据状态维护完全由 MVVM 来统一管理。

二、Vue的生命周期

beforeCreate（创建前） 在数据观测和初始化事件还未开始
created（创建后） 完成数据观测，属性和方法的运算，初始化事件，$el属性还没有显示出来
beforeMount（载入前） 在挂载开始之前被调用，相关的render函数首次被调用。实例已完成以下的配置：编译模板，把data里面的数据和模板生成html。注意此时还没有挂载html到页面上。
mounted（载入后） 在el 被新创建的 vm.$el 替换，并挂载到实例上去之后调用。实例已完成以下的配置：用上面编译好的html内容替换el属性指向的DOM对象。完成模板中的html渲染到html页面中。此过程中进行ajax交互。
beforeUpdate（更新前） 在数据更新之前调用，发生在虚拟DOM重新渲染和打补丁之前。可以在该钩子中进一步地更改状态，不会触发附加的重渲染过程。
updated（更新后） 在由于数据更改导致的虚拟DOM重新渲染和打补丁之后调用。调用时，组件DOM已经更新，所以可以执行依赖于DOM的操作。然而在大多数情况下，应该避免在此期间更改状态，因为这可能会导致更新无限循环。该钩子在服务器端渲染期间不被调用。
beforeDestroy（销毁前） 在实例销毁之前调用。实例仍然完全可用。
destroyed（销毁后） 在实例销毁之后调用。调用后，所有的事件监听器会被移除，所有的子实例也会被销毁。该钩子在服务器端渲染期间不被调用。
1.什么是vue生命周期？
答： Vue 实例从创建到销毁的过程，就是生命周期。从开始创建、初始化数据、编译模板、挂载Dom→渲染、更新→渲染、销毁等一系列过程，称之为 Vue 的生命周期。

2.vue生命周期的作用是什么？
答：它的生命周期中有多个事件钩子，让我们在控制整个Vue实例的过程时更容易形成好的逻辑。

3.vue生命周期总共有几个阶段？
答：它可以总共分为8个阶段：创建前/后, 载入前/后,更新前/后,销毁前/销毁后。

4.第一次页面加载会触发哪几个钩子？
答：会触发 下面这几个beforeCreate, created, beforeMount, mounted 。

5.DOM 渲染在 哪个周期中就已经完成？
答：DOM 渲染在 mounted 中就已经完成了。

三、 Vue实现数据双向绑定的原理：Object.defineProperty（）

vue实现数据双向绑定主要是：采用数据劫持结合发布者-订阅者模式的方式，通过Object.defineProperty（）来劫持各个属性的setter，getter，在数据变动时发布消息给订阅者，触发相应监听回调。当把一个普通 Javascript 对象传给 Vue 实例来作为它的 data 选项时，Vue 将遍历它的属性，用 Object.defineProperty 将它们转为 getter/setter。用户看不到 getter/setter，但是在内部它们让 Vue 追踪依赖，在属性被访问和修改时通知变化。

vue的数据双向绑定 将MVVM作为数据绑定的入口，整合Observer，Compile和Watcher三者，通过Observer来监听自己的model的数据变化，通过Compile来解析编译模板指令（vue中是用来解析 {{}}），最终利用watcher搭起observer和Compile之间的通信桥梁，达到数据变化 —>视图更新；视图交互变化（input）—>数据model变更双向绑定效果。

js实现简单的双向绑定

<body>
    <div id="app">
    <input type="text" id="txt">
    <p id="show"></p>
</div>
</body>
<script type="text/javascript">
    var obj = {}
    Object.defineProperty(obj, 'txt', {
        get: function () {
            return obj
        },
        set: function (newValue) {
            document.getElementById('txt').value = newValue
            document.getElementById('show').innerHTML = newValue
        }
    })
    document.addEventListener('keyup', function (e) {
        obj.txt = e.target.value
    })
</script>

四、Vue组件间的参数传递

1.父组件与子组件传值
父组件传给子组件：子组件通过props方法接受数据;
子组件传给父组件：$emit方法传递参数
2.非父子组件间的数据传递，兄弟组件传值
eventBus，就是创建一个事件中心，相当于中转站，可以用它来传递事件和接收事件。项目比较小时，用这个比较合适。（虽然也有不少人推荐直接用VUEX，具体来说看需求咯。技术只是手段，目的达到才是王道。）

五、Vue的路由实现：hash模式 和 history模式

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

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

六、Vue与Angular以及React的区别？

（版本在不断更新，以下的区别有可能不是很正确。我工作中只用到vue，对angular和react不怎么熟）
1.与AngularJS的区别
相同点：
都支持指令：内置指令和自定义指令；都支持过滤器：内置过滤器和自定义过滤器；都支持双向数据绑定；都不支持低端浏览器。

不同点：
AngularJS的学习成本高，比如增加了Dependency Injection特性，而Vue.js本身提供的API都比较简单、直观；在性能上，AngularJS依赖对数据做脏检查，所以Watcher越多越慢；Vue.js使用基于依赖追踪的观察并且使用异步队列更新，所有的数据都是独立触发的。

2.与React的区别
相同点：
React采用特殊的JSX语法，Vue.js在组件开发中也推崇编写.vue特殊文件格式，对文件内容都有一些约定，两者都需要编译后使用；中心思想相同：一切都是组件，组件实例之间可以嵌套；都提供合理的钩子函数，可以让开发者定制化地去处理需求；都不内置列数AJAX，Route等功能到核心包，而是以插件的方式加载；在组件开发中都支持mixins的特性。
不同点：
React采用的Virtual DOM会对渲染出来的结果做脏检查；Vue.js在模板中提供了指令，过滤器等，可以非常方便，快捷地操作Virtual DOM。

七、vue路由的钩子函数

首页可以控制导航跳转，beforeEach，afterEach等，一般用于页面title的修改。一些需要登录才能调整页面的重定向功能。

beforeEach主要有3个参数to，from，next：

to：route即将进入的目标路由对象，

from：route当前导航正要离开的路由

next：function一定要调用该方法resolve这个钩子。执行效果依赖next方法的调用参数。可以控制网页的跳转。

八、vuex是什么？怎么使用？哪种功能场景使用它？

只用来读取的状态集中放在store中； 改变状态的方式是提交mutations，这是个同步的事物； 异步逻辑应该封装在action中。
在main.js引入store，注入。新建了一个目录store，….. export 。
场景有：单页应用中，组件之间的状态、音乐播放、登录状态、加入购物车

state
Vuex 使用单一状态树,即每个应用将仅仅包含一个store 实例，但单一状态树和模块化并不冲突。存放的数据状态，不可以直接修改里面的数据。
mutations
mutations定义的方法动态修改Vuex 的 store 中的状态或数据。
getters
类似vue的计算属性，主要用来过滤一些数据。
action
actions可以理解为通过将mutations里面处里数据的方法变成可异步的处理数据的方法，简单的说就是异步操作数据。view 层通过 store.dispath 来分发 action。

const store = new Vuex.Store({ //store实例
      state: {
         count: 0
             },
      mutations: {                
         increment (state) {
          state.count++
         }
          },
      actions: { 
         increment (context) {
          contextmit('increment')
   }
 }
})

modules
项目特别复杂的时候，可以让每一个模块拥有自己的state、mutation、action、getters,使得结构非常清晰，方便管理。

const moduleA = {
  state: { ... },
  mutations: { ... },
  actions: { ... },
  getters: { ... }
 }
const moduleB = {
  state: { ... },
  mutations: { ... },
  actions: { ... }
 }

const store = new Vuex.Store({
  modules: {
    a: moduleA,
    b: moduleB
})

九、vue-cli如何新增自定义指令？

1.创建局部指令

var app = new Vue({
    el: '#app',
    data: {    
    },
    // 创建指令(可以多个)
    directives: {
        // 指令名称
        dir1: {
            inserted(el) {
                // 指令中第一个参数是当前使用指令的DOM
                console.log(el);
                console.log(arguments);
                // 对DOM进行操作
                el.style.width = '200px';
                el.style.height = '200px';
                el.style.background = '#000';
            }
        }
    }
})

2.全局指令

Vue.directive('dir2', {
    inserted(el) {
        console.log(el);
    }
})

3.指令的使用

<div id="app">
    <div v-dir1></div>
    <div v-dir2></div>
</div>

十、vue如何自定义一个过滤器？

html代码：

<div id="app">
     <input type="text" v-model="msg" />
     {{msg| capitalize }}
</div>

JS代码：

var vm=new Vue({
    el:"#app",
    data:{
        msg:''
    },
    filters: {
      capitalize: function (value) {
        if (!value) return ''
        value = value.toString()
        return value.charAt(0).toUpperCase() + value.slice(1)
      }
    }
})

全局定义过滤器

Vue.filter('capitalize', function (value) {
  if (!value) return ''
  value = value.toString()
  return value.charAt(0).toUpperCase() + value.slice(1)
})

过滤器接收表达式的值 (msg) 作为第一个参数。capitalize 过滤器将会收到 msg的值作为第一个参数。

十一、对keep-alive 的了解？

keep-alive是 Vue 内置的一个组件，可以使被包含的组件保留状态，或避免重新渲染。
在vue 2.1.0 版本之后，keep-alive新加入了两个属性: include(包含的组件缓存) 与 exclude(排除的组件不缓存，优先级大于include) 。

使用方法

<keep-alive include='include_components' exclude='exclude_components'>
  <component>
    <!-- 该组件是否缓存取决于include和exclude属性 -->
  </component>
</keep-alive>

参数解释
include - 字符串或正则表达式，只有名称匹配的组件会被缓存
exclude - 字符串或正则表达式，任何名称匹配的组件都不会被缓存
include 和 exclude 的属性允许组件有条件地缓存。二者都可以用“，”分隔字符串、正则表达式、数组。当使用正则或者是数组时，要记得使用v-bind 。

使用示例

<!-- 逗号分隔字符串，只有组件a与b被缓存。 -->
<keep-alive include="a,b">
  <component></component>
</keep-alive>

<!-- 正则表达式 (需要使用 v-bind，符合匹配规则的都会被缓存) -->
<keep-alive :include="/a|b/">
  <component></component>
</keep-alive>

<!-- Array (需要使用 v-bind，被包含的都会被缓存) -->
<keep-alive :include="['a', 'b']">
  <component></component>
</keep-alive>

十二、一句话就能回答的面试题

1.css只在当前组件起作用
答：在style标签中写入scoped即可 例如：<style scoped></style>

2.v-if 和 v-show 区别
答：v-if按照条件是否渲染，v-show是display的block或none；

3.和router的区别
答：是路由信息对象，包括，，，，，，等路由信息参数。而router是“路由实例”对象包括了路由的跳转方法，钩子函数等。

4.vue.js的两个核心是什么？
答：数据驱动、组件系统

5.vue几种常用的指令
答：v-for 、 v-if 、v-bind、v-on、v-show、v-else

6.vue常用的修饰符？
答：.prevent: 提交事件不再重载页面；.stop: 阻止单击事件冒泡；.self: 当事件发生在该元素本身而不是子元素的时候会触发；.capture: 事件侦听，事件发生的时候会调用

7.v-on 可以绑定多个方法吗？
答：可以

8.vue中 key 值的作用？
答：当 Vue.js 用 v-for 正在更新已渲染过的元素列表时，它默认用“就地复用”策略。如果数据项的顺序被改变，Vue 将不会移动 DOM 元素来匹配数据项的顺序， 而是简单复用此处每个元素，并且确保它在特定索引下显示已被渲染过的每个元素。key的作用主要是为了高效的更新虚拟DOM。

9.什么是vue的计算属性？
答：在模板中放入太多的逻辑会让模板过重且难以维护，在需要对数据进行复杂处理，且可能多次使用的情况下，尽量采取计算属性的方式。好处：①使得数据处理结构清晰；②依赖于数据，数据更新，处理结果自动更新；③计算属性内部this指向vm实例；④在template调用时，直接写计算属性名即可；⑤常用的是getter方法，获取数据，也可以使用set方法改变数据；⑥相较于methods，不管依赖的数据变不变，methods都会重新计算，但是依赖数据不变的时候computed从缓存中获取，不会重新计算。

10.vue等单页面应用及其优缺点
答：优点：Vue 的目标是通过尽可能简单的 API 实现响应的数据绑定和组合的视图组件，核心是一个响应的数据绑定系统。MVVM、数据驱动、组件化、轻量、简洁、高效、快速、模块友好。
缺点：不支持低版本的浏览器，最低只支持到IE9；不利于SEO的优化（如果要支持SEO，建议通过服务端来进行渲染组件）；第一次加载首页耗时相对长一些；不可以使用浏览器的导航按钮需要自行实现前进、后退。

11.怎么定义 vue-router 的动态路由? 怎么获取传过来的值
答：在 router 目录下的 index.js 文件中，对 path 属性加上 /:id，使用 router 对象的 params.id 获取。

 

一）vue router 跳转方式

1.this.$router.push() 

跳转到不同的url，但这个方法会向history栈添加一个记录，点击后退会返回到上一个页面。

1.  this.$router.push({path: '/home/sort/detail',query:{id: 'abc'}})     

    获取参数 {{this.$route.query.userId}}

2.  this.$router.push({name: 'detail',params:{id: 'abc'}})
   获取参数：{{this.$route.params.userId}}

ps:

query和params 的区别：

1.用法上

query要用path来引入，params要用name来引入：eg

this.$router.push({
   name:"detail",
   params:{
    name:'nameValue',
    code:10011
 }
});

2.展示上的

　　query更加类似于我们ajax中get传参，params则类似于post，说的再简单一点，前者在浏览器地址栏中显示参数，后者则不显示

2.this.$router.replace()

同样是跳转到指定的url，但是这个方法不会向history里面添加新的记录，点击返回，会跳转到上上一个页面。上一个记录是不存在的。

3.this.$router.go(n)

相对于当前页面向前或向后跳转多少个页面,类似 window.history.go(n)。n可为正数可为负数。正数返回上一个页面

4.声明式：

1) 根据路由路径（/home/sort/detail）跳转 <router-link :to="{path: '/home/sort/detail', query:{id: 'abc'}}">点击查看子页面</router-link>

2) 根据路由名称（detail）跳转 <router-link :to="{name: 'detail', params:{id: 'abc'}}">点击查看子页面</router-link>    :to="" 可以实现绑定动态的 路由 和 参数

 

二）Cookie和localStorage、sessionStorage的区别

名称	cookie	localStorage	sessionStorage
相同点	都可以用来在浏览器端存储数据，都是字符串的键值对
数据声明周期	一般由服务器生成，可设置失效时间；若在浏览器生成，默认关闭浏览器之后失效	除非被清除，否则永久有效	仅对当前对话有效，关闭当前页面或者浏览器后被清除
存储大小	4kb	一般5mb
与服务端通信	每次都会携带在http请求头中，如果使用cookie保存过多，性能不太好	仅在客户端存储，不参与服务端通信
用途	一般由服务器生成，来标识用户身份	勇于浏览器端缓存数据

三）数组相关

参考文章数组相关：https://wwwblogs/jiajiamiao/p/11641574.html

四）let var const 的区别

1：var  全局变量，存在变量提升，在声明前取值为undefined 会挂载在window上 如：
var a = 1;
console.log(a,window.a) // 1 1
2：let 声明局部变量，只在块级作用域内有效
console.log(b); // 报错：b在初始化之前不能接收
let b = 10;
var a = [];

for (var i = 0; i < 10; i++) {  
    a[i] = function () { 
       console.log(i);  
    };
}
a[2]();    //10

var b = []; 
for (let k = 0; k < 10; k++) {  
    b[k] = function () { 
        console.log(k);  
    };
}
b[2]();     //2
3：const 声名的是常量，一经声明不可改变。但是引用类型的对象和数组可以改变：
const person = {
     name : 'jony',
     sex : '男'
 }
 person.name = '九九'
 
 console.log(person.name)   //九九

ps//因为对象是引用类型的，person中保存的仅是对象的指针，这就意味着，const仅保证指针不发生改变，修改对象的属性不会改变对象的指针，所以是被允许的。也就是说const定义的引用类型只要指针不发生改变，其他的不论如何改变都是允许的。

五）vue的常用指令有哪些？

 

v-for 循环 ps：如果list是对象，还有value,key属性，如v-for="（value,key,index） in list";
v-for 中key必须为唯一的 作用是：主要是为了高效的更新虚拟DOM

v-bind 绑定属性 简写： v-bind:属性名="常量 || 变量名"

v-on 绑定时间 简写@  v-on:click = "方法名 || 直接改变 vue 内部变量"

双向绑定:v-model   所谓的双向绑定，就是你在视图层里面改变了值，vue里面对应的值也会改变。只能给具备value属性的元素进行双向数据绑定。

v-html  插入HMTL

v-text   插入文本

条件渲染： v-if   v-show
v-show 本质就是标签display设置为none，控制隐藏
v-if   是动态的向DOM树内添加或者删除DOM元素
从性能上来说：
v-show只编译一次，后面其实就是控制css，而v-if不停的销毁和创建，故v-show性能更好一点

 

六）Ajax请求原理解析

1：创建XMLHttpRequest对象

var xhr;
if(XMLHttpRequest){
xhr = new XMLHttpRequest();
}else{
xhr = new ActiveXObject("Microsoft.XMLHTTP");
}

2：准备请求

xhr.open(method,url,async);
method：get   post
url：请求地址
async：true异步 false同步

3：发送请求

xhr.send();
get ：xhr.open("GET",url,true);
xhr.send(null);

post:
xhr.open("POST",url,true);
xhr.setRequestHeder("Content-Type","application/x-www-form-urlencoded;charset=UTF-8");   //规定表头
xhr.send("name="+userName+"&age="+userAge);//参数

4：处理响应

xhr.onreadystatechange = function(){
  if(xhr.readyState == 4 && xhr.status == 200){
    console.log(“响应成功成功”，xhr.responseText);
  }
}

七）get和post请求的区别

 

八）从输入url到页面加载完成发生了什么？——前端角度

1、浏览器的地址栏输入URL并按下回车。
2、浏览器查找当前URL的DNS缓存记录。
3、DNS解析URL对应的IP。
4、根据IP建立TCP连接（三次握手）。
5、HTTP发起请求。
6、服务器处理请求，浏览器接收HTTP响应。
7、渲染页面，构建DOM树。
8、关闭TCP连接（四次挥手）

参考博客：https://wwwblogs/daijinxue/p/6640153.html

 九）http和https的区别

Http：超文本传输协议（Http，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议。设计Http最初的目的是为了提供一种发布和接收HTML页面的方法。它可以使浏览器更加高效。Http协议是以明文方式发送信息的，如果黑客截取了Web浏览器和服务器之间的传输报文，就可以直接获得其中的信息。

Https：是以安全为目标的Http通道，是Http的安全版。Https的安全基础是SSL。SSL协议位于TCP/IP协议与各种应用层协议之间，为数据通讯提供安全支持。SSL协议可分为两层：SSL记录协议（SSL Record Protocol），它建立在可靠的传输协议（如TCP）之上，为高层协议提供数据封装、压缩、加密等基本功能的支持。SSL握手协议（SSL Handshake Protocol），它建立在SSL记录协议之上，用于在实际的数据传输开始前，通讯双方进行身份认证、协商加密算法、交换加密密钥等。

HTTP与HTTPS的区别

1、HTTP是超文本传输协议，信息是明文传输，HTTPS是具有安全性的SSL加密传输协议。

2、HTTPS协议需要ca申请证书，一般免费证书少，因而需要一定费用。

3、HTTP和HTTPS使用的是完全不同的连接方式，用的端口也不一样。前者是80，后者是443。

4、HTTP连接是无状态的，HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，安全性高于HTTP协议。

https的优点

尽管HTTPS并非绝对安全，掌握根证书的机构、掌握加密算法的组织同样可以进行中间人形式的攻击，但HTTPS仍是现行架构下最安全的解决方案，主要有以下几个好处：

1）使用HTTPS协议可认证用户和服务器，确保数据发送到正确的客户机和服务器；

2）HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全，可防止数据在传输过程中不被窃取、改变，确保数据的完整性。

3）HTTPS是现行架构下最安全的解决方案，虽然不是绝对安全，但它大幅增加了中间人攻击的成本。

4）谷歌曾在2014年8月份调整搜索引擎算法，并称“比起同等HTTP网站，采用HTTPS加密的网站在搜索结果中的排名将会更高”。

Https的缺点

1）Https协议握手阶段比较费时，会使页面的加载时间延长近。

2）Https连接缓存不如Http高效，会增加数据开销，甚至已有的安全措施也会因此而受到影响；

3）SSL证书通常需要绑定IP，不能在同一IP上绑定多个域名，IPv4资源不可能支撑这个消耗。

4）Https协议的加密范围也比较有限。最关键的，SSL证书的信用链体系并不安全，特别是在某些国家可以控制CA根证书的情况下，中间人攻击一样可行。

十）json和xml数据的区别

1，数据体积方面：xml是重量级的，json是轻量级的，传递的速度更快些。。

2，数据传输方面：xml在传输过程中比较占带宽，json占带宽少，易于压缩。

3，数据交互方面：json与javascript的交互更加方便，更容易解析处理，更好的进行数据交互

4，数据描述方面：json对数据的描述性比xml较差

5，xml和json都用在项目交互下，xml多用于做配置文件，json用于数据交互。

十一）svg和canvas的区别

cancas：

   通过js来绘制2D图形  逐像素渲染的    canvas中，一旦图形被绘制完成，他就不会继续得到浏览器的关注，如果他的位置变化，那么就需要重新来绘制图形，其中包括任何或者已经被图形覆盖的对象。

svg：

      svg是xml描述的2D图形    svg是基于xml的，也就是svg dom中的每个元素都是可用的，可以为某个元素附加js事件处理器。     在svg中，每个被绘制的图像均视为对象，如果svg对象的属性变化，那么浏览器可以自行重现图形。

区别：

canvas       

　　a：依赖分辨率

　　b：不支持事件处理器

　　c:  弱的文本渲染能力

　　d：能够以.jpg或者.png格式保存结果图像

　　e：最适合图像密集型的游戏，其中的很多对象会被频繁的绘制

svg

　　a：不依赖分辨率

　　b: 支持事件处理器

　　c: 最适合带有大型渲染区域的应用程序（谷歌地图）

　　d: 复杂度高会减慢渲染速度

　　e：不适合游戏应用

十二）不知宽高的盒子如何居中

 1 <div class="warp"><div class="box"></div></div>
 2 
 3 1)display:flex
 4 .warp{display:flex;   justify-content:center;  align-item:center;}
 5 
 6 2).warp{position:relative;}
 7 .box{position:absolute; left:50%; right:50%;  transform:translate(-50%,-50%)}
 8 
 9 3).warp{position:relative;}
10 .box{position:absolute; left:0; right:0; top:0; bottom:0; 
11  margin:auto;}
12 
13 4).warp{display：table；}
14 .box{display:table-cell; text-align:center; vertical-align:middle; }

十三）computed和watch的区别

computed

计算结果并返回，只有当被计算的属性发生改变时才会触发（即：计算属性的结果会被缓存，除非依赖的响应属性变化才会重新及孙）

watch

 监听某一个值，当被监听的值发生变化时，执行相关操作。（与computed的区别是，watch更加适用于监听某一个值得变化，并做对应操作，比如请求后太接口等。而computed适用于计算已有的值并返回结果。）

监听简单数据类型：

 

data(){
      return{
        'first':2
      }
    },
    watch:{
      first(){
        console.log(this.first)
      }
    },

 

监听复杂数据类型：

 

data(){
      return{
        'first':{
          second:0
        }
      }
    },
    watch:{
      secondChange:{
        handler(oldVal,newVal){
          console.log(oldVal)
          console.log(newVal)
        },
        deep:true
      }
    },

 

十四）vue的生命周期

Vue 实例有一个完整的生命周期，也就是从开始创建、初始化数据、编译模板、挂载Dom→渲染、更新→渲染、卸载等一系列过程，我们称这是 Vue 的生命周期。通俗说就是 Vue 实例从创建到销毁的过程，就是生命周期。

beforeCreate: vue元素的挂载元素el和数据都为undefined，还未初始化；

 

 

created：vue实例的数据对象data有了，el还没有；

beforeMount：vue实例的$el和data都初始化了，但是还挂载在之前的虚拟dom节点上，data.message还未替换；

mounted：vue实例挂载完成，data.message成功渲染。

更新前后：data变化时会触发beforeUpdate和updated方法；

销毁前后：beforeDestory和destoryed，在执行destoryed方法后，对data的改变不会触发周期函数，说明vue实例已经解除了事件监听以及dom绑定，但是dom结构依然存在；

vue生命周期的作用：

他的生命周期中有多个事件钩子，让我们控制整个vue实例的过程时更容易形成良好的逻辑。

生命周期钩子的一些使用方法：

beforeCreate：loading事件，在加载实例时触发。

created：初始化完成事件，异步请求。

mounted：挂载元素，获取dom节点

uptaded：对数据统一处理

beforeDestory：确认事件停止。

nextTick：更新数据后立即操作dom。

十五）vuex如何实现按需加载配合webpack配置

webpack中提供了require.ensure()来实现按需加载。以前引入路由是通过import 这样的方式引入，改为const定义的方式进行引入。

        不进行页面按需加载引入方式：import  home   from '../../common/home.vue'

        进行页面按需加载的引入方式：const  home = r => require.ensure( [], () => r (require('../../common/home.vue')))

十六）vue-router有哪几种导航守卫

1》全局守卫

a：router.beforeEach 全局前置守卫，进入路由之前

b：router.beforResolve 全局解析守卫，在beforeRouterEnter调用之后调用

c：router.afterEach 全局后置钩子，进入路由之后

 

//main.js  入口文件
import router from ’./router‘
router.beforeEach(to,from,next)=>{
    next();
}

router.beforeResolve(to,from,next)=>{
    next();
}

router.afterEach(to,from)=>{
    console.log('全局后置钩子')
}

 

2》路由独享守卫

如果不想全局配置守卫的话，可以为某些路由单独配置守卫

 

{
    path: '/home',
    name: 'home',
    component: Home,
    beforeEnter(to, from, next) {
        if (window.localStorage.getItem("id")) {
            next()
        } else {
            next({ name: "login" })
        }
    }
}

 

 

 

3》路由组件内的守卫

 

beforeRouteEnter 进入路由前, 在路由独享守卫后调用 不能 获取组件实例 this，组件实例还没被创建

 

beforeRouteUpdate (2.2) 路由复用同一个组件时, 在当前路由改变，但是该组件被复用时调用 可以访问组件实例 this

 

beforeRouteLeave 离开当前路由时, 导航离开该组件的对应路由时调用，可以访问组件实例 this

 

 

beforeRouteEnter(to, from, next) {
    // do someting
    // 在渲染该组件的对应路由被 confirm 前调用
},
beforeRouteUpdate(to, from, next) {
    // do someting
    // 在当前路由改变，但是依然渲染该组件是调用
},
beforeRouteLeave(to, from ,next) {
    // do someting
    // 导航离开该组件的对应路由时被调用
}

 十七）this--------参考https://github/koala-coding/goodBlog/blob/master/docs/javascript/this.md

默认绑定：

默认绑定是函数针对的独立调用的时候，不带任何修饰的函数引用进行调用，非严格模式下 this 指向全局对象(浏览器下指向 Window，Node.js 环境是 Global ），严格模式下，this 绑定到 undefined ,严格模式不允许this指向全局对象。

var  a = 'hello'

var obj =
 {
    a:'koala',
    foo: function(){
        console.log(this.a)    
    }
}

var  bar = obj.foo
bar()              
// 浏览器中输出: "hello"

这段代码， bar()就是默认绑定，函数调用的时候，前面没有任何修饰调用，也可以用之前的 call函数调用形式理解，所以输出结果是 hello。

默认绑定的另一种情况

在函数中以函数作为参数传递，例如 setTimeOut和 setInterval等，这些函数中传递的函数中的 this指向，在非严格模式指向的是全局对象。

var name='koala';
  var person2 ={
        name:'程序员成长指北',
      sayHi:sayHi
      }
  function sayHi() {
      console.log('Hello,',this.name);
    }
  setTimeout(function() {
      person2.sayHi();
  },200);
  // 输出结果 Hello,koala

隐式绑定

判断 this 隐式绑定的基本标准:函数调用的时候是否在上下文中调用，或者说是否某个对象调用函数

var name='koala';
  var person2 ={
        name:'程序员成长指北',
        sayHi:function{
　　　　　　　console.log('Hello,',this.name);
        }
      }

  person2.sayHi(); // 浏览器中输出: "程序员成长指北"

sayHi方法是作为对象的属性调用的，那么此时 foo 方法执行时，this 指向person2对象。

隐式绑定的另一种情况

当有多层对象嵌套调用某个函数的时候，如 对象.对象.函数,this 指向的是最后一层对象。

var person2 ={
        name:'程序员成长指北',
      sayHi:sayHi
      }
  function sayHi() {
      console.log('Hello,',this.name);
    }
    var
  var person1 ={
    name:'koala',
    friend:person2
    }
  person1.friend.sayHi();  
// 输出结果为 Hello, 程序员成长指北

显式绑定

显式绑定，通过函数call apply bind 可以修改函数this的指向。call 与 apply 方法都是挂载在 Function 原型下的方法，所有的函数都能使用。

call 和 apply 的区别

1,call和apply的第一个参数会绑定到函数体的this上，如果 不传参数，例如 fun.call()，非严格模式，this默认还是绑定到全局对象

2.call函数接收的是一个参数列表，apply函数接收的是一个参数数组。

var person ={
  "name":"koala"
};
function changeJob(company,work){
    thispany = company;
    this.work    = work;
};
changeJob.call(person,'百度','程序员');
console.log(person.work);
// '程序员'
changeJob.apply(person,['百度', '测试']);
console.log(person.work);
//测试

call和apply的注意点

这两个方法在调用的时候，如果我们传入数字或者字符串，这两个方法会把传入的参数转成对象类型。

var number = 1 , string = '程序员成长指北';
function getThisType(){
    var number = 3;
    console.log('this指向内容',this);
    console.log(typeof(this))
}
getThisType.call(number)
getThisType.apply(string)
 
// 输出结果
// this指向内容 [Number: 1]
// object
// this指向内容 [String: '程序员成长指北']
// objec

bind函数      bind 方法 会创建一个新函数。当这个新函数被调用时，bind() 的第一个参数将作为它运行时的 this，之后的一序列参数将会在传递的实参前传入作为它的参数。(定义内容来自于 MDN )

bind函数      bind 方法 会创建一个新函数。当这个新函数被调用时，bind() 的第一个参数将作为它运行时的 this，之后的一序列参数将会在传递的实参前传入作为它的参数。(定义内容来自于 MDN )
var publicAccounts = {
  name:'测试11111',
  author:'hoster',
  subscribe:function(subscriber){
    console.log(subscriber+this.name)
  }

}
publicAccounts.subscribe('aa') 
//"aa 测试11111"

var subscribe1 = publicAccounts.subscribe.bind({name:'测试bbb',author:'持有者'},'bb')
subscribe1()//bb测试bbb

new 绑定

使用new调用函数的时候，会执行怎样的流程：

1.创建一个空对象

2.将空对象的 proto 指向原对象的 prototype

3.执行构造函数中的代码

4.返回这个新对象

function demo(name){
  this.name = name
}
var demoNew = new demo('妹妹')；
console.log(demoNew);
console.log(demoNew.name)
//demo {name: "妹妹"}
//妹妹

在 new Demo('妹妹')的时候，会改变this指向，将 this指向指定到了studyDay对象。注意:如果创建新的对象，构造函数不传值的话，新对象中的属性不会有值，但是新的对象中会有这个属性。

function demo(name){
  this.name = name
}
var demoNew = new demo();
console.log(demoNew);
console.log(demoNew.name)
// demo {name: undefined}
// undefined

手动实现一个new创建对象代码(多种实现方式哦)

function New(func) {
    var res = {};
    if (func.prototype !== null) {
        res.__proto__ = func.prototype;
    }
    var ret = func.apply(res, Array.prototype.slice.call(arguments, 1));
    if ((typeof ret === "object" || typeof ret === "function") && ret !== null) {
        return ret;
    }
    return res;
}
var obj = New(A, 1, 2);
// equals to
var obj = new A(1, 2);

this绑定优先级

上面介绍了 this 的四种绑定规则，但是一段代码有时候会同时应用多种规则，这时候 this 应该如何指向呢？其实它们也是有一个先后顺序的，具体规则如下:

new绑定 > 显式绑定 > 隐式绑定 > 默认绑定

箭头函数表达式的语法比函数表达式更短，并且不绑定自己的this，arguments，super或 new.target。这些函数表达式最适合用于非方法函数(non-method functions)，并且它们不能用作构造函数。

常规函数可以直接拿到 arguments 属性，但是在箭头函数中如果使用 arguments 属性，拿到的是箭头函数外层函数的 arguments 属性

function constant() {
    return () => arguments[0]
}

let result = constant(1);
console.log(result()); // 1

箭头函数中没有自己的 this，箭头函数中的 this 不能用 call()、apply()、bind() 这些方法改变 this 的指向，箭头函数中的 this 直接指向的是调用函数的 上一层运行时。

let a = 'kaola'

let obj = {
    a: '程序员成长指北',
    foo: () => {
        console.log(this.a)
    }
}

obj.foo()             // 输出结果: "koala"

(function(){
    console.log('测试1111')
})()

(function(){
  console.log('ceshi2222')
}())

(()=>{
  console.log('测试33333')
})()

 十八）操作运算符的一些常见的题

console.log( 0=={})
//1 false

console.log(0 == false)
//1 true

console.log(NaN == NaN)
// false

console.log(null === null)
// true

console.log(undefined === undefined)
// true

var a
console.log(a == Object)
// false

console.log(0 === false)
// false

console.log(0 == false)
// true

console.log(1 == true)
//true

console.log(1 === true)
// false

console.log("" == false)
// true

console.log("" === false)
// false

console.log(undefined == null )
// true

console.log(undefined === null )
//false

null == 0
//false

['']==''
//true

[0]==0
//true
ps**值得一提的是，在全等运算中， NaN 与其他任何值相比,结果都是 false。

 十八）经典面试题

//JS实现一个无限累加的add函数
add(1) //1
add(1)(2) //3
add(1)(2)(3) //6

 

function add(a) {
    function sum(b) { // 使用闭包
        a = a + b; // 累加
        return sum;
     }
     sum.toString = function() { // 重写toString()方法
        return a;
    }
     return sum; // 返回一个函数
}

add(1); // 1
add(1)(2);  // 3
add(1)(2)(3)；// 6

 十九）link和@inmport的区别

1》link是html的标签，不仅可以加载css还可以定义Rss , rel连接属性；@import是css的语法规则，只能引入样式；
2》加载页面时，link是同时加载的，@impor是页面加载完后才加载
3》link没有兼容性的问题，而@import只在较高版本的浏览器才可以识别
4》link可以通过js插入操作dom，@import 不可以！

二十）css写一个三角形及0.5px的线

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>三角形及0.5px的线</title>
    <style>
    .box{
        width:0;
        height:0;
        border-color: transparent transparent red;
        border-width: 0 15px 15px;
        border-style: solid ; 
    }
    .line {
        position: relative;
    }
    .line:after {
        content: "";
        position: absolute;
        left: 0;
        top: 0;
        width: 100%;
        height: 1px;
        background-color: #000000;
        -webkit-transform: scaleY(.5);
        transform: scaleY(.5);
    }
    </style>

</head>

<body>
    <div class="box"></div>
    <div class="line"></div>
</body>
</html>

 二十一）vuex：Vue.js应用程序的状态管理模式+库。

1.state

保存vuex中的数据源，通过this.$store.state获取

 

2.getters

用于监听state中的值的变化，返回计算后的结果。getter的返回值会根据它的依赖被缓存起来

 

3.mutations

是修改store中的值得唯一方式

 

4.action 

官方建议提交一个actions，在actions中提交mutations再去修改状态值。 this.$store.dispatch('add')

//this.$storemit('add')

5.modules 模块化

二十二）如何理解js中的原型链

1；每个构造函数都有一个原型对象

2；每个原型对象都有一个指向构造函数的指针

3；每个实例函数都有一个指向原型对象的指针。

4；查找方式是一层一层查找，直至顶层。Object.prototype

二十三）怎么理解js中的内存泄露

定义：程序不需要的内存，由于某些原因其不会返回到操作系统或者可用内存池中。   内存泄露会导致（运行缓慢 ，高延迟，崩溃）的问题

常见的导致内存泄露的原因有：

1；意外的全局变量

2；被遗忘的计时器或回调函数

3；脱离文档的DOM的引用

4；闭包

 二十四）跨域问题

由于浏览器的同源策略会导致跨域，同源策略又分为

一：DOM同源策略：禁止对不同源页面的DOM进行操作，主要是不同域名的ifram是限制互相访问的

二：xmlHttpRequest同源策略：禁止使用XHR对象向不同源的服务器地址发起http请求，只要域名  协议  端口有一个不同都被当做不同的域之间的请求，即跨域请求

解决方式：

1.CORS跨域资源共享   后端需要设置Access--Control-Allow-Credentials:true

2.jsonp实现跨域：动态创建script，利用src属性进行跨域

3. nginx代理跨域

4.nodejs中间件代理跨域

5WebSokect协跨域

6.window.name+ifram跨域

二十五）JS 实现千位分隔符

1：正则表达式和replace函数

function numFormat(num){
  var res=num.toString().replace(/\d+/, function(n){ // 先提取整数部分
       return n.replace(/(\d)(?=(\d{3})+$)/g,function($1){
          return $1+",";
        });
  })
  return res;
}

var a=1234567890123;
var b=123456.123456;
console.log(numFormat(a)); // "1,234,567,890,123"
console.log(numFormat(b)); // "123,456.123456"

 

2：js自带函数toLocaleString()   //返回这个数字在特定语言环境下的表示字符串

var a=1234567894532;
var b=673439.4542;

console.log(a.toLocaleString());  // "1,234,567,894,532"
console.log(b.toLocaleString());  // "673,439.454"  （小数部分四舍五入了）

3:先转字符串--》转数组---》反转---》三位加逗号----》反转----》转字符串-----》实现

function numFormat(num){
    num=num.toString().split(".");  // 分隔小数点
    var arr=num[0].split("").reverse();  // 转换成字符数组并且倒序排列
    var res=[];
    for(var i=0,len=arr.length;i<len;i++){
      if(i%3===0&&i!==0){
         res.push(",");   // 添加分隔符
      }
      res.push(arr[i]);
    }
    res.reverse(); // 再次倒序成为正确的顺序
    if(num[1]){  // 如果有小数的话添加小数部分
      res=res.join("").concat("."+num[1]);
    }else{
      res=res.join("");
    }
    return res;
}

var a=1234567894532;
var b=673439.4542;
console.log(numFormat(a)); // "1,234,567,894,532"
console.log(numFormat(b)); // "673,439.4542"

转自：https://wwwblogs/jiajiamiao/p/11609335.html

vue前端面试题知识点整理

1. 说一下Vue的双向绑定数据的原理

vue 实现数据双向绑定主要是：采用数据劫持结合发布者-订阅者模式的方式，通过  Object.defineProperty() 来劫持各个属性的  setter， getter，在数据变动时发布消息给订阅者，触发相应监听回调

2. 解释单向数据流和双向数据绑定

单向数据流： 顾名思义，数据流是单向的。数据流动方向可以跟踪，流动单一，追查问题的时候可以更快捷。缺点就是写起来不太方便。要使UI发生变更就必须创建各种  action 来维护对应的  state

双向数据绑定：数据之间是相通的，将数据变更的操作隐藏在框架内部。优点是在表单交互较多的场景下，会简化大量与业务无关的代码。缺点就是无法追踪局部状态的变化，增加了出错时 debug 的难度

3. Vue 如何去除url中的 #

vue-router 默认使用 hash 模式，所以在路由加载的时候，项目中的 url 会自带 #。如果不想使用 #， 可以使用 vue-router 的另一种模式 history

new Router({
  mode: 'history',
  routes: [ ]
})

需要注意的是，当我们启用  history 模式的时候，由于我们的项目是一个单页面应用，所以在路由跳转的时候，就会出现访问不到静态资源而出现  404 的情况，这时候就需要服务端增加一个覆盖所有情况的候选资源：如果  URL 匹配不到任何静态资源，则应该返回同一个  index.html 页面

4. 对 MVC、MVVM的理解

MVC

特点：

1. View 传送指令到 Controller
2. Controller 完成业务逻辑后，要求 Model 改变状态
3. Model 将新的数据发送到 View，用户得到反馈

所有通信都是单向的

MVVM

特点：

1. 各部分之间的通信，都是双向的
2. 采用双向绑定：View 的变动，自动反映在 ViewModel，反之亦然

具体请移步 这里

5. 介绍虚拟DOM

参考这里

6. vue生命周期的理解

vue实例有一个完整的生命周期，生命周期也就是指一个实例从开始创建到销毁的这个过程

• beforeCreated() 在实例创建之间执行，数据未加载状态
• created() 在实例创建、数据加载后，能初始化数据，dom渲染之前执行
• beforeMount() 虚拟dom已创建完成，在数据渲染前最后一次更改数据
• mounted() 页面、数据渲染完成，真实dom挂载完成
• beforeUpadate() 重新渲染之前触发
• updated() 数据已经更改完成，dom 也重新 render 完成,更改数据会陷入死循环
• beforeDestory() 和 destoryed() 前者是销毁前执行（实例仍然完全可用），后者则是销毁后执行

7. 组件通信

父组件向子组件通信

子组件通过 props 属性，绑定父组件数据，实现双方通信

子组件向父组件通信

将父组件的事件在子组件中通过 $emit 触发

非父子组件、兄弟组件之间的数据传递

/*新建一个Vue实例作为中央事件总嫌*/
let event = new Vue();

/*监听事件*/
event.$on('eventName', (val) => {
    //......do something
});

/*触发事件*/
event.$emit('eventName', 'this is a message.')

Vuex 数据管理

8. vue-router 路由实现

路由就是用来跟后端服务器进行交互的一种方式，通过不同的路径，来请求不同的资源，请求不同的页面是路由的其中一种功能

参考 这里

9. v-if 和 v-show 区别

使用了  v-if 的时候，如果值为  false ，那么页面将不会有这个  html 标签生成。

v-show 则是不管值为 true 还是 false ，html 元素都会存在，只是 CSS 中的 display 显示或隐藏

10. $route和$router的区别

$router 为  VueRouter 实例，想要导航到不同  URL，则使用  $router.push 方法

$route 为当前 router 跳转对象里面可以获取 name 、 path 、 query 、 params 等

11. NextTick 是做什么的

$nextTick 是在下次  DOM 更新循环结束之后执行延迟回调，在修改数据之后使用  $nextTick，则可以在回调中获取更新后的  DOM

具体可参考官方文档 深入响应式原理

12. Vue 组件 data 为什么必须是函数

因为js本身的特性带来的，如果  data 是一个对象，那么由于对象本身属于引用类型，当我们修改其中的一个属性时，会影响到所有Vue实例的数据。如果将  data 作为一个函数返回一个对象，那么每一个实例的  data 属性都是独立的，不会相互影响了

13. 计算属性computed 和事件 methods 有什么区别

我们可以将同一函数定义为一个 method 或者一个计算属性。对于最终的结果，两种方式是相同的

不同点：

computed: 计算属性是基于它们的依赖进行缓存的,只有在它的相关依赖发生改变时才会重新求值

对于 method ，只要发生重新渲染，method 调用总会执行该函数

14. 对比 jQuery ，Vue 有什么不同

jQuery 专注视图层，通过操作 DOM 去实现页面的一些逻辑渲染； Vue 专注于数据层，通过数据的双向绑定，最终表现在 DOM 层面，减少了 DOM 操作

Vue 使用了组件化思想，使得项目子集职责清晰，提高了开发效率，方便重复利用，便于协同开发

15. Vue 中怎么自定义指令

全局注册

// 注册一个全局自定义指令 `v-focus`
Vue.directive('focus', {
  // 当被绑定的元素插入到 DOM 中时……
  inserted: function (el) {
    // 聚焦元素
    el.focus()
  }
})

局部注册

directives: {
  focus: {
    // 指令的定义
    inserted: function (el) {
      el.focus()
    }
  }
}

参考 官方文档-自定义指令

16. Vue 中怎么自定义过滤器

可以用全局方法  Vue.filter() 注册一个自定义过滤器，它接收两个参数：过滤器  ID 和过滤器函数。过滤器函数以值为参数，返回转换后的值

Vue.filter('reverse', function (value) {
  return value.split('').reverse().join('')
})

<!-- 'abc' => 'cba' -->
<span v-text="message | reverse"></span>

过滤器也同样接受全局注册和局部注册

17. 对 keep-alive 的了解

keep-alive 是  Vue 内置的一个组件，可以使被包含的组件保留状态，或避免重新渲染

<keep-alive>
  <component>
    <!-- 该组件将被缓存！ -->
  </component>
</keep-alive>

可以使用API提供的props，实现组件的动态缓存

具体参考 官方API

18. Vue 中 key 的作用

key 的特殊属性主要用在  Vue 的虚拟  DOM 算法，在新旧  nodes 对比时辨识  VNodes。如果不使用  key， Vue 会使用一种最大限度减少动态元素并且尽可能的尝试修复/再利用相同类型元素的算法。使用  key，它会基于  key 的变化重新排列元素顺序，并且会移除  key 不存在的元素。

有相同父元素的子元素必须有独特的 key。重复的 key 会造成渲染错误

具体参考 官方API

19. Vue 的核心是什么

数据驱动 组件系统

20. vue 等单页面应用的优缺点

优点：

• 良好的交互体验
• 良好的前后端工作分离模式
• 减轻服务器压力

缺点：

• SEO难度较高
• 前进、后退管理
• 初次加载耗时多

看了阮一峰的文章通俗易懂：http://www.ruanyifeng/blog/2009/08/learning_javascript_closures.html

闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。

下面就是我的学习笔记，对于Javascript初学者应该是很有用的。

一、变量的作用域

要理解闭包，首先必须理解Javascript特殊的变量作用域。

变量的作用域无非就是两种：全局变量和局部变量。

Javascript语言的特殊之处，就在于函数内部可以直接读取全局变量。

var n=999;

　　function f1(){
　　　　alert(n);
　　}

　　f1(); // 999

另一方面，在函数外部自然无法读取函数内的局部变量。

function f1(){
　　　　var n=999;
　　}

　　alert(n); // error

这里有一个地方需要注意，函数内部声明变量的时候，一定要使用var命令。如果不用的话，你实际上声明了一个全局变量！

function f1(){
　　　　n=999;
　　}

　　f1();

　　alert(n); // 999

二、如何从外部读取局部变量？

出于种种原因，我们有时候需要得到函数内的局部变量。但是，前面已经说过了，正常情况下，这是办不到的，只有通过变通方法才能实现。

那就是在函数的内部，再定义一个函数。

function f1(){

　　　　var n=999;

　　　　function f2(){
　　　　　　alert(n); // 999
　　　　}

　　}

在上面的代码中，函数f2就被包括在函数f1内部，这时f1内部的所有局部变量，对f2都是可见的。但是反过来就不行，f2内部的局部变量，对f1就是不可见的。这就是Javascript语言特有的"链式作用域"结构（chain scope），子对象会一级一级地向上寻找所有父对象的变量。所以，父对象的所有变量，对子对象都是可见的，反之则不成立。

既然f2可以读取f1中的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！

function f1(){

　　　　var n=999;

　　　　function f2(){
　　　　　　alert(n); 
　　　　}

　　　　return f2;

　　}

　　var result=f1();

　　result(); // 999

三、闭包的概念

上一节代码中的f2函数，就是闭包。

各种专业文献上的"闭包"（closure）定义非常抽象，很难看懂。我的理解是，闭包就是能够读取其他函数内部变量的函数。

由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成"定义在一个函数内部的函数"。

所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。

四、闭包的用途

闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。

怎么来理解这句话呢？请看下面的代码。

function f1(){

　　　　var n=999;

　　　　nAdd=function(){n+=1}

　　　　function f2(){
　　　　　　alert(n);
　　　　}

　　　　return f2;

　　}

　　var result=f1();

　　result(); // 999

　　nAdd();

　　result(); // 1000

在这段代码中，result实际上就是闭包f2函数。它一共运行了两次，第一次的值是999，第二次的值是1000。这证明了，函数f1中的局部变量n一直保存在内存中，并没有在f1调用后被自动清除。

为什么会这样呢？原因就在于f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。

这段代码中另一个值得注意的地方，就是"nAdd=function(){n+=1}"这一行，首先在nAdd前面没有使用var关键字，因此nAdd是一个全局变量，而不是局部变量。其次，nAdd的值是一个匿名函数（anonymous function），而这个匿名函数本身也是一个闭包，所以nAdd相当于是一个setter，可以在函数外部对函数内部的局部变量进行操作。

五、使用闭包的注意点

1）由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。解决方法是，在退出函数之前，将不使用的局部变量全部删除。

2）闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。

六、思考题

如果你能理解下面两段代码的运行结果，应该就算理解闭包的运行机制了。

代码片段一。

var name = "The Window";

　　var object = {
　　　　name : "My Object",

　　　　getNameFunc : function(){
　　　　　　return function(){
　　　　　　　　return this.name;
　　　　　　};

　　　　}

　　};

　　alert(object.getNameFunc()());

代码片段二。

var name = "The Window";

　　var object = {
　　　　name : "My Object",

　　　　getNameFunc : function(){
　　　　　　var that = this;
　　　　　　return function(){
　　　　　　　　return that.name;
　　　　　　};

　　　　}

　　};

　　alert(object.getNameFunc()())

 

如何解决IOS 下固定定位fixed 失效问题？

 

相信大家在做移动端项目时都会遇到fixed失效的问题，在这里我们说的是在ios 下 ，头部底部都采用固定定位时，滑动中心部分时整个页面都跟着滚动也就是说固定定位失效了。那么如何解决这个问题呢？这里有个小诀窍分享给大家。

   <body>
<!-- fixed定位的头部 -->
<div class="header">

</div>
<!-- 可以滚动的区域 -->
<div class="main">
    <div class="content"> 
    <!-- 内容区域 -->
    </div>
</div>
    <!-- fixed定位的底部 -->
    <footer class="footer">
        <input type="text" placeholder="请输入姓名">

    </footer>
 </body>



    .header,.footer,.main{
        display: block;
    }
.header {
    position: fixed;
    top:0;
    left: 0;
    right:0;
    height:100px;
    }

.footer {
    position: fixed;
    bottom: 0;
    left: 0;
    right:0;
    height: 30px;
}
    .main{
        /*main绝对定位，进行内部滚动*/
        position: absolute;
        /*top是头部的高度*/
        top: 100px;  
        /*bottom是底部的高度*/
        bottom: 30px;
        /*使之可以滚动*/
        overflow-y: scroll;
        /*增加弹性滚动,解决滚动不流畅的问题*/
        -webkit-overflow-scrolling:touch;
    }
    .main .content{
    height:2000px;
    }

• 另外,代码中header和footer采用的是fixed定位，如果考虑到更老一些的iOS系统不支持fixed，完全可以吧fixed换成absolute。

webpack的loader和plugin的区别

【Loader】：用于对模块源码的转换，loader描述了webpack如何处理非javascript模块，并且在buld中引入这些依赖。loader可以将文件从不同的语言（如TypeScript）转换为JavaScript，或者将内联图像转换为data URL。比如说：CSS-Loader，Style-Loader等。

loader的使用很简单：

在webpack.config.js中指定loader。module.rules可以指定多个loader，对项目中的各个loader有个全局概览。

loader是运行在NodeJS中，可以用options对象进行配置。plugin可以为loader带来更多特性。loader可以进行压缩，打包，语言翻译等等。

loader从模板路径解析，npm install node_modules。也可以自定义loader，命名XXX-loader。

语言类的处理器loader：CoffeeScript，TypeScript，ESNext（Bable）,Sass,Less,Stylus。任何开发技术栈都可以使用webpack。

【Plugin】：目的在于解决loader无法实现的其他事，从打包优化和压缩，到重新定义环境变量，功能强大到可以用来处理各种各样的任务。webpack提供了很多开箱即用的插件：CommonChunkPlugin主要用于提取第三方库和公共模块，避免首屏加载的bundle文件，或者按需加载的bundle文件体积过大，导致加载时间过长，是一把优化的利器。而在多页面应用中，更是能够为每个页面间的应用程序共享代码创建bundle。

webpack功能强大，难点在于它的配置文件，webpack4默认不需要配置文件，可以通过mode选项为webpack指定了一些默认的配置，mode分为：development/production，默认是production。

插件可以携带参数，所以在plugins属性传入new实例。

【Mode】可以在config文件里面配置，也可以在CLI参数中配置：webpack --mode=production（一般会选择在CLI，也就是npm scripts里面进行配置）。

在webpack4以下版本，webpack3.XX，通过plugins进行环境变量的配置。

【resolve】模块，resolver是个库，帮助webpack找到bundle需要引入的模块代码，打包时，webpack使用enhanced-resolve来解析路径。 

 resolve: {
    extensions: ['.js', '.vue', '.json'],
    alias: {
      'vue$': 'vue/dist/vue.esm.js',
      '@': resolve('src'),
    }
  }

 【Manifest】管理所有模块之间的交互。runtime将能够查询模块标识符，检索出背后对应的模块。

问题1：webpack通过使用bundle计算content hash作为文件名称，文件修改，新的content hash执向新的文件，缓存无效，但是文件内容没有修改，计算的hash还是会改变，因为，runtime和manifest的注入在每次构建都会发生变化。要想解决这个文件可以了解更多的runtime和manifest。

webpack原理：从配置文件定义的模块列表开始，处理应用程序，从入口文件开始递归构建一个依赖图，然后将所有模块打包为少量的bundle，通常只有一个，可由浏览器加载。

 

1. Vue.js介绍    

Vue.js是一个轻巧、高性能、可组件化的MVVM库，同时拥有非常容易上手的API；

Vue.js是一个构建数据驱动的Web界面的库。

Vue.js是一套构建用户界面的 渐进式框架。与其他重量级框架不同的是，Vue 采用自底向上增量开发的设计。Vue的核心库只关注视图层，并且非常容易学习，非常容易与其它库或已有项目整合。另一方面，Vue 完全有能力驱动采用单文件组件和 Vue生态系统支持的库开发的复杂单页应用。数据驱动+组件化的前端开发。

简而言之：Vue.js是一个构建数据驱动的 web 界面的渐进式框架。Vue.js 的目标是通过尽可能简单的 API实现响应的数据绑定和组合的视图组件。核心是一个响应的数据绑定系统。

2、使用Vue的好处

vue两大特点：响应式编程、组件化

vue的优势：轻量级框架、简单易学、双向数据绑定、组件化、视图、数据和结构的分离、虚拟DOM、运行速度快

3、MVVM定义

MVVM是Model-View-ViewModel的简写。即模型-视图-视图模型。【模型】指的是后端传递的数据。【视图】指的是所看到的页面。【视图模型】mvvm模式的核心，它是连接view和model的桥梁。它有两个方向：一是将【模型】转化成【视图】，即将后端传递的数据转化成所看到的页面。实现的方式是：数据绑定。二是将【视图】转化成【模型】，即将所看到的页面转化成后端的数据。实现的方式是：DOM 事件监听。这两个方向都实现的，我们称之为数据的双向绑定。总结：在MVVM的框架下视图和模型是不能直接通信的。它们通过ViewModel来通信，ViewModel通常要实现一个observer观察者，当数据发生变化，ViewModel能够监听到数据的这种变化，然后通知到对应的视图做自动更新，而当用户操作视图，ViewModel也能监听到视图的变化，然后通知数据做改动，这实际上就实现了数据的双向绑定。并且MVVM中的View 和 ViewModel可以互相通信

4、Vue的生命周期

beforeCreate（创建前） 在数据观测和初始化事件还未开始

created（创建后） 完成数据观测，属性和方法的运算，初始化事件，$el属性还没有显示出来

beforeMount（载入前） 在挂载开始之前被调用，相关的render函数首次被调用。实例已完成以下的配置：编译模板，把data里面的数据和模板生成html。注意此时还没有挂载html到页面上。

mounted（载入后） 在el 被新创建的 vm.$el 替换，并挂载到实例上去之后调用。实例已完成以下的配置：用上面编译好的html内容替换el属性指向的DOM对象。完成模板中的html渲染到html页面中。此过程中进行ajax交互。

beforeUpdate（更新前） 在数据更新之前调用，发生在虚拟DOM重新渲染和打补丁之前。可以在该钩子中进一步地更改状态，不会触发附加的重渲染过程。

updated（更新后） 在由于数据更改导致的虚拟DOM重新渲染和打补丁之后调用。调用时，组件DOM已经更新，所以可以执行依赖于DOM的操作。然而在大多数情况下，应该避免在此期间更改状态，因为这可能会导致更新无限循环。该钩子在服务器端渲染期间不被调用。

beforeDestroy（销毁前） 在实例销毁之前调用。实例仍然完全可用。

destroyed（销毁后） 在实例销毁之后调用。调用后，所有的事件监听器会被移除，所有的子实例也会被销毁。该钩子在服务器端渲染期间不被调用。

5、Vue的响应式原理

当一个Vue实例创建时，vue会遍历data选项的属性，用 Object.defineProperty 将它们转为 getter/setter并且在内部追踪相关依赖，在属性被访问和修改时通知变化。 每个组件实例都有相应的 watcher 程序实例，它会在组件渲染的过程中把属性记录为依赖，之后当依赖项的 setter 被调用时，会通知 watcher 重新计算，从而致使它关联的组件得以更新。

6、第一次页面加载会触发哪几个钩子？

触发 下面这几个beforeCreate, created, beforeMount, mounted ，并在mounted的时候DOM渲染完成

7、vue中data必须是一个函数

对象为引用类型，当重用组件时，由于数据对象都指向同一个data对象，当在一个组件中修改data时，其他重用的组件中的data会同时被修改；而使用返回对象的函数，由于每次返回的都是一个新对象（Object的实例），引用地址不同，则不会出现这个问题。

8、vue中做数据渲染的时候如何保证将数据原样输出？

v-text：将数据输出到元素内部，如果输出的数据有HTML代码，会作为普通文本输出

v-html：将数据输出到元素内部，如果输出的数据有HTML代码，会被渲染

 {{}}：插值表达式，可以直接获取Vue实例中定义的数据或函数，使用插值表达式的时候，值可能闪烁；而使用v-html、v-text不会闪烁，有值就显示，没值就隐藏

9、active-class是哪个组件的属性？

vue-router模块的router-link组件。

10、vue-router有哪几种导航钩子？

三种。

一种是全局导航钩子：router.beforeEach(to,from,next)，作用：跳转前进行判断拦截。

第二种：组件内的钩子；

第三种：单独路由独享组件

11、$route和$router的区别

$route是“路由信息对象”，包括path，params，hash，query，fullPath，matched，name等路由信息参数。而$router是“路由实例”对象包括了路由的跳转方法，钩子函数等

12、vue几种常用的指令

v-for 、 v-if 、v-bind、v-on、v-show、v-else

13、v-if 和 v-show 区别

v-if按照条件是否渲染，v-show是display的block或none

14、vue常用的修饰符？

.prevent: 提交事件不再重载页面；.stop: 阻止单击事件冒泡；.self: 当事件发生在该元素本身而不是子元素的时候会触发；.capture: 事件侦听，事件发生的时候会调用

15、vue-loader是什么？使用它的用途有哪些？

解析.vue文件的一个加载器，跟template/js/style转换成js模块。

用途：js可以写es6、style样式可以scss或less、template可以加jade等

16、computed、watch、methods的区别

computed计算属性是用来声明式的描述一个值依赖了其它的值。当你在模板里把数据绑定到一个计算属性上时，Vue 会在其依赖的任何值导致该计算属性改变时更新 DOM。这个功能非常强大，它可以让你的代码更加声明式、数据驱动并且易于维护。

watch监听的是你定义的变量,当你定义的变量的值发生变化时，调用对应的方法。就好在div写一个表达式name，data里写入num和lastname,firstname,在watch里当num的值发生变化时，就会调用num的方法，方法里面的形参对应的是num的新值和旧值，而计算属性computed,计算的是Name依赖的值,它不能计算在data中已经定义过的变量。

methods方法，函数，绑定事件调用；不会使用缓存

17、什么是js的冒泡？Vue中如何阻止冒泡事件？

js冒泡概念：当父元素内多级子元素绑定了同一个事件，js会依次从内往外或者从外往内（？）执行每个元素的该事件，从而引发冒泡

 js解决冒泡：event.stopPropagation()

vue解决冒泡： 事件.stop,例如：@click.stop="" ,@mouseover.stop=""

18、vue 组件通信

1.父组件与子组件传值

父组件传给子组件：子组件通过props方法接受数据;

子组件传给父组件：$emit方法传递参数

2.非父子组件间的数据传递，兄弟组件传值

eventBus，就是创建一个事件中心，相当于中转站，可以用它来传递事件和接收事件。也可使用vuex

19、<keep-alive></keep-alive>的作用是什么？

<keep-alive></keep-alive>包裹动态组件时，会缓存不活动的组件实例,主要用于保留组件状态或避免重新渲染。 大白话: 比如有一个列表和一个详情，那么用户就会经常执行打开详情=>返回列表=>打开详情…这样的话列表和详情都是一个频率很高的页面，那么就可以对列表组件使用<keep-alive></keep-alive>进行缓存，这样用户每次返回列表的时候，都能从缓存中快速渲染，而不是重新渲染

20、$nextTick是什么？

vue实现响应式并不是数据发生变化后dom立即变化，而是按照一定的策略来进行dom更新。

$nextTick 是在下次 DOM 更新循环结束之后执行延迟回调，在修改数据之后使用 $nextTick，则可以在回调中获取更新后的 DOM

21、Vue子组件调用父组件的方法

第一种方法是直接在子组件中通过this.$parent.event来调用父组件的方法

第二种方法是在子组件里用$emit向父组件触发一个事件，父组件监听这个事件就行了。

22、Promise对象是什么？

1.Promise是异步编程的一种解决方案，它是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise 提供统一的 API，各种异步操作都可以用同样的方法进行处理。promise对象是一个构造函数，用来生成Promise实例；

2.promise的两个特点 对象状态不受外界影响 && 一旦状态改变，就不会再变，任何时候都可以得到结果（pending状态-->fulfilled || pending-->rejected）

23、axios的特点有哪些？

1、axios是一个基于promise的HTTP库，支持promise的所有API；

2、它可以拦截请求和响应；

3、它可以转换请求数据和响应数据，并对响应回来的内容自动转换为json类型的数据；

4、它安全性更高，客户端支持防御XSRF；

24、vue中的 ref 是什么？

ref 被用来给元素或子组件注册引用信息。引用信息将会注册在父组件的 $refs 对象上。如果在普通的 DOM 元素上使用，引用指向的就是 DOM 元素；如果用在子组件上，引用就指向组件实例。

25、vue如何兼容ie

babel-polyfill插件

26、页面刷新vuex被清空解决办法？

1.localStorage 存储到本地再回去

2.重新获取接口获取数据

27、Vue与Angular以及React的区别？

1.与AngularJS的区别

相同点：

都支持指令：内置指令和自定义指令；都支持过滤器：内置过滤器和自定义过滤器；都支持双向数据绑定；都不支持低端浏览器。

不同点：

AngularJS的学习成本高，比如增加了Dependency Injection特性，而Vue.js本身提供的API都比较简单、直观；在性能上，AngularJS依赖对数据做脏检查，所以Watcher越多越慢；Vue.js使用基于依赖追踪的观察并且使用异步队列更新，所有的数据都是独立触发的。

2.与React的区别

相同点：

React采用特殊的JSX语法，Vue.js在组件开发中也推崇编写.vue特殊文件格式，对文件内容都有一些约定，两者都需要编译后使用；中心思想相同：一切都是组件，组件实例之间可以嵌套；都提供合理的钩子函数，可以让开发者定制化地去处理需求；都不内置列数AJAX，Route等功能到核心包，而是以插件的方式加载；在组件开发中都支持mixins的特性。

不同点：

React采用的Virtual DOM会对渲染出来的结果做脏检查；Vue.js在模板中提供了指令，过滤器等，可以非常方便，快捷地操作Virtual DOM。

28、localstorage和sessionstorage是什么?区别是什么?

localstorage和sessionstorage一样都是用来存储客户端临时信息的对象，他们均只能存储字符串类型对象

localstorage生命周期是永久的，这意味着除非用户在浏览器提供的UI上清除localstorage信息，否则这些信息将永远存在。

sessionstorage生命周期为当前窗口或标签，一旦窗口或标签被永久关闭了，那么所有通过sessionstorage存储的数据也将被清空。

不同浏览器无法共享localstorage或sessionstorage中的信息。相同浏览器的不同页面可以共享相同的localstorage（页面属于相同的域名和端口），但是不同页面或标签间无法共享sessionstorage。这里需要注意的是，页面及标签仅指顶级窗口，如果一个标签页包含多个iframe标签他们属于同源页面，那么他们之间是可以共享sessionstorage的。

29、为什么要进行前后端分离？前后端分离的优势在哪里？劣势在哪里？

优点：前端专门负责前端页面和特效的编写，后端专门负责后端业务逻辑的处理，前端追求的是页面美观、页面流畅、页面兼容等。后端追求的是三高（高并发、高可用、高性能）让他们各自负责各自的领域，让专业的人负责处理专业的事情，提高开发效率

缺点：1 、当接口发生改变的时候，前后端都需要改变

           2、 当发生异常的时候，前后端需要联调--联调是非常浪费时间的

 

浏览器的九种缓存模式

 

来源：https://my.oschina/zhangstephen/blog/591575
摘要: 浏览器缓存（Browser Caching）是浏览器端保存数据用于快速读取或避免重复资源请求的优化机制，有效的缓存使用可以避免重复的网络请求和浏览器快速地读取本地数据，整体上加速网页展示给用户。浏览器端缓存的机制种类较多，总体归纳为九种，这里详细分析下这九种缓存机制的原理和使用场景。打开浏览器的调试模式->resources左侧就有浏览器的8种缓存机制。

浏览器缓存（Browser Caching）是浏览器端保存数据用于快速读取或避免重复资源请求的优化机制，有效的缓存使用可以避免重复的网络请求和浏览器快速地读取本地数据，整体上加速网页展示给用户。浏览器端缓存的机制种类较多，总体归纳为九种，这里详细分析下这九种缓存机制的原理和使用场景。打开浏览器的调试模式->resources左侧就有浏览器的8种缓存机制。

 

 

一、http缓存
http缓存是基于HTTP协议的浏览器文件级缓存机制。即针对文件的重复请求情况下，浏览器可以根据协议头判断从服务器端请求文件还是从本地读取文件，chrome控制台下的Frames即展示的是浏览器的http文件级缓存。以下是浏览器缓存的整个机制流程。主要是针对重复的http请求，在有缓存的情况下判断过程主要分3步：
判断expires，如果未过期，直接读取http缓存文件，不发http请求，否则进入下一步
判断是否含有etag，有则带上if-none-match发送请求，未修改返回304，修改返回200，否则进入下一步
判断是否含有last-modified，有则带上if-modified-since发送请求，无效返回200，有效返回304，否则直接向服务器请求

 

如果通过etag和last-modified判断，即使返回304有至少有一次http请求，只不过返回的是304的返回内容，而不是文件内容。所以合理设计实现expires参数可以减少较多的浏览器请求。
二、websql
websql这种方式只有较新的chrome浏览器支持，并以一个独立规范形式出现，主要有以下特点
Web Sql 数据库API 实际上不是HTML5规范的组成部分；
在HTML5之前就已经存在了，是单独的规范；
它是将数据以数据库的形式存储在客户端，根据需求去读取；
跟Storage的区别是： Storage和Cookie都是以键值对的形式存在的；
Web Sql 更方便于检索，允许sql语句查询；
让浏览器实现小型数据库存储功能；
这个数据库是集成在浏览器里面的，目前主流浏览器基本都已支持；

websql API主要包含三个核心方法：
openDatabase : 这个方法使用现有数据库或创建新数据库创建数据库对象。
transaction : 这个方法允许我们根据情况控制事务提交或回滚。
executeSql : 这个方法用于执行真实的SQL查询。

openDatabase方法可以打开已经存在的数据库，不存在则创建
var db = openDatabase('mydatabase', '2.0', my db', 2 * 1024);

openDatabasek中五个参数分别为：数据库名、版本号、描述、数据库大小、创建回调。创建回调没有也可以创建数据库。
database.transaction() 函数用来查询，executeSql()用于执行sql语句
例如在mydatabase数据库中创建表t1：
var db = openDatabase(' mydatabase ', '1.0', 'Test DB', 2 * 1024 * 1024); db.transaction(function (tx) { tx.executeSql('CREATE TABLE IF NOT EXISTS t1 (id unique, log)'); });

插入操作
var db = openDatabase('mydatabase', '2.0', my db', 2 * 1024); db.transaction(function (tx) { tx.executeSql('CREATE TABLE IF NOT EXISTS t1 (id unique, log)'); tx.executeSql('INSERT INTO t1 (id, log) VALUES (1, "foobar")'); tx.executeSql('INSERT INTO t1 (id, log) VALUES (2, "logmsg")'); });

在插入新记录时，我们还可以传递动态值，如：
var db = openDatabase(' mydatabase ', '2.0', 'my db', 2 * 1024); db.transaction(function (tx) { tx.executeSql('CREATE TABLE IF NOT EXISTS t1 (id unique, log)'); tx.executeSql('INSERT INTO t1 (id,log) VALUES (?, ?'), [e_id, e_log]; //e_id和e_log是外部变量 });

读操作，如果要读取已经存在的记录，我们使用一个回调捕获结果：
var db = openDatabase(mydatabase, '2.0', 'my db', 2*1024); db.transaction(function (tx) { tx.executeSql('CREATE TABLE IF NOT EXISTS t1 (id unique, log)'); tx.executeSql('INSERT INTO t1 (id, log) VALUES (1, "foobar")'); tx.executeSql('INSERT INTO t1 (id, log) VALUES (2, "logmsg")'); }); db.transaction(function (tx) { tx.executeSql('SELECT * FROM t1, [], function (tx, results) { var len = results.rows.length, i; msg = "<p>Found rows: " + len + "</p>"; document.querySelector('#status').innerHTML += msg; for (i = 0; i < len; i++){ alert(results.rows.item(i).log ); } }, null); });

三、indexDB
IndexedDB 是一个为了能够在客户端存储可观数量的结构化数据，并且在这些数据上使用索引进行高性能检索的 API。虽然 DOM 存储 对于存储少量数据是非常有用的，但是它对大量结构化数据的存储就显得力不从心了。IndexedDB 则提供了这样的一个解决方案。 IndexedDB 分别为同步和异步访问提供了单独的 API 。同步 API 本来是要用于仅供 Web Workers 内部使用，但是还没有被任何浏览器所实现。异步 API 在 Web Workers 内部和外部都可以使用，另外浏览器可能对indexDB有50M大小的限制，一般用户保存大量用户数据并要求数据之间有搜索需要的场景。
异步API

异步 API 方法调用完后会立即返回，而不会阻塞调用线程。要异步访问数据库，要调用 window 对象 indexedDB 属性的 open() 方法。该方法返回一个 IDBRequest 对象 (IDBOpenDBRequest)；异步操作通过在 IDBRequest 对象上触发事件来和调用程序进行通信。

• IDBFactory 提供了对数据库的访问。这是由全局对象 indexedDB 实现的接口，因而也是该 API 的入口。- IDBCursor 遍历对象存储空间和索引。- IDBCursorWithValue 遍历对象存储空间和索引并返回游标的当前值。- IDBDatabase 表示到数据库的连接。只能通过这个连接来拿到一个数据库事务。- IDBEnvironment 提供了到客户端数据库的访问。它由 window 对象实现。- IDBIndex 提供了到索引元数据的访问。- IDBKeyRange 定义键的范围。- IDBObjectStore 表示一个对象存储空间。- IDBOpenDBRequest 表示一个打开数据库的请求。-IDBRequest 提供了到数据库异步请求结果和数据库的访问。这也是在你调用一个异步方法时所得到的。- IDBTransaction 表示一个事务。你在数据库上创建一个事务，指定它的范围（例如你希望访问哪一个对象存储空间），并确定你希望的访问类型（只读或写入）。- IDBVersionChangeEvent 表明数据库的版本号已经改变。

同步API

规范里面还定义了API 的同步版本。同步 API 还没有在任何浏览器中得以实现。它原本是要和webWork一起使用的。
http://mxr.mozilla/mozilla-central/source/modules/libpref/src/init/all.jshttp://caniuse/#feat=indexeddb
四、cookie
Cookie（或者Cookies），指一般网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据（通常经过加密）。cookie一般通过http请求中在头部一起发送到服务器端。一条cookie记录主要由键、值、域、过期时间、大小组成，一般用户保存用户的认证信息。cookie最大长度和域名个数由不同浏览器决定，具体如下：
浏览器
支持域名个数
最大长度

IE7以上
50个
4095B

Firefox
50个
4097B

Opera
30个
4096B

Safari/WebKit
无限制
4097B

不同域名之间的cookie信息是独立的，如果需要设置共享可以在服务器端设置cookie的path和domain来实现共享。浏览器端也可以通过document.cookie来获取cookie，并通过js浏览器端也可以方便地读取/设置cookie的值。
https://github/component/cookie/blob/master/index.js
五、localstorage
localStorage是html5的一种新的本地缓存方案，目前用的比较多，一般用来存储ajax返回的数据，加快下次页面打开时的渲染速度。
浏览器
最大长度

IE8以上
5M

Firefox 8以上
5.24M

Opera
2M

Safari/WebKit
2.6M

//localStorage核心API:localStorage.setItem(key, value) //设置记录localStorage.getItem(key) //获取记录localStorage.removeItem(key) //删除该域名下单条记录localStorage.clear() //删除该域名下所有记录

值得注意的是，localstorage大小有限制，不适合存放过多的数据，如果数据存放超过最大限制会报错，并移除最先保存的数据。
https://github/machao/localStorage
六、sessionstorage
sessionStorage和localstorage类似，但是浏览器关闭则会全部删除，api和localstorage相同，实际项目中使用较少。
七、application cache
application cahce是将大部分图片资源、js、css等静态资源放在manifest文件配置中。当页面打开时通过manifest文件来读取本地文件或是请求服务器文件。 离线访问对基于网络的应用而言越来越重要。虽然所有浏览器都有缓存机制，但它们并不可靠，也不一定总能起到预期的作用。HTML5 使用ApplicationCache 接口可以解决由离线带来的部分难题。前提是你需要访问的web页面至少被在线访问过一次。 使用缓存接口可为您的应用带来以下三个优势：
离线浏览 – 用户可在离线时浏览您的完整网站
速度 – 缓存资源为本地资源，因此加载速度较快。
服务器负载更少 – 浏览器只会从发生了更改的服务器下载资源。

一个简单的离线页面主要包含以下几个部分：
index.html
<html manifest="clock.manifest"> <head> <title>AppCache Test</title> <link rel="stylesheet" href="clock.css"> <script src="clock.js"></script> </head> <body> <p><output id="clock"></output></p> <div id="log"></div> </body></html>

clock.manifest
CACHE MANIFEST#VERSION 1.0CACHE:clock.cssclock.js

clock.js和clock.css为独立的另外文件。 另外需要注意的是更新缓存。在程序中，你可以通过window.applicationCache 对象来访问浏览器的app cache。你可以查看 status 属性来获取cache的当前状态：
var appCache = window.applicationCache;switch (appCache.status) { case appCache.UNCACHED: // UNCACHED == 0 return 'UNCACHED'; break; case appCache.IDLE: // IDLE == 1 return 'IDLE'; break; case appCache.CHECKING: // CHECKING == 2 return 'CHECKING'; break; case appCache.DOWNLOADING: // DOWNLOADING == 3 return 'DOWNLOADING'; break; case appCache.UPDATEREADY: // UPDATEREADY == 4 return 'UPDATEREADY'; break; case appCache.OBSOLETE: // OBSOLETE == 5 return 'OBSOLETE'; break; default: return 'UKNOWN CACHE STATUS'; break;};

为了通过编程更新cache，首先调用 applicationCache.update()。这将会试图更新用户的 cache（要求manifest文件已经改变）。最后，当 applicationCache.status 处于 UPDATEREADY 状态时， 调用applicationCache.swapCache()，旧的cache就会被置换成新的。
var appCache = window.applicationCache;appCache.update(); // Attempt to update the user’s cache.…if (appCache.status == window.applicationCache.UPDATEREADY) { appCache.swapCache(); // The fetch was successful, swap in the new cache.}

这里是通过更新menifest文件来控制其它文件更新的。
八、cacheStorage
CacheStorage是在ServiceWorker的规范中定义的。CacheStorage 可以保存每个serverWorker申明的cache对象，cacheStorage有open、match、has、delete、keys五个核心方法，可以对cache对象的不同匹配进行不同的响应。
cacheStorage.has()如果包含cache对象，则返回一个promise对象。cacheStorage.open()打开一个cache对象，则返回一个promise对象。cacheStorage.delete()删除cache对象，成功则返回一个promise对象，否则返回false。cacheStorage.keys()含有keys中字符串的任意一个，则返回一个promise对象。cacheStorage.delete()匹配key中含有该字符串的cache对象，返回一个promise对象。
caches.has('v1').then(function() { caches.open('v1').then(function(cache) { return cache.addAll(myAssets); });}).catch(function() { someCacheSetupfunction();});;

var response;var cachedResponse = caches.match(event.request).catch(function() { return fetch(event.request);}).then(function(r) { response = r; caches.open('v1').then(function(cache) { cache.put(event.request, response); }); return response.clone();}).catch(function() { return caches.match('/sw-test/gallery/myLittleVader.jpg');});

then.addEventListener('activate', function(event) { var cacheWhitelist = ['v2']; event.waitUntil( caches.keys().then(function(keyList) { return Promise.all(keyList.map(function(key) { if (cacheWhitelist.indexOf(key) === -1) { return caches.delete(keyList[i]); } }); }) );});

https://developer.mozilla/en-US/docs/Web/API/CacheStorage
九、flash缓存
这种方式基本不用，这一方法主要基于flash有读写浏览器端本地目录的功能，同时也可以向js提供调用的api，则页面可以通过js调用flash去读写特定的磁盘目录，达到本地数据缓存的目的。
注释PS
Web Storage / Web SQL Database / Indexed Database 的数据都存储在浏览器对应的用户配置文件目录(user profile directory)下，以 Windows 7 为例，Chrome 的数据存储在”C:\Users\your-account-name\AppData\Local\Google\Chrome\User Data\Default\”下，而 Firefox 的数据存储在”C:\Users\your-account-name\AppData\Local\Mozilla\Firefox\Profiles\”目录下。
cookie文件存储于documents and settings\userName\cookie\文件夹下。通常的命名格式为：userName@domain.txt。

较多的缓存机制目前主流浏览器并不兼容，不过可以使用polyfill的方法来处理

浏览器涉及的缓存方式主要包含这些，具体结合自己的业务场景进行选择使用
https://ouvens.github.io/frontend-javascript/2015/12/28/nine-browser-cache-methods.html

前端面试题总结（js、html、小程序、React、ES6、Vue、算法、全栈热门视频资源）持续更新

参考：https://blog.csdn/MingL520/article/details/88549999

10道经典小程序面试题了解一下

参考：https://www.jianshu/p/832bec01de37

JavaScript中的Object，Function和自定义function之间的区别和联系

 

 

前端面试题大集合

转自:https://segmentfault/a/1190000016481101

express和koa的对比，两者中间件的原理，koa捕获异常多种情况说一下

你项目里用到第三方登录涉及的oAuth(JWT)协议的实现原理，以及你本地的实现原理，第三方登录怎么样保证安全性

说下快排完整性

react和vue的区别，你开发如何选择技术栈

express里面登录的session服务怎么样实现分布式服务

vue的理解

vue的双向数据绑定的原理

vue怎么样实现数组绑定

js的继承

call和apply的区别

ajax是同步还是异步，怎么样实现同步

ajax实现过程

闭包的作用理解，以及那些地方用过闭包，以及闭包的缺点，如何实现闭包

跨域方法以及怎么样实现的与原理

工作中做的项目有什么亮点

webpack工程构建工具怎么样用

数组去重

快排和冒泡原理

http状态码

nodejs了解多少

为什么css样式初始化，目的是为了什么

为什么浏览器会产生同源策略

axios有什么特点

cookie和webstrage的区别以及cookie怎么样使用？原生cookie怎么样封装

三次握手

对跨域了解吗。jsonp的限制

浏览器那些地方用到了异步

css弹性布局，那些地方用到过

position属性有哪些值，分别有什么含义

ES6用过吗，新增了那些东西，你用到过什么

const和let的区别，可以改变const定义对象某个属性吗

箭头函数，箭头函数的特点

js的this理解， 如何改变this的指向

cookie有什么限制

js的事件机制

settimeout的机制

遇到过兼容性的问题吗，要如何处理

项目中使用过构建工具吗

平时如何学习前端的，最近在看的一本书

内存泄露的排除定位和解决方法

垃圾回收机制

websocket实现原理

http状态码301 302的区别，304是啥

缓存机制，协商协议

定时器setTimeout的运行机制

事件循环机制 eventloop

异步es5 es6 es7分别怎么样解决

js的继承的实现方法

清除浮动的方法

常见布局的方法

从输入一个url到浏览器页面展示都经历了哪些过程

new生成了一个对象的过程（核心return this）

请简单说明什么是事件冒泡和事件捕获以及事件委托

实现一个两边宽度固定中间自适应的三列布局，圣杯布局，双飞燕

flex布局有没有了解

请简述一下js原型链

es6有了解吗，请简单说一下promise机制，异步的承诺机制，顺势说一下解决回调地狱的问题

手写一下深拷贝，答案提示：JSON.parse(JSON.stringify(obj)) 用JSON实现深拷贝

== 和 === 的却别，，typeof null的结果是什么

同步和异步的执行顺序

get和post的请求区别

什么情况算是跨域，如何解决跨域问题

一个有序的数组如何进行查找操作

手写一个快速排序

事件委托理解，原理，好处，应用场景

前端框架用过什么？

vue和react的区别

vue的原理

闭包

let和var的区别，let的产生背景？

定宽定高，如何垂直居中，那不定宽定高呢？

https的请求过程

代码规范

项目中遇到过什么难点，如何解决的

尾递归问题

电脑里有很多大小不一样的照片，我现在要复制到U盘上，但是U盘容量固定，让你写一个程序，挑选一组照片，让U盘的剩余空间最小。

后端会哪些语言

讲下如何负载均衡

cookie和session的区别和联系

nodejs是单线程还是多线程的，为什么能去开很多异步请求去访问其他接口

一般你是如何操作数据库的？会哪些数据库

mysql的底层引擎，发布

mysql语言写的如何，怎么样判断sql语句的性能？如何优化？

如何去除数组中的重复的项？

遍历数组处理用for循环还有什么方法吗

浏览器出于安全考虑有？（同源策略）

登录原理

让我设计一个页面，选择男或女，搜索出相对性

发送请求有哪些？

web的安全问题？

自我介绍

JS如何计算浏览器的渲染时间的

浏览器的缓存

var的变量提升底层原理是什么？

event loop讲讲

JS的回收机制说一下

数组常用的方法有哪些

websock的底层原理讲讲

你的聊天室项目，如果数据传输出错了怎么办？

现在有一大段文字，如何在页面中设置一个窗口滚动播出这段文件（轮播），轮播图如何解决卡顿问题，有手写过轮播图你，原理是什么

垂直水平居中的方式

实现三栏布局，中间自适应有几种方法

算法：给你一个无序数字数组，里面是随机的书，并给出一个目标值，求这个数组的两个数，这个数的和等于目标值，要求这两个数并给出下标，
你能想到最优的办法是什么吗（提示：快排，双指针）

算法：给一个无序的数组，让我分割成m组，这个m组里和最大的一组是所有可能的分割情况最小的（二分答案法）

webpack的原理

proto 和prototype分别是什么

原型链原理

在原型链上Object再往上是什么

new和Object.create的区别

哪种情况下__proto__和prototype的指向是同一个？

typeof array null undefined NaN分别是什么

把undefined和null转成Number分别是什么

如何判断是否为数组？（instanceOf和constructor可以，但是有原型链断裂的风险，Object.toString.call()最稳定）

instanceOf和constructor的区别

原型链断裂了以后的结果是什么

如果让你实现一个promise怎么样实现

如何学前端的，看了哪些书

博客写了多少篇

你的技术亮点在哪里

写一下实现合理化

你对三大框架的理解是什么

前端性能理解，优化有哪些

nodejs了解多少

你遇到的最有难度的技术问题是什么

redux原理讲讲

了解web移动开发吗，移动端适配方案有哪些

你有Native开发经验吗，讲下Android如何调用页面的资源

行内元素和块级元素有哪些，img属于什么元素

margin坍塌

BFC原理

写一下清除浮动

写一下不知道宽高元素垂直水平居中方法

写一下节点的增删改

如何获取元素的父节点和兄弟节点

JS如何获得用户来源（navigator.userAgent）

跨域方法说一下

jsonp的原理是什么，处理script标签还可以通过什么实现？（静态资源标签）

原型链说一下

谈谈对原型链继承

前端缓存

给你一个乱序数组，你怎么样排序

你的项目有什么亮点

你的文件上传方案是什么

写一个方法提取一下search里面的参数

写一个API实现insertAfter

CSS3哪些用的比较多

CSS动画会吗，怎么样用CSS实现一个loading效果

如何处理CSS兼容问题

webpack有个插件可以解决css兼容性问题你知道吗（postcss-loader）

ES6新特性说说

ES6的代理是什么
let和var的区别讲讲

箭头函数和ES5和this的指向区别讲讲

前端安全这块了解多少

写一个API，实现jQuery的$(selector)选择器，要求兼容IE6

浏览器是如何实现通过你的代码去找到指定的元素的

用JS模拟一个双向链表

前端工程化思想

模块化思想

你为什么选择前端

cookie，session，localStorage和sessionStorage的区别

Nodejs的线程管理

JS设计模式有哪些

跨域的方法有哪些

说说bind，apply，call的区别以及bind的实现

算法：反转二叉树以及时间复杂度

链表找环

react的virtual DOM和Diff算法

React的生命周期

Vue的生命周期

boostrap的底层原理

图片压缩的原理

如何处理高并发的情况下，用户顺序问题

说一下web安全，xss，csrf防范
csrf流程，举例子

session+cookie的登录机制

token香港，浏览器缓存

vue双向绑定原理，vue-loader做了什么

webpack的插件大致流程

编程题：给出一个字符串(“obj.a”)，返回对象属性obj.a，类似eval的效果

前端路由会不会发请求

画布濡染有了解吗

前端监控，pm2，如果我服务器挂了，如何快速发现并且定位错误

pm2除了监控还能干什么，如何实现

express中间件如何实现

了解TCP吗，数据结构简单介绍一下以及你的想法

webpack项目太大了怎么办

深拷贝

如果弹出的菜单位置过于贴近边框，如何调整这个元素的位置

计算50个人至少有2个生日相同的概率

一个升序数组，求两个元素的和为一个指定数

vue的生命周期

vuex的状态管理的原理是什么

如何在浏览器端和原生端的代码复用，讲到weex又简单讲了它的原理

跨域如何解决

前端性能优化问题

csrf攻击原理以及防御手段

平衡二叉树

如何在上亿规模的数据中找到最大的一个数

最近看过的技术文章和一遍非技术文章（考察表达能力，和主动学习新知识的习惯）

算法题：二叉树层序遍历

JS的全排列

get和post的区别

301和302的区别

如何避免301跳转https

tcp建立连接三次握手的区别

操作系统进程和线程的区别

线程的哪些资源共享，哪些资源不共享

设计模式有哪些

Linux命令用的多吗，怎么样进行进程间通信

kill指令了解过吗

如何画一个三角形

CSS中对溢出的处理

CSS选择器有哪些，优先级呢？

ES6中用过什么

promise的状态有哪些

讲讲JS的闭包

你有用到express吗

express和koa2的区别

讲讲JS的语言特性吗

最近在学啥

项目用到JAVA，反射来讲

你用过什么数据库

MySQL里面的索引用过吗

B+树了解过吗

mongoDB有哪些特点

实现一个两列等高布局，思路

清除浮动的方法

如何让一个元素消失

重排和重绘

HTTP状态码

讲讲304

浏览器缓存机制

强缓存，协商缓存什么时候用哪个

如何判断一个数组

你说到typeof，能不能加一个限制条件typeof只能判断是object，可以判断一下是否拥有数组的方法

JS的如何实现倒计时，为什么不准，校正方式

JS实现跨域

React的特性

nodejs的时间方法讲讲看

nodejs的特性，适合处理什么场景

IO多路复用

前端优化

实现一个ajax，兼容

如何有一个很多的列表，像头条的新闻列表，用户看得多了，列表越来越大，怎么样处理，思考一下

如果有这样的场景：一个模块A作为输出，BCD等扩展模块可以在A做更改后展示A的原来内容或者驾驶CSS后的内容，想想思路

同一个网站，在上海打开慢，在北京打开快，怎么样分析原因，（DNS解析和CDN）

vue react jquery比较，有测试过性能吗

对大前端的理解，前端会发展怎么样

算法：两个排序好的数组，怎么样找他的中位数

React虚拟DOM，生命周期

react父子通信

nodejs如何require一个包

es6和es5的区别

Nodejs加载原生的包与自己定义的包路径如何查找

HTTP2.0的优势

flex弹性布局裂解，移动端适配方案有哪些

页面缓存

页面性能优化

css性能优化，就动画效果，如何从js，cs角度减少回流？

webpack的plugin和loader的区别

es5如何转为es5-babel

了解webpack如何打败

原型基础

BFC

原型链与作用域链

jQuery的源码看过没

移动端开发经验

css会吗

怎么样学前端

遇到问题如何解决

正则如何将一个数千分化表示

js设计模式知道哪些，单例详细说

函数式编程-柯里化

es6的变量定义和es5的区别

JS事件流

七层网络协议，每层干嘛的

tcp三次握手，四次挥手

排序算法有哪些，时间复杂度，选择排序怎么样搞

数据结构有哪些，红黑树和二叉树的区别，二叉搜索树与二叉平衡树

项目经验

树数据多少非常多怎么样办（懒加载）

页面优化方法

设计模式

cookie和session的却别

如果现在重新做这个项目，有什么想优化的

多长时间开始独立做前端，这段时间是如何学习的

学习生涯最失败的事情是什么，怎么样走出来的

如何看待竞争

项目里最难的事情，如何克服

职业规范是怎么样的

是独生子女吗

别人对你的项目认可度，项目做的怎么样

block元素和inline元素的区别

position有哪些，特性

css选择器有哪些

es5和es6：let，const打包后如何变-块级作用域

JS基本数据类型

作用域链

递归

react生命周期

react通信机制

js事件流

redux

flex弹性布局

this

promise如何从then转为catch的

介绍你做过的项目

promise函数

es6模块新特性

浏览器内存泄露，闭包内存泄露如何解决

怎么样让页面加载更快

兼容过IE的方法

缓存

会pc换还是移动端

观察者模式如何实现

行元素，块级元素的却别

css选择器的优先级

水平垂直居中布局

前端性能优化

闭包的概念，平时如何实现

es6的特性以及这些特性如何实现的

事件冒泡，事件捕获，事件委托的原理，如何实现委托，事件，委托的有点是什么，事件监听

输入URL浏览器是如何工作的

requirejs组件化

jQuery和vue的区别

vue的特点

vue的双向绑定原理

谈谈js设计模式

如何实现订阅者发者模式

MVVM实现原理

vue生命周期

vue跨组件通信实现

vue的props和slot的使用，区别

vuex的原理

详细说明解决跨域的方式

前端安全（资源枚举，XSS共计，DOS攻击，CSRF攻击）

HTTP状态码

重排重绘

谈谈JS的异步机制

项目中是是如何优化页面的

如何实现移动端布局，适配方案

call apply bind的区别

深拷贝的实现

jQuery原理，平时用jQuery都做过什么

用过webpack吗，谈一下webpack打包

给了一个settimeout代码输出的顺序

git命令

Linux命令

JS基础有几种

流式布局

对前端的了解和个人规划

html5的新特性

float和position的区别

如何获取当前日期

html语义化，好处

计算器

清除浮动

盒子模型

border-box和content-box

css伪元素有哪些

打开连接到网页呈现的流程

HTTP请求头，响应头里面有哪些

异步加载JS

JS原型

看哪些技术网站

觉得自己的不足

cookie实现

cookie长度限制

http状态码

301 302

性能优化

一个网页很多很多页面，怎么样让用户体验好一点

一个项目可能要延期，怎么样处理

URL长度限制

缓存

什么时候用local，什么时候用session和 storage

长连接

有没有抓过包

有没有用过代理

DNS

图片压缩

gzip

浏览器兼容

webpack css兼容

css性能

垂直居中，水平居中

盒子米线

last-modifined，etg怎么样判断

css动画优化

401状态码

reflow和repaint

应用层协议有哪些

TCP和UDP

有哪些状态码

Ajax如何实现的

Ajax返回204算是成功吗

settimeout异步

tcp ip分成

vue diff算法

vue的生命周期

pwa

vue-router不能解决情况和边界情况

transition生命周期

线程和进程的区别

什么是异步

promise是如何解析异步操作的

如果给a,b,c,d四个时间，执行时间分别为1，2，3，4，怎么样做才能在abc都在执行完后再执行d，除了使用promise还能使用什么方法

数组去重方法

函数节流和函数防抖知道吗，区别是什么

TCP和UDP的区别

HTTP1.0和HTTP1.1相关我让你听

强缓存和协商缓存知道吗

为什么HTTP1.1中使用Cache-Control代替Expires

HTTP1.1中Etg和f-None-Match哪个权重比较大

排序的几种方法知道吗，是如何实现的

栈和队列有什么区别，具体的应用场景

hashmap原理

react中props和state的区别

组件怎么样拿到redux的数据

给你一个DOM元素，用CSS的方式让他呈现两个的想过，只有一个DOM元素

一个数组只有1和2，排序，1在前面，2在后面

js事件模型，捕获和冒泡，阻止冒泡

preventDefault和stopPropagation的区别

HTTP缓存

https

react的事件绑定和原生有什么区别吗

一个数组，有很多数字存在2次，只有一个数字寸一次，怎么样找出这个数字

关于iframe内部和外部变量的读取是如何的

前端防连击throttle和debounce

ES6 generator async/await了解吗

HTTP/2有什么新特性

哈希的原理

如何反转链表

二叉搜索树的原理

给定两个文本文件，找出他们中相同的行都有哪些

对JS单线程的理解

页面共享数据的方法有哪些

amd，cmd规范

用户页面打开很慢，有哪些优化方式

react的虚拟DOM了解什么，这些类型的框架和传统的jd操作dom的优势

koa generator能讲一下吗

如何做单侧，单侧和开发占比应该是多少

hybrid

v-model参数

mvvm，mvc，mvp区别

cdn

网络安全xss，csfr是什么，怎么样解决安全

https怎么样校验证书有效性

websocket协议，nodejs中有哪些实现了这个协议

TCP/IP体系结构以及每层的主要协议

TCP的三次握手

HTTP各版本比较

数据结构学过什么

js如何实现一个栈

哈希表是怎么样的结构

说说操作系统的内存管理

怎么样实现一个服务器

如何删除一个dom节点

浏览器如何渲染页面的

GitHub的项目问

看过什么书

你是如何理解HTML语义化的

HTML的黑钻模型有哪些构成的，盒子模型有哪些，默认是哪些

盒子模型有没有办法把宽度设置为包含padding

浮动元素有没有什么特性

清除浮动的所有方法

ji基本数据类型

typeof去判断数据类型返回值有哪些

说说事件代理利用的是什么原理

阻止冒泡的函数是什么

cookie有什么特征

加入访问A存进了一个cookie，在另外一个页面用ajax向A的域名发请求会携带cookie吗

cookie的其他解决方案

localStorage存储数据格式是什么

怎么样把一个数组存进localSorage

storage有哪些存储方法

html5有哪些新的特性

假设两台电脑之间同步画板如何实现

promise的两个方法，具体实现

es6用的多的有哪些

箭头函数

如果一个页面做辛夷花，从哪些方面考察，从哪些地方优化

vue开发模式和jQuery模式有哪些不同，有哪些优缺点

假设一个object A里面的值n为1，怎么样知道n改变了，有事件绑定吗

react是如何实现数据绑定的

给数字加千位分隔符

HTTP1 SPDY HTTP2的对比

webkit内核渲染页面过程

简单介绍一下backbone

react首次渲染过程

redux和vuex的区别

了解过weex吗

typescript和es6的区别

知道xss吗，介绍一下，如何避免

跨域方式

如何理解html语义化

浏览器如何处理未知的的tab

html5有什么新的tag，canvas…

nodejs的优势，用过nodejs的哪些模块

预约系统如何解决高并发的问题

kut如何优化react的diff，有去提pr吗，为什么

简单说一下ICP UDP

Socks5代理是如何实现的，读过协议吗

http状态码，307是什么，401和403的区别

酸酸是如何实现穿墙的

如何实现文件上传的功能

垂直居中的实现

react和vue的区别

介绍一下盒子模型

实现css动画有哪些

jsonp如何实现，过程

知道哪些http状态码

200和304实现缓存的区别

localstorage和cookie的区别，如何设置cookie

表单提交和ajax的区别

calc属性

symbol

事件监听

常见的请求方式

tcp和http的区别

css的定位属性，怎么样定位的

情景题：给你一个ul列表，找到点击的li对象，把点击到的对象的字符串翻转，讲出思路并且写出代码

只能用获取到对象的属性

小程序的生命周期

小程序的Onlaunch周期不支持同步获取信息之后再执行到下一个生命周期

你怎么样维持用户登录状态的

给你一颗树，如何找到其公共的父节点

你最荣耀的事情

你怎么样知道我们公司的，为什么来我们公司

rem，px，em的区别

协同开发需要注意什么

 

 

 

 

本文标签： 面试题常见