面试总结

前端

前端

更新于 4月14日 约 45 分钟

1. px、rem 和 em的区别?
  • em是相对于父元素的font-size的大小,一单位的em的值根据父元素font-size的改变而改变
  • rem是相对于根元素( html )的font-size的大小
盒子模型

所有的页面的元素都可以看成是一个盒子,占据一定的页面空间。
盒子模型是由内容、边框、内边距间隙(padding)、外边距(margin)组成。

  • 标准盒模型:width = content,不包含 border + padding
  • 怪异盒模型 width = border + padding + content
什么是BFC

BFC是一个独立的布局环境,我们可以理解为一个箱子(实际上是看不见摸不着的),箱子内部的元素无论如何翻江倒海,都不会影响到外部。转换为BFC的理解则是:BFC中的元素的布局是不受外界的影响(我们往往利用这个特性来消除浮动元素对其非浮动的兄弟元素和其子元素带来的影响。比如清除浮动)并且在一个BFC中,块元素与行元素都会垂直的沿着其父元素的边框排列。

div垂直居中方案
1.子元素设置position: absolute;left:50%;top:50%;transform: translate(-50%,-50%);
2.子元素设置position:absolute;left:0;top:0;right:0;bottom:0;margin:auto;
3.父元素设置display:table-cell;vertical-algin:middle;text-algin:center;子元素设置display:inline-block
4.父元素设置display:flex;justity-content:center;align-center:center;
两边固定中间自适应方案
  1. flex布局,左右两边固定宽,中间设置flex:1
  2. float浮动,左边右边分别左浮动和右浮动,中间左浮动
  3. 绝对定位,左边右边设置position:absolute,固定宽,中间设置margin为左右两边宽
css实现多行多列布局

WechatIMG1.png

  1. calc()
<div class="container">
    <div class="item">A</div>
    <div class="item">B</div>
    <div class="item">C</div>
    <div class="item">D</div>
    <div class="item">E</div>
</div>
  
.container {
    width: 100%;
    background: yellow;
}

.item {
    display: inline-block;
    width: 30%;
    height: 44px;
    line-height: 44px;
    text-align: center;
    background: red;
    margin: 0 0 calc(10%/4) calc(10%/4);
}
  1. flex
<div class="container">
    <div class="item">A</div>
    <div class="item">B</div>
    <div class="item">C</div>
    <div class="item">D</div>
    <div class="item">E</div>
</div>

.container {
  width: 100%;
  background: yellow;
  display: flex;
  flex-wrap: wrap;
  justify-content: space-between;
}

.item {
  width: 30%;
  height: 44px;
  line-height: 44px;
  text-align: center;
  background: red;
  margin-bottom: calc(10%/3);
}
清除浮动方案
  1. 在尾部添加一个标签,css样式写clear:both
  2. 父元素添加overflow:hidden
  3. 父元素添加伪元素after,css样式写clear:both,display:block,content:""
伪类元素有哪些?

伪类元素before,after
伪类选择器first-child,last-child,nth-of-child(从前面开始算),nth-last-of-child(从后面开始算)
伪类选择器first-type,last-type,nth-of-type(从前面开始算),nth-last-of-type(从后面开始算)
伪类选择器not(),参数包括一些基本选择器,但是不支持伪类选择器
:link 用这个可以设置未被访问的链接的样式
:visited 用这个设置已经被访问的链接的样式
:hover 用于设置将鼠标悬浮在链接上的样式
:active 用于设置鼠标点击链接时到鼠标松开时的样式
:focus 用于设置用键盘将焦点放在链接上时的样式

html5有哪些新特性、移除了那些元素?如何处理HTML5新标签的浏览器兼容问题?
- html5的新特性
语义化标签:article、header,footer,section,nav,aside
表单元素:calendar,date,time,number,url,search;
多媒体:video,audio;
控件元素: websockt,webwork
绘画:canvas;
存储:localStorage;sessionStorage
定位:Geolocation用于定位用户信息
- 移除的元素
big font basefont,s,tt,u,frame.iframe
- 兼容性处理
1.  IE6/IE7/IE8支持通过document.createElement方法产生的标签,利用这一特性让这些浏览器支持HTML5新标签。浏览器支持新标签后,还需要添加标签默认的样式;
2. 使用是html5shim框架
Doctype作用?

声明文档的解析类型,避免浏览器的怪异模式。如果你的页面不声明,将会解析类型默认是怪异模式。

