自用—前端面试题

  • Vue的生命周期

    创建到销毁的执行函数

    创建阶段 beforeCreate --> created

    挂载阶段 beforeMount --> mounted

    更新阶段 beforeUpdate --> updated

    销毁阶段 beforeDestroy --> destroyed

  • ajax请求应该放在mounted生命周期

    在created的时候,视图中的dom并没有被渲染出来,所以此时如果直接去操作dom节点,无法找到相关元素。
    在mounted中,由于此时的dom元素已经渲染出来了,所以可以直接使用dom节点。

    一般情况下,都放在mounted中,保证逻辑的统一性。因为生命周期是同步执行的,ajax是异步执行的。

    服务端渲染不支持mounted方法,所以在服务端渲染的情况下统一放在created中。

  • 前端优化:尽量少操作DOM
  • Vue核心之虚拟DOM

    什么是虚拟dom?

    虚拟DOM本质:是JavaScript对象,是对真实DOM的抽象状态变更时,记录新树和旧树的差异
    最后把差异更新到真正的dom中.
    虚拟DOM的作用:使用原生js或者jquery写页面的时候会发现操作DOM是一件非常麻烦的一件事情,往往是DOM标签和js逻辑同时写在js文件里,数据交互时不时还要写很多的input隐藏域,如果没有好的代码规范的话会显得代码非常冗余混乱,耦合性高并且难以维护。
    另外一方面在浏览器里一遍又一遍的渲染DOM是非常非常消耗性能的,常常会出现页面卡死的情况;所以尽量减少对DOM的操作成为了优化前端性能的必要手段,vdom就是将DOM的对比放在了js层,通过对比不同之处来选择新渲染DOM节点,从而提高渲染效率。

    DOM Diff

    Dom diff 则是通过JS层面的计算,返回一个patch对象,即补丁对象,在通过特定的操作解析patch对象,完成页面的重新渲染

  • 数据加载完首页白屏怎么处理?

1、图片压缩

2、去掉.map文件

3、CDN外部加载

4、vue路由懒加载

5、gzip静态资源压缩,这个需要结合服务器端的配置。

  • sessionstorage和localstorage的区别

localStorage生命周期是永久,除非用户清除localStorage信息,否则这些信息将永远存在;sessionStorage生命周期为当前窗口或标签页,一旦窗口或标签页被永久关闭了,那么所有通过它存储的数据也就被清空了

  • Cookie与Session的区别

cookie数据存放在客户的浏览器上,session数据放在服务器上;

cookie不是很安全,别人可以分析存放在本地的cookie并进行cookie欺骗,考虑到安全应当使用session;

session会在一定时间内保存在服务器上。当访问增多,会比较占用你服务器的性能。考虑到减轻服务器性能面,应当使用cookie;

