来自大厂 300+ 道前端面试题大全附答案（整理版）+前端常见算法面试题~

---

• 能不能说一说浏览器缓存?
• 能不能说一说浏览器的本地存储？各自优劣如何？
• 能不能实现事件的防抖和节流？
• 浏览器缓存
• 谈谈你对重绘和回流的理解
• 能不能实现图片懒加载？
• 说一说从输入URL到页面呈现发生了什么？
• 能不能说一说XSS攻击？
• BOM对象模型
  …

6、计算机网络面试题

---

• HTTP 缓存
• HTTP 常用的状态码及使用场景？
• HTTP 常用的请求方式，区别和用途？
• 你对计算机网络的认识怎么样
• HTTPS 是什么？具体流程
• WebSocket与Ajax的区别
• TCP 如何保证有效传输及拥塞控制原理。
• TCP 协议怎么保证可靠的，UDP 为什么不可靠？

7、一些开放性题目

---

1)说说最近最流行的一些东西吧？常去哪些网站？

2)自我介绍：除了基本个人信息以外，面试官更想听的是你与众不同的地方和你的优势。

3)项目介绍

4)前端开发的职业现状和前景是什么？

5)平时是如何学习前端开发的？

6)1-3年工作经验，你有信心顺利跳槽到BATJ等一线互联网大公司吗？

7)你觉得哪个框架比较好,好在哪里

8)你觉得最难得技术难点是什么

8、算法题

---

链表

面试题：反转单向链表

题目需要将一个单向链表反转。思路很简单，使用三个变量分别表示当前节点和当前节点的前后节点，虽然这题很简单，但是却是一道常考题

以下是实现该算法的代码

var reverseList = function(head) {
  // 判断下变量边界问题
  if (!head || !head.next) return head
  // 初始设置为空，因为第一个节点反转后就是尾部，尾部节点指向 null
  let pre = null
  let current = head
  let next
  // 判断当前节点是否为空
  // 不为空就先获取当前节点的下一节点
  // 然后把当前节点的 next 设为上一个节点
  // 然后把 current 设为下一个节点，pre 设为当前节点
  while(current) {
    next = current.next
    current.next = pre
    pre = current
    current = next
 }
  retur
**作者徽是vip1024c**
n pre
};

二叉树遍历

• 原理: 递归

function traversal(node,tempOrderTraversal) {
if (node != null) {
  // tempOrderTraversal.push(node.value) 前序遍历
  if (node.left != null) {
    preOrderTraversal(node.left,tempOrderTraversal)
  }
  // tempOrderTraversal.push(node.value) 中序遍历
  if (node.right != null) {
    preOrderTraversal(node.right,tempOrderTraversal)
    }
    // tempOrderTraversal.push(node.value) 后序遍历
     }
  }

不能使用递归时，则使用栈就是JS的数组push、pop

// 非递归遍历
var kthSmallest = function(root, k) {
const tempArr = [];
let result;
tempArr.push(root);
while (tempArr.length > 0) {
 result = tempArr.pop();
 if (result.value == k) break;
 if (result.left != null) tempArr.push(result.left);
 if (result.right != null) tempArr.push(result.right);
}
return result;
};

堆排序

堆排序利用了二叉堆的特性来做，二叉堆通常用数组表示，并且二叉堆是一颗完全二叉树（所有叶节点（最底层的节点）都是从左往右顺序排序，并且其他层的节点都是满的）。二叉堆又分为大根堆与小根堆。

• 大根堆是某个节点的所有子节点的值都比他小
• 小根堆是某个节点的所有子节点的值都比他大

堆排序的原理就是组成一个大根堆或者小根堆。以小根堆为例，某个节点的左边子节点索引是 i * 2 +1 ，右边是 i * 2 + 2 ，父节点是 (i - 1) /2 。

1. 首先遍历数组，判断该节点的父节点是否比他小，如果小就交换位置并继续判断，直到他的父节点
   比他大
2. 重新以上操作 1，直到数组首位是最大值
3. 然后将首位和末尾交换位置并将数组长度减一，表示数组末尾已是最大值，不需要再比较大小
4. 对比左右节点哪个大，然后记住大的节点的索引并且和父节点对比大小，如果子节点大就交换位置
5. 重复以上操作 3 - 4 直到整个数组都是大根堆。
   
   以下是实现该算法的代码