标准模式与兼容模式各有什么区别?

标准模式的排版 和JS运作模式都是以该浏览器支持的最高标准运行。在兼容模式中,页面以宽松的向后兼容的方式显示,模拟老式浏览器的行为以防止站点无法工作。

HTML5 为什么只需要写 <!DOCTYPE HTML>

HTML5 不基于 SGML,因此不需要对DTD进行引用,但是需要doctype来规范浏览器的行为(让浏览器按照它们应该的方式来运行);
而HTML4.01基于SGML,所以需要对DTD进行引用,才能告知浏览器文档所使用的文档类型。

link和@import有什么区别?
1.    link属于html标签,而@import是css提供的
2.    页面加载时,link会同时被加载,而@import引用的css会等到页面加载完成后加载
3.    link没有兼容性问题,@import有兼容性问题
4.    link方式样式的权重高于@import
移动端适配方案
Viewport
Flex
vw/vh
position现在有五个属性值
1.static:静态定位,没有特殊的定位规则,遵循正常的文档流对象
2.relative:相对定位,相对于元素自身进行定位
3.absolute:绝对定位,相对于最近的有定位的父元素进行定位
4.fixed:固定定位,相对于浏览器页面进行定位
5.sticky :粘性定位,基于用户的滚动位置来定位
import和require什么区别
1. 
    a.import是ES6的模块规范
    b.require是commonjs的模块规范
2. 
    a.import是编译时调用,具有提升效果,会提升到模块的头部(编译时执行)
    b.require是运行时加载整个模块(即模块中所有方法)
3. 
    a.require是赋值过程,export的一个对象,赋给某个变量;
    b.import是解构过程(需要谁,加载谁)
new发生了什么?
1.创建一个空的新对象;
2.将构造函数中的this指针指向新对象;
3.执行构造函数中的代码;
4.返回新对象。
0.1+0.2!=0.3吗?请说出为什么?

浮点数运算的精度问题 计算机在进行运算时会将其他进制的数值转换成二进制在进行计算。
方法一:(换成整数计算)

(0.1*10+0.2*10)/10

方法二:

parseFloat((0.1+0.2).toFixed(10))
js的数据类型,以及区别
  • 基本数据类型: Number、String、Boolean、Null、 Undefined、Symbol(ES6)
    特点:数据存贮在栈内存中,复制的时候是值传递
  • 引用数据类型:Object(Array,Date,RegExp,Function)
    特点:存储的是该对象在栈中引用,复制的时候是地址的引用
js数据类型的检测

1.typeof

typeof操作符只可以对除null以外的基本类型做出正确的判断,但是对于引用数据类型,检测出来都是object

2.instanceof

instanceof是用来判断 A 是否为 B 的实例,表达式为:`A instanceof B`,如果 A 属于 B 的实例,则返回true,否则返回false
console.log([] instanceof Array);       //true
console.log({} instanceof Object);       //true
console.log(new Date() instanceof Date); //true

3.constructor
constructor可以打印出实例所属的类,表达式为:实例.constructor。

console.log([].constructor == Array)       //true
console.log({}.constructor == Object)      //true
console.log("string".constructor == String)  //true
console.log((1).constructor == Number)       //true
console.log(true.constructor == Boolean)      //true
js求数组中的最大值和最小值的方法?

1.排序法(先把数组从小到大排序,数组第一个即为最小值,最后一个即为最大值)

ary.sort(function(a,b){return a-b;})
var minN = ary[0]
var maxN = ary[ary.length-1]

2.使用Math.max以及apply或者结构...来实现
apply(null,arr) apply会将传入的数组结构成一个一个的数值
... 展开运算符会将数组中的值提取成一个个的数值

var maxN = Math.max.apply(null,ary)
var minN = Math.min.apply(null,ary)

或者

var maxN = Math.max(...ary)
var minN = Math.min(...ary)
JavaScript原型,原型链 ? 有什么特点

1.JS中每个函数都存在有一个原型对象属性prototype。并且所有函数的默认原型都是Object的实例。
2.每个继承父函数的子函数的对象都包含一个内部属性_proto_。该属性包含一个指针(就像链表一样),指向父函数的prototype。若父函数的原型对象的_proto_属性为再上一层函数。在此过程中就形成了原型链。
3.原型链实现了继承。原型链存在两个问题:a 包含引用类型值的原型属性会被所有实例共享。b 在创建子类型时,无法向超类型的构造函数中传递参数。js在当初设计过程中,并没有设计继承,是利用原型继承,es6新增特性支持class类就解决了这些问题。

