精华内容
下载资源
问答
  • 一、vue相关 Q:vue的底层原理? A:Vue是采用数据劫持配合发布者-订阅者模式,通过Object.defineProperty来()来劫持各个属性的getter和setter。 在数据发生变化的时候,发布消息给依赖收集器,去通知观察者,做出...
  • 转眼2019又要过去了,作为一名前端码农,又熬过一个没日没夜的年头,头发又少了不少,去年的学习计划一半也没完成,唉。。。现在为大家总结一下这一年面试的几家公司的关于前端面试题吧
  • 此文档讲解了WEB前端经典的36道选择题,文档中会有详细的描述与讲解,对于自我能力的进阶和前端知识的巩固,都有很重大的意义和价值。
  • web前端面试题(全)

    2018-07-16 22:05:58
    前端 面试题 js html css 等系列 面试题 全 全!前端 面试题 js html css 等系列 面试题 全 全!
  • WEB前端面试宝典

    2018-09-18 15:48:06
    这个是WEB前端面试宝典,特别详细的面试总结,希望对你有帮助
  • 96道web前端面试题.pdf

    2021-01-30 13:49:17
    整理的web前端面试
  • web前端面试宝典

    2017-06-15 10:12:33
    web前端面试宝典
  • 2021年最新Web前端面试题精选大全及答案

    万次阅读 多人点赞 2021-01-07 11:53:44
    1.网络中使用最多的图片格式有哪些 JPEG,GIF,PNG,最流行的是jpeg格式,可以把文件压缩到最小 在ps以jpeg格式存储时,提供11级压缩级别 2.请简述css盒子模型 一个css盒子从外到内可以分成四个部分:margin...

    目录

    HTML、CSS相关

    Javascript相关

    三者的异同

    Vue相关

    55.Vue路由懒加载(按需加载路由)

    React相关

    react 生命周期函数

    ******为什么虚拟 dom 会提高性能?(必考)

    (组件的)状态(state)和属性(props)之间有何不同

    shouldComponentUpdate 是做什么的

    react diff 原理

    何为受控组件

    调用 super(props) 的目的是什么

    React 中构建组件的方式

    小程序相关的

    其他

    企业中的项目流程

    奇葩问题


    HTML、CSS相关

    1.网络中使用最多的图片格式有哪些

    JPEG,GIF,PNG,最流行的是jpeg格式,可以把文件压缩到最小 在ps以jpeg格式存储时,提供11级压缩级别

    2.请简述css盒子模型

    https://bkimg.cdn.bcebos.com/pic/a9d3fd1f4134970a37cf81a69fcad1c8a6865dfe?x-bce-process=image/resize,m_lfit,w_268,limit_1/format,f_jpg

    一个css盒子从外到内可以分成四个部分:margin(外边距),border(边框),padding(内边距),content(内容)

    默认情况下,盒子的width和height属性只是设置content(内容)的宽和高

    盒子真正的宽应该是:内容宽度+左右填充+左右边距+左右边框

    盒子真正的高应该是:内容高度+上下填充+上下边距+上下边框

    3.视频/音频标签的使用

    视频:<video src=””></video>

    视频标签属性:

    src 需要播放的视频地址

    width/height 设置播放视频的宽高,和img标签的宽高属性一样

    autoplay 是否自动播放

    controls 是否显示控制条

    poster 没有播放之前显示的展位图片

    loop 是否循环播放

    perload 预加载视频(缓存)与autoplay相冲突,设置了autoplay属性,perload属性会失效。

    muted 静音模式

    音频: 音频属性和视频属性差不多,不过宽高和poster属性不能用

    <audio>

    <source src=”” type=””>

    </audio>

    4.HTML5新增的内容有哪些

    新增语义化标签

    新增表单类型

    表单元素

    表单属性

    表单事件

    多媒体标签

    5.Html5 新增的语义化标签有哪些

    语义化标签优点:

    1.提升可访问性 2.seo 3.结构清晰,利于维护

    Header页面头部 main页面主要内容 footer页面底部

    Nav导航栏 aside侧边栏 article加载页面一块独立内容

    Section相当于div  figure加载独立内容(上图下字) figcaption  figure的标题

    Hgroup标题组合标签 mark高亮显示 dialog 加载对话框标签(必须配合open属性)

    Embed加载插件的标签 video加载视频 audio加载音频(支持格式ogg,mp3,wav)

    6.Css3新增的特性

    边框:

    border-radius添加圆角边框       

    border-shadow:给框添加阴影 (水平位移,垂直位移,模糊半径,阴影尺寸,阴影颜色,insetr(内/外部阴影))

    border-image:设置边框图像

    border-image-source 边框图片的路径

    border-image-slice 图片边框向内偏移

    border-image-width 图片边框的宽度

    border-image-outset 边框图像区域超出边框的量

    border-image-repeat 图像边框是否平铺(repeat平铺 round铺满 stretch 拉伸)

    背景:

    Background-size 背景图片尺寸

    Background-origin规定background-position属性相对于什么位置定位

    Background-clip 规定背景的绘制区域(padding-box,border-box,content-box)

    渐变:

    Linear-gradient()线性渐变

    Radial-gradient()径向渐变

    文本效果:

    Word-break:定义如何换行

    Word-wrap:允许长的内容可以自动换行

    Text-overflow:指定当文本溢出包含它的元素,应该干啥

    Text-shadow:文字阴影(水平位移,垂直位移,模糊半径,阴影颜色)

    转换:

    Transform 应用于2D3D转换,可以将元素旋转,缩放,移动,倾斜

    Transform-origin 可以更改元素转换的位置,(改变xyz轴)

    Transform-style 指定嵌套元素怎么样在三位空间中呈现

    2D转换方法:

    rotate旋转 translate(x,y)指定元素在二维空间的位移 scale(n)定义缩放转换

    3D转换方法:

    Perspective(n)为3D转换 translate rotate scale

    过渡:

    Transition-property过渡属性名

    Transition-duration 完成过渡效果需要花费的时间

    Transition-timing-function 指定切换效果的速度

    Transition-delay 指定什么时候开始切换效果

    动画:animation

    Animation-name 为@keyframes动画名称

    animation-duration 动画需要花费的时间

    animation-timing-function 动画如何完成一个周期

    animation-delay 动画启动前的延迟间隔

    animation-iteration-count 动画播放次数

    animation-direction 是否轮流反向播放动画

    7.清除浮动的方式有哪些?请说出各自的优点

    高度塌陷:当所有的子元素浮动的时候,且父元素没有设置高度,这时候父元素就会产生高度塌陷。

    清除浮动方式1:给父元素单独定义高度

    优点:快速简单,代码少 缺点:无法进行响应式布局

    清除浮动方式2:父级定义overflow:hidden;zoom:1(针对ie6的兼容)

    优点:简单快速、代码少,兼容性较高 缺点:超出部分被隐藏,布局时要注意

    清除浮动方式3:在浮动元素后面加一个空标签,clear:both;height:0;overflow:hidden

    优点:简单快速、代码少,兼容性较高。

    缺点:增加空标签,不利于页面优化

    清除浮动方式4:父级定义overflow:auto

    优点:简单,代码少,兼容性好

    缺点:内部宽高超过父级div时,会出现滚动条

    清除浮动方式5:万能清除法:

    给塌陷的元素添加伪对象

    .father:after{

             Content:“随便写”;

             Clear:both;

             display:block;

             Height:0;

             Overflow:hidden;

             Visibility:hidden

    }

    优点:写法固定,兼容性高        缺点:代码多

    8.定位的属性值有何区别

    Position有四个属性值:relative absolute fixed static

    Relative相对定位 不脱离文档流,相对于自身定位

    Absolute 绝对定位,脱离文档流 相对于父级定位

    Fixed 固定定位,脱离文档流,相对于浏览器窗口定位

    Static 默认值,元素出现在正常的流中

    9.子元素如何在父元素中居中

    水平居中:

    1.子父元素宽度固定,子元素设置margin:auto,并且子元素不能设置浮动,否则居中失效

    2.子父元素宽度固定,父元素设置text-align:center,子元素设置display:inline-block,并且子元素不能设置浮动,否则居中失效

    水平垂直居中:

    1. 子元素相对于父元素绝对定位,子元素top,left设置50%,子元素margin-top和margin-left减去各自宽高的一半
    2. 子元素相对于父元素绝对定位,子元素上下左右全为0,然后设置子元素margin:auto
    3. 父元素设置display:table-cell vertical-align:middle,子元素设置margin:auto
    4. 子元素相对定位,子元素top,left值为50%,transform:translate(-50%,-50%)
    5. 子元素相对父元素绝对定位,子元素top,left值为50%,transform:translate(-50%,-50%)
    6. 父元素设置弹性盒子,

    display:flex; justfy-content:center ;align-item:center; justfy-content:center

    10.Border-box与content-box的区别?

    Content-box 标准盒模型 width不包括padding和border

    Border-box 怪异盒模型width包括padding和border

    11.如何让元素垂直居中?

    1).设置子元素和父元素的行高一样

    2).子元素设置为行内块,再加vertical-align:middle

    3).已知父元素高度,子元素相对定位,通过transform:translateY(-50%)

    4).不知道父元素高度,子绝父相,子元素top:50%,transform:translateY(-50%)

    5).创建一个隐藏节点,让隐藏节点的height为剩余高度的一半

    6).给父元素display:table,子元素display:table-cell,vertical-align:middle

    7).给父元素添加伪元素

    8).弹性盒,父元素display:flex,子元素align-self:center

    12.如何让chrome浏览器显示小于12px的文字?

    本来添加谷歌私有属性 -webkit-text-size-adjust:none,现在-webkit-transform:scale()

    13.Css选择器有哪些,那些属性可以继承,优先级如何计算?Css3新增的伪类有哪些?

    Css2选择器:元素选择器,id选择器,群组选择器,类选择器,*通配符选择器,后代选择器

    Css2伪类选择器:a:link/visited/hover/active

    Css3选择器:空格 >  +相邻兄弟选择器  ~通用选择器(查找后面所有)

    结构伪类选择器:

    查找第几个nth-child(n)

    查找同一类型第几个nth-of-type

    查找唯一类型 only-of-type

    属性选择器:根据标签属性查找 [attr=value]

    : root 查找根元素html标签

    : empty 查赵空标签

    目标伪类选择器:(表单)

    :enabled 查找可以使用的标签

    :disabled 查找禁止使用的标签

    :checked 查找被选中的标签

    伪元素选择器 ::selection设置选中文本内容的高亮显示(只能用于背景色和文本颜色)

    否定伪类选择器 not()

    语言伪类选择器 lang(取值)

    优先级(权重):

    元素选择器1

    伪元素选择器1

    class选择器10

    伪类选择器10

    属性选择器10

    Id选择器100

    内联样式的权重1000

    包含选择器权重为权重之和

    继承样式权重为0

    那些属性可以继承:

    Css继承特性主要是文本方面

    所有元素可继承:visibility和cursor

    块级元素可继承:text-indent和text-align

    列表元素可继承:list-style,list-style-type,list-style-position,list-style-image

    内联元素可继承:letter-spacing,word-spacing,line-height,color,font,font-family,font-size

    Font-style,font-variant,font-weight,text-decoration,text-transform,direction

    字母间距 段落间距  行高   字体颜色 字体种类 字体大小 字体样式  字体粗细 小型大写字母文本 文本修饰 转换不同元素中的文本 文本方向

    14.网页中有大量图片加载很慢 你有什么办法进行优化?

    1.图片懒加载,在图片未可视区域加一个滚动条事件,判断图片位置与浏览器顶端和页面的距离,如果前者小鱼后者,优先加载

    2.使用图片预加载技术,将当前展示图片的前一张和后一张优先下载

    3.使用csssprite或者svgsprite

    15.行内元素/块级元素有哪些?

    行内元素:相邻的行内元素会排列在同一行,不会独占一行 设置宽高无效 span

    块级元素:会独占一行 可以设置宽高等属性div

    可变元素:根据上下文预警决定该元素为块元素还是内联元素

    块级元素:div h1-h6 hr p ul ol table address blockquote dir from menu

    行内元素:a br I em img input select span sub sup u textarea

    可变元素:button del iframe ins

    16.浏览器的标准模式和怪异模式区别?

    标准模式:浏览器按照W3C标准解析执行代码

    怪异模式:浏览器根据自己的方式解析执行代码,因为不同浏览器解析执行方式不一样,所以叫怪异模式

    区别:

    1. 在怪异模式下,盒模型为怪异盒模型 而在标准模式下为标准盒子模型
    2. 图片元素的垂直对齐方式     对于行内元素和table-cell元素,标准模式下vertical-align属性默认值是baseline,而在怪异模式下,table单元格中的图片的vertical-align属性默认值是bottom,因此在图片底部会有几像素的空间
    3. 元素中的字体         css中font的属性都是可以继承的,怪异模式下,对于table元素,字体的某些元素不能从其他封装元素继承中得到,特别是font-size属性
    4. 内联元素的尺寸     标准模式下,non-replaced inline元素无法自定义大写,怪异模式下,定义元素的宽高会影响元素的尺寸
    5. 元素的百分比高度         当一个元素使用百分比高度时,在标准模式下,高度取决于内容变化,在怪异迷失下,百分比被准确应用
    6. 元素溢出的处理              标准模式下,overflow取值默认值为visible,在怪异模式下,这个溢出会被当做扩展box对待,就是元素的大小由内容决定,溢出不会裁剪,元素框自动调整,包含溢出内容

    17.Margin和padding在什么场合下使用

    Margin外边距 自身边框到另一个边框之间的距离

    Padding 内边距 自身边距到自身内容之间的距离

    当需要在border外侧添加空白时用margin,当需要在border内侧添加空白时用padding

    18.弹性盒子布局属性有那些请简述?

    Flex-direction:弹性容器中子元素排列方式(主轴排列方式)

    Flex-wrap:设置弹性盒子的子元素超出父容器时是否换行

    Flex-flow:是flex-direction和flex-wrap简写形式

    Align-item:设置弹性盒子元素在侧轴上的对齐方式

    Align-content:设置行对齐

    Justify-content:设置弹性盒子元素在主轴上的对齐方式

    19.怎么实现标签的禁用

    添加disabled属性

    20.Flex布局原理

    就是通过给父盒子添加flex属性,来控制子盒子的位置和排列方式

    21.Px,rem,em的区别

    Px,绝对长度单位,像素px是相对于显示器屏幕分辨率来说的

    em 相对长度单位,相对于当前对象内文本的字体尺寸

             em的值并不是固定的

             em会继承父级元素的字体大小(参考物是父元素的font-size)

             em中所有的字体都是相对于父元素的大小决定的

    rem 相对于html根元素的font-size

    1em=1rem=16px 在body中加入font-size:62.5% 这样直接就是原来的px数值除以10加上em就可以

    22.网页的三层结构有哪些

    结构(html或xhtm标记语言)表现(css样式表)行为(js)

    1. 请简述媒体查询

    媒体查询扩展了media属性, 就是根据不同的媒体类型设置不同的css样式,达到自适应的目的。

    1. Rem缺点

    比如:小说网站,屏幕越小的移动设备如果用了rem肯定文字就越小,就会导致看文章的时候特别费眼

    25.常见的兼容性一阶段内容中记几个

    26.垂直与水平居中的方式

    27.三栏布局方式两边固定中间自适应

    1. margin负值法:左右两栏均左浮动,左右两栏采用负的margin值。中间栏被宽度为100%的浮动元素包起来

    2. 自身浮动法:左栏左浮动,右栏右浮动,中间栏放最后

    3. 绝对定位法:左右两栏采用绝对定位,分别固定于页面的左右两侧,中间的主体栏用左右margin值撑开距离。

    4.flex  左右固定宽  中间flex:1

    5.网格布局

    6. table布局

    28.Doctype作用

    声明文档类型

    Javascript相关

    1.Js基本数据类型有哪些

    字符串String 数值Number  布尔boolean   null  undefined  对象 数组

    2.Ajax如何使用

    一个完整的AJAX请求包括五个步骤:

    1. 创建XMLHTTPRequest对象
    2. 使用open方法创建http请求,并设置请求地址

    xhr.open(get/post,url,async,true(异步),false(同步))经常使用前三个参数

    1. 设置发送的数据,用send发送请求
    2. 注册事件(给ajax设置事件)
    3. 获取响应并更新页面

    3.如何判断一个数据是NaN

    NaN 非数字 但是用typeof检测是number类型

    1. 利用NaN的定义  用typeof判断是否为number类型并且判断是否满足isnan
    2. 利用NaN是唯一一个不等于任何自身的特点 n!==n
    3. 利用ES6中提供的Object.is()方法(判断两个值是否相等)  n==nan
    4. Js中null与undefined区别

    相同点:用if判断时,两者都会被转换成false

    不同点:

    number转换的值不同 number(null)为0   number(undefined)为NaN

    Null表示一个值被定义了,但是这个值是空值

    Undefined 变量声明但未赋值

    5.闭包是什么?有什么特性?对页面会有什么影响

    闭包可以简单理解成:定义在一个函数内部的函数。其中一个内部函数在包含它们的外部函数之外被调用时,就会形成闭包。

    特点:

    1.函数嵌套函数。

    2.函数内部可以引用外部的参数和变量。

    3.参数和变量不会被垃圾回收机制回收。

    使用:

    1.读取函数内部的变量;

     2.这些变量的值始终保持在内存中,不会在外层函数调用后被自动清除。

    优点:

    1:变量长期驻扎在内存中;

    2:避免全局变量的污染;

    3:私有成员的存在 ;

    缺点:会造成内存泄露

    6.Js中常见的内存泄漏:

    1.意外的全局变量

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

    3.脱离DOM的引用

    4.闭包

    7.事件委托是什么?如何确定事件源(Event.target  谁调用谁就是事件源)

    JS高程上讲:事件委托就是利用事件冒泡,只制定一个时间处理程序,就可以管理某一类型的所有事件。

    事件委托,称事件代理,是js中很常用的绑定事件的技巧,事件委托就是把原本需要绑定在子元素的响应事件委托给父元素,让父元素担当事件监听的职务,事件委托的原理是DOM元素的事件冒泡

    8.什么是事件冒泡?

    一个事件触发后,会在子元素和父元素之间传播,这种传播分为三个阶段,

    捕获阶段(从window对象传导到目标节点(从外到里),这个阶段不会响应任何事件),目标阶段,(在目标节点上触发),冒泡阶段(从目标节点传导回window对象(从里到外)),事件委托/事件代理就是利用事件冒泡的机制把里层需要响应的事件绑定到外层

    9.本地存储与cookie的区别

    Cookie 是小甜饼的意思。顾名思义,cookie 确实非常小,它的大小限制为4KB左右。它的主要用途有保存登录信息,比如你登录某个网站市场可以看到“记住密码”,这通常就是通过在 Cookie 中存入一段辨别用户身份的数据来实现的。

    localStorage

    localStorage 是 HTML5 标准中新加入的技术,它并不是什么划时代的新东西。早在 IE 6 时代,就有一个叫 userData 的东西用于本地存储,而当时考虑到浏览器兼容性,更通用的方案是使用 Flash。而如今,localStorage 被大多数浏览器所支持,如果你的网站需要支持 IE6+,那以 userData 作为你方案是种不错的选择。

    sessionStorage

    sessionStorage 与 localStorage 的接口类似,但保存数据的生命周期与 localStorage 不同。做过后端开发的同学应该知道 Session 这个词的意思,直译过来是“会话”。而 sessionStorage 是一个前端的概念,它只是可以将一部分数据在当前会话中保存下来,刷新页面数据依旧存在。但当页面关闭后,sessionStorage 中的数据就会被清空。

    三者的异同

    特性

    Cookie

    localStorage

    sessionStorage

    数据的生命期

    一般由服务器生成,可设置失效时间。如果在浏览器端生成Cookie,默认是关闭浏览器后失效

    除非被清除,否则永久保存

    仅在当前会话下有效,关闭页面或浏览器后被清除

    存放数据大小

    4K左右

    一般为5MB

    与服务器端通信

    每次都会携带在HTTP头中,如果使用cookie保存过多数据会带来性能问题

    仅在客户端(即浏览器)中保存,不参与和服务器的通信

    易用性

    需要程序员自己封装,源生的Cookie接口不友好

    源生接口可以接受,亦可再次封装来对Object和Array有更好的支持

    10.ES6新特性

    const和let、模板字符串、箭头函数、函数的参数默认值、对象和数组解构、for...of 和 for...in、ES6中的类

    11.Let与var与const的区别

    Var声明的变量会挂载在window上,而let和const声明的变量不会

    Var声明的变量存在变量提升,let和const不存在变量提升

    同一作用域下var可以声明同名变量,let和const、不可以

    Let和const声明会形成块级作用域

    Let暂存死区

    Const一旦声明必须赋值,不能用null占位,声明后不能再修改,如果声明的是复合类型数据,可以修改属性

    12.数组方法有哪些请简述

    push() 从后面添加元素,返回值为添加完后的数组的长度

    arr.pop() 从后面删除元素,只能是一个,返回值是删除的元素

    arr.shift() 从前面删除元素,只能删除一个 返回值是删除的元素

    arr.unshift() 从前面添加元素, 返回值是添加完后的数组的长度

     arr.splice(i,n) 删除从i(索引值)开始之后的那个元素。返回值是删除的元素

    arr.concat() 连接两个数组 返回值为连接后的新数组

    str.split() 将字符串转化为数组

     arr.sort() 将数组进行排序,返回值是排好的数组,默认是按照最左边的数字进行排序,不是按照数字大小排序的

    arr.reverse() 将数组反转,返回值是反转后的数组

     arr.slice(start,end) 切去索引值start到索引值end的数组,不包含end索引的值,返回值是切出来的数组

     arr.forEach(callback) 遍历数组,无return  即使有return,也不会返回任何值,并且会影响原来的数组

     arr.map(callback) 映射数组(遍历数组),有return 返回一个新数组 。

     arr.filter(callback) 过滤数组,返回一个满足要求的数组 

    13.Json如何新增/删除键值对

    14.什么是面向对象请简述

    面向对象是一种思想,是基于面向过程而言的,就是说面向对象是将功能等通过对象来实现,将功能封装进对象之中,让对象去实现具体的细节;这种思想是将数据作为第一位,这是对数据一种优化,操作起来更加的方便,简化了过程。

    Js本身是没有class类型的,但是每个函数都有一个prototype属性,prototype指向一个对象,当函数作为构造函数时,prototype就起到类似于class的作用

    面向对象有三个特点:封装(隐藏对象的属性和实现细节,对外提供公共访问方式),

    继承(提高代码复用性,继承是多态的前提),多态(是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象)

    15.普通函数和构造函数的区别

    1.构造函数也是一个普通函数,创建方式和普通函数一样,但是构造函数习惯上首字母大写

    2.调用方式不一样,普通函数直接调用,构造函数要用关键字new来调用

    3.调用时,构造函数内部会创建一个新对象,就是实例,普通函数不会创建新对象

    4.构造函数内部的this指向实例,普通函数内部的this指向调用函数的对象(如果没有对象调用,默认为window)

    5.构造函数默认的返回值是创建的对象(也就是实例),普通函数的返回值由return语句决定

    6.构造函数的函数名与类名相同

    *****16.请简述原型/原型链/(原型)继承*****

    什么是原型:
        任何对象实例都有一个原型,也叫原型对象,这个原型对象由对象的内置属性_proto_指向它的构造函数的prototype指向的对象,即任何对象都是由一个构造函数创建的,但是不是每一个对象都有prototype,只有方法才有prototype。
    什么是原型链?
    原型链基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。我们知道,每个构造函数都有一个原型对象,每个原型对象都有一个指向构造函数的指针,而实例又包涵一个指向原型对象的内部指针。
        原型链的核心就是依赖对象的_proto_的指向,当自身不存在的属性时,就一层层的扒出创建对象的构造函数,直至到Object时,就没有_proto_指向了。
    因为_proto_实质找的是prototype,所以我们只要找这个链条上的构造函数的prototype。其中Object.prototype是没有_proto_属性的,它==null。

    每个构造函数都有一个原型对象,原型对象都包含一个指向构造函数的指针,而实例都包含指向原型对象内部的指针。我们让原型对象(1)等于另一个原型对象的实例(2),
    此时原型对象(2)将包含一个指向原型对象(1)的指针,
    再让原型对象(2)的实例等于原型对象(3),如此层层递进就构成了实例和原型的链条,这就是原型链的概念

    每个构造函数都有一个原型对象,原型对象都包含一个指向构造函数想指针(constructor),而实例对象都包含一个指向原型对象的内部指针(__proto__)。如果让原型对象等于另一个原型对象的实例,此时的原型对象将包含一个指向另一个原型的指针(__proto__),另一个原型也包含着一个指向另一个构造函数的指针(constructor)。假如另一个原型又是另一个类型的实例……这就构成了实例与原型的链条。也叫原型链
    原型继承是js的一种继承方式,原型链作为实现继承的主要方法,其基本思路是利用原型让一个引用类型继承另一个引用类型的属性和方法, 
    原型继承:利用原型中的成员可以被和其相关的对象共享这一特性,可以实现继承,这种实现继承的方式,就叫做原型继承.

    17.Promise的理解 

    一、什么是Promise?我们用Promise来解决什么问题?
    我们都知道,Promise是承诺的意思,承诺它过一段时间会给你一个结果。
    Promise 是一种解决异步编程的方案,相比回调函数事件更合理和更强大。
    从语法上讲,promise是一个对象,从它可以获取异步操作的消息;
    二、promise有三种状态:pending 初始状态也叫等待状态,fulfiled成功状态,rejected失败状态;状态一旦改变,就不会再变。创造promise实例后,它会立即执行。
    三、Promise的两个特点
    1、Promise对象的状态不受外界影响
    2、Promise的状态一旦改变,就不会再变,任何时候都可以得到这个结果,状态不可以逆,
    四、Promise的三个缺点
    1)无法取消Promise,一旦新建它就会立即执行,无法中途取消
    2)如果不设置回调函数,Promise内部抛出的错误,不会反映到外部
    3)当处于pending(等待)状态时,无法得知目前进展到哪一个阶段,是刚刚开始还是即将完成

    promise是用来解决两个问题的:
    1.回调地狱,代码难以维护, 常常第一个的函数的输出是第二个函数的输入这种现象
    2.promise可以支持多并发的请求,获取并发请求中的数据
    这个promise可以解决异步的问题,本身不能说promise是异步的     

    19.请简述async的用法

    Async就是generation和promise的语法糖,async就是将generator的*换成async,将yiled换成await

    函数前必须加一个async,异步操作方法前加一个await关键字,意思就是等一下,执行完了再继续走,注意:await只能在async函数中运行,否则会报错

    Promise如果返回的是一个错误的结果,如果没有做异常处理,就会报错,所以用try..catch捕获一下异常就可以了

    20.. 一个页面从输入 URL 到页面加载显示完成,这个过程中都发生了什么?

    分为4个步骤:

    1. 当发送一个 URL 请求时,不管这个 URL 是 Web 页面的 URL 还是 Web 页面上每个资源的 URL,浏览器都会开启一个线程来处理这个请求,同时在远程 DNS 服务器上启动一个 DNS 查询。这能使浏览器获得请求对应的 IP 地址。

    2. 浏览器与远程 Web 服务器通过 TCP 三次握手协商来建立一个 TCP/IP 连接。该握手包括一个同步报文,一个同步-应答报文和一个应答报文,这三个报文在 浏览器和服务器之间传递。该握手首先由客户端尝试建立起通信,然后服务器响应并接受客户端的请求,最后由客户端发出该请求已经被接受的报文。

    3. 一旦 TCP/IP 连接建立,浏览器会通过该连接向远程服务器发送 HTTP 的 GET 请求。远程服务器找到资源并使用 HTTP 响应返回该资源

    4. 此时,Web 服务器提供资源服务,客户端开始下载资源。

    jQuery相关的知识

    Css预处理sass less是什么?为什么使用他们

    Sass和less都是css预处理器,是css上的一种抽象层,是一种特殊的语法,最终会编译成css,less是一种动态样式语言,给css赋予了动态语言的特性,比如:变量,继承,嵌套。Less既可以在客户端运行,在可以在服务端运行(需要借助node)

    Js中.call()与.apply()区别

    apply:调用一个对象的一个方法,用另一个对象替换当前对象。

    call:调用一个对象的一个方法,用另一个对象替换当前对象。

    从定义中可以看出,call和apply都是调用一个对象的一个方法,用另一个对象替换当前对象。而不同之处在于传递的参数,apply最多只能有两个参数——新this对象和一个数组argArray,如果arg不是数组则会报错

    相同点:两个方法产生的作用是完全一样的。call, apply作用就是借用别人的方法来调用,就像调用自己的一样.

    不同点:方法传递的参数不同

    为什么会造成跨域/请简述同源策略

    出现跨域问题的原因:

    在前后端分离的模式下,前后端的域名是不一致的,此时就会发生跨域访问问题。在请求的过程中我们要想回去数据一般都是post/get请求,所以..跨域问题出现

    跨域问题来源于JavaScript的同源策略,即只有 协议+主机名+端口号(如存在)相同,则允许相互访问。也就是说JavaScript只能访问和操作自己域下的资源,不能访问和操作其他域下的资源。

    同源策略 是由NetScape提出的一个著名的安全策略。所谓的同源,指的是协议,域名,端口相同。浏览器处于安全方面的考虑,只允许本域名下的接口交互,不同源的客户端脚本,在没有明确授权的情况下,不能读写对方的资源。

    请输出三种减少页面加载时间的方式

    1. 优化图片 

    2. 图像格式的选择(GIF:提供的颜色较少,可用在一些对颜色要求不高的地方) 

    3. 优化CSS(压缩合并css,如 margin-top, margin-left...) 

    4. 网址后加斜杠(如www.campr.com/目录,会判断这个目录是什么文件类型,或者是目录。)  cdn托管

    5. 标明高度和宽度(如果浏览器没有找到这两个参数,它需要一边下载图片一边计算大小,如果图片很多,浏览器需要不断地调整页面。这不但影响速度,也影响浏览体验。 

    当浏览器知道了高度和宽度参数后,即使图片暂时无法显示,页面上也会腾出图片的空位,然后继续加载后面的内容。从而加载时间快了,浏览体验也更好了) 

    6. 减少http请求(合并文件,合并图片)

    This指向

    在JavaScript中,this通常指向的是我们正在执行的函数本身,或者是,指向该函数所属的对象。

    全局的this → 指向的是Window

    对象中的this → 指向其本身

    事件中this → 指向事件对象

    什么是jsonp工作原理是什么?他为什么不是真正的ajax

    Jsonp其实就是一个跨域解决方案。

    Js跨域请求数据是不可以的,但是js跨域请求js脚本是可以的

    所以可以把要请求的数据封装成一个js语句,做一个方法的调用。

    跨域请求js脚本可以得到此脚本。得到js脚本之后会立即执行。

    可以把数据做为参数传递到方法中。就可以获得数据。从而解决跨域问题。

    jsonp原理:(动态创建script标签,回调函数)

    浏览器在js请求中,是允许通过script标签的src跨域请求,可以在请求的结果中添加回调方法名,在请求页面中定义方法,就可获取到跨域请求的数据。

    为什么不是真正的 ajax?    

    1、ajax和jsonp这两种技术在调用方式上"看起来"很像,目的也一样,都是请求一个url,然后把服务器返回的数据进行处理,因此jquery和ext等框架都把jsonp作为ajax的一种形式进行了封装;

    2、但ajax和jsonp其实本质上是不同的东西。ajax的核心是通过XmlHttpRequest获取本页内容,而jsonp的核心则是动态添加<script>标签来调用服务器提供的js脚本。

    3、所以说,其实ajax与jsonp的区别不在于是否跨域,ajax通过服务端代理一样可以实现跨域,jsonp本身也不排斥同域的数据的获取。

    4、还有就是,jsonp是一种方式或者说非强制协议,如同ajax一样,它也不一定非要json格式来传递数据,如果你愿意,字符换也行,只不过这样不利于jsonp提供公开服务。

    请掌握2种以上数组去重的方式

    1. 使用indexof()方法
    2. 使用lastindexof()方法  和indexof方法一样  indexof从头部开始匹配  lastindexof从尾部匹配
    3. ES6的set结构  set不接受重复数据
    4.  使用sort方法先将原数组排序,然后与相邻的比较,如果不同则存入新数组
    5. 使用filiter和indexof方法
    6. 使用ES6 的set和扩展运算符
    7. 使用set和Array.from()方法             array.from可以将set结构转成数组
    8. 用splice和双层循环
    9. 使用includes方法

    深浅拷贝是什么如何实现?

    深拷贝:指针赋值,并且内容拷贝、                                                                浅拷贝:只是简单的指针赋值                                                                  数组浅拷贝: 如果是数组,可以使用数组的一些方法实现:slice(),concat()返回一个新数组的特性实现拷贝。用扩展运算符spread实现                                                                 数组深拷贝: JSON.parse(JSON.stringify())不仅适用于数组还适用于对象。不能拷贝函数,undefined,symbol。

    为什么js是弱类型语言

    弱类型语言实现相对于强类型语言来说的,在强类型语言中,变量类型有多种,比如int char float Boolean  不同类型相互转换有时需要强制转换,而jacascript只有一种类型var,为变量赋值时会自动判断类型并转换,所以是弱类型语言。

    怎么转换less为css

    1. 用node将less文件生成为css文件

    2.用webstorm自动生成

    echarts使用最多的是什么

    图表及图表组合

    For循环与map循环有什么区别

    For遍历对象自身的和继承可枚举的属性,也就是说会包括哪些原型链上的属性

    Map方法不会对空数组进行检测,map会返回一个新数组,不会对原数组产生影响

    请写出一个简单的类与继承

    创建类有三种:

    1. 使用function和this关键字
    2. 原型方法  用prototype和this关键字
    3. 使用object.create()方法构造

    继承有六种:原型继承        借用构造函数继承        组合继承        原型式继承    寄生式继承         寄生组合式继承

    同步与异步的区别/阻塞与非阻塞区别

    同步(阻塞的)

    异步(非阻塞)

    比如:同步,咱两在一起上班,到吃饭时间了,我去喊你一起吃饭,你很忙,我就坐着等你忙完再一起去吃饭

             异步,咱两在一起上班,到吃饭时间了,我去喊你一起吃饭,你很忙,我就先自己去吃了,你忙完了再去吃饭

    同步(阻塞)异步(非阻塞)这两个关注的是程序在等待调用结果时的状态

    重绘和回流是什么

    回流:当render tree中的一部分或者全部因为元素的规模尺寸,布局,隐藏等改变而需要重新构建,这就叫回流,每个页面至少需要一次回流,就是在页面第一次加载的时候,这时候一定会发生回流,因为要构建render tree

    在回流的时候,浏览器会使渲染树中收到影响的部分失效,并重新构造这部分渲染树,完成回流后,浏览器会重新绘制受影响的部分到屏幕中,这就是重绘

    render tree中的一些元素需要更新属性,而这些属性只是影响元素的外观,不会影响布局,就叫重绘

    http是什么?有什么特点

    http叫做超文本传输协议,是互联网应用最广泛的一种网络协议

    特点:基于请求-响应的模式   无状态保存   无连接

    HTTP协议和HTTPS区别

    1. http是超文本传输协议,信息是明文传输,https是具有安全性的ssl解密传输协议
    2. http和https连接方式完全不同,端口也不同,http是80,https是443
    3. http的连接很简单,是无状态的,https协议是由ssl+http协议构建的可进行加密传输,身份认证的网络协议,比http协议安全

    原型和继承,prototype,call和apply继承的区别(第一个参数是相同的,第二个的区别在哪)

    apply()接收两个参数,一个是函数运行的作用域(this),另一个是参数数组。

    call()方法第一个参数与apply()方法相同,但传递给函数的参数必须列举出来。

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

    1. 箭头函数是匿名函数,不能作为构造函数,不能使用new
    2. 箭头函数不能绑定arguments,要用rest参数解决
    3. 箭头函数没有原型属性
    4. 箭头函数的this永远指向其上下文的this,
    5. 箭头函数不能绑定this,会捕获其所在的上下文的this值,作为自己的this值

    什么是js内存泄露?

    内存泄漏是指一块被分配的内存既不能使用又不能回收,直到浏览器进程结束

    释放内存的方法:赋值为null

    你如何对网站的文件和资源进行优化?

    1、文件合并(目的是减少http请求)

    2、文件压缩(目的是直接减少文件下载的体积)

    3、使用cdn托管资源

    4、使用缓存

    5、gizp压缩你的js和css文件

    6、meta标签优化(title,description,keywords)、heading标签的优化、alt优化             7、反向链接,网站外链接优化

    请简述ajax的执行过程 以及常见的HTTP状态码

    100:这个状态码是告诉客户端应该继续发送请求,这个临时响应是用来通知客户端的,部分的请求服务器已经接受,但是客户端应继续发送求请求的剩余部分,如果请求已经完成,就忽略这个响应,而且服务器会在请求完成后向客户发送一个最终的结果

    200:这个是最常见的http状态码,表示服务器已经成功接受请求,并将返回客户端所请求的最终结果

    202:表示服务器已经接受了请求,但是还没有处理,而且这个请求最终会不会处理还不确定

    204:服务器成功处理了请求,但没有返回任何实体内容 ,可能会返回新的头部元信息

    301:客户端请求的网页已经永久移动到新的位置,当链接发生变化时,返回301代码告诉客户端链接的变化,客户端保存新的链接,并向新的链接发出请求,已返回请求结果

    404:请求失败,客户端请求的资源没有找到或者是不存在

    500:服务器遇到未知的错误,导致无法完成客户端当前的请求。

    503:服务器由于临时的服务器过载或者是维护,无法解决当前的请求

    预加载和懒加载的区别,预加载在什么时间加载合适

             预加载是指在页面加载完成之前,提前将所需资源下载,之后使用的时候从缓存中调用;懒加载是延迟加载,按照一定的条件或者需求等到满足条件的时候再加载对应的资源

    两者主要区别是一个是提前加载,一个是迟缓甚至不加载。懒加载对服务器前端有一定的缓解压力作用,预加载则会增加服务器前端压力。

    Jquery选择器有哪些

    一、基本选择器
    基本选择器是jQuery中最常用也是最简单的选择器,它通过元素的id、class和标签名等来查找DOM元素。
    1、ID选择器 #id
    描述:根据给定的id匹配一个元素, 返回单个元素(注:在网页中,id名称不能重复)
    示例:$("#test") 选取 id 为 test 的元素
    2、类选择器 .class
    描述:根据给定的类名匹配元素,返回元素集合
    示例:$(".test") 选取所有class为test的元素
    3、元素选择器 element
    描述:根据给定的元素名匹配元素,返回元素集合
    示例:$("p") 选取所有的<p>元素
    4、*
    描述:匹配所有元素,返回元素集合
    示例:$("*") 选取所有的元素
    5、selector1,selector2,...,selectorN
    描述:将每个选择器匹配到的元素合并后一起返回,返回合并后的元素集合
    示例:$("p,span,p.myClass") 选取所有<p>,<span>和class为myClass的<p>标签的元素集合
    二、层次选择器
    层次选择器根据层次关系获取特定元素。
    1、后代选择器
    示例:$("p span") 选取<p>元素里的所有的<span>元素(注:后代选择器选择父元素所有指定选择的元素,不管是儿子级,还是孙子级)
    2、子选择器 $("parent>child")
    示例:$("p>span") 选择<p>元素下的所有<span>元素 (注:子选择器只选择直属于父元素的子元素)
    3、同辈选择器 $("prev+next")
    描述:选取紧接在prev元素后的next元素,返回元素集合
    示例:$(".one+p") 选取class为one的下一个<p>同辈元素集合
    4、同辈选择器 $("prev~siblings")
    描述:选取prev元素后的所有siblings元素,返回元素集合
    示例:$("#two~p")选取id为two的元素后所有<p>同辈元素集合
    三、过滤选择器
    1>基本过滤选择器
    1、 :first
    描述:选取第一个元素,返回单个元素
    示例:$("p:first") 选取所有<p>元素中第一个<p>元素
    2、 :last
    描述:选取最后一个元素,返回单个元素
    示例:$("p:last") 选取所有<p>元素中最后一个<p>元素
    3、 :not(selector)
    描述:去除所有与给定选择器匹配的元素,返回元素集合
    示例:$("input:not(.myClass)") 选取class不是myClass的<input>元素
    4、 :even
    描述:选取索引是偶数的所有元素,索引从0开始,返回元素集合
    5、 :odd
    描述:选取索引是奇数的所有元素,索引从0开始,返回元素集合
    6、 :eq(index)
    描述:选取索引等于index的元素,索引从0开始,返回单个元素
    7、 :gt(index)
    描述:选取索引大于index的元素,索引从0开始,返回元素集合
    8、 :lt(index)
    描述:选取索引小于于index的元素,索引从0开始,返回元素集合
    9、 :focus
    描述:选取当前获取焦点的元素
    2>内容过滤选择器
    1、:contains(text)
    描述:选取含有文本内容为text的元素,返回元素集合
    示例:$("p:contains('我')") 选取含有文本“我”的元素
    2、:empty
    描述:选取不包含子元素或者文本元素的空元素,返回元素集合
    示例:$("p:empty") 选取不包含子元素或者文本元素的空<p>元素(<p></p>)
    3、:has(selector)
    描述:选取含有选择器所匹配的元素的元素,返回元素集合
    示例:$("p:has(p)") 选取含有<p>元素的<p>元素(<p><p/></p>)
    4、:parent
    描述:选取含有子元素或者文本的元素,返回元素集合
    示例:$("p:parent") 选取含有子元素或者文本元素的<p>元素(<p><p/></p>或者<p>文本</p>)
    3>可见性过滤选择器
    1、:hidden
    描述:选取所有不可见的元素,返回元素集合
    2、:visible
    描述:选取所有可见的元素,返回元素集合
    4>属性过滤选择器(返回元素集合)
    1、[attribute]
    示例:$("p[id]") 选取拥有id属性的p元素
    2、[attribute=value]
    示例:$("input[name=text]") 选取拥有name属性等于text的input元素
    3、[attribute!=value]
    示例:$("input[name!=text]") 选取拥有name属性不等于text的input元素
    4、[attribute^=value]
    示例:$("input[name^=text]") 选取拥有name属性以text开始的input元素
    5、[attribute$=value]
    示例:$("input[name$=text]") 选取拥有name属性以text结束的input元素
    6、[attribute*=value]
    示例:$("input[name*=text]") 选取拥有name属性含有text的input元素
    7、[attribute~=value]
    示例:$("input[class~=text]") 选取拥有class属性以空格分割的值中含有text的input元素
    8、[attribute1][attribute2][attributeN]
    描述:合并多个属性过滤选择器
    5>表单对象属性过滤选择器(返回元素集合)
    1、:enabled
    描述:选取所有可用元素
    2、:disabled
    描述:选取所有不可用元素
    3、:checked
    描述:选取所有被选中的元素(单选框,复选框)
    示例:$("input:checked") 选取所有被选中的<input>元素
    4、:selected
    描述:选取所有被选中的选项元素(下拉列表)
    示例:$("select option:selected") 选取所有被选中的选项元素

    Jquery插入节点的方法

    append()  向每个匹配的元素内部追加内容

    appendTo()  将所有匹配的元素追加到指定元素中,实际上,使用该方法是颠倒了常规的$(A).append(B)的操作 将A追加到B中

    prepend()  向每个匹配的元素内部前置内容

    prependTo()  将所有匹配的元素前置到指定的元素中。实际上,使用该方法是颠倒了常规的$(A).prepend(B)的操作,即不是将B前置到A中,而是将A前置到B中

    after()  在每个匹配的元素之后插入内容

    insertAfter()  将所有匹配的元素插入到指定元素的后面。实际上,使用该方法是颠倒了常规的$(A).after(B)的操作,即不是讲B插入到A后面,而是将A插入到B后面

    before()  在每个匹配的元素之前插入内容

    insertBefore()  将所有匹配的元素插入到指定的元素的前面。实际上,使用该方法是颠倒了常规的$(A).before(B)的操作,即不是将B插入到A前面,而是将A插入到B前面

    Js的函数节流和函数防抖的区别

    函数节流是指一定时间内js方法只执行一次。

    函数防抖是指频繁触发的情况下,只有足够的空闲时间,才执行代码一次

    函数节流是 声明一个变量当标志位,记录当前代码是否在执行,如果正在执行,取消这次方法执行,直接return,如果空闲,正常触发方法执行

    函数防抖是需要一个延时器来辅助实现,延迟执行需要执行的代码,如果方法多次触发,把上次记录的延迟执行代码用cleartimeout清除掉,重新开始,如果计时完毕,没有方法来访问触发,则执行代码

    Get和post不同

    Get是从服务器上获取数据,post是向服务器传送数据

    在客户端,get通过url提交数据,数据在url中可以看到,post方式,数据放在html header中提交

    安全性问题

    Get提交数据最多只能有1024字节,post没有限制

    什么是csrf攻击

    Csrf(跨站点请求伪造) 攻击者在用户已经登录目标网站之后,诱使用户访问一个攻击页面,利用目标网站对用户的信任,以用户身份再攻击页面对目标网站发起伪造用户操作的请求,达到攻击目的

    Js中手写一个深拷贝

    什么时候用深拷贝 /浅拷贝

    无论深浅,都是需要的,当深拷贝发生时通常表明存在着一个聚合关系,当浅拷贝发生时,通常表明存在着相识关系

    举个简单例子:当实现一个组合模式Composite  Pattern时通常都会实现深拷贝

    当实现一个观察者模式Observer  Pattern,时,就需要实现浅拷贝

    Vue相关

    1.Vue的核心是什么

    Vue是一套构建用户界面的渐进式自底向上增量开发的MVVM框架,vue的核心只关注视图层,

    核心思想:  

    数据驱动(视图的内容随着数据的改变而改变)

    组件化(可以增加代码的复用性,可维护性,可测试性,提高开发效率,方便重复使用,体现了高内聚低耦合)

    2.请简述你对vue的理解

    Vue是一套构建用户界面的渐进式的自底向上增量开发的MVVM框架,核心是关注视图层,vue的核心是为了解决数据的绑定问题,为了开发大型单页面应用和组件化,所以vue的核心思想是数据驱动和组件化,这里也说一下MVVM思想,MVVM思想是 模型  视图  vm是v和m连接的桥梁,当模型层数据修改时,VM层会检测到,并通知视图层进行相应修改

    3.请简述vue的单向数据流

    父级prop的更新会向下流动到子组件中,每次父组件发生更新,子组件所有的prop都会刷新为最新的值

    数据从父组件传递给子组件,只能单向绑定,子组件内部不能直接修改父组件传递过来的数据,(可以使用data和computed解决)

    1. Vue常用的修饰符有哪些

    修饰符:.lazy 改变后触发,光标离开input输入框的时候值才会改变

                       .number 将输出字符串转为number类型

                       .trim 自动过滤用户输入的首尾空格

    事件修饰符:

    .stop 阻止点击事件冒泡,相当于原生js中的event.stopPropagation()

    .prevent 防止执行预设的行为,相当于原生js中event.preventDefault()

    .capture 添加事件侦听器时使用事件捕获模式,就是谁有该事件修饰符,就先触发谁

    .self  只会触发自己范围内的事件,不包括子元素

    .once 只执行一次

    键盘修饰符:

    .enter 回车键          .tab 制表键             .esc返回键     .space 空格键

    .up向上键                .down 向下键        .left向左建    .right向右键

    系统修饰符:.ctrl .alt   .shift  .meta

    5.v-text与{{}}与v-html区别

    {{}} 将数据解析为纯文本,不能显示输出html

    v-html 可以渲染输出html

    v-text 将数据解析为纯文本,不能输出真正的html,与花括号的区别是在页面加载时不显示双花括号

    v-text 指令:

    作用:操作网页元素中的纯文本内容。{{}}是他的另外一种写法

    v-text与{{}}区别:

    v-text与{{}}等价,{{}}叫模板插值,v-text叫指令。

    有一点区别就是,在渲染的数据比较多的时候,可能会把大括号显示出来,俗称屏幕闪动:

    6.v-on可以绑定多个方法吗

    可以  如果绑定多个事件,可以用键值对的形式 事件类型:事件名

             如果绑定是多个相同事件,直接用逗号分隔就行

    7.Vue循环的key作用

    Key值的存在保证了唯一性,Vue在执行时,会对节点进行检查,如果没有key值,那么vue检查到这里有dom节点,就会对内容清空并赋新值,如果有key值存在,那么会对新老节点进行对比,比较两者key是否相同,进行调换位置或删除操作

    8.什么是计算属性

    计算属性是用来声明式的描述一个值依赖了其他的值,当它依赖的这个值发生改变时,就更新DOM

    当在模板中把数据绑定到一个计算属性上时,vue会在它依赖的任何值导致该计算属性改变时更新DOM

    每个计算属性都包括一个getter和setter,读取时触发getter,修改时触发setter

    1. Vue单页面的优缺点

    单页面spa

    优点:前后端分离  用户体验好 一个字  快  内容改变不需要重新加载整个页面

    缺点:不利于seo,  初次加载时耗长(浏览器一开始就要加载html  css js ,所有的页面内容都包含在主页面中) ,页面复杂度提高了,导航不可用

    1. Vuex是什么?怎么使用?在那种场景下使用

    Vuex是一个专为vue.js应用程序开发的状态管理模式,通过创建一个集中的数据存储,方便程序中的所有组件进行访问,简单来说 vuex就是vue的状态管理工具

    Vuex有五个属性 state  getters  mutations  actions  modules

    State就是数据源存放地,对应一般vue对象的data,state里面存放的数据是响应式的,state数据发生改变,对应这个数据的组件也会发生改变  用this.$store.state.xxx调用

    Getters 相当于store的计算属性,主要是对state中数据的过滤,用this.$store.getters.xxx调用

    Mutations 处理数据逻辑的方法全部放在mutations中,当触发事件想改变state数据的时候使用mutations,用this.$store.commit调用,给这个方法添加一个参数,就是mutation的载荷(payload

    Actions 异步操作数据,但是是通过mutation来操作 用this.$store.dispatch来触发,actions也支持载荷

    使用场景:组件之间的状态,登录状态,加入购物车,音乐播放

    Vuex使用流程:

    下载vuex 

    在src下创建store以及index.js

    引入vue和vuex, 使用vuex  ,导出实例对象

    在main.js中引入,在.vue文件中使用

    1. Vue中路由跳转方式(声明式/编程式)

    Vue中路由跳转有两种,分别是声明式和编程式

    用js方式进行跳转的叫编程式导航   this.$router.push()

    用router-link进行跳转的叫声明式   router-view 路由出口,路由模板显示的位置

    1. 路由中name属性有什么作用?
    1. 在router-link中使用name导航到对应路由
    2. 使用name导航的同时,给子路由传递参数

    12.vue跨域的解决方式

    1.后台更改header

    2.使用jq提供jsonp

    3.用http-proxy-middleware(配置代理服务器的中间件)

    13.Vue的生命周期请简述

    vue的生命周期就是vue实例创建到实例销毁的过程。期间会有8个钩子函数的调用。

    beforeCreate(创建实例)

    created(创建完成)、

    beforeMount(开始创建模板)

    mounted(创建完成)、

    beforeUpdate(开始更新)

    updated(更新完成)、

    beforeDestroy(开始销毁)

    destroyed(销毁完成)

    1. Vue生命周期的作用

    给了用户在不同阶段添加自己的代码的机会

    15.DOM渲染在那个生命周期阶段内完成

    DOM渲染在mounted周期中就已经完成

    1. Vue路由的实现

    前端路由就是更新视图但不请求页面,

    利用锚点完成切换,页面不会刷新

    官网推荐用vue-router.js来引入路由模块

    1. 定义路由组件
    2. 定义路由,使用component进行路由映射组件,用name导航到对应路由
    3. 创建router实例,传入routes配置
    4. 创建和挂载根实例
    5. 用router-link设置路由跳转

    17.Vue路由模式hashhistory,简单讲一下

             Hash模式地址栏中有#,history没有,history模式下刷新,会出现404情况,需要后台配置

    使用  JavaScript 来对 loaction.hash 进行赋值,改变 URL 的 hash 值

    可以使用 hashchange 事件来监听 hash 值的变化

    HTML5 提供了 History API 来实现 URL 的变化。其中最主要的 API 有以下两个:history.pushState() 和 history.repalceState()。这两个 API 可以在不进行刷新的情况下,操作浏览器的历史纪录。唯一不同的是,前者是新增一个历史记录,后者是直接替换当前的历史记录。

    18.Vue路由传参的两种方式,params和query方式与区别

    动态路由也可以叫路由传参,就是根据不同的选择在同一个组件渲染不同的内容

    用法上:query用path引入,params用name引入接收参数都是类似的,分别是this.$route.query.name和this.$route.params.name

    url展示上:params类似于post,query类似于get,也就是安全问题,params传值相对更安全点,query通过url传参,刷新页面还在,params刷新页面不在了

    19.Vue数据绑定的几种方式

    1.单向绑定  双大括号 {{}}  html内字符串绑定

    2.v-bind绑定  html属性绑定

    3.双向绑定 v-model

    4.一次性绑定  v-once 依赖于v-model

    20.Vue注册一个全局组件

    Vue.componnet(“组件的名字”{对象   template <div>组建的内容</div>})

    21.Vue的路由钩子函数/路由守卫有哪些

    全局守卫:beforeEach(to,from,next)和afterEach(to,from)

    路由独享守卫:beforeEnter

    组件内的守卫:路由进入/更新/离开之前 beforeRouterEnter/update/leave

    22.Vue中如何进行动态路由设置?有哪些方式?怎么获取传递过来的数据?

    动态路由也可以叫路由传参,

    动态路由有query和prrams两种方式传参

    query用path引入,params用name引入,query用this.$route.query.name接收参数

    params用this.$route.params.name接收参数

    23.Elementui中的常用组件有哪些?请简述你经常使用的 并且他们的属性有哪些?

    Container布局容器 

    <el-container>外层容器

    <el-header>顶栏容器

    <el-aside>侧边栏容器

    <el-main>主要内容容器

    <el-footer>底栏容器

    Dropdown  下拉菜单

    <el-container split-buton> 下拉按钮   

    <el-container-menu> 下拉菜单   

    <el-container-item> 下拉项

    Table  表格

    Tabs  标签页

    Form  表单

    Pagination 分页

    Message  消息提示

    24.Vue-cli中如何自定义指令

    25.Vue中指令有哪些

    v-for:循环数组,对象,字符串,数字

    v-on:绑定事件监听

    v-bind:动态绑定一个或者多个属性

    v-model:表单控件或者组件上创建双向绑定

    v-if  v-else  v-else-if  条件渲染

    v-show  根据表达式真假,切换元素的display

    v-html 更新元素的innerhtml

    v-text 更新元素的textcontent

    v-pre 跳过这个元素和子元素的编译过程

    v-clock 这个指令保持在元素上知道关联实例结束编译

    v-once  只渲染一次

    26.Vue如何定义一个过滤器

    过滤器本质就是一个有参数有返回值的方法

    new Vue({

        filters:{

          myCurrency:function(myInput){

            return 处理后的数据

          }

        }

    })

    使用方法:<h1>{{表达式 | 过滤器}}</h1>

    过滤器高级用法:可以指定参数,告诉过滤器按照参数进行数据的过滤

    27.对vue 中keep-alive的理解

    概念:keep-alive是vue的内置组件,当它动态包裹组件时,会缓存不活动的组件实例,它自身不会渲染成一个DOM元素也不会出现在父组件链中

    作用:在组件切换过程中将状态保留在内存中,防止重复渲染DOM,减少加载时间以及性能消耗,提高用户体验。

    生命周期函数:Activated在keep-alive组件激活时调用,deactivated在keep-alive组件停用时调用

    28.如何让组件中的css在当前组件生效

    在styled中加上scoped

    29.Vue生命周期一共几个阶段

    创建  加载   更新   销毁

    Beforecreate创建前

    Created   创建后

    Beforemount   加载前

    Mounted 加载后

    Beforeupdate 更新前

    Updated 更新后

    Beforedestroy 销毁前

    Destroyed  销毁后

    页面第一次加载会触发 beforecreate  created   beforemount   mounted

    DOM渲染在mounted周期中就已经完成

    30.Mvvm与mvc的区别

    Mvc模型视图控制器,视图是可以直接访问模型,所以,视图里面会包含模型信息,mvc关注的是模型不变,所以,在mvc中,模型不依赖视图,但是视图依赖模型

    Mvvm 模型  视图  和vm  vm是作为模型和视图的桥梁,当模型层数据改变,vm会检测到并通知视图层进行相应的修改

    31.Vue组件中的data为什么是函数

    Data是一个函数时,每个组件实例都有自己的作用域,每个实例相互独立,不会相互影响

    如果是引用类型(对象),当多个组件共用一个数据源时,一处数据改变,所有的组件数据都会改变,所以要利用函数通过return返回对象的拷贝,(返回一个新数据),让每个实例都有自己的作用域,相互不影响。

    32.Vue双向绑定的原理

    Vue双向绑定就是:数据变化更新视图,视图变化更新数据

    Vue数据双向绑定是通过数据劫持观察者模式来实现的,

    数据劫持,object.defineproperty它的目的是:当给属性赋值的时候,程序可以感知到,就可以控制改变属性值

    观察者模式 当属性发生改变的时候,使用该数据的地方也发生改变

    33.Vue中组件怎么传值

    正向:父传子  父组件把要传递的数据绑定在属性上,发送,子组件通过props接收

    逆向:子传父        子组件通过this.$emit(自定义事件名,要发送的数据),父组件设置一个监听事件来接收,然后拿到数据

    兄弟:eventbus  中央事件总线

    通过Vuex

    34.Bootstrap的原理

    网格系统的实现原理,通过定义容器大小,平分12份,(24份或者32份),再调整内外边距,结合媒体查询,就成了强大的响应式网格系统。

    比如  row  col-xs-4

    36.如果一个组件在多个项目中使用怎么办

    37.槽口请简述

    大概分这几点,首先槽口(插槽)可以放什么内容?放在哪?什么作用?可以放任意内容,在子组件中使用,是为了将父组件中的子组件模板数据正常显示。

    具名插槽和匿名插槽,作用域插槽,说白了就是在组件上的属性,可以在组件元素内使用,

    可以在父组件中使用slot-scope从子组件获取数据

    38.Watch请简述

    Watch的作用是监控一个值的变化,并调用因为变化需要执行的方法

    39.Vant Ui请简述下

    轻量、可靠的移动端 Vue 组件库

    40.计算属性与watch区别

    Computed  watch   区别就是computed的缓存功能,当无关数据数据改变时,不会重新计算,直接使用缓存中的值。计算属性是用来声明式的描述一个值依赖了其他的值,当所依赖的值后者变量发生变化时,计算属性也跟着改变,

    Watch监听的是在data中定义的变量,当该变量变化时,会触发watch中的方法

    41.mvvm框架是什么?它和其它框架(jquery)的区别是什么?哪些场景适合?

    Mvvm和其他框架的区别是  vue数据驱动  通过数据来显示视图而不是节点操作

    适用于数据操作比较多的场景

    42.Vue首屏加载慢的原因,怎么解决的,白屏时间怎么检测,怎么解决白屏问题

    首屏加载慢的原因:

    第一次加载页面有很多组件数据需要渲染

    解决方法:

    1.路由懒加载  component:()=>import(“路由地址”)

    2.ui框架按需加载

    3.gzip压缩

    白屏时间检测:

    ????

    解决白屏问题:

    ①使用v-text渲染数据

    ②使用{{}}语法渲染数据,但是同时使用v-cloak指令(用来保持在元素上直到关联实例结束时候进行编译),v-cloak要放在什么位置呢,v-cloak并不需要添加到每个标签,只要在el挂载的标签上添加就可以

    43.Vue双数据绑定过程中,这边儿数据改变了怎么通知另一边改变

    数据劫持和观察者模式

    Vue数据双向绑定是通过数据劫持观察者模式来实现的,

    数据劫持,object.defineproperty它的目的是:当给属性赋值的时候,程序可以感知到,就可以控制属性值的有效范围,可以改变其他属性的值

    观察者模式它的目的是当属性发生改变的时候,使用该数据的地方也发生改变

    44.Vuex流程

    在vue组件里面,通过dispatch来触发actions提交修改数据的操作,然后通过actions的commit触发mutations来修改数据,mutations接收到commit的请求,就会自动通过mutate来修改state,最后由store触发每一个调用它的组件的更新

    45.Vuex怎么请求异步数据

    1.首先在state中创建变量

    2.然后在action中调用封装好的axios请求,异步接收数据,commit提交给mutations

    Mutations中改变state中的状态,将从action中获取到的值赋值给state

    46.Vuex中action如何提交给mutation的

    Action函数接收一个与store实例具有相同方法和属性的context对象,可以调用context.commit提交一个mutation,或者通过context.state和context.getters获取state和getters

    47.Route与router区别

    1.   router是VueRouter的一个对象,通过Vue.use(VueRouter)和VueRouter构造函数得到一个router的实例对象,这个对象中是一个全局的对象,他包含了所有的路由包含了许多关键的对象和属性。

    2.route是一个跳转的路由对象,每一个路由都会有一个route对象,是一个局部的对象,可以获取对应的name,path,params,query等

    49.vuex的State特性是?

    State就是数据源的存放地

    State里面的数据是响应式的,state中的数据改变,对应这个数据的组件也会发生改变

    State通过mapstate把全局的state和getters映射到当前组件的计算属性中

    50.vuex的Getter特性是?

    Getter可以对state进行计算操作,它就是store的计算属性

    Getter可以在多组件之间复用

    如果一个状态只在一个组件内使用,可以不用getters

    51.vuex的Mutation特性是?

    更改vuex  store中修改状态的唯一办法就是提交mutation,可以在回调函数中修改store中的状态

    52.vuex的actions特性是?

    Action类似于mutation,不同的是 action提交的是mutation,不是直接变更状态,可以包含任意异步操作

    54.vuex的优势

    优点:解决了非父子组件的通信,减少了ajax请求次数,有些可以直接从state中获取

    缺点:刷新浏览器,vuex中的state会重新变为初始状态,解决办法是vuex-along,得配合计算属性和sessionstorage来实现

    55.Vue路由懒加载(按需加载路由)

    56.v-for与v-if优先级

    首先不要把v-if与v-for用在同一个元素上,原因:v-for比v-if优先,如果每一次都需要遍历整个数组,将会影响速度,尤其是当之需要渲染很小一部分的时候。

    v-for 比 v-if 具有更高的优先级

    请写出饿了么5个组件
    <el-alert>弹窗</el-alert>
    <el-dialog>对话</el-dialog>
    <el-calender>日历表</el-calender>
    <el-progress:percentage="0">进度条<el-progrees>
    <el-switch>开关</el-switch>

    React相关

    fetch VS ajax VS axios

    传统 Ajax 指的是 XMLHttpRequest(XHR), 最早出现的发送后端请求技术,隶属于原始js中,核心使用XMLHttpRequest对象,多个请求之间如果有先后关系的话,就会出现回调地狱。JQuery ajax 是对原生XHR的封装

    axios 是一个基于Promise ,本质上也是对原生XHR的封装,只不过它是Promise的实现版本,符合最新的ES规范,

    fetch不是ajax的进一步封装,而是原生js,没有使用XMLHttpRequest对象。

    React事件处理---修改this指向

    方式1:通过bind方法进行原地绑定,从而改变this指向

    方式2:通过创建箭头函数

    方式3:在constructor中提前对事件进行绑定

    方式4:将事件调用的写法改为箭头函数的形式

    请简述你对react的理解

    React起源于facebook,react是一个用于构建用户界面的js库

    特点:

    声明式设计:react采用范式声明,开发者只需要声明显示内容,react就会自动完成

    高效: react通过对dom的模拟(也就是虚拟dom),最大限度的减少与dom的交互

    灵活: react可以和已知的库或者框架很好配合

    组件: 通过react构建组件,让代码更容易复用,能够很好应用在大型项目开发中,把页面功能拆分成小模块  每个小模块就是组件

    单向数据流:  react是单向数据流,数据通过props从父节点传递到子节点,如果父级的某个props改变了,react会重新渲染所有的子节点

    react组件之间的数据传递

    正向传值用props

    逆向传值用函数传值 通过事件调用函数传递

    同级传值用pubsub-js

    用pubsub.publish(事件名,数据)抛出数据

    用pubsub.subscribe(监听的事件,()=){})接收数据

    跨组件传递  用context  要使用context进行跨组件传值就需要使用createContext()方法,这个方法有两个对象  provider  生产者   Consumer 消费者

    Vue与react区别

    相同点:

    1. 都支持服务器渲染
    2. 都有虚拟dom,组件化开发,通过props参数进行父子组件数据的传递,都实现webcomponent规范
    3. 都是数据驱动视图
    4. 都有状态管理,react有redux,vue有vuex
    5. 都有支持native’的方案 react有react native  vue有weex

    不同点:

    1. react严格上只针对mvc的view层,vue是mvvm模式
    2. 虚拟dom不一样,vue会跟踪每一个组件的依赖关系,不需要重新渲染整个dom组件树,而react不同,当应用的状态被改变时,全部组件都会重新渲染,所以react中用shouldcomponentupdate这个生命周期的钩子函数来控制
    3. 组件写法不一样 ,react是jsx和inline style ,就是把html和css全写进js中,vue则是html,css ,js在同一个文件
    4. 数据绑定不一样,vue实现了数据双向绑定,react数据流动是单向的
    5. 在react中,state对象需要用setstate方法更新状态,在vue中,state对象不是必须的,数据由data属性在vue对象中管理

    请简述虚拟dom与diff算法

    虚拟DOM也就是常说的虚拟节点,它是通过js的object对象模拟DOM中的节点,然后再通过特定的渲染方法将其渲染成真实的DOM节点。

    频繁的操作DOM,或大量造成页面的重绘和回流

    Diff算法:把树形结构按照层级分解,只比较同级元素,给列表结构的每个单元添加唯一的key值,方便比较

    你对组件的理解

    可组合,可复用,可维护,可测试

    调用 setState 之后发生了什么?

    React在调用setstate后,react会将传入的参数对象和组件当前的状态合并,触发调和过程,

    在调和过程中,react会根据新的状态构建react元素树重新渲染整个UI界面,在得到元素树之后,react会自动计算新老节点的差异,根据差异对界面进行最小化重新渲染

    react 生命周期函数

    componentWillMount  组件渲染之前调用

    componentDidMount  在第一次渲染之后调用

    componentWillReceiveProps  在组件接收到一个新的props时调用

    shouldComponentUpdate  判断组件是否更新html

    componentWillupdate  组件即将更新html时调用

    componentDidupdate  在组件完成更新后立即调用

    componentWillUnmount  在组件移除之前调用

    ******为什么虚拟 dom 会提高性能?(必考)

    虚拟 dom 相当于在 js 和真实 dom 中间加了一个缓存,利用 dom diff 算法避免了没有必要的 dom 操作,从而提高性能

    (组件的)状态(state)和属性(props)之间有何不同

    State与props区别

    Props是一个从外部传进组件的参数,主要作用就是父组件向子组件传递数据,但是props对于使用它的组件来说是只读的,一旦赋值不能修改,只能通过外部组件主动传入新的props来重新渲染子组件

    State 一个组件的显示形态可以由数据状态和外部参数决定,外部参数是props,数据状态就是state,首先,在组件初始化的时候,用this.state给组件设定一个初始的state,在第一次渲染的时候就会用这个数据来渲染组件,state不同于props一点时,state可以修改,通过this.setState()方法来修改state

    shouldComponentUpdate 是做什么的

    这个react生命周期钩子函数是来解决这个问题:

    在更新数据的时候用setState修改整个数据,数据变了之后,遍历的时候所有内容都要被重新渲染,数据量少还好,数据量大就会严重影响性能

    解决办法:

    1.shouldcomponentupdate 在渲染前进行判断组件是否更新,更新了再渲染

    2.purecomponent(纯组件)省去了虚拟dom生成和对比的过程  在类组件中使用

    3.react.memo() 类似于纯组件 在无状态组件中使用

    react diff 原理

    它是基于三个策略:

    1. tree diff  web UI中dom节点跨层级的移动操作特别少,可以忽略不计
    2. component diff 拥有相同类的两个组件将会生成相似的树形结构,拥有不同类的两个组件会生成不同的树形结构
    3. element diff 对于同一层级的一组子节点,他们可以通过唯一的id进行区分

    何为受控组件

    React负责渲染表单的组件,值是来自于state控制的,输入表单元素称为受控组件

    调用 super(props) 的目的是什么

    Super()调用父类的构造方法,有super,组件才有自己的this,在组件全局中都可以使用this,如果只是constructor而不执行super,之后的this都是错的,super继承父组件的this

    React 中构建组件的方式

    自定义组件:函数组件或者无状态组件  组件首字母大写

    类组件:一个类组件必须实现一个render方法,这个方法必须返回一个jsx元素,要用一个外层的元素把所有内容包裹起来

    小程序相关的

    小程序的优势

    无需下载安装,直接使用,运行速度快,项目搭建迅速,短小精悍,每个app源代码不超过2mb

    小程序的页面构成(4个文件)

    Index.js   index.json   index.wxml    index.wxss

    小程序的生命周期

    Onload   onready    onshow    onhide   onunload  

    Onpulldownrefresh    onreachbottom    onshareappmessage

    小程序如何请求数据

    用request

    如何提高小程序的首屏加载时间

    提前请求:异步数据数据请求不需要等待页面渲染完成

    利用缓存:利用storage API对异步请求数据进行缓存,二次启动时先利用缓存数据渲染页面,再进行后台更新

    避免白屏:先展示页面骨架和基础内容

    及时反馈:及时地对需要用户等待的交互操作给出反馈,避免用户以为小程序没有响应

    性能优化:避免不当使用setdata和onpagescroll

    请简述你经常使用的小程序的组件

    View  icon   text  image   swiper   navigator  input   button   map

    Wxss与css的区别请简述

    Wxss新增了尺寸单位 rpx

    提供了全局样式和局部样式

    Wxss仅支持部分css选择器  id’  class  元素等

    小程序如何实现响应式

    Rpx

    怎么优化小程序

    提高页面加载速度

    用户行为预测

    减少默认data的大小

    组件化方案

    自主获知自己的服务器

    小程序如何显示用户头像与用户名

    传统接口wx.getuserinfo 目前可以用,需要用户授权,使用时会有官方发提示,这个方法需要升级

    最新方法:open-data标签,使用这个标签可以不用用户授权直接获取头像和用户名,

    可以在button中将opendata作为属性写进去,写个点击事件就直接获取到了

    请谈谈小程序的双向绑定和vue的异同?

    Vue双向绑定是通过数据拦截和观察者模式,通过this.value获取值,小程序是通过触发表单元素绑定的方法,在方法中用this.setData({key:value})来取值

    小程序中传参是怎么传的

    vue类比介绍

    说一下微信小程序的适配问题

    小程序页面间有哪些传递数据的方法?

    你是怎么封装微信小程序的数据请求的

    说一下微信小程序的适配问题

    小程序跳转页面的方式

    微信小程序如何跳转到其他小程序

    小程序加载过慢的解决方式

    其他

    Typescript是什么 请简述?

    Typescript 与javascript 的优势?

    Webpack与gulp区别

    Gulp是一种能够优化前端开发流程的工具,webpack是一种模块化的解决方案 (grunt)

    请简述webpack中的loaders与plugin的区别

    什么是loaders,loaders是文件加载器,能够加载资源文件,并对这些文件进行处理,例如,编译,压缩等,最终一起打包到指定文件中。

    什么是plugin,在webpack运行的生命周期会有许多事件,plugin可以监听这些事件

    区别:加载器是用来加载文件的,webpack本身只能加载js文件(内置babel-loader),加载其他文件就需要安装别的loader,比如:css-loader  file-loader

    Plugin是扩展webpack功能的,通过plugin  ,webpack可以实现loader不能完成的复杂功能

    怎么提升页面性能?性能优化有哪些?

    Node使用来做什么的

    能够在服务器端运行JavaScript

    Webpack:入口,出口,加载器,插件

    说一下webpack的打包原理

    Webpack是把项目当做一个整体,通过给定一个主文件,webpack将从这个主文件开始找到项目中所有依赖的文件,使用loaders类处理,最后打包成一个或者多个浏览器可识别的js文件

    Commonjs ES6模块区别?

    1. common模块是拷贝,可以修改值,es6模块是引用,只读状态,不能修改值
    2. commonjs模块是运行时加载,es6模块是编译时输出接口

    Git如何使用/常用指令有哪些

    你们后台用的是什么技术

    你的项目比较小为什么还是用vue全家桶

    请简述你在项目中使用的ui框架

    前端性能优化的方式越多越好

    什么是cors

    说一下对websocked的理解

    Websocked是一种双向通信协议,在建立连接后,websocked服务器和浏览器都能主动向对方发送或者接收数据,websocked需要类似于tcp的客户端和服务器通过握手连接,连接成功后才能互相通信

    后台传递过来的数据是那些

    谈谈Ajaxfetchaxios的区别

    企业中的项目流程

    1.WEB前端项目开发流程

    项目需求分析

    这个环节是由项目经理完成,项目经理首先和客户进行交流,了解客户的需求,然后分析项目的可行性,如果项目可以被实现,项目经理写出项目需求文档交给设计师完成后续的开发。

    页面设计/项目选型

    这个环节主要是UI设计师参与,UI设计师根据产品需求分析文档,对产品的整体美术风格、交互设计、界面结构、操作流程等做出设计。负责项目中各种交互界面、图标、LOGO、按钮等相关元素的设计与制作。并且确定使用技术

    编码

    这个部分由程序员来实现。(程序员分为WEB前端开发工程师和后台开发工程师。前端开发人员主要做我们可以在网页上看的见的页面,后台就做一些我们看不见的管理系统以及功能的实现。)程序员根据UI设计师的设计,用编码来完成整个项目的各个功能。

    测试

    这部分由程序测试员来完成。程序测试员主要就是测试寻找程序还存在的bug,一般来说刚编码完成的程序都是存在问题的,就需要测试人员反复不断的测试并将存在问题的测试结果交给编码人员进行bug的修复。等到几乎所有bug修复完成,这个项目差不多就可以上线了。

    维护

    程序的维护是整个项目的最后一个阶段,但也是耗时最多,成本最高最高的的一个阶段。程序的维护包括程序上线后后续bug的修复和程序版本的更新。

    1. 更换接口域名

    就是在开发的时候调用的后台接口是后台测试的接口  项目上线后要把请求的接口替换成上线的域名

    1. 经常使用的工具

    代码管理平台:github 码云

    需求发布平台:钉钉任务,禅道

    Ui交互平台:蓝湖

    产品原型工具:axure

    企业邮箱:阿里 腾讯企业邮箱

    后台语言:java php python(西安不多)

    4大公司和小公司开发的区别

    大型外包公司更加流程化,人员多,沟通少,项目交付后不需要自己维护,采用瀑布开发模式(以文档为主)

    小型公司:人少 需求经常改变 沟通方便 采用敏捷开发(快速推出v1版本 ,之后迭代)

    5.前后台分离怎么测试?

    奇葩问题

    你们后端开发用的什么?

    移动端如何刷新页面?

    项目初始化构建流程

    项目中自己觉得骄傲的地方?

    说说自己的缺点

    热部署是什么?

    用户有多少

    怎么调用接口(是怎么跟后台沟通的)

    单元格测试是怎么做的

    开发环境,测试环境,上线环境的环境变量你们在开发中是如何处理的

    展开全文
  • 如何正确地写简历,面试中的常规问题(如自我介绍、为何跳槽)该如何回答,有哪些禁忌,这些看似简单的问题,你真的都了解吗?还有,复习面试题的时候,该以怎样的思路、框架来进行,有哪些常考的知识点,你都了解吗...
  • 今天千锋武汉Web前端培训小编为大家整理了一些经典的Web前端面试题,希望这些题目能够对大家有所帮助。 一、HTML常见题目 01、Doctype作用?严格模式与混杂模式如何区分?它们有何意义? 02、HTML5为什么只...

    想成功就业Web前端工程师,想要能高薪就业,那么除了好的Web前端技能以外,还得有好的面试技巧,如果提前就了解更多企业的面试要求及面试题目,那么可以让我们的面试成功的几率大大的提高。今天千锋武汉Web前端培训小编为大家整理了一些经典的Web前端面试题,希望这些题目能够对大家有所帮助。

    Web前端面试:这40个经典Web前端面试题面试者必看!

     

    一、HTML常见题目

    01、Doctype作用?严格模式与混杂模式如何区分?它们有何意义?

    02、HTML5为什么只需要写?

    03、行内元素有哪些?块级元素有哪些?空(void)元素有哪些?

    04、页面导入样式时,使用link和@import有什么区别?

    05、介绍一下你对浏览器内核的理解?

    06、常见的浏览器内核有哪些?

    07、html5有哪些新特性、移除了哪些元素?如何处理HTML5新标签的浏览器兼容问题?

    08、如何区分HTML和HTML5?

    09、简述一下你对HTML语义化的理解?

    10、HTML5的离线储存怎么使用,工作原理能不能解释一下?

    二、CSS类的题目

    01、介绍一下标准的CSS的盒子模型?与低版本IE的盒子模型有什么不同的?

    02、CSS选择符有哪些?哪些属性可以继承?

    03、CSS优先级算法如何计算?

    04、CSS3新增伪类有哪些?

    05、如何居中div?如何居中一个浮动元素?如何让绝对定位的div居中?

    06、display有哪些值?说明他们的作用。

    07、position的值relative和absolute定位原点是?

    08、CSS3有哪些新特性?

    09、请解释一下CSS3的Flexbox(弹性盒布局模型),以及适用场景?

    10、用纯CSS创建一个三角形的原理是什么?

    三、JavaScript类的题目

    01、JavaScript中this是如何工作的

    02、请解释原型继承的原理。

    03、什么是闭包(closure),如何使用它,为什么要使用它?

    04、.call 和.apply的区别是什么?

    05、请指出JavaScript 宿主对象(host objects) 和原生对象(native objects) 的区别?

    06、请指出以下代码的区别:function Person(){}、var person = Person()、var person = new Person()?

    07、请解释变量声明提升(hoisting)。

    08、什么是 “use strict”; ? 使用它的好处和坏处分别是什么?

    09、什么是事件循环 (event loop)?

    10、请解释同步 (synchronous) 和异步 (asynchronous) 函数的区别。

    四、开发及性能优化类题目

    01、如何规避javascript多人开发函数重名问题?

    02、请说出三种减低页面加载时间的方法.

    03、说说你所了解到的Web攻击技术。

    04、说说你说了解的前端性能优化方法?

    05、前端开发中,如何优化图像?图像格式的区别?

    06、浏览器是如何渲染页面的?

    07、页面重构怎么操作?

    08、什么叫优雅降级和渐进增强?

    09、前端需要注意哪些SEO?如何做SEO优化?

    10、平时如何管理你的项目?

     

    以上是Web前端一部分的面试题,小编今天为大家分享的关于Web前端面试常见问题汇总,加v芯获取:xxff751,掌握这些顺利拿offer!的文章,这些题目都是在Web面试中经常会出现的题目,快看看你能回答出几道?希望本篇文章能够对正准备参加Web面试的小伙伴们有所帮助。最后祝愿小伙伴们面试成功,顺利找到工作!

    展开全文
  • web前端面试

    2018-05-22 17:29:06
    达*内部整理的面试题,里面有很多基础内容,总共有几百道题
  • 经典web前端面试

    2018-07-08 15:13:02
    经典的web前端面试题,大部分web面试都会考的面试题。
  • 2018web前端面试资料

    2018-09-04 10:26:42
    2018年各厂(百度、滴滴、美团等)面试题及js的一些整理
  • 前端面试题,包含JavaScript的闭包,作用域,原型,原型链,上下文环境以及DOM,BOM封装函数深度克隆,以及一些常见的·JS问题,试题简单但是容易混淆,作为前端工程师必考题
  • 进阶web高级前端知识体系:来自个人的...2018年阿里资深web前端面试题 2018年网易高级web前端面试题 2018年中级/高级web前端面试题 2018年8月15日面试题 2018年8月17日面试题 2018年8月31日面试题 2018年9月11日面试题
  • 该文是面试小白的一个指导文章,希望你们也别向本博主一样走比较多的弯路,加油,多面试,不要害怕,学会总结面试经验,你一定会成功的!!!!如有错误可以向我留言,谢谢指点~~
  • web前端面试宝典 .docx

    2016-11-25 11:31:01
    web前端面试宝典 .docx
  • 96道web前端面试题96道web前端面试题.pdf
  • 9月份亲自出去面试,跑的所有公司,面试官问的问题总结。 没有答案,只有问题。
  • 翻boss直聘的时候看到了这个面试要求,觉得含金量相当高,也很适合参考制定职业规划,与君共勉。(转载自:https://share.weiyun.com/5KXKau8 密码:vcei9g | 招聘地址:...
  • web前端面试题(全)

    万次阅读 多人点赞 2019-04-17 11:23:57
    近来看到网上格式各样的web前端求职的面试题,接下来我用我的经验总结了一套在面试过程中高频率问到的面试题,希望能帮助各位求职者在求职的过程中顺利通过,废话不多说,直接说题。。。 一、HTML5部分 1.说一下对...

    近来看到网上格式各样的web前端求职的面试题,接下来我用我的经验总结了一套在面试过程中高频率问到的面试题,希望能帮助各位求职者在求职的过程中顺利通过,废话不多说,直接说题。。。

    一、HTML5部分

    1.说一下对css盒模型的理解
    答:css盒子模型 又称框模型 (Box Model) ,包含了元素内容(content)、内边距(padding)、边框(border)、外边距(margin)几个要素。
    盒模型有两种:标准盒模型和IE盒模型。
    标准盒模型中width和height指的是内容区域的宽度和高度,增加内边距、边框和外边距不会影响内容区域的尺寸,但是会增加元素框的总尺寸;但在IE6浏览器的width不是内容的宽度,而是内容、内边距和边框的宽总和;IE的content部分包含了border和padding。

    2. rem,px,em之间的关系和区别
    答:px
    实际上就是像素,用PX设置字体大小时,比较稳定和精确。
    但是px不支持用户进行浏览器缩放或者不同移动端的兼容,因为像素是固定的,屏幕大小是变化的。
    em
    是根据父元素来对应大小,是一种相对值;
    em值 = 1/父元素的font-size*需要转换的像素值。
    进行任何元素设置,都有可能需要知道他父元素的大小,这很不方便。
    rem
    是根据根元素html的font-size来对应大小,
    1rem = 16px,可以在根元素html中写固定像素也可以写百分比,然后在具体的标签上设置rem。

    3.描述一下cookies,sessionStorage和localStorage的区别
    答:(1)cookies在浏览器和服务器间来回传递,sessionstoragelocalStorage不会。
    (2)sessionStorage和localStorage的存储空间更大。
    (3)sessionStorage和localStorage有更多丰富易用的接口。
    (4)sessionStorage和localStorage各自独立的存储空间。

    4. 说一下怎么减少页面加载时间的方法
    答:(1)压缩css、js文件
    (2)合并js、css文件,减少http请求
    (3)外部js、css文件放在最底下
    (4)减少dom操作,尽可能用变量替代不必要的dom操作

    5. css优化、提高性能的方法有哪些
    答:(1)加载性能
    (2)选择器性能
    (3)渲染性能
    (4)可维护性

    6. css定义的权重
    答:标签权重为1、class权重为10、id权重为100、style权重为1000

    7. position:fixed,在Android下无效怎么处理
    答:使用JS处理判断当前设备是否是Android,如果是则添加监听当前页面滚动情况,设置position:absolute,不断改变top值。

    8. 说一下Flexbox(弹性盒子)的适用场景
    答:注意:主要应用场景为移动端布局。
    flexbox的布局是一个用于页面布局的全新css3模块功能。
    它可以把列表放在同一个方向(从左到右或从上到下排列),并且让这些列表能延伸到占用可用的空间。较为复杂的布局可以通过嵌套一个伸缩器(flex ,container)来辅助实现。
    flexbox可以简单快速的创建一个具有弹性功能的布局,当在一个小屏幕上显示的时候,flexbox可以让元素在容器中进行自由扩展和收缩,从而容易调整整个布局。它的目的是使用常见的布局模式,比如说三列布局,可以非常简单的实现。

    9. ::before和:after中双冒号和单冒号有什么区别(这个不是常问的!!!)
    先解释一下这两个伪元素,本质上并不支持伪元素的双冒号(::)写法,而是忽略掉了其中的一个冒号,仍以单引号来解释,所以等同变相支持了::before
    答:在before元素前面,after元素的后面插入内容(经典场景使用font-face小图标结合content:" ")

    10. 说一下html5的离线储存
    答:(主要问的是localStorage和sessionStorage)
    (1)localStorage长期储存在数据,浏览器关闭后数据不会丢失。
    (2)sessionStorage数据在浏览器关闭后自动删除。

    二、JS部分

    1. 闭包
    答:函数嵌套函数,内部函数使用外部函数的变量或者参数,使其长期驻扎在内存中,就形成了闭包!!!
    缺点:容易引起内存泄漏
    使用场景:
    (1)变量私有化
    (2)onclick(操作DOM元素是需要相应的索引值)

    2. 描述一下对"异步"和"同步的理解"
    答:异步:不按顺序执行,同一时刻只能执行一个事件
    同步:按顺序执行,同一时刻只能执行一个事件

    3.说一下事件冒泡、事件捕获的区别
    这个问题和事件流回答一样即可
    先说下什么是事件流吧!!!
    事件流:事件流分为三个阶段
    (1)捕获阶段
    (2)目标阶段
    (3)冒泡阶段
    捕获过程:1.window——>2.document——>3.body——>4.div——>5.text
    目标过程:捕获过程的5
    冒泡过程:6.text——>7.div——>8.body——>9.document——>10.window
    事件捕获:首先window会捕获到事件,之后document、documentElement、body会捕获到,在之后就是body到dom元素一层一层的捕获到事件,有wrap div、inner p;
    目标阶段:真正点击元素textSpan的事件发生了两次,因为在上面的JavaScript代码中,textSpan既在捕获阶段绑定事件,又在冒泡阶段绑定了事件,所以发生2次。
    事件冒泡:和捕获阶段相反的事件一步一步地冒泡到window
    (补充:冒泡为false、捕获为true)
    4.事件委托
    答:利用事件冒泡的原理,子元素的事件会冒泡到父元素,可以只给父元素添加事件,通过事件目标判断元素。
    优点:节省内存,动态添加的子元素也包含事件

    5. 解决跨域的方法
    答:(1)通过jsop解决跨域
    (2)通过修改document.domain来跨子域
    (3)使用window.name来进行跨域
    (4)使用HTML5中新引进的window.postMessage方法来跨域

    6. es5的面向对象
    说出特点就好
    答:特点:抽象、封装、继承、多态
    继承的三种方式:(1)原型链继承;(2)call和play继承;(3)call和play组合继承

    7. es6面向对象
    答:使用关键词class定义类来实现面向对象编程

    8. 说一下什么是垃圾回收
    (补充:JavaScript 中的内存管理是自动执行的,而且是不可见的。我们创建基本类型、对象、函数……所有这些都需要内存。当不再需要某样东西时会发生什么? JavaScript 引擎是如何发现并清理它?)
    答:
    (1)垃圾回收概述

    回答一: 垃圾回收机制(GC:Garbage Collection),执行环境负责管理代码执行过程中使用的内存。垃圾收集器会定期(周期性)找出那些不在继续使用的变量,然后释放其内存。但是这个过程不是实时的,因为其开销比较大,所以垃圾回收器会按照固定的时间间隔周期性的执行。
    回答二: 一般来说没有被引用的对象就是垃圾,就是要被清除, 有个例外如果几个对象引用形成一个环,互相引用,但根访问不到它们,这几个对象也是垃圾,也要被清除。
    (2)垃圾回收策略:
    2种最为常用:标记清除和引用计数,其中标记清除更为常用。
    1. 标记清除(mark-and-sweep):是对于脱离作用域的变量进行回收,当进入作用域时,进行标记,离开作用域时,标记并回收这些变量。到目前为止,IE、Firefox、Opera、Chrome、Safari的js实现使用的都是标记清除的垃圾回收策略或类似的策略,只不过垃圾收集的时间间隔互不相同。
    2. 引用计数:引用计数是跟踪记录每个值被引用的次数。就是变量的引用次数,被引用一次则加1,当这个引用计数为0时,被视为准备回收的对象,每当过一段时间开始垃圾回收的时候,就把被引用数为0的变量回收。引用计数方法可能导致循环引用,类似死锁,导致内存泄露。

    (3)常见内存泄露的原因
    1. 全局变量引起的内存泄露
    2. 闭包引起的内存泄露:慎用闭包
    3. dom清空或删除时,事件未清除导致的内存泄漏
    4. 循环引用带来的内存泄露

    9. 反向代理
    答: 反向代理(Reverse Proxy),以代理服务器来接受internet上的连接请求,然后将请求转发给内部网络上的服务器,并将从服务器上得到的结果返回给internet上请求的客户端,此时代理服务器对外表现为一个反向代理服务器。
    理解起来有些抽象,可以这么说:A向B借钱,B没有拿自己的钱,而是悄悄地向C借钱,拿到钱之后再交给A,A以为是B的钱,他并不知道C的存在。

    三、jQuery框架部分

    1. jQuery绑定事件的方法书写至少两种?

    答:bind(),on(),click()

    2.jQuery对象和Dom对象相互转换

    答:jQuery对象转原生Dom对象 $(“div”).get(0)
    原生Dom对象转jQuery对象 $(ele)

    3.Js用过的插件
    答:tween.js,swiper.js,touch.js,zepto.js

    4.jQuery如何获取元素?
    答:$(selector)

    5.JQuery链式写法原理
    答:jQuery里的方法调用完毕返回return this

    6.用jQuery如何获取标签的id
    答:$(element).attr(“id”)

    7.用jQuery如何获取标签


    答:$(“div”)

    8.用jQuery如何获取标签内容
    答: ( e l e m e n t ) . t e x t ( ) / (element).text()/ (element).text()/(element).html();

    9.用jQuery如何更换背景色
    答:$(element).css({backgroundColor:”red”})

    10.jQuery中,如何阻止事件冒泡和浏览器默认行为?
    答:e.preventDefault();e.stopPropagation();

    **11. ( d o c u m e n t ) . r e a d y 与 w i n d o w . o n l o a d 有 何 区 别 ? ∗ ∗ 答 : (document).ready与window.onload有何区别?** 答: (document).readywindow.onload(document).ready 对于支持DOMContentLoaded事件的浏览器,会使用该事件,所有的节点渲染完毕,就执行,可以调用多次,不支持的就使用 onload事件
    window.onload事件要等到所有的资源加载完毕,如图片,视频,js脚本等,只能绑定一次,后面绑定的覆盖前面所绑定的事件

    12.列举jQuery的优势
    答:兼容性处理,dom操作,获取元素简单,封装了ajax…

    13.jQuery中 :odd :gt 这两种选择器的含义以及用法举例
    :odd 匹配所有索引值为奇数的元素,从 0 开始计数 $(“div:odd”)
    :gt(index) 匹配所有大于给定索引值的元素 $(“div:gt(2)”)

    14.jQuery中,使用nth-child(3n+2)所选中的是以下哪些
    在这里插入图片描述
    nth-child()匹配其父元素下的第N个子或奇偶元素
    ‘:eq(index)’ 只匹配一个元素,而这个将为每一个父元素匹配子元素。:nth-child从1开始的,而:eq()是从0算起的
    2,5,8
    在这里插入图片描述
    15.使用jQuery中的链式书写方法书写如下代码
    答:$(“#test”).css(“color”,”red”).width(20)

    16.jQuery中对动画的操作命令有哪些?举出不少于8种,并说明含义
    答:animate(),fadeIn(),fadeOut(),slideDown(),slideUp(),hide(),show(),toggle()

    17.jQuery中绑定事件的方法是什么,尝试书写例子:为id名为con的div绑定一个事件,事件为弹出一个数字0。获取标签时不要使用原生javascript方法。
    答:$(“#con”).click(function(){alert(0)})

    18.jQuery中获取相对文档的坐标的方法是什么?
    答:offset(),获取匹配元素在当前视口的相对偏移。返回的对象包含两个整型属性:top 和 left,以像素计。此方法只对可见元素有效。
    position()获取匹配元素相对定位父级的偏移。没有定位父级即为文档坐标
    返回的对象包含两个整型属性:top 和 left。为精确计算结果,请在补白、边框和填充属性上使用像素单位。此方法只对可见元素有效。

    19.jQuery中对于节点的操作有哪些(举出不少于8种)?写出含义以及用法。
    在这里插入图片描述
    20.jQuery动画效果的实现
    答:$ele().animate({top:100},500)

    21.jQuery中的两个合成事件是_________和__________
    答:toggle、hover

    22.用jQuery获取标签

    div内部的信息
    当中的内容的代码为______?
    答:$(“#con”).text()

    23.举出不少于6种的jQuery中对动画的操作命令,并说明其含义:_________、_________、_________、_________、_________、_________
    在这里插入图片描述
    24.编写一个jQuery的扩展方法(插件),让调用的对象设置宽度为200像素
    jQuery.fn.extend({
    setWidth:function() {
    $(this).width(200);
    return this;
    }
    })

    25.你使用过哪些Javascript库?
    答:jQuery Zepto(注意了:面试官可能问你这2个库都什么区别

    jQuery是在Web上应用很广泛的JavaScript库,它提供了大量的工具和API函数,使用它的人相当普遍,使用的门槛也比较低。
    Zepto最初是为移动端开发的库,是jQuery的轻量级替代品,因为它的API和jQuery相似,而文件更小,对任何项目都是个不错的选择,Zepto是不支持IE浏览器。

    针对移动端程序,Zepto还有一些基本的触摸事件可以用来做触摸屏交互,如:tap事件——tap,singleTap,doubleTap,longTap;
    Swipe事件——swipe,swipeLeft,swipeRight,swipeUp,swipeDown。

    四、 AJAX

    1.如何实现局部内容和后台交互时的变化

    答:使用ajax

    2.什么是AJAX ,AJAX原理
    答:AJAX即“Asynchronous Javascript And XML”(异步JavaScript和XML)通过在后台与服务器进行少量数据交换,AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下,对网页的某部分进行更新。传统的网页(不使用 AJAX)如果需要更新内容,必须重载整个网页页面。
    原理:XMLHttpRequest

    3.使用异步加载获取JS数据至少两种方法?

    答:post,get

    4.什么是JSON,JSON的格式

    答:JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON 语法是 JavaScript 对象表示语法的子集。
    数据在键值对中
    数据由逗号分隔
    花括号保存对象
    方括号保存数组

    5.除了AJAX还有什么模板可以与后台交互
    答:jsonp

    6.AJAX中的跨域问题:什么是跨域?如何解决跨域问题?
    答:域不一样的,即为跨域,包括(协议,域名,端口号)
    1.// 指定允许其他域名访问
    header(‘Access-Control-Allow-Origin:*’);
    2.使用jsonp

    7.AJAX的流程是什么?
    1.客户端产生js的事件
    2.创建XMLHttpRequest对象
    3.对XMLHttpRequest进行配置
    4.通过AJAX引擎发送异步请求
    5.服务器端接收请求并且处理请求,返回html或者xml内容
    6.XML调用一个callback()处理响应回来的内容
    7.页面局部刷新

    8.AJAX如何调用JSON数据
    答:xml.responseText

    9.AJAX能够处理哪些格式的文件
    https://developer.mozilla.org/zh-CN/docs/Web/API/XMLHttpRequest

    在这里插入图片描述
    XMLHttpRequest 2.0 新增了多种类型
    支持txt,json,js,图片,文档等等…

    10.AJAX实现表单验证用户注册流程
    用户触发ajax请求,后台接口返回json格式字符串

    11.JSON数据的解析方法
    1.JSON.parse(json)
    2.new Function(“return ” + json) ();
    3.eval(“(”+json+”)”)

    12.如何转化成JSON字符串
    答:JSON.stringify(json)

    13.说明异步请求的get和post方法的区别
    1.使用Get请求时,参数在URL中显示,而使用Post方式,则不会显示出来
    2.使用Get请求发送数据量小,Post请求发送数据量大
    get 请求:
    在这里插入图片描述
    在这里插入图片描述
    post 请求:
    在这里插入图片描述
    14.列举AJAX的优势
    答:传统的Web应用交互由用户触发一个HTTP请求到服务器,服务器对其进行处理后再返回一个新的HTHL页到客户端, 每当服务器处理客户端提交的请求时,客户都只能空闲等待,并且哪怕只是一次很小的交互、只需从服务器端得到很简单的一个数据,都要返回一个完整的HTML页,而用户每次都要浪费时间和带宽去重新读取整个页面。这个做法浪费了许多带宽,由于每次应用的交互都需要向服务器发送请求,应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。
    与此不同,AJAX应用可以仅向服务器发送并取回必需的数据,它使用SOAP或其它一些基于XML的Web Service接口,并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少,结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成,所以Web服务器的处理时间也减少了。

    15.AJAX中创建请求的兼容性处理
    答:var xmlHttp = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject(“Microsoft.XMLHTTP”);

    16.对于request.status的http状态码 用于表示网页服务器HTTP响应状态的3位数字代码。1,2,3,4,5开头的状态码分别代表什么(提示:404页面表示禁止访问等)
    1xx(临时响应)表示临时响应并需要请求者继续执行操作的状态代码。
    2xx (成功)表示成功处理了请求的状态代码。
    3xx (重定向) 表示要完成请求,需要进一步操作。 通常,这些状态代码用来重定向。
    4xx(请求错误) 这些状态代码表示请求可能出错,妨碍了服务器的处理。
    5xx(服务器错误)这些状态代码表示服务器在尝试处理请求时发生内部错误。 这些错误可能是服务器本身的错误,而不是请求出错。

    17.下列对get和post的区别描述错误的是( )
    A、get比post更常用 B、get发送信息为明文发送,安全性较差
    C、get的性能只有post的1/3 D、get传输数据是通过URL进行的
    答案:C

    18.如何将js对象转化成JSON字符串( )
    A、JSON.parseInt() B、JSON.parse()
    C、JSON.string () D、JSON.stringify ()
    答案:D

    19.你对Ajax的理解。
    1.AJAX 是一种用于创建更好更快以及交互性更强的 Web 应用程序的技术;
    2.通过Ajax你的 JavaScript 可在不重载页面的情况与 Web 服务器交换数据;
    3.AJAX 在浏览器与 Web 服务器之间使用异步数据传输(HTTP 请求),这样就可使网页从服务器请求少量的信息,而不是整个页面;
    4.AJAX 可使因特网应用程序更小、更快,更友好;
    5.AJAX 是一种独立于 Web 服务器软件的浏览器技术。

    20.什么是Ajax和JSON,它们的优缺点
    什么是Ajax???
    术语Ajax用来描述一组技术,它使浏览器可以为用户提供更为自然的浏览体验。
    Ajax它是“Asynchronous JavaScript + XML的简写”

    定义Ajax:
    Ajax不是一种技术。实际上,它由几种蓬勃发展的技术以新的强大方式组合而成。Ajax包含:
    * 基于XHTML和CSS标准的表示;
    * 使用Document Object Model进行动态显示和交互;
    * 使用XMLHttpRequest与服务器进行异步通信;
    * 使用JavaScript绑定一切。

    Ajax的工作原理(一定要掌握)
    一共4步,每一步代表什么意思以及什么作用?面试题1里面有提到

    对于JSON,首先要明白JSON和XML一样也是一种简单文本格式。
    JSON来自于javascript,但是应用上面远远不止是javascript的json,它相当于xml,是一种比较流行的标准格式,是数据的载体
    javascript json 是用于javascript程序的,它可以支持对象引用以及函数;ajax json只是最简单的字符串和数字,它不可能完全支持javascript里面的数据类型。
    相对于XML,JSON更加易读、更便于肉眼检查。在语法的层面上,JSON与其他格式的区别是在于分隔数据的字符

    21.浅谈一下如何避免用户多次点击造成的多次请求。
    答:我们在访问有的网站,输入表单完成以后,单击提交按钮进行提交以后,提交按钮就会变为灰色,用户不能再单击第二次,直到重新加载页面或者跳转。这样,可以一定程度上防止用户重复提交导致应用程序上逻辑错误。
    还有很多其他的方式进行防止重复点击提交,如
    1> 定义标志位:
     点击触发请求后,标志位为false量;请求(或者包括请求后具体的业务流程处理)后,标志位为true量。通过标志位来判断用户点击是否具备应有的响应。
    2> 卸载及重载绑定事件:
    点击触发请求后,卸载点击事件;请求(或者包括请求后具体的业务流程处理)后,重新载入绑定事件。
    3> 替换(移除)按钮DOM
    点击触发请求后,将按钮DOM对象替换掉(或者将之移除),自然而然此时不在具备点击事件;请求(或者包括请求后具体的业务流程处理)后,给新的按钮DOM定义点击事件。

    22.浅谈一下如何避免用户多次点击造成的多次请求。
    答:我们在访问有的网站,输入表单完成以后,单击提交按钮进行提交以后,提交按钮就会变为灰色,用户不能再单击第二次,直到重新加载页面或者跳转。这样,可以一定程度上防止用户重复提交导致应用程序上逻辑错误。
    还有很多其他的方式进行防止重复点击提交,如
    1> 定义标志位:
     点击触发请求后,标志位为false量;请求(或者包括请求后具体的业务流程处理)后,标志位为true量。通过标志位来判断用户点击是否具备应有的响应。
    2> 卸载及重载绑定事件:
    点击触发请求后,卸载点击事件;请求(或者包括请求后具体的业务流程处理)后,重新载入绑定事件。
    3> 替换(移除)按钮DOM
    点击触发请求后,将按钮DOM对象替换掉(或者将之移除),自然而然此时不在具备点击事件;请求(或者包括请求后具体的业务流程处理)后,给新的按钮DOM定义点击事件。

    32.如何解决跨域问题?
    答:jsonp、iframe、window.name、window.postMessage、服务器上设置代理页面

    33.异步加载的方式有哪些?
    (1)defer,只支持 IE
    (2)async:
    (3)创建 script,插入到 DOM 中,加载完毕后 callBack

    ---------------------------------欢迎留言补充小伙伴儿们在面试中问到问题-----------------------

    展开全文
  • Web前端面试题.txt

    2019-09-25 11:40:15
    Web前端面试题.txt 面试的时候法宝,了解前端的基础面试题
  • 自己整理的 包括mvvm原理 深浅拷贝 判断js类型方式 原型原型链等面试重难点!非常通俗易懂 很详细!!
  • 2020 web前端面试题及答案大全

    万次阅读 多人点赞 2020-05-12 13:43:50
    css相关 1. 万能居中 1.margin: 0 auto;水平 2.text-align: center;水平 3.行高,垂直 4.表格,center,middle;...5.display:table-cell;...7.绝对定位,上下左右全0,margin:auto ...9.IE6,IE7:给父元素设一个font-size...

    css相关

    1. 万能居中

    1.margin: 0 auto;水平
    2.text-align: center;水平
    3.行高,垂直
    4.表格,center,middle;水平垂直
    5.display:table-cell;模拟表格,all
    6.绝对定位,50%减自身宽高
    7.绝对定位,上下左右全0,margin:auto
    8.绝对定位加相对定位。不需要知道宽高
    9.IE6,IE7:给父元素设一个font-size:高度/1.14,vertical-align:middle

    2. BFC优化

    块格式化上下文, 特性:

    • 使 BFC 内部浮动元素不会到处乱跑;

    • 和浮动元素产生边界。

    3. 盒模型哪两种模式?什么区别?如何设置

    • 标准模式: box-sizing: content-box; 宽高不包括内边距和边框

    • 怪异模式: box-sizing: border-box

    4. 常用清除浮动的方法,如不清除浮动会怎样?

    当父元素不给高度的时候,内部元素不浮动时会撑开, 而浮动的时候,父元素变成一条线, 造成塌陷.

    • 额外标签法(在最后一个浮动标签后,新加一个标签,给其设置clear:both;)(不推荐)

    • 父元素添加overflow:hidden; (触发BFC)

    • 使用after伪元素清除浮动(推荐使用)

    • 使用before和after双伪元素清除浮动

    5. 删格化的原理

    比如antd的row和col, 将一行等分为24份, col是几就占几份, 底层按百分比实现; 结合媒体查询, 可以实现响应式

    6. 纯css实现三角形

    // 通过设置border.box        {            width:0px;            height:0px;
                border-top:50px solid rgba(0,0,0,0);            border-right:50px solid  rgba(0,0,0,0);            border-bottom:50px solid green;            border-left:50px solid  rgba(0,0,0,0);            }

    7. 高度不定,宽100%,内一p高不确定,如何实现垂直居中?

    • verticle-align: middle;

    • 绝对定位50%加translateY(-50%)

    • 绝对定位,上下左右全0,margin:auto

    8. 至少两种方式实现自适应搜索

    • rem, em

    • 百分比

    • 媒体查询

    • bs, antd等的栅格布局

    9. 设置一段文字的大小为6px

    • 谷歌最小12px, 其他浏览器可以更小

    • 通过transform: scale实现

    10. css菊花图

    四个小圆点一直旋转

    // 父标签animation: antRotate 1.2s infinite linear;// 子标签animation: antSpin 1s infinite linear;@keyframe antSpin {  to {    opacity: 1  }}@keyframe antRotate {  to {    transform: rotate(405)  }}// animation-delay: 逐个延迟0.4s

    11. 关于em

     <p style="font-size: 20px">      123      <p style="font-size: 2em;width: 2em">456</p> </p>// 此时子元素的font-size为40px, 宽度为80px(还要乘以子元素font-size的系数)

    12. 关于vh, vw

    vw:viewpoint width,视窗宽度,1vw等于视窗宽度的1%。
    vh:viewpoint height,视窗高度,1vh等于视窗高度的1%。
    vmin:vw和vh中较小的那个。
    vmax:vw和vh中较大的那个。

    13. Flex布局

    • flex-direction控制主副轴

    • flex-wrap控制换行(默认不换行)

    • flex-flow是上两个的结合

    • justify-content主轴对齐方式

    • align-items交叉轴对齐方式

    14. overflow原理

    • overflow: hidden能清除块内子元素的浮动影响. 因为该属性进行超出隐藏时需要计算盒子内所有元素的高度, 所以会隐式清除浮动

    • 创建BFC条件(满足一个):

      • float的值不为none;

      • overflow的值不为visible;

      • position的值为fixed / absolute;

      • display的值为table-cell / table-caption / inline-block / flex / inline-flex。

    15. 实现自适应的正方形:

    • 使用vw, vh

    • width百分比, height: 0padding-top(bottom): 50%

    16. 标准模式和怪异模式

    • document.compatMode属性可以判断是否是标准模式,当 document.compatMode为“CSS1Compat”,是标准模式,“BackCompat”是怪异模式。

    • 怪异模式是为了兼容旧版本的浏览器, 因为IE低版本document.documentElement.clientWidth获取不到

    • 怪异模式盒模型: box-sizing: border-box; 标准模式: box-sizing: content-box

    17. CSS3实现环形进度条

    两个对半矩形遮罩, 使用rotate以及overflow: hidden进行旋转

    18. css优先级

    选择器的特殊性值表述为4个部分,用0,0,0,0表示。

    • ID选择器的特殊性值,加0,1,0,0。

    • 类选择器、属性选择器或伪类,加0,0,1,0。

    • 元素和伪元素,加0,0,0,1。

    • 通配选择器*对特殊性没有贡献,即0,0,0,0。

    • 最后比较特殊的一个标志!important(权重),它没有特殊性值,但它的优先级是最高的,为了方便记忆,可以认为它的特殊性值为1,0,0,0,0。

    JS相关

    1. ES5和ES6继承方式区别

    • ES5定义类以函数形式, 以prototype来实现继承

    • ES6以class形式定义类, 以extend形式继承

    2. Generator了解

    ES6 提供的一种异步编程解决方案, Generator 函数是一个状态机,封装了多个内部状态。

    function* helloWorldGenerator() {  yield 'hello';  yield 'world';  return 'ending';}
    var hw = helloWorldGenerator();

    调用后返回指向内部状态的指针, 调用next()才会移向下一个状态, 参数:

    hw.next()// { value: 'hello', done: false }hw.next()// { value: 'world', done: false }hw.next()// { value: 'ending', done: true }hw.next()// { value: undefined, done: true }

    3. 手写Promise实现

    var myPromise = new Promise((resolve, reject) => {  // 需要执行的代码  ...  if (/* 异步执行成功 */) {    resolve(value)  } else if (/* 异步执行失败 */) {    reject(error)  }})
    myPromise.then((value) => {  // 成功后调用, 使用value值}, (error) => {  // 失败后调用, 获取错误信息error})

    4. Promise优缺点

    • 优点: 解决回调地狱, 对异步任务写法更标准化与简洁化

    • 缺点: 首先,无法取消Promise,一旦新建它就会立即执行,无法中途取消; 其次,如果不设置回调函数,Promise内部抛出的错误,不会反应到外部; 第三,当处于pending状态时,无法得知目前进展到哪一个阶段(刚刚开始还是即将完成).
      极简版promise封装:

    function promise () {  this.msg = '' // 存放value和error  this.status = 'pending'  var that = this  var process = arguments[0]
      process (function () {    that.status = 'fulfilled'    that.msg = arguments[0]  }, function () {    that.status = 'rejected'    that.msg = arguments[0]  })  return this}
    promise.prototype.then = function () {  if (this.status === 'fulfilled') {    arguments[0](this.msg)  } else if (this.status === 'rejected' && arguments[1]) {    arguments[1](this.msg)  }}

    5. 观察者模式

    又称发布-订阅模式, 举例子说明.
    实现: 发布者管理订阅者队列, 并有新消息推送功能. 订阅者仅关注更新就行

    6. 手写实现bind

    Function.prototype.bind = function () {   // 保存原函数  var self = this  // 取出第一个参数作为上下文, 相当于[].shift.call(arguments)  var context = Array.prototype.shift.call(arguments)  // 取剩余的参数作为arg; 因为arguments是伪数组, 所以要转化为数组才能使用数组方法  var arg = Array.prototype.slice.call(arguments)  // 返回一个新函数  return function () {    // 绑定上下文并传参    self.apply(context, Array.prototype.concat.call(arg, Array.prototype.slice.call(arguments)))  }}

    7. 手写实现4种继承

    function Father () {}function Child () {}// 1\. 原型继承Child.prototype = new Father()// 2\. 构造继承function Child (name) {  Father.call(this, name)}// 3\. 组合继承function Child (name) {  Father.call(this, name)}Child.prototype = new Father()// 4\. 寄生继承function cloneObj (o) {  var clone = object.create(o)  clone.sayName = ...  return clone}// 5\. 寄生组合继承// 6\. ES6 class extend继承

    8. css菊花图

    四个小圆点一直旋转

    // 父标签animation: antRotate 1.2s infinite linear;// 子标签animation: antSpin 1s infinite linear;@keyframe antSpin {  to {    opacity: 1  }}@keyframe antRotate {  to {    transform: rotate(405)  }}// animation-delay: 逐个延迟0.4s

    9. http状态码

    • 1**: 服务器收到请求, 需请求者进一步操作

    • 2**: 请求成功

    • 3**: 重定向, 资源被转移到其他URL了

    • 4**: 客户端错误, 请求语法错误或没有找到相应资源

    • 5**: 服务端错误, server error

    • 304: Not Modified. 指定日期后未修改, 不返回资源

    10. Object.create实现(原型式继承,特点:实例的proto指向构造函数本身)

    11. async和await:

    • Generator函数的语法糖,将*改成async,将yield换成await。

    • 是对Generator函数的改进, 返回promise。

    • 异步写法同步化,遇到await先返回,执行完异步再执行接下来的.

    • 内置执行器, 无需next()

    12. 算法和数据结构:

    • 算法:
      解决具体问题所需要的解决方法。执行效率最快的最优算法。时间复杂度。输入,输出,有穷性,确定性,可行性。冒泡排序,二叉树遍历,最长回文,二分查找,指针,链表等,堆栈,队列等。力扣,codewar,算法导论。

    • 数据结构:
      逻辑结构:集合、线性、树形、图形结构
      物理结构:顺序、链式存储结构

    13. 封装JSONP

    function jsonp ({url, param, callback}) {  return new Promise((resolve, reject) => {    var script = document.createElement('script')    window.callback = function (data) {      resolve(data)      document.body.removeChild('script')    }    var param = {...param, callback}    var arr = []    for (let key in param) {      arr.push(`${key}=${param[key]}`)    }    script.src = `${url}?${arr.join('&')}`    document.body.appendChild(script)  })}

    14. 手动实现map(forEach以及filter也类似)

    // for循环实现Array.prototype.myMap = function () {  var arr = this  var [fn, thisValue] = Array.prototype.slice.call(arguments)  var result = []  for (var i = 0; i < arr.length; i++) {    result.push(fn.call(thisValue, arr[i], i, arr))  }  return result}var arr0 = [1, 2, 3]console.log(arr0.myMap(v => v + 1))
    // forEach实现(reduce类似)Array.prototype.myMap = function (fn, thisValue) {  var result = []  this.forEach((v, i, arr) => {    result.push(fn.call(thisValue, v, i, arr))  })  return result}var arr0 = [1, 2, 3]console.log(arr0.myMap(v => v + 1))

    15. js实现checkbox全选以及反选

    <body>    <button id="other">反选</button>    <input type="checkbox" id="all" />全选    <input type="checkbox" class="check" />1    <input type="checkbox" class="check" />2    <input type="checkbox" class="check" />3    <script>      var checkbox = document.getElementsByClassName('check')      var checkAll = document.getElementById('all')      var checkOther = document.getElementById('other')      checkAll.onclick = function() {        var flag = true        for (var i = 0; i < checkbox.length; i++) {          if (!checkbox[i].checked) flag = false        }        if (flag) {          for (var i = 0; i < checkbox.length; i++) {            checkbox[i].checked = false          }        } else {          for (var i = 0; i < checkbox.length; i++) {            checkbox[i].checked = true          }        }      }      checkOther.onclick = function() {        for (var i = 0; i < checkbox.length; i++) {          checkbox[i].checked = !checkbox[i].checked        }      }</script>  </body>

    16. 对原型链的理解?prototype上都有哪些属性

    • 在js里,继承机制是原型继承。继承的起点是 对象的原型(Object prototype)。

    • 一切皆为对象,只要是对象,就会有 proto 属性,该属性存储了指向其构造的指针。

    • Object prototype也是对象,其 proto 指向null。

    • 对象分为两种:函数对象和普通对象,只有函数对象拥有『原型』对象(prototype)。

    • prototype的本质是普通对象。

    • Function prototype比较特殊,是没有prototype的函数对象。

    • new操作得到的对象是普通对象。

    • 当调取一个对象的属性时,会先在本身查找,若无,就根据 proto 找到构造原型,若无,继续往上找。最后会到达顶层Object prototype,它的 proto 指向null,均无结果则返回undefined,结束。

    • 由 proto 串起的路径就是『原型链』。

    • 通过prototype可以给所有子类共享属性

    17. 为什么使用继承

    通常在一般的项目里不需要,因为应用简单,但你要用纯js做一些复杂的工具或框架系统就要用到了,比如webgis、或者js框架如jquery、ext什么的,不然一个几千行代码的框架不用继承得写几万行,甚至还无法维护。

    18. setTimeout时间延迟为何不准

    单线程, 先执行同步主线程, 再执行异步任务队列

    19. 事件循环述,宏任务和微任务有什么区别?

    • 先主线程后异步任务队列

    • 先微任务再宏任务

    20. let const var作用域

    块级作用域, 暂时性死区

    21. 节流和防抖

    • 函数节流是指一定时间内js方法只跑一次。比如人的眨眼睛,就是一定时间内眨一次。这是函数节流最形象的解释。

    // 函数节流   滚动条滚动var canRun = true;document.getElementById("throttle").onscroll = function(){    if(!canRun){        // 判断是否已空闲,如果在执行中,则直接return        return;    }
        canRun = false;    setTimeout(function(){        console.log("函数节流");        canRun = true;    }, 300);};
    • 函数防抖是指频繁触发的情况下,只有足够的空闲时间,才执行代码一次。比如生活中的坐公交,就是一定时间内,如果有人陆续刷卡上车,司机就不会开车。只有别人没刷卡了,司机才开车。

    // 函数防抖var timer = false;document.getElementById("debounce").onscroll = function(){    clearTimeout(timer); // 清除未执行的代码,重置回初始化状态
        timer = setTimeout(function(){        console.log("函数防抖");    }, 300);};

    22. 实现一个sleep函数

    // 这种实现方式是利用一个伪死循环阻塞主线程。因为JS是单线程的。所以通过这种方式可以实现真正意义上的sleep()。function sleep(delay) {  var start = (new Date()).getTime();  while ((new Date()).getTime() - start < delay) {    continue;  }}
    function test() {  console.log('111');  sleep(2000);  console.log('222');}
    test()

    23. 闭包

    • 概念: 内层函数能够访问外层函数作用域的变量

    • 缺点: 引起内存泄漏(释放内存)

    • 作用:

      • 使用闭包修正打印值

      • 实现柯里化

      • 实现node commonJs 模块化, 实现私有变量

      • 保持变量与函数活性, 可延迟回收和执行

    24. Immutable.js

    Facebook出品, 倡导数据的不可变性, 用的最多就是List和Map.

    25. js实现instanceof

    // 检测l的原型链(__proto__)上是否有r.prototype,若有返回true,否则falsefunction myInstanceof (l, r) {  var R = r.prototype  while (l.__proto__) {    if (l.__proto__ === R) return true  }  return false}

    27. ES6的模块引入和CommonJs区别

    28. 严格模式

    // 严格模式下, 隐式绑定丢失后this不会指向window, 而是指向undefined      'use strict'      var a = 2      var obj = {        a: 1,        b: function() {          // console.log(this.a)          console.log(this)        }      }      var c = obj.b      c() // undefined

    29. fetch, axios区别

    30. typescript缺点

    • 并不是严格意义的js的超集, 与js不完全兼容, 会报错

    • 更多的限制, 是一种桎梏

    • 有些js第三方库没有dts, 有问题

    31. 构造函数实现原理

    • 构造函数中没有显示的创建Object对象, 实际上后台自动创建了

    • 直接给this对象赋值属性和方法, this即指向创建的对象

    • 没有return返回值, 后台自动返回了该对象

    // 模拟构造函数实现var Book = function(name) {          this.name = name;        };
            //正常用法        var java = new Book(‘Master Java’);
            //使用代码模拟,在非IE浏览器中测试,IE浏览器不支持        var python = {};        python.__proto__ = Book.prototype;        Book.call(python, 'Master Python');

    32. for in 和 for of区别

    • for in遍历数组会遍历到数组原型上的属性和方法, 更适合遍历对象

    • forEach不支持break, continue, return

    • 使用for of可以成功遍历数组的值, 而不是索引, 不会遍历原型

    • for in 可以遍历到myObject的原型方法method,如果不想遍历原型方法和属性的话,可以在循环内部判断一下,hasOwnPropery方法可以判断某属性是否是该对象的实例属性

    33. JS实现并发控制:

    使用消息队列以及setIntervalpromise进行入队和出队

    34. ajax和axios、fetch的区别

    35. promise.finally实现

    Promise.prototype.finally = function (callback) {  let P = this.constructor;  return this.then(    value  => P.resolve(callback()).then(() => value),    reason => P.resolve(callback()).then(() => { throw reason })  );};

    浏览器网络相关

    1. reflow(回流)和repaint(重绘)优化

    • 浏览器渲染过程: DOM tree, CSS tree --> Render tree --> Paint

    • DOM tree根节点为html

    • 渲染从浏览器左上角到右下角

    • 第一次打开页面至少触发一次重绘和回流, 结构如宽高位置变化时, 触发reflow回流;非结构如背景色变化时, 触发repaint重绘. 二者都会造成体验不佳

    • 如何减少重绘和回流?

      • 通过classname或cssText一次性修改样式, 而非一个一个改

      • 离线模式: 克隆要操作的结点, 操作后再与原始结点交换, 类似于虚拟DOM

      • 避免频繁直接访问计算后的样式, 而是先将信息保存下来

      • 绝对布局的DOM, 不会造成大量reflow

      • p不要嵌套太深, 不要超过六层

    2.一个页面从输入 URL 到页面加载显示完成,这个过程中都发生了什么?

    • 浏览器根据请求的URL交给DNS域名解析,找到真实IP,向服务器发起请求;

    • 服务器交给后台处理完成后返回数据,浏览器接收文件(HTML、JS、CSS、图象等);

    • 浏览器对加载到的资源(HTML、JS、CSS等)进行语法解析,建立相应的内部数据结构(如HTML的DOM Tree);

    • 载入解析到的资源文件,渲染页面,完成。

    3.localStorage 与 sessionStorage 与cookie的区别总结

    • 共同点: 都保存在浏览器端, 且同源

    • localStorage 与 sessionStorage 统称webStorage,保存在浏览器,不参与服务器通信,大小为5M

    • 生命周期不同: localStorage永久保存, sessionStorage当前会话, 都可手动清除

    • 作用域不同: 不同浏览器不共享local和session, 不同会话不共享session

    • Cookie: 设置的过期时间前一直有效, 大小4K.有个数限制, 各浏览器不同, 一般为20个.携带在HTTP头中, 过多会有性能问题.可自己封装, 也可用原生

    4.浏览器如何阻止事件传播,阻止默认行为

    • 阻止事件传播(冒泡): e.stopPropagation()

    • 阻止默认行为: e.preventDefault()

    5.虚拟DOM方案相对原生DOM操作有什么优点,实现上是什么原理?

    虚拟DOM可提升性能, 无须整体重新渲染, 而是局部刷新.
    JS对象, diff算法

    6.浏览器事件机制中事件触发三个阶段

    • 事件捕获阶段: 从dom树节点往下找到目标节点, 不会触发函数

    • 事件目标处理函数: 到达目标节点

    • 事件冒泡: 最后从目标节点往顶层元素传递, 通常函数在此阶段执行.
      addEventListener第三个参数默认false(冒泡阶段执行),true(捕获阶段执行).
      阻止冒泡见以上方法

    7.什么是跨域?为什么浏览器要使用同源策略?你有几种方式可以解决跨域问题?了解预检请求嘛?

    • 跨域是指一个域下的文档或脚本试图去请求另一个域下的资源

    • 防止XSS、CSFR等攻击, 协议+域名+端口不同

    • jsonp; 跨域资源共享(CORS)(Access control); 服务器正向代理等

    • 预检请求: 需预检的请求要求必须首先使用 OPTIONS 方法发起一个预检请求到服务器,以获知服务器是否允许该实际请求。"预检请求“的使用,可以避免跨域请求对服务器的用户数据产生未预期的影响

    8.了解浏览器缓存机制吗?

    • 浏览器缓存就是把一个已经请求过的资源拷贝一份存储起来,当下次需要该资源时,浏览器会根据缓存机制决定直接使用缓存资源还是再次向服务器发送请求.

    • from memory cache ; from disk cache

    • 作用: 减少网络传输的损耗以及降低服务器压力。

    • 优先级: 强制缓存 > 协商缓存; cache-control > Expires > Etag > Last-modified

    9.为什么操作 DOM 慢?

    DOM本身是一个js对象, 操作这个对象本身不慢, 但是操作后触发了浏览器的行为, 如repaint和reflow等浏览器行为, 使其变慢

    10.什么情况会阻塞渲染?

    • js脚本同步执行

    • css和图片虽然是异步加载, 但js文件执行需依赖css, 所以css也会阻塞渲染

    11.如何判断js运行在浏览器中还是node中?

    判断有无全局对象global和window

    12.关于web以及浏览器处理预加载有哪些思考?

    图片等静态资源在使用之前就提前请求
    资源使用到的时候能从缓存中加载, 提升用户体验
    页面展示的依赖关系维护

    13.http多路复用

    • Keep-Alive: Keep-Alive解决的核心问题:一定时间内,同一域名多次请求数据,只建立一次HTTP请求,其他请求可复用每一次建立的连接通道,以达到提高请求效率的问题。这里面所说的一定时间是可以配置的,不管你用的是Apache还是nginx。

    • 解决两个问题: 串行文件传输(采用二进制数据帧); 连接数过多(采用流, 并行传输)

    14. http和https:

    • http: 最广泛网络协议,BS模型,浏览器高效。

    • https: 安全版,通过SSL加密,加密传输,身份认证,密钥

    1. https相对于http加入了ssl层, 加密传输, 身份认证;

    2. 需要到ca申请收费的证书;

    3. 安全但是耗时多,缓存不是很好;

    4. 注意兼容http和https;

    5. 连接方式不同, 端口号也不同, http是80, https是443

    15. CSRF和XSS区别及防御

    16. cookie可设置哪些属性?httponly?

    chrome控制台的application下可查看:

    • name  字段为一个cookie的名称。

    • value  字段为一个cookie的值。

    • domain  字段为可以访问此cookie的域名。

    • path  字段为可以访问此cookie的页面路径。比如domain是abc.com,path是/test,那么只有/test路径下的页面可以读取此cookie。

    • expires/Max-Age   字段为此cookie超时时间。若设置其值为一个时间,那么当到达此时间后,此cookie失效。不设置的话默认值是Session,意思是cookie会和session一起失效。当浏览器关闭(不是浏览器标签页,而是整个浏览器) 后,此cookie失效。

    • Size  字段 此cookie大小。

    • http  字段 cookie的httponly属性。若此属性为true,则只有在http请求头中会带有此cookie的信息,而不能通过document.cookie来访问此cookie。

    • secure   字段 设置是否只能通过https来传递此条cookie

    17. 登录后,前端做了哪些工作,如何得知已登录

    • 前端存放服务端下发的cookie, 简单说就是写一个字段在cookie中表明已登录, 并设置失效日期

    • 或使用后端返回的token, 每次ajax请求将token携带在请求头中, 这也是防范csrf的手段之一

    18. http状态码

    • 1**: 服务器收到请求, 需请求者进一步操作

    • 2**: 请求成功

    • 3**: 重定向, 资源被转移到其他URL了

    • 4**: 客户端错误, 请求语法错误或没有找到相应资源

    • 5**: 服务端错误, server error

    • 301: 资源(网页等)被永久转移到其他URL, 返回值中包含新的URL, 浏览器会自动定向到新URL

    • 302: 临时转移. 客户端应访问原有URL

    • 304: Not Modified. 指定日期后未修改, 不返回资源

    • 403: 服务器拒绝执行请求

    • 404: 请求的资源(网页等)不存在

    • 500: 内部服务器错误

    19. # Http请求头缓存设置方法

    Cache-control, expire, last-modify

    20. 实现页面回退刷新

    • 旧: window.history.back() + window.location.href=document.referrer;

    • 新: HTML5的新API扩展了window.history,使历史记录点更加开放了。可以存储当前历史记录点、替换当前历史记录点、监听历史记录点onpopstate, replaceState

    21. 正向代理和反向代理

    • 正向代理:

    (1)访问原来无法访问的资源,如google
    (2) 可以做缓存,加速访问资源
    (3)对客户端访问授权,上网进行认证
    (4)代理可以记录用户访问记录(上网行为管理),对外隐藏用户信息

    • 反向代理:

    (1)保证内网的安全,可以使用反向代理提供WAF功能,阻止web攻击大型网站,通常将反向代理作为公网访问地址,Web服务器是内网。

    (2)负载均衡,通过反向代理服务器来优化网站的负载

     

    22. 关于预检请求

    在非简单请求且跨域的情况下,浏览器会自动发起options预检请求。

    23. 三次握手四次挥手

    • 开启连接用三次握手, 关闭用四次挥手

    24. TCP和UDP协议

    • TCP(Transmission Control Protocol:传输控制协议;面向连接,可靠传输

    • UDP(User Datagram Protocol):用户数据报协议;面向无连接,不可靠传输

    25. 进程和线程的区别

    • 进程:是并发执行的程序在执行过程中分配和管理资源的基本单位,是一个动态概念,竞争计算机系统资源的基本单位。

    • 线程:是进程的一个执行单元,是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。

    • 一个程序至少一个进程,一个进程至少一个线程。

    vue相关

    1. 生命周期

    2 .双向数据绑定v-model。这个最好也是自己实现一下 理解更深

    通过v-model
    VUE实现双向数据绑定的原理就是利用了 Object.defineProperty() 这个方法重新定义了对象获取属性值(get)和设置属性值(set)的操作来实现的。

    // 依赖收集// 简化版var obj = { }var name//第一个参数:定义属性的对象。//第二个参数:要定义或修改的属性的名称。//第三个参数:将被定义或修改的属性描述符。Object.defineProperty(obj, "data", {  //获取值  get: function () {    return name  },  //设置值  set: function (val) {    name = val    console.log(val)  }})//赋值调用setobj.data = 'aaa'//取值调用getconsole.log(obj.data)
    // 详细版 myVue.prototype._obverse = function (obj) { // obj = {number: 0}    var value;    for (key in obj) {  //遍历obj对象      if (obj.hasOwnProperty(key)) {        value = obj[key];        if (typeof value === 'object') {  //如果值是对象,则递归处理          this._obverse(value);        }        Object.defineProperty(this.$data, key, {  //关键          enumerable: true,          configurable: true,          get: function () {            console.log(`获取${value}`);            return value;          },          set: function (newVal) {            console.log(`更新${newVal}`);            if (value !== newVal) {              value = newVal;            }          }        })      }    }  }

    3.vue父子组件传递参数

    • 父 -->子: 通过props

    • 子 -->父: 通过 $$refs 或 $emit

    4.vue传递参数方法

    • 父子组件传参如上, v-bind : v-on @

    • 兄弟组件传参:(通过EventBus事件总线实现)

    // 1\. 新建eventBus.jsimport Vue from 'vue'export default new Vue// 或直接在main.js中初始化EventBus(全局)Vue.prototype.$EventBus = new Vue()
    // 2\. 发射与接收// 如果是定义在eventBus.js中import eventBus from 'eventBus.js'eventBus.$emit()eventBus.$on()
    // 如果是定义在main.js中this.bus.$emit()this.bus.$on()
    // 3\. 移除监听eventBus.$off()

    5.vue自定义组件

    可以使用独立可复用的自定义组件来构成大型应用, 采用帕斯卡命名法或横线连接, 通过以上方式进行组件间通信. 每一个组件都是Vue实例, 可以使用生命周期钩子.

    6. vue自定义指令

    • 除核心指令之外的指令, 使用directive进行注册.

    • 指令自定义钩子函数: bind, inserted, update, componentUpdated, unbind

    7.vuex组成和原理

    • 组成: 组件间通信, 通过store实现全局存取

    • 修改: 唯一途径, 通过commit一个mutations(同步)或dispatch一个actions(异步)

    • 简写: 引入mapState、mapGetters、mapActions

    8.vue-router的原理,例如hashhistory和History interface这些东西要弄明白。其实看一下源码就好了,看不懂可以直接看解析的相关技术博客。

    • vue-router用法:
      在router.js或者某一个路由分发页面配置path, name, component对应关系

      • 每个按钮一个value, 在watch功能中使用this.$router.push实现对应跳转, 类似react的this.history.push

      • 或直接用router-link to去跳转, 类似react的link to

    • vue-router原理: 通过hash和History interface两种方式实现前端路由

      • HashHistory: 利用URL中的hash(“#”);replace()方法与push()方法不同之处在于,它并不是将新路由添加到浏览器访问历史的栈顶,而是替换掉当前的路由

      • History interface: 是浏览器历史记录栈提供的接口,通过back(), forward(), go()等方法,我们可以读取浏览器历史记录栈的信息,进行各种跳转操作. pushState(), replaceState() 这下不仅是读取了,还可以对浏览器历史记录栈进行修改

    9.vue的seo问题

    seo关系到网站排名, vue搭建spa做前后端分离不好做seo, 可通过其他方法解决:

    • SSR服务端渲染: 将同一个组件渲染为服务器端的 HTML 字符串.利于seo且更快.

    • vue-meta-info, nuxt, prerender-spa-plugin页面预渲染等

    10.预渲染和ssr
    以上

    11.生命周期内create和mounted的区别

    • created: 在模板渲染成html前调用,即通常初始化某些数据,然后再渲染成视图。

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

    12.监听watch

    对应一个对象,键是观察表达式,值是对应回调。值也可以是methods的方法名,或者是对象,包含选项。在实例化时为每个键调用 $watch()

    13.登录验证拦截(通过router)

    • 先设置requireAuth:

    routes = [    {        name: 'detail',        path: '/detail',        meta: {            requireAuth: true        }    },    {        name: 'login',        path: '/login'    }]
    • 再配置router.beforeEach:

    router.beforeEach((from, to, next) => {    if (to.meta.requireAuth) { // 判断跳转的路由是否需要登录        if (store.state.token) { // vuex.state判断token是否存在            next() // 已登录        } else {            next({                path: '/login',                query: {redirect: to.fullPath} // 将跳转的路由path作为参数,登录成功后跳转到该路由            })        }    } else {       next()    }})

    14. v-for key值

    不写key值会报warning, 和react的array渲染类似. 根据diff算法, 修改数组后, 写key值会复用, 不写会重新生成, 造成性能浪费或某些不必要的错误

    15. vue3.0的更新和defineProperty优化

    • 放弃 Object.defineProperty ,使用更快的原生 Proxy (访问对象拦截器, 也成代理器)

    • 提速, 降低内存使用, Tree-shaking更友好

    • 支持IE11等

    • 使用Typescript

    15. vue使用this获取变量

    正常要通过vm.[图片上传失败...(image-6d2f4e-1570591304185)]

    root传参取值

    16. jQuery的优缺点,与vue的不同,vue的优缺点?

    • jq优点: 比原生js更易书写, 封装了很多api, 有丰富的插件库; 缺点: 每次升级与之前版本不兼容, 只能手动开发, 操作DOM很慢, 不方便, 变量名污染, 作用域混淆等。

    • vue优缺点: 双向绑定, 虚拟DOM, diff算法, MVVM, 组件化, 通信方便, 路由分发等

    17. vue解除双向绑定

    •  
    let obj = JSON.parse(JSON.stringify(this.temp1));

    18. vue异步组件

    为了简化,Vue 允许你以一个工厂函数的方式定义你的组件,这个工厂函数会异步解析你的组件定义。Vue 只有在这个组件需要被渲染的时候才会触发该工厂函数,且会把结果缓存起来供未来重渲染

    Vue.component(  'async-webpack-example',  // 这个 `import` 函数会返回一个 `Promise` 对象。  () => import('./my-async-component'))

    19. MVC与MVVM

    • model-数据层 view-视图层 controller-控制层

    • MVC的目的是实现M和V的分离,单向通信,必须通过C来承上启下

    • MVVM中通过VM(vue中的实例化对象)的发布者-订阅者模式实现双向绑定,数据绑定,dom事件监听

    • 区别:MVC和MVVM的区别并不是VM完全取代了C,ViewModel存在目的在于抽离Controller中展示的业务逻辑,而不是替代Controller,其它视图操作业务等还是应该放在Controller中实现。也就是说MVVM实现的是业务逻辑组件的重用

    20. vue渐进式

    小到可以只使用核心功能,比如单文件组件作为一部分嵌入;大到使用整个工程,vue init webpack my-project来构建项目;VUE的核心库及其生态系统也可以满足你的各式需求(core+vuex+vue-route)

    react相关

    1. 新旧生命周期

    • 旧: will, did; mount, update...

    • 新: 16版本之后:

      • getDerivedStateFromProps: 虚拟dom之后,实际dom挂载之前, 每次获取新的props或state之后, 返回新的state, 配合didUpdate可以替代willReceiveProps

      • getSnapshotBeforeUpdate: update发生的时候,组件更新前触发, 在render之后,在组件dom渲染之前;返回一个值,作为componentDidUpdate的第三个参数;配合componentDidUpdate, 可以覆盖componentWillUpdate的所有用法

      • componentDidCatch: 错误处理

    • 对比: 弃用了三个will, 新增两个get来代替will, 不能混用, 17版本会彻底删除. 新增错误处理

    2. react核心

    • 虚拟DOM, Diff算法, 遍历key值

    • react-dom: 提供了针对DOM的方法,比如:把创建的虚拟DOM,渲染到页面上 或 配合ref来操作DOM

    • react-router

    3. fiber核心(react 16)

    • 旧: 浏览器渲染引擎单线程, 计算DOM树时锁住整个线程, 所有行为同步发生, 有效率问题, 期间react会一直占用浏览器主线程,如果组件层级比较深,相应的堆栈也会很深,长时间占用浏览器主线程, 任何其他的操作(包括用户的点击,鼠标移动等操作)都无法执行。

    • 新: 重写底层算法逻辑, 引入fiber时间片, 异步渲染, react会在渲染一部分树后检查是否有更高优先级的任务需要处理(如用户操作或绘图), 处理完后再继续渲染, 并可以更新优先级, 以此管理渲染任务. 加入fiber的react将组件更新分为两个时期(phase 1 && phase 2),render前的生命周期为phase1,render后的生命周期为phase2, 1可以打断, 2不能打断一次性更新. 三个will生命周期可能会重复执行, 尽量避免使用。

    4. 渲染一个react

    • 分为首次渲染和更新渲染

    • 生命周期, 建立虚拟DOM, 进行diff算法

    • 对比新旧DOM, 节点对比, 将算法复杂度从O(n^3)降低到O(n)

    • key值优化, 避免用index作为key值, 兄弟节点中唯一就行

    5. 高阶组件

    高阶组件就是一个函数,且该函数(wrapper)接受一个组件作为参数,并返回一个新的组件。
    高阶组件并不关心数据使用的方式和原因,而被包裹的组件也不关心数据来自何处.

    • react-dnd: 根组件, source, target等
      export default DragSource(type, spec, collect)(MyComponent)

    • 重构代码库使用HOC提升开发效率

    6. hook(v16.7测试)

    在无状态组件(如函数式组件)中也能操作state以及其他react特性, 通过useState

    7. redux和vuex以及dva:

    • redux: 通过store存储,通过action唯一更改,reducer描述如何更改。dispatch一个action

    • dva: 基于redux,结合redux-saga等中间件进行封装

    • vuex:类似dva,集成化。action异步,mutation非异步

    8. react和vue的区别

    • 数据是否可变: react整体是函数式的思想,把组件设计成纯组件,状态和逻辑通过参数传入,所以在react中,是单向数据流,推崇结合immutable来实现数据不可变; vue的思想是响应式的,也就是基于是数据可变的,通过对每一个属性建立Watcher来监听,当属性变化的时候,响应式的更新对应的虚拟dom。总之,react的性能优化需要手动去做,而vue的性能优化是自动的,但是vue的响应式机制也有问题,就是当state特别多的时候,Watcher也会很多,会导致卡顿,所以大型应用(状态特别多的)一般用react,更加可控。

    • 通过js来操作一切,还是用各自的处理方式: react的思路是all in js,通过js来生成html,所以设计了jsx,还有通过js来操作css,社区的styled-component、jss等; vue是把html,css,js组合到一起,用各自的处理方式,vue有单文件组件,可以把html、css、js写到一个文件中,html提供了模板引擎来处理。

    • 类式的组件写法,还是声明式的写法: react是类式的写法,api很少; 而vue是声明式的写法,通过传入各种options,api和参数都很多。所以react结合typescript更容易一起写,vue稍微复杂。

    • 扩展不同: react可以通过高阶组件(Higher Order Components--HOC)来扩展,而vue需要通过mixins来扩展。

    • 什么功能内置,什么交给社区去做: react做的事情很少,很多都交给社区去做,vue很多东西都是内置的,写起来确实方便一些,
      比如 redux的combineReducer就对应vuex的modules,
      比如reselect就对应vuex的getter和vue组件的computed,
      vuex的mutation是直接改变的原始数据,而redux的reducer是返回一个全新的state,所以redux结合immutable来优化性能,vue不需要。

    9. react单向数据流怎么理解

    React是单向数据流,数据主要从父节点传递到子节点(通过props)。如果顶层(父级)的某个props改变了,React会重渲染所有的子节点。

    10. React算法复杂度优化

    react树对比是按照层级去对比的, 他会给树编号0,1,2,3,4.... 然后相同的编号进行比较。所以复杂度是n,这个好理解。

    关键是传统diff的复杂度是怎么算的?传统的diff需要出了上面的比较之外,还需要跨级比较。他会将两个树的节点,两两比较,这就有n^2的复杂度了。然后还需要编辑树,编辑的树可能发生在任何节点,需要对树进行再一次遍历操作,因此复杂度为n。加起来就是n^3了。

    11. React优点

    声明式, 组件化, 一次学习, 随处编写. 灵活, 丰富, 轻巧, 高效

    移动端相关

    1. 移动端兼容适配

    • <meta name="viewport" content="width=device-width, initial-scale=1.0">

    • rem, em, 百分比

    • 框架的栅格布局

    • media query媒体查询

    • 手淘团队的一套flexible.js, 自动判断dpr进行整个布局视口的放缩

    2. flexible如何实现自动判断dpr

    判断机型, 找出样本机型去适配. 比如iphone以6为样本, 宽度375px, dpr是2

    3. 为什么以iPhone6为标准的设计稿的尺寸是以750px宽度来设计的呢?

    iPhone6的满屏宽度是375px,而iPhone6采用的视网膜屏的物理像素是满屏宽度的2倍,也就是dpr(设备像素比)为2, 并且设计师所用的PS设计软件分辨率和像素关系是1:1。所以为了做出的清晰的页面,设计师一般给出750px的设计图,我们再根据需求对元素的尺寸设计和压缩。

    4. 如何处理异形屏iphone X

    • safe area: 默认放置在安全区域以避免遮挡, 但会压缩

    • 在meta中添加viewport-fit=cover: 告诉浏览器要讲整个页面渲染到浏览器中,不管设备是圆角与否,这个时候会造成页面的元素被圆角遮挡

    • padding: constant(env): 解决遮挡问题

    5. 移动端首屏优化

    • 采用服务器渲染ssr

    • 按需加载配合webpack分块打包, 通过entry和commonChunkPlugin

    • 很有必要将script标签➕异步

    • 有轮播图 最好给个默认 另外要处理图片懒加载

    • 打包线上也要注意去掉map 文件

    • 组件, 路由懒加载

    • webpack的一切配置 肯定是必须的

    • 压缩图片 tinypng.com/

    • 建议还是用webpack的图片压缩插件

    • 骨架屏

    • Loading页面

    6. PWA全称Progressive Web App,即渐进式WEB应用

    一个 PWA 应用首先是一个网页, 可以通过 Web 技术编写出一个网页应用. 随后添加上 App Manifest 和 Service Worker 来实现 PWA 的安装和离线等功能
    解决了哪些问题?

    • 可以添加至主屏幕,点击主屏幕图标可以实现启动动画以及隐藏地址栏

    • 实现离线缓存功能,即使用户手机没有网络,依然可以使用一些离线功能

    • 实现了消息推送
      它解决了上述提到的问题,这些特性将使得 Web 应用渐进式接近原生 App。

    7. 离线包方案

    现在 web 页面在移动端的地位越来越高,大部分主流 App 采用 native + webview 的 hybrid 模式,加载远程页面受限于网络,本地 webview 引擎,经常会出现渲染慢导致的白屏现象,体验很差,于是离线包方案应运而生。动态下载的离线包可以使得我们不需要走完整的 App 审核发布流程就完成了版本的更新

    8. 自适应和响应式布局的区别

    1. 自适应布局通过检测视口分辨率,来判断当前访问的设备是:pc端、平板、手机,从而请求服务层,返回不同的页面;响应式布局通过检测视口分辨率,针对不同客户端在客户端做代码处理,来展现不同的布局和内容。

    2. 自适应布局需要开发多套界面,而响应式布局只需要开发一套界面就可以了。

    3. 自适应对页面做的屏幕适配是在一定范围:比如pc端一般要大于1024像素,手机端要小于768像素。而响应式布局是一套页面全部适应。

    4. 自适应布局如果屏幕太小会发生内容过于拥挤。而响应式布局正是为了解决这个问题而衍生出的概念,它可以自动识别屏幕宽度并做出相应调整的网页设计。

    插件及工具相关

    1. babel和polyfill

    • Babel: Babel 是一个广泛使用的 ES6 转码器,可以将 ES6 代码转为 ES5 代码。注意:Babel 默认只转换新的 JavaScript 句法(syntax),而不转换新的 API

    • Polyfill: Polyfill的准确意思为,用于实现浏览器并不支持的原生API的代码。

    2. jpg, jpeg和png区别

    • jpg是jpeg的缩写, 二者一致

    • PNG就是为取代GIF而生的, 无损压缩, 占用内存多

    • jpg牺牲图片质量, 有损, 占用内存小

    • PNG格式可编辑。如图片中有字体等,可利用PS再做更改。JPG格式不可编辑

    3. git rebase和merge区别

    前端性能优化

    1. 减少HTTP请求(合并css、js,雪碧图/base64图片)

    2. 压缩(css、js、图片皆可压缩,使用webpack uglify和 svg)

    3. 样式表放头部,脚本放底部

    4. 使用CDN(这部分,不少前端都不用考虑,负责发布的兄弟可能会负责搞好)

    5. http缓存

    6. bosify图片压缩: 根据具体情况修改图片后缀或格式 后端根据格式来判断存储原图还是缩略图

    7. 懒加载, 预加载

    8. 替代方案: 骨架屏, SSR

    9. webpack优化

    原生通信

    1.JSBridge通信原理, 有哪几种实现的方式?

    JsBridge给JavaScript提供了调用Native功能,Native也能够操控JavaScript。这样前端部分就可以方便使用地理位置、摄像头以及登录支付等Native能力啦。JSBridge构建 Native和非Native间消息通信的通道,而且是 双向通信的通道。

    • JS 向 Native 发送消息 : 调用相关功能、通知 Native 当前 JS 的相关状态等。

    • Native 向 JS 发送消息 : 回溯调用结果、消息推送、通知 JS 当前 Native 的状态等。

    2.实现一个简单的 JSBridge,设计思路?

    算法相关

    1. 二分查找和冒泡排序

    • 二分查找: 递归(分左右, 传递start,end参数)和非递归(使用while(l < h))

    • 冒泡排序: 两个for循环

    2. 快速排序

    function quickSort (arr) {  if (arr.length < 2) return arr  var middle = Math.floor(arr.length / 2)  var flag = arr.splice(middle, 1)[0]  var left = [],        right = []  for (var i = 0; i < arr.length; i++) {    if (arr[i] < flag) {      left.push(arr[i])    } else {      right.push(arr[i])    }  }  return quickSort(left).concat([flag], quickSort(right))}

    3. 最长公共子串

    function findSubStr(str1, str2) {        if (str1.length > str2.length) {          [str1, str2] = [str2, str1]        }        var result = ''        var len = str1.length        for (var j = len; j > 0; j--) {          for (var i = 0; i < len - j; i++) {            result = str1.substr(i, j)            if (str2.includes(result)) return result          }        }      }      console.log(findSubStr('aabbcc11', 'ppooiiuubcc123'))

    4. 最长公共子序列(LCS动态规划)

    // dp[i][j] 计算去最大长度,记住口诀:相等左上角加一,不等取上或左最大值function LCS(str1, str2){        var rows =  str1.split("")        rows.unshift("")        var cols =  str2.split("")        cols.unshift("")        var m = rows.length        var n = cols.length        var dp = []        for(var i = 0; i < m; i++){            dp[i] = []            for(var j = 0; j < n; j++){                if(i === 0 || j === 0){                    dp[i][j] = 0                    continue                }
                    if(rows[i] === cols[j]){                    dp[i][j] = dp[i-1][j-1] + 1 //对角+1                }else{                    dp[i][j] = Math.max( dp[i-1][j], dp[i][j-1]) //对左边,上边取最大                }            }            console.log(dp[i].join(""))//调试        }        return dp[i-1][j-1]    }//!!!如果它来自左上角加一,则是子序列,否则向左或上回退。//findValue过程,其实就是和 就是把T[i][j]的计算反过来。// 求最长子序列function findValue(input1,input2,n1,n2,T){    var i = n1-1,j=n2-1;    var result = [];//结果保存在数组中    console.log(i);    console.log(j);    while(i>0 && j>0){        if(input1[i] == input2[j]){            result.unshift(input1[i]);            i--;            j--;        }else{            //向左或向上回退            if(T[i-1][j]>T[i][j-1]){                //向上回退                i--;            }else{                //向左回退                j--;            }        }
        }
        console.log(result);}

    5. 数组去重,多种方法

    • 双for循环, splice剔除并i--回退

    • indexOf等于index

    • filter indexOf === index

    • 新数组indexOf === index

    • 使用空对象等

    6. 实现一个函数功能:sum(1,2,3,4..n)转化为 sum(1)(2)(3)(4)…(n)

    // 使用柯里化 + 递归function curry ( fn ) {  var c = (...arg) => (fn.length === arg.length) ?          fn (...arg) : (...arg1) => c(...arg, ...arg1)  return c}

    7. 反转二叉树

    var invertTree = function (root) {  if (root !== null) {    [root.left, root.right] = [root.right, root.left]    invertTree(root.left)    invertTree(root.right)  }  return root}

    8. 贪心算法解决背包问题

    var items = ['A','B','C','D']var values = [50,220,60,60]var weights = [5,20,10,12]var capacity = 32 //背包容积
    greedy(values, weights, capacity) // 320
    function greedy(values, weights, capacity) {        var result = 0        var rest = capacity        var sortArray = []        var num = 0        values.forEach((v, i) => {          sortArray.push({            value: v,            weight: weights[i],            ratio: v / weights[i]          })        })        sortArray.sort((a, b) => b.ratio - a.ratio)        sortArray.forEach((v, i) => {          num = parseInt(rest / v.weight)          rest -= num * v.weight          result += num * v.value        })        return result      }

    9. 输入一个递增排序的数组和一个数字S,在数组中查找两个数,使得他们的和正好是S,如果有多对数字的和等于S,输出两个数的乘积最小的。

    function FindNumbersWithSum(array, sum){    var index = 0    for (var i = 0; i < array.length - 1 && array[i] < sum / 2; i++) {        for (var j = i + 1; j < array.length; j++) {            if (array[i] + array[j] === sum) return [array[i], array[j]]        }        //index = array.indexOf(sum - array[i], i + 1)       // if (index !== -1) {       //     return [array[i], array[index]]        //}    }    return []

    10. 二叉树各种(层序)遍历

    深度广度遍历

    // 根据前序和中序重建二叉树/* function TreeNode(x) {    this.val = x;    this.left = null;    this.right = null;} */function reConstructBinaryTree(pre, vin){    var result = null    if (pre.length === 1) {        result = {            val: pre[0],            left: null,            right: null        }    } else if (pre.length > 1) {        var root = pre[0]        var vinRootIndex = vin.indexOf(root)        var vinLeft = vin.slice(0, vinRootIndex)        var vinRight = vin.slice(vinRootIndex + 1, vin.length)        pre.shift()        var preLeft = pre.slice(0, vinLeft.length)        var preRight = pre.slice(vinLeft.length, pre.length)        result = {            val: root,            left: reConstructBinaryTree(preLeft, vinLeft),            right: reConstructBinaryTree(preRight, vinRight)        }    }    return result}
    // 递归// 前序遍历function prevTraverse (node) {  if (node === null) return;
      console.log(node.data);  prevTraverse(node.left);  prevTraverse(node.right);}
    // 中序遍历function middleTraverse (node) {  if (node === null) return;
      middleTraverse(node.left);  console.log(node.data);  middleTraverse(node.right);}
    // 后序遍历function lastTraverse (node) {  if (node === null) return;
      lastTraverse(node.left);  lastTraverse(node.right);  console.log(node.data);}
    // 非递归// 前序遍历function preTraverse(tree) {        var arr = [],          node = null        arr.unshift(tree)        while (arr.length) {          node = arr.shift()          console.log(node.root)          if (node.right) arr.unshift(node.right)          if (node.left) arr.unshift(node.left)        }      }
    // 中序遍历function middleTraverseUnRecursion (root) {  let arr = [],      node = root;
      while (arr.length !== 0 || node !== null) {    if (node === null) {      node = arr.shift();      console.log(node.data);      node = node.right;    } else {      arr.unshift(node);      node = node.left;    }  }
    }
    // 广度优先-层序遍历// 递归var result = []var stack = [tree]var count = 0var bfs = function () {  var node = stack[count]  if (node) {    result.push(node.value)    if (node.left) stack.push(node.left)    if (node.right) stack.push(node.right)    count++    bfs()  }}bfs()console.log(result)// 非递归function bfs (node) {  var result = []  var queue = []  queue.push(node)  while (queue.length) {    node = queue.shift()    result.push(node.value)    node.left && queue.push(node.left)    node.right && queue.push(node.right)  }  return result}

    11. 各种排序

    // 插入排序function insertSort(arr) {        var temp        for (var i = 1; i < arr.length; i++) {          temp = arr[i]          for (var j = i; j > 0 && temp < arr[j - 1]; j--) {            arr[j] = arr[j - 1]          }          arr[j] = temp        }        return arr      }      console.log(insertSort([3, 1, 8, 2, 5]))
    // 归并排序function mergeSort(array) {        var result = array.slice(0)        function sort(array) {          var length = array.length          var mid = Math.floor(length * 0.5)          var left = array.slice(0, mid)          var right = array.slice(mid, length)          if (length === 1) return array          return merge(sort(left), sort(right))        }        function merge(left, right) {          var result = []
              while (left.length || right.length) {            if (left.length && right.length) {              if (left[0] < right[0]) {                result.push(left.shift())              } else {                result.push(right.shift())              }            } else if (left.length) {              result.push(left.shift())            } else {              result.push(right.shift())            }          }          return result        }        return sort(result)      }      console.log(mergeSort([5, 2, 8, 3, 6]))
    // 二分插入排序function twoSort(array) {        var len = array.length,          i,          j,          tmp,          low,          high,          mid,          result        result = array.slice(0)        for (i = 1; i < len; i++) {          tmp = result[i]          low = 0          high = i - 1          while (low <= high) {            mid = parseInt((high + low) / 2, 10)            if (tmp < result[mid]) {              high = mid - 1            } else {              low = mid + 1            }          }          for (j = i - 1; j >= high + 1; j--) {            result[j + 1] = result[j]          }          result[j + 1] = tmp        }        return result      }      console.log(twoSort([4, 1, 7, 2, 5]))

    12. 使用尾递归对斐波那契优化

    递归非常耗费内存,因为需要同时保存成千上百个调用帧,很容易发生“栈溢出”错误(stack overflow)。但对于尾递归来说,由于只存在一个调用帧,所以永远不会发生“栈溢出”错误。

    // 传统递归斐波那契, 会造成超时或溢出function Fibonacci (n) {  if ( n <= 1 ) {return 1};
      return Fibonacci(n - 1) + Fibonacci(n - 2);}
    Fibonacci(10) // 89Fibonacci(100) // 超时Fibonacci(500) // 超时
    // 使用尾递归优化, 可规避风险function Fibonacci2 (n , ac1 = 1 , ac2 = 1) {  if( n <= 1 ) {return ac2};
      return Fibonacci2 (n - 1, ac2, ac1 + ac2);}
    Fibonacci2(100) // 573147844013817200000Fibonacci2(1000) // 7.0330367711422765e+208Fibonacci2(10000) // Infinity

    13. 两个升序数组合并为一个升序数组

    function sort (A, B) {  var i = 0, j = 0, p = 0, m = A.length, n = B.length, C = []  while (i < m || j < n) {    if (i < m && j < n) {      C[p++] = A[i] < B[j] ? A[i++] : B[j++]    } else if (i < m) {      C[p++] = A[i++]    } else {      C[p++] = B[j++]    }  }  return C}
    展开全文
  • 2020年最新web前端面试题,包含html,css,javascript基础,web开发常见技术。
  • 2021年最新web前端面试题及答案:CSS相关专题 说一下闭包 (1)什么是闭包: 闭包是指有权访问另外一个函数作用域中的变量的函数。 闭包就是函数的局部变量集合,只是这些局部变量在函数返回后会继续存在。闭包就是...
  • web前端面试

    2016-07-16 18:46:59
    web前端面试
  • 1.初入前端,就不要想着大厂了,其实一家中大型公司就已经薪资算可以了。大厂不仅要求业务基础,还有懂源码,甚至说问你算法 2.面试过程和人事礼貌交流,一般来说,人事会从以下问题问你: (1)你住哪里啊? (2...
  • WEB前端面试技巧

    2018-11-06 14:42:02
    面试完了多总结自己哪里做得不好,哪里做得好,都记录下来,后续扬长避短;通过面试肯定亲身体会到了公司团队文化、面试官体现出来的技术能力、专业性以及职位将来所做的事情,跟自己预期是否有差距,多个 offer 的...
  • web前端面试题.doc

    2021-01-21 14:08:00
    内部包括h5、css3、es6、get、post、forEach、Vue、React等当前大前端时代常规面试

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,315
精华内容 26,126
关键字:

web前端面试