function heap(array) {
 checkArray(array);
 // 将最大值交换到首位
 for (let i = 0; i < array.length; i++) {
  heapInsert(array, i);
}
 let size = array.length;
 // 交换首位和末尾
 swap(array, 0, --size);
 while (size > 0) {
  heapify(array, 0, size);
  swap(array, 0, --size);
}
 return array;
}
function heapInsert(array, index) {
 // 如果当前节点比父节点大，就交换
 while (array[index] > array[parseInt((index - 1) / 2)]) {
  swap(array, index, parseInt((index - 1) / 2));
  // 将索引变成父节点
  index = parseInt((index - 1) / 2);
}
}
function heapify(array, index, size) {
 let left = index \* 2 + 1;
 while (left < size) {
  // 判断左右节点大小
  let largest =
   left + 1 < size && array[left] < array[left + 1] ? left + 1 : left;
  // 判断子节点和父节点大小
  largest = array[index] < array[largest] ? largest : index;
  if (largest === index) break;
  swap(array, index, largest);
  index = largest;
  left = index \* 2 + 1;
}
}

以上代码实现了小根堆，如果需要实现大根堆，只需要把节点对比反一下就好。

插入排序
将一个新的数，和前面的比较，只要当前数小于前一个则和前一个交换位置，否则终止；
时间复杂度：O(N^2)；
空间复杂度：O(1)

以下是实现该算法的代码

function insertSort(arr) {
    if(arr == null  || arr.length <= 0){
        return [];
    }
    var len = arr.length;
    for(var i = 1; i < len; i++) {
        for(var j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
            swap(arr, j, j + 1);
        }
    }
    return arr;
}

function swap(arr, i, j){
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

去掉一组整型数组重复的值

这道问题出现在诸多的前端面试题中，主要考察个人对Object的使用，利用key来进行筛选。

以下是实现该算法的代码

let unique = function(arr) {  
  let hashTable = {};
  let data = [];
  for(let i=0,l=arr.length;i<l;i++) {
    if(!hashTable[arr[i]]) {
      hashTable[arr[i]] = true;
      data.push(arr[i]);
    }
  }
  return data
}
module.exports = unique;

快速排序

以下是实现该算法的代码

def quick\_sort(arr):
    if len(arr) < 2:
        return arr
    mid = arr[len(arr)//2]
    left, right = [], []
    arr.remove(mid)
    for item in arr:
        if item > mid:
            right.append(item)
        else:
            left.append(item)
    return quick\_sort(left)+[mid]+quick\_sort(right)
 
b = [11, 99, 33, 69, 77, 88, 55, 11, 33, 36, 39, 66, 44, 22]
print(quick\_sort(b))

无重复字符的最长子串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

以下是实现该算法的代码

var lengthOfLongestSubstring = function(s) {
  let window = {};
  let left = 0, right = 0;
  let maxLen = 0, maxStr = '';
  while (right < s.length) {
    let c = s[right];
    right++;
    if (window[c]) window[c]++;
    else window[c] = 1
    while (window[c] > 1) {
      let d = s[left];
      left++;
      window[d]--;
    }
    if (maxLen < right - left) {
      maxLen = right - left;
    }
  }
  return maxLen;
};

时间复杂度： O(n2)， 其中 arr.indexOf() 时间复杂度为 O(n) ，arr.splice(0, index+1) 的时间复杂度也为 O(n)
空间复杂度： O(n)

队列
队列和栈类似，不同的是队列是先进先出 (FIFO) 原则的有序集合，它的结构类似如下：

常见队列的操作有：enqueue(e) 进队、 dequeue() 出队、 isEmpty() 是否是空队、 front() 获取队头元素、clear() 清空队，以及 size() 获取队列长度。

以下是实现该算法的代码

function Queue() {
  let items = []
  this.enqueue = function(e) {
    items.push(e)
  }
  this.dequeue = function() {
    return items.shift()
  }
  this.isEmpty = function() {
    return items.length === 0
  }
  this.front = function() {
    return items[0]
  }
  this.clear = function() { 
    items = [] 
  }
  this.size = function() {
    return items.length
  }
}

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！