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

• 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

}

return 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

基础学习：

前端最基础的就是 HTML , CSS 和 JavaScript 。

网页设计：HTML和CSS基础知识的学习

HTML是网页内容的载体。内容就是网页制作者放在页面上想要让用户浏览的信息，可以包含文字、图片、视频等。

CSS样式是表现。就像网页的外衣。比如，标题字体、颜色变化，或为标题加入背景图片、边框等。所有这些用来改变内容外观的东西称之为表现。

动态交互：JavaScript基础的学习

JavaScript是用来实现网页上的特效效果。如：鼠标滑过弹出下拉菜单。或鼠标滑过表格的背景颜色改变。还有焦点新闻（新闻图片）的轮换。可以这么理解，有动画的，有交互的一般都是用JavaScript来实现的。

ems.length === 0

}

this.front = function() {

return items[0]

}

this.clear = function() {

items = []

}

this.size = function() {

return items.length

基础学习：

前端最基础的就是 HTML , CSS 和 JavaScript 。

网页设计：HTML和CSS基础知识的学习

HTML是网页内容的载体。内容就是网页制作者放在页面上想要让用户浏览的信息，可以包含文字、图片、视频等。

[外链图片转存中…(img-emOK9Ibz-1718101377707)]

CSS样式是表现。就像网页的外衣。比如，标题字体、颜色变化，或为标题加入背景图片、边框等。所有这些用来改变内容外观的东西称之为表现。

[外链图片转存中…(img-RmHB1D79-1718101377708)]

动态交互：JavaScript基础的学习

JavaScript是用来实现网页上的特效效果。如：鼠标滑过弹出下拉菜单。或鼠标滑过表格的背景颜色改变。还有焦点新闻（新闻图片）的轮换。可以这么理解，有动画的，有交互的一般都是用JavaScript来实现的。