谈谈This对象的理解

框架中的this不一样。vue中this指向当前vue实例,angular中this指向当前类。
this表示当前对象,this的指向是根据调用的上下文来决定的,默认指向window对象

1. 如果在全局环境下直接调用函数,this指向就是window。
2. 对象函数调用,哪个对象调用就指向哪个对象。
3. 构造函数中的this,指向new实例化的对象。
4. 可以使用call和apply改变this的指向。
5. es6中箭头函数没有上下文环境,this直接指向上一级。
jQuery链式调用的原理
每次调用都返回this,this指向调用者
谈谈对闭包的理解以及闭包的形成

闭包就是能够读取其他函数内部变量的函数。闭包保护了一些私有变量,支持在函数作用域外调用,避免了全局污染。使用闭包会导致内存泄漏。
当某个函数的作用域链还引用着其他函数的活动对象时,就会形成闭包。(外层函数和内层函数)

闭包的优缺点
优点:避免全局变量的污染
缺点:常驻内存 会增大内存的使用量 使用不当会造成内存泄露
什么是内存泄漏

内存泄漏(Memory Leak)是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放,造成系统内存的浪费,导致程序运行速度减慢甚至系统崩溃等严重后果。

浏览器是如何渲染页面的?
1.解析HTML,构建DOM树
2.解析CSS,生成CSS规则树
3.合并DOM树和CSS规则,生成render树
4.布局render树(Layout/reflow),负责各元素尺寸、位置的计算
5.绘制render树(paint),绘制页面像素信息
6.浏览器会将各层的信息发送给GPU,GPU会将各层合成(composite),显示在屏幕上
1.在浏览器的地址栏输入url地址,

2.浏览器会在浏览器缓存,系统缓存,路由缓存里查看,如果路由缓存有数据就显示在页面上,如果没有,就继续第三步。
3.在发起http请求前,需要域名解析,解析获取ip地址。
4.浏览器向服务器发起tcp请求(传输控制协议),与浏览器建立tcp三次握手
5.握手成功后,浏览器向服务器发起http请求,请求数据包。
6.服务器处理请求,发送数据给浏览器。
7.浏览器收到http响应。
8.读取页面数据,浏览器渲染,解析html源码。
9.生成DOM树,解析css样式,js交互。
10.客户端和服务器交互。
11.ajax查询。

从输入url到显示页面,都经历了什么?

1.在浏览器的地址栏输入url地址,
2.浏览器会在浏览器缓存,系统缓存,路由缓存里查看,如果路由缓存有数据就显示在页面上,如果没有,就继续第三步。
3.在发起http请求前,需要域名解析,解析获取ip地址。
4.浏览器向服务器发起tcp请求(传输控制协议),与浏览器建立tcp三次握手
5.握手成功后,浏览器向服务器发起http请求,请求数据包。
6.服务器处理请求,发送数据给浏览器。
7.浏览器收到http响应。
8.读取页面数据,浏览器渲染,解析html源码。
9.生成DOM树,解析css样式,js交互。
10.客户端和服务器交互。
11.ajax查询。

http和https的区别

1.https协议需要到ca申请证书,一般免费证书较少,因而需要一定费用。
2.http是超文本传输协议,信息是明文传输,https则是具有安全性的ssl加密传输协议。
3.http和https使用的是完全不同的连接方式,用的端口也不一样,前者是80,后者是443。
4.http的连接很简单,是无状态的;HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议,比http协议安全。

http是怎么进行缓存的
什么是跨域
当一个请求url的**协议、域名、端口**三者之间任意一个与当前页面url不同即为跨域
同源策略
同源策略是指协议,域名,端口都要相同,其中有一个不同都会产生跨域
跨域是怎么解决的
  1. JSONPscript标签不受同源策略的限制,只支持get方法
    网页通过添加一个<script>元素,向服务器请求 JSON 数据,服务器收到请求后,将数据放在一个指定名字的回调函数的参数位置传回来。
 <script src="http://test.com/data.php?callback=dosomething"></script>
// 向服务器test.com发出请求,该请求的查询字符串有一个callback参数,用来指定回调函数的名字
 