单个cookie在客户端的限制是3K,就是说一个站点在客户端存放的cookie不能超过3K;

  • vuex定义 包含的state mutations modules getters action作用 叙述图片过程

  • vue3.0和vue2.0的区别

    vue2.0中不管数据多大,都会在一开始就为其创建观察者;当数据很大时,这可能会在页面载入时造成明显的性能压力。而vue3.0只会对“被用于渲染初始可见部分的数据”创建观察者,而且vue3.0的观察者更高效。

  • 原型链和原型

    原型 :每个函数都有 prototype 属性,该属性指向 原型 对象;使用 原型 对象的好处是所有对象实例共享它所包含的属性和方法。

    原型链 :主要解决了继承的问题;每个对象都拥有一个 原型 对象,通过__proto__ 指针指向其 原型 对象,并从中继承方法和属性,同时 原型 对象也可能拥有 原型 ,这样一层一层,最终指向 null。

    原型 的作用: 1.数据共享 2.节约内存空间

  • 同步和异步代码

    同步的优点是:同步是按照顺序一个一个来,不会乱掉,更不会出现上面代码没有执行完就执行下面的代码, 缺点:是解析的速度没有异步的快;

    异步的优点是:异步是接取一个任务,直接给后台,在接下一个任务,一直一直这样,谁的先读取完先执行谁的, 缺点:没有顺序 ,谁先读取完先执行谁的 ,会出现上面的代码还没出来下面的就已经出来了,会报错。

    promise.generator,async/awiait以同步代码执行异步

  • 事件委托:利用冒泡原理,子类事件委托给父类执行

  • js中throttle(事件节流)和 debounce(事件防抖)

    function throttle(fn,interval){

    ​ var late =0;

    return function(){

    ​ let _this = this;

    ​ //console.log(_this)

    ​ let ags = arguments;

    ​ let now = new Date()

    ​ if(now-late >=interval){

    ​ late = now

    ​ fn.apply(_this,ags)

    ​ }

    }

    }

    const better_scroll = throttle(()=>{console.log(“我被执行了”)},3000)

    document.addEventListener(“scroll”,better_scroll)

    function debounce(fn,delay){

    ​ let timer = null;

    ​ return function(){

    ​ let_this = this;

    ​ let arg = arguments;

    ​ if(timer){

    ​ clearTimeout(timer)

    ​ }

    ​ timer}

    }

    const better_scroll = throttle(()=>{console.log(“我被执行了”)},3000)

    document.addEventListener(“scroll”,better_scroll)

    阶段性产物分析

    这五个流程分别对应了以下五个产物:

    • DOM树
    • SSOM树
    • 渲染树
    • 盒模型
    • 目标界面
    资源文件到页面绘制:

    整体来看,这五个过程分别完成了以下任务:

  1. HTML解析 在这一步浏览器对HTML文档进行解析,并在解析 HTML 的过程中发出了页面渲染所需的各种外部资源请求。
  2. CSS解析 浏览器将识别并加载所有的 CSS 样式信息。
  3. 样式与结构合并 将样式信息和文档结构合并,最终生成页面 render 树(:after :before 这样的伪元素会在这个环节被构建到 DOM 树中)。
  4. 布局阶段 页面中所有元素的相对位置信息,大小等信息均在这一步得到计算。
  5. 页面绘制 在这一步中浏览器会根据我们前面处理出来的结果,把每一个页面图层转换为像素,并对所有的媒体文件进行解 码。

一、利用ES6 Set去重(ES6中最常用)