// 处理服务器返回回调函数的数据
<script type="text/javascript">
    function dosomething(res){
        // 处理获得的数据
        console.log(res.data)~~~~
    }
</script>

服务端返回时即执行全局函数

2.CORS

服务器设置HTTP响应头中Access-Control-Allow-Origin值,解除跨域限制
  1. nginx代理跨域
  2. nodejs中间件代理跨域
前端上传图片到服务器的格式是什么?
  • base64格式
  • new FormData (ios,andorid只支持FormData 却不支持base64)
创建一个空的FormData对象,然后再用append方法逐个添加键值对
var formdata = new FormData()
formdata.append("name", "xiaomei")
深拷贝和浅拷贝的区别,以及实现方式
  • 区别:

浅拷贝只复制指向某个对象的指针,而不复制对象本身,新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象,新对象跟原对象不共享内存,修改新对象不会改到原对象

  • 深拷贝的实现方式
1. 通过json方式实现
function deepClone (obj){
  return JSON.parse(JSON.stringify(obj))
}
2. 通过递归实现
function deepClone (obj){
  let result = {}
  for(let key in obj){
    if(Object.prototype.hasOwnProperty.call(obj, key)){
      if(typeof obj[key] === 'object'){
        result[key] = deepClone(obj[key])
      }else{
        result[key] = obj[key]
      }
    }
  }
}
  • 浅拷贝的实现方式
1. ... 解构赋值
2. Object.assign(target, …sources)
Cookie,session,sessionStorage和localStorage的之间的区别
  • cookie
    1、Cookie由服务端生成,保存在客户端。
    2、存储大小只有4kb,存储内容只接受String类型,若没有设置过期时间,保存在内存中,浏览器关闭消失;若设置了过期时间,则保存在系统硬盘中,直到过期时间结束才消失(即使关闭浏览器)
  • session
    1、sessionStorage仅在当前会话下有效,关闭页面或浏览器后被清除
    2、存放数据大小为一般为5MB
    3、它仅在客户端(即浏览器)中保存,不参与和服务器的通信
  • sessionStorage
    1、生命期为只在设置的cookie过期时间之前一直有效,即使窗口或浏览器关闭
    2、存放数据大小为4K左右
    3、有个数限制(各浏览器不同),一般不能超过50个
    4、与服务器端通信:每次都会携带在HTTP头中,如果使用cookie保存过多数据会带来性能问题
  • localStorage
    1、localStorage生命周期是永久,这意味着除非用户显示在浏览器提供的UI上清除localStorage信息,否则这些信息将永远存在
    2、存放数据大小为一般为5MB
    3、它仅在客户端(即浏览器)中保存不参与和服务器的通信
  • 区别

  1、存放数据的大小:localStorage、sessionStorage的可以存放的数据大小明显大于cookie的可以存放数据大小
 2、与服务器端通信:cookie会被携带在请求头中,而localStorage/sessionStorage不会参与与服务器的通信
  3、会话级别:localStorage永久会话级别,sessionStorage浏览器关闭会话结束,cookie是根据他自身参数expires所设置的时间来决定会话级别
  4、个数限制:localStorage/sessionStorage无限制,cookie根据浏览器的不同,个数稍有区别,一般不会超过50个

什么防抖与节流,它们的区别是什么?应用什么场景如何实现

一.函数防抖(高频事件触发时使用):
在第一次触发事件时,不立即执行函数,而是给出一个期限值比如100ms后执行
应用场景:

  1. 用户在输入框中连续输入一串字符后,只会在输入完后去执行最后一次的查询ajax请求,这样可以有效减少请求次数,节约请求资源;
  2. window的resize、scroll事件,不断地调整浏览器的窗口大小、或者滚动时会触发对应事件,防抖让其只触发一次;

(可以传参 不能用箭头函数)

function debounce(fn,delay = 100){
  let timer = null
  return function (){
    if(timer){
      clearTimer(timer)
    }
    timer = setTimeOut(() => {
      fn.apply(this,arguments)
      timer  = null
    },delay)
  }
}

二.函数节流
让函数执行一次后,在某个时间段内暂时失效,过了这段时间后再重新激活(类似于技能冷却时间)
应用场景:
连续不断地触发某事件(如点击),只在单位时间内只触发一次。