function unique (arr) {
 return Array.from(new Set(arr))
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
 //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]

不考虑兼容性,这种去重的方法代码最少。这种方法还无法去掉“{}”空对象,后面的高阶方法会添加去掉重复“{}”的方法。

二、利用for嵌套for,然后splice去重(ES5中最常用)

function unique(arr){ 
 for(var i=0; i<arr.length; i++){
 for(var j=i+1; j<arr.length; j++){
 if(arr[i]==arr[j]){ //第一个等同于第二个,splice方法删除第二个
  arr.splice(j,1);
  j--;
 }
 }
 }
return arr;
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
 console.log(unique(arr))
 //[1, "true", 15, false, undefined, NaN, NaN, "NaN", "a", {…}, {…}] //NaN和{}没有去重,两个null直接消失了

双层循环,外层循环元素,内层循环时比较值。值相同时,则删去这个值。
想快速学习更多常用的ES6语法,可以看我之前的文章《学习ES6笔记──工作中常用到的ES6语法》。

三、利用indexOf去重

function unique(arr) {
 if (!Array.isArray(arr)) {
 console.log('type error!')
 return
 }
 var array = [];
 for (var i = 0; i < arr.length; i++) {
 if (array .indexOf(arr[i]) === -1) {
 array .push(arr[i])
 }
 }
 return array;
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
 // [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a", {…}, {…}] //NaN、{}没有去重

新建一个空的结果数组,for 循环原数组,判断结果数组是否存在当前元素,如果有相同的值则跳过,不相同则push进数组。

四、利用sort()

function unique(arr) {
 if (!Array.isArray(arr)) {
 console.log('type error!')
 return;
 }
 arr = arr.sort()
 var arrry= [arr[0]];
 for (var i = 1; i < arr.length; i++) {
 if (arr[i] !== arr[i-1]) {
 arrry.push(arr[i]);
 }
 }
 return arrry;
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
 console.log(unique(arr))
// [0, 1, 15, "NaN", NaN, NaN, {…}, {…}, "a", false, null, true, "true", undefined] //NaN、{}没有去重

利用sort()排序方法,然后根据排序后的结果进行遍历及相邻元素比对。

五、利用对象的属性不能相同的特点进行去重(这种数组去重的方法有问题,不建议用,有待改进)

function unique(arr) {
 if (!Array.isArray(arr)) {
 console.log('type error!')
 return
 }
 var arrry= [];
 var obj = {};
 for (var i = 0; i < arr.length; i++) {
 if (!obj[arr[i]]) {
 arrry.push(arr[i])
 obj[arr[i]] = 1
 } else {
 obj[arr[i]]++
 }
 }
 return arrry;
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
 console.log(unique(arr))
//[1, "true", 15, false, undefined, null, NaN, 0, "a", {…}] //两个true直接去掉了,NaN和{}去重

六、利用includes

function unique(arr) {
 if (!Array.isArray(arr)) {
 console.log('type error!')
 return
 }
 var array =[];
 for(var i = 0; i < arr.length; i++) {
 if( !array.includes( arr[i]) ) {//includes 检测数组是否有某个值
  array.push(arr[i]);
 }
 }
 return array
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
 console.log(unique(arr))
 //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}] //{}没有去重

七、利用hasOwnProperty

function unique(arr) {
 var obj = {};
 return arr.filter(function(item, index, arr){
 return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
 })
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
 console.log(unique(arr))
//[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}] //所有的都去重了

利用hasOwnProperty 判断是否存在对象属性

八、利用filter

function unique(arr) {
 return arr.filter(function(item, index, arr) {
 //当前元素,在原始数组中的第一个索引==当前索引值,否则返回当前元素
 return arr.indexOf(item, 0) === index;
 });
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
 console.log(unique(arr))
//[1, "true", true, 15, false, undefined, null, "NaN", 0, "a", {…}, {…}]

九、利用递归去重

function unique(arr) {
 var array= arr;
 var len = array.length;
 
 array.sort(function(a,b){ //排序后更加方便去重
 return a - b;
 })
 
 function loop(index){
 if(index >= 1){
 if(array[index] === array[index-1]){
 array.splice(index,1);
 }
 loop(index - 1); //递归loop,然后数组去重
 }
 }
 loop(len-1);
 return array;
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
//[1, "a", "true", true, 15, false, 1, {…}, null, NaN, NaN, "NaN", 0, "a", {…}, undefined]

十、利用Map数据结构去重

function arrayNonRepeatfy(arr) {
 let map = new Map();
 let array = new Array(); // 数组用于返回结果
 for (let i = 0; i < arr.length; i++) {
 if(map .has(arr[i])) { // 如果有该key值
 map .set(arr[i], true); 
 } else { 
 map .set(arr[i], false); // 如果没有该key值
 array .push(arr[i]);
 }
 } 
 return array ;
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
 console.log(unique(arr))
//[1, "a", "true", true, 15, false, 1, {…}, null, NaN, NaN, "NaN", 0, "a", {…}, undefined]

创建一个空Map数据结构,遍历需要去重的数组,把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值,所以最终得到的就是去重后的结果。

十一、利用reduce+includes

function unique(arr){
 return arr.reduce((prev,cur) => prev.includes(cur) ? prev : [...prev,cur],[]);
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr));
// [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}, {…}]

十二、[…new Set(arr)]

[…new Set(arr)]

//代码就是这么少----(其实,严格来说并不算是一种,相对于第一种方法来说只是简化了代码)

function distinct(a, b) {
 return Array.from(new Set([...a, ...b]))
}
  • get和post的区别
     get是获取数据,post是修改数据
    

(1)post更安全(不会作为url的一部分,不会被缓存、保存在服务器日志、以及浏览器浏览记录中)

(2)post发送的数据更大(get有url长度限制)

(3)post能发送更多的数据类型(get只能发送ASCII字符)

(4)post比get慢

(5)post用于修改和写入数据,get一般用于搜索排序和筛选之类的操作(淘宝,支付宝的搜索查询都是get提交),目的是资源的获取,读取数据
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值