function throttle(fn,delay = 100){
  let timer = null
  return function(){
    if(timer) return
    timer = setTimeOut(() => {
      fn.apply(this,arguments)
      timer = null
    },delay)
  }
}
es6使用过吗?说说你常用的(谈谈var、let、const它们的区别)
1. let const
var定义的变量,没有块的概念,可以跨块访问, 不能跨函数访问。
let定义的变量,只能在块作用域里访问,不能跨块访问,也不能跨函数访问。
const用来定义常量,使用时必须初始化(即必须赋值),只能在块作用域里访问,基本类型数据不可修改,对象和数组等引用类型数据只要地址不变,可改变其中的属性和内容。
2. ``模板字符串。
3. ...运算符,可以合并数组,合并对象。
let bar = { a: 1, b: 2 };
let baz = { ...bar }; // { a: 1, b: 2 }
实际上和使用Object.assign
4. Object.assign(targer,...resource)
5. 解构赋值
6. 函数参数默认值
7. Promise
8. 箭头函数
9. class类
10. set和map数据结构
promise原理

promise内部有一个状态管理器,有三种状态:pending,fulfilled,rejected。一旦状态修改成功后,promise状态就不能在次改变。
1.promise对象初始化状态为pending
2.当调用resolve时,会由pending => fulfilled。当你调用then方法时,then方法是放在promise原型中的一个方法,每个实例都会有,然后向then的成功的回调函数传值。
3.当调用reject时,会由pending => rejected。然后向then的成功的回调函数传值。

async/await的使用
  • async 是一个修饰符,async 定义的函数会默认的返回一个Promise对象resolve的值,因此对async函数可以直接进行then操作,返回的值即为then方法的传入函数
  • await 关键字 只能放在 async 函数内部, await关键字的作用 就是获取 Promise中返回的内容, 获取的是Promise函数中resolve或者reject的值
什么是单线程?和异步有何关系?

程序的执行顺序就是从上到下依次执行。同步阻塞,异步非阻塞。
一个js程序的单线程用来执行栈中的同步任务,异步任务会存放到一个任务队列中,当所有同步任务执行完毕后,栈被清空,然后会读取任务队列中的一个待处理任务,并把相关回调函数压入栈中,单线程开始执行新的同步任务,执行完毕。

什么是事件循环

因为javascript是单线程的,js引擎遇到一个异步事件后并不会一直等待其返回结果,而是会将这个事件挂起,继续执行执行栈中的其他任务。当一个异步事件返回结果后,js会将这个事件加入与当前执行栈不同的另一个队列,我们称之为事件队列。被放入事件队列不会立刻执行其回调,而是等待当前执行栈中的所有任务都执行完毕, 主线程处于闲置状态时,主线程会去查找事件队列是否有任务。如果有,那么主线程会从中取出排在第一位的事件,并把这个事件对应的回调放入执行栈中,然后执行其中的同步代码...,如此反复,这样就形成了一个无限的循环。这就是这个过程被称为“事件循环(Event Loop)”的原因。

字符串和数组排序以及去重
  • 字符串去重
1. indexOf()方法
function removeRepeatStr (str) {
  var newStr = ''
   var len = str.length
   for (var i = 0; i < len; i++) {
     if (newStr.indexOf(str[i]) == -1) {
       newStr = newStr + str[i]
     }
   }
   return newStr
 }
 
2. search()方法
function removeRepeatStr(str){
  var newStr = ''
  var len = str.length
  for(var i=0; i<len; i++){
      if(newStr.search(str[i])==-1){
        newStr = newStr + str[i]
      }
  }
  return newStr
}
3. includes()方法
function repetition(str) {  
  let newStr=""  
  for (let i=0; i<str.length; i++) {  
    if (!newStr.includes(str[i])) {  
        newStr += str[i]
    }  
  } 
  return newStr
}
4. set()方法
function repetition(str) {  
  return [...new Set(str)].join('')
}
5. filter()方法
function repetition(str) {  
  return [].filter.call(str,(s,i,o)=>o.indexOf(s)==i).join()
}
  • 数组去重
1. indexOf()去重
function unique(arr){
  let newArr=[]
  for(let item of arr){
    if(newArr.indexOf(item)==-1){
      newArr.push(item)
    }
  }
  return newArr
}

2. includes()去重
function unique(arr){
  let newArr=[]
  for(let i = 0; i < arr.length; i++) {
    if(!newArr.includes(arr[i])){
      newArr.push(arr[i])
    }
  }
  return newArr
}
3. new Set()去重
function unique(arr){
  return [...new Set(arr)]
}

评论

暂无评论