把这些根底算法题把握好，根底不牢地动山摇，前面中级题很多都是在这些根底题的根底上的。
二叉树（DFS）
二叉树前中后遍历套路详解
前序遍历题目如下：
root节点是A节点（下图的A节点），而后让你依照下图数字的程序顺次打印出节点。
咱们能够看到这其中的法则，就是深度优先遍历，先遍历左子树，再遍历右子树，这里咱们不必递归，因为一些大厂严格要求二叉树遍历不必递归，递归太简略了。
重点思路就是：深度优先遍历，先遍历左子树，再遍历右子树，
所以，咱们须要一套如何遍历一颗二叉树，并且是先左子树，再右子树的通用模板，如下
var Traversal = function(root) { const stack = []; while (root || stack.length){ while(root){ stack.push(root); root = root.left; } root = stack.pop(); root = root.right; } return res;};咱们联合图片发现这个遍历产生的整体压栈的程序是
- A、B、D入栈，
- D出栈
- B出栈
- E入栈
- E出栈
- A出栈
- C入栈
- C出栈
- F入栈
- F出栈
咱们把下面入栈的元素按顺序排列一下就是，A、B、D、E、C、F，而这就是前序遍历的程序！解答结束！
是不是很有意思，上面的中序遍历，咱们看看出栈程序是不是中序遍历的要求：D、B、E、A、C、F（这就是中序遍历的要求，好了，两个题解决）
放具体前序遍历代码：
var preorderTraversal = function(root) { // 初始化数据 const res =[]; const stack = []; while (root || stack.length){ while(root){ res.push(root.val); stack.push(root); root = root.left; } root = stack.pop(); root = root.right; } return res;};中序遍历是一个意思，在前序遍历的根底上革新一下
var preorderTraversal = function(root) { // 初始化数据 const res =[]; const stack = []; while (root || stack.length){ while(root){ stack.push(root); root = root.left; } root = stack.pop(); res.push(root.val); root = root.right; } return res;};后序遍历有点不太一样，然而套路是一样的，咱们须要先遍历右子树，再遍历左子树，反着来，就能够了，代码如下：
var postorderTraversal = function(root) { // 初始化数据 const res =[]; const stack = []; while (root || stack.length){ while(root){ stack.push(root); res.unshift(root.val); root = root.right; } root = stack.pop(); root = root.left; } return res;};对称二叉树
这个题简而言之就是判断一个二叉树是对称的，比如说：
二叉树 [1,2,2,3,4,4,3] 是对称的。
1 / \ 2 2 / \ / \3 4 4 3然而上面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1 / \ 2 2 \ \ 3 3思路：
递归解决：
- 判断两个指针以后节点值是否相等
- 判断 A 的右子树与 B 的左子树是否对称
判断 A 的左子树与 B 的右子树是否对称
function isSame(leftNode, rightNode){ if(leftNode === null && rightNode === null) return true; if(leftNode === null || rightNode === null) return false; return leftNode.val === rightNode.val && isSame(leftNode.left, rightNode.right) && isSame(leftNode.right, rightNode.left)}var isSymmetric = function(root) { if(!root) return root; return isSame(root.left, root.right);};二叉树的最大深度
这个题在面试滴滴的时候遇到过，次要是把握二叉树遍历的套路
- 只有遍历到这个节点既没有左子树，又没有右子树的时候
- 阐明就到底部了，这个时候如果之前记录了深度，就能够比拟是否比之前记录的深度大，大就更新深度
而后以此类推，始终比拟到深度最大的
var maxDepth = function(root) { if(!root) return root; let ret = 1; function dfs(root, depth){ if(!root.left && !root.right) ret = Math.max(ret, depth); if(root.left) dfs(root.left, depth+1); if(root.right) dfs(root.right, depth+1); } dfs(root, ret); return ret};将有序数组转化为二叉搜寻树
咱们先看题：
给你一个整数数组 nums ，其中元素曾经按 升序 排列，请你将其转换为一棵 高度均衡 二叉搜寻树。
高度均衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
示例 1：输出：nums = [-10,-3,0,5,9]输入：[0,-3,9,-10,null,5]解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：示例 2：
输出：nums = [1,3]输入：[3,1]解释：[1,3] 和 [3,1] 都是高度均衡二叉搜寻树。 提醒：<= nums.length <= 104
-104 <= nums[i] <= 104
nums 按 严格递增 顺序排列- 构建一颗树包含：构建root、构建 root.left 和 root.right
- 题目要求"高度均衡" — 构建 root 时候，抉择数组的两头元素作为 root 节点值，即可保持平衡。
递归函数能够传递数组，也能够传递指针，抉择传递指针的时候：l r 别离代表参加构建BST的数组的首尾索引。
var sortedArrayToBST = function(nums) { return toBST(nums, 0, nums.length - 1)};const toBST = function(nums, l, r){ if( l > r){ return null; } const mid = l + r >> 1; const root = new TreeNode(nums[mid]); root.left = toBST(nums, l, mid - 1); root.right = toBST(nums, mid + 1, r); return root;}栈
栈是一种先进先出的数据结构，所以波及到你须要先进先出这个想法后，就能够应用栈。
其次我感觉栈跟递归很类似，递归是不是先压栈，而后先进来的先进来，就跟函数调用栈一样。
无效的括号
这是一道很典型的用栈解决的问题， 给定一个只包含 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否无效。
无效字符串需满足：
左括号必须用雷同类型的右括号闭合。左括号必须以正确的程序闭合。
示例 1：输出：s = "()"输入：true示例 2：输出：s = "()[]{}"输入：true示例 3：输出：s = "(]"输入：false示例 4：输出：s = "([)]"输入：false思路：这道题有一法则：
1.右括号后面，必须是绝对应的左括号，能力对消！
2.右括号后面，不是对应的左括号，那么该字符串，肯定不是无效的括号！
也就是说左括号咱们间接放入栈中即可，发现是右括号就要比照是否跟栈顶元素相匹配，不匹配就返回false
var isValid = function(s) { const map = { '{': '}', '(': ')', '[': ']' }; const stack = []; for(let i of s){ if(map[i]){ stack.push(i); } else { if(map[stack[stack.length - 1]] === i){ stack.pop() }else{ return false; } } } return stack.length === 0;};### 最小栈
先看题目：
设计一个反对 push ，pop ，top 操作，并能在常数工夫内检索到最小元素的栈。
- push(x) —— 将元素 x 推入栈中。
- pop() —— 删除栈顶的元素。
- top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
示例:MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.getMin(); --> 返回 -3.minStack.pop();minStack.top(); --> 返回 0.minStack.getMin(); --> 返回 -2.提醒：pop、top 和 getMin 操作总是在 非空栈 上调用。咱们先不写getMin办法，满足其余办法实现就非常简单，咱们来看一下：
var MinStack = function() { this.stack = [];};MinStack.prototype.push = function(x) { this.stack.push(x);};MinStack.prototype.pop = function() { this.stack.pop();};MinStack.prototype.top = function() { return this.stack[this.stack.length - 1];};如何保障每次取最小呢，咱们举一个例子：
如上图，咱们须要一个辅助栈来记录最小值，- 开始咱们向stack push -2
- 此时辅助栈minStack，因为此时stack最小的是-2，也push -2
stack push 0 - 此时辅助站minStack 会用 0 跟 -2比照，-2更小，minstack会push -2
- stack push -3
- 此时辅助站minStack 会用 -3 跟 -2比照，-3更小，minstack会push -3
所以咱们取最小的时候，总能在minStack中取到最小值，所以解法就进去了：
var MinStack = function() { this.stack = []; // 辅助栈 this.minStack = [];};MinStack.prototype.push = function(x) { this.stack.push(x); // 如果是第一次或者以后x比最小栈里的最小值还小才push x if(this.minStack.length === 0 || x < this.minStack[this.minStack.length - 1]){ this.minStack.push(x) } else { this.minStack.push( this.minStack[this.minStack.length - 1]) }};MinStack.prototype.pop = function() { this.stack.pop(); this.minStack.pop();};MinStack.prototype.top = function() { return this.stack[this.stack.length - 1];};MinStack.prototype.getMin = function() { return this.minStack[this.stack.length - 1];};动静布局
动静布局，肯定要晓得动静转移方程，有了这个，就相当于解题的钥匙，咱们从题目中领会一下
最大子序和
题目如下：
给定一个整数数组 nums ，找到一个具备最大和的间断子数组（子数组起码蕴含一个元素），返回其最大和。
示例 1：输出：nums = [-2,1,-3,4,-1,2,1,-5,4]输入：6解释：间断子数组 [4,-1,2,1] 的和最大，为 6 。示例 2：输出：nums = [1]输入：1示例 3：输出：nums = [0]输入：0思路：
- 这道题能够用动静布局来解决，要害是找动静转移方程
- 咱们动静转移方程中，dp示意每一个nums下标的最大自序和，所以dp[i]的意思为：包含下标i之前的最大间断子序列和为dp[i]。
确定本义方程的公示：
dp[i]只有两个方向能够推出来：
- 1、如果dp[i - 1] < 0，也就是以后遍历到nums的i，之前的最大子序和是正数，那么咱们就没必要持续加它了，因为dp[i] = dp[i - 1] + nums[i] 会比nums[i]更小，所以此时还不如dp[i] = nums[i]，就是目前遍历到i的最大子序和呢
- 2、同理dp[i - 1] > 0，阐明nums[i]值得去加dp[i - 1]，此时回避nums[i]更大
这样代码就进去了，其实更多的就是求dp，遍历nums每一个下标都会产生最大子序和，咱们记录下来即可
var maxSubArray = function(nums) { let res = nums[0]; const dp = [nums[0]]; for(let i=1;i < nums.length;i++){ if(dp[i-1]>0){ dp[i]=nums[i]+dp[i-1] }else{ dp[i]=nums[i] } res=Math.max(dp[i],res) } return res};爬楼梯
先看题目：
假如你正在爬楼梯。须要 n 阶你能力达到楼顶。
每次你能够爬 1 或 2 个台阶。你有多少种不同的办法能够爬到楼顶呢？
留神：给定 n 是一个正整数。
示例 1：输出： 2输入： 2解释： 有两种办法能够爬到楼顶。1. 1 阶 + 1 阶2. 2 阶示例 2：输出： 3输入： 3解释： 有三种办法能够爬到楼顶。1. 1 阶 + 1 阶 + 1 阶2. 1 阶 + 2 阶3. 2 阶 + 1 阶波及到动静布局，肯定要晓得动静转移方程，有了这个，就相当于解题的钥匙，
这道题咱们假如dp[10]示意爬到是你爬到10阶就达到楼顶的办法数，
那么，dp[10] 是不是就是你爬到8阶，而后再走2步就到了，还有你走到9阶，再走1步就到了，
所以 dp[10] 是不是等于 dp[9]+dp[8]
延长一下 dp[n] 是不是等于 dp[n - 1] + dp[n - 2]
代码如下：
var climbStairs = function(n) { const dp = {}; dp[1] = 1; dp[2] = 2; for(let i = 3; i <= n; i++){ dp[i] = dp[i-1] + dp[i-2] } return dp[n]};数学问题
加一
题目如下：
给定一个由 整数 组成的 非空 数组所示意的非负整数，在该数的根底上加一。
最高位数字寄存在数组的首位， 数组中每个元素只存储单个数字。
你能够假如除了整数 0 之外，这个整数不会以零结尾。
示例 1：输出：digits = [1,2,3]输入：[1,2,4]解释：输出数组示意数字 123。示例 2：输出：digits = [4,3,2,1]输入：[4,3,2,2]解释：输出数组示意数字 4321。示例 3：输出：digits = [0]输入：[1]这个题的要害有两点：
- 须要有一个进位的变量carry记录到底进位是几
还须要一个每次迭代都重置和的变量sum来帮咱们算是否进位，以及进位后的数字
记住这个题，这是两数字相加的套路，这次是+1，其实就是两数相加的题（腾讯面试遇到过两数相加）var plusOne = function(digits) {let carry = 1; // 进位（因为咱们确定+1，初始化进位就是1）for(let i = digits.length - 1; i >= 0; i--){ let sum = 0; // 这个变量是用来每次循环计算进位和digits[i]的值的 sum = digits[i] + carry; digits[i] = sum % 10; // 模运算取个位数 carry = (sum / 10) | 0; // 除以10是取百位数，并且｜0示意舍弃小数位}if(digits[0] === 0) digits.unshift(carry);return digits};x的平方根
题目如下：实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
因为返回类型是整数，后果只保留整数的局部，小数局部将被舍去。
示例 1:输出: 4输入: 2示例 2:
输出: 8输入: 2阐明: 8 的平方根是 2.82842..., 因为返回类型是整数，小数局部将被舍去。这道题是典型的二分法解题，所以咱们须要相熟二分法的通用模板，咱们出一个题：
在 [1, 2, 3, 4, 5, 6] 中找到 4，若存在则返回下标，不存在返回-1const arr = [1, 2, 3, 4, 5, 6];function getIndex1(arr, key) {let low = 0;const high = arr.length - 1;while (low <= high) { const mid = Math.floor((low + high) / 2); if (key === arr[mid]) { return mid; } if (key > arr[mid]) { low = mid + 1; } else { height = mid - 1; }}return -1;}console.log(getIndex1(arr, 5)); // 4所以这道题的意思就是，咱们找一个数平方跟x最相近的数，二分法的用法中也有找相近数的性能
所以代码如下：
var mySqrt = function(x) { let [l , r] = [0, x]; let ans = -1; while(l <= r) { const mid = (l + r) >> 1; if(mid * mid > x){ r = mid - 1 } else if(mid * mid < x){ ans = mid; // 避免越界 l = mid + 1; } else { ans = mid; return ans; } } return ans;};};Excel表序列号
这个题比拟重要，也比拟根底，简而言之就是进制转换，必须牢牢把握
题目如下：
给你一个整数 columnNumber ，返回它在 Excel 表中绝对应的列名称。
例如：
A -> 1B -> 2C -> 3...Z -> 26AA -> 27AB -> 28 ...示例 1：输出：columnNumber = 1输入："A"示例 2：输出：columnNumber = 28输入："AB"示例 3：输出：columnNumber = 701输入："ZY"示例 4：输出：columnNumber = 2147483647输入："FXSHRXW"说白了，这就是一道26进制的问题，以前咱们晓得10进制转2进制就是不停的除2，把余数加起来，26进制也是一样，不停的除26
思路：
- 初始化后果 ans = 0，遍历时将每个字母与 A 做减法，因为 A 示意 1，所以减法后须要每个数加 1，计算其代表的数值 num = 字母 - ‘A’ + 1
- 因为有 26 个字母，所以相当于 26 进制，每 26 个数则向后退一位
- 所以每遍历一位则ans = ans * 26 + num
以 ZY 为例，Z 的值为 26，Y 的值为 25，则后果为 26 * 26 + 25=701
var titleToNumber = function(columnTitle) { let ans = 0; for(let i = 0; i < columnTitle.length; i++){ ans = ans * 26 + (columnTitle[i].charCodeAt() - 'A'.charCodeAt() + 1) } return ans;};阶乘中的零
题目：
给定一个整数 n，返回 n! 后果尾数中零的数量。示例 1:输出: 3输入: 0解释: 3! = 6, 尾数中没有零。示例 2:输出: 5输入: 1解释: 5! = 120, 尾数中有 1 个零.这道题很简略，有多少个5就有多少个0，为什么这么说呢，咱们剖析一下题目
比如说 5!，
- 也就是 5 4 3 2 1 = 120，咱们发现只有1个0，怎么产生的呢，次要造成者就是 2 * 5 结构了一个0
- 再看看10!
10! = 10 9 8 7 6 5 4 3 2 1 其中，除了10 = 2 5和自身有一对2 * 5，所以有两个0，这样这道题的法则就进去了，咱们再精进一步
如上图，每四个数字都会呈现一个或者多个2的因子，然而只有每 5 个数字能力找到一个或多个5的因子。所以总体上看来，2的因子是远远多于5的因子的，所以咱们只须要找5的倍数就能够了。
咱们再进一步，依照下面的说法，咱们须要计算比方10的阶乘有多少个0，要把10的阶乘算进去，其实咱们只须要算10有几个5就好了，为什么呢
咱们再进一步，依照下面的说法，咱们须要计算比方10的阶乘有多少个0，要把10的阶乘算进去，其实咱们只须要算10有几个5就好了，为什么呢
咱们发现只有5的倍数的阶乘，才会产生5, 所以咱们须要看看阶层数有多少个5，代码如下：
var trailingZeroes = function (n) { let r = 0; while (n > 1) { n = Math.floor(n / 5); r += n; } return r;};颠倒二进制位
题目如下：
颠倒给定的 32 位无符号整数的二进制位。
示例 1：
输出: 00000010100101000001111010011100输入: 00111001011110000010100101000000解释: 输出的二进制串 00000010100101000001111010011100 示意无符号整数 43261596， 因而返回 964176192，其二进制示意模式为 00111001011110000010100101000000。示例 2：
输出：11111111111111111111111111111101输入：10111111111111111111111111111111解释：输出的二进制串 11111111111111111111111111111101 示意无符号整数 4294967293， 因而返回 3221225471 其二进制示意模式为 10111111111111111111111111111111 。这类题，就是翻转字符串，咱们能够把其转为字符串，再转成数组，再reverse一下，这里咱们选用数学的形式去解答，不必这种转字符串的形式。
解答这道题之前，咱们须要理解的前置常识：
1.与估算 &
1 & 1 // 1的2进制最初一位是1，失去12 & 0 // 2的2进制最初一位是0，失去03 & 1 // 3的2进制最初一位是1，失去14 & 0 // 4的2进制最初一位是0，失去0所以咱们晓得了怎么取10进制最初1位的2进制是几。
2.JavaScript 应用 32 位按位运算数(意思是咱们的按位运算都会转成32位，你的数字不能超过32位，会出问题)
- JavaScript 将数字存储为 64 位浮点数，但所有按位运算都以 32 位二进制数执行。
- 在执行位运算之前，JavaScript 将数字转换为 32 位有符号整数。
- 执行按位操作后，后果将转换回 64 位 JavaScript 数。
3.'<< 1' 运算
这个运算实际上就是把10进制乘以2，这个乘2在2进制上体现出左边填了一个0，咱们距举例来说，
- 2的2进制是 10，2 << 1 失去4， 4的2进制是100，所以比10多了个0
- 3的2进制是 11，3 << 1 失去6。6的2进制是110，所以比11多了个0
以上就是法则
思路：循环取最初一位拼接起来即可
var reverseBits = function (n) { let result = 0 for (let i = 0; i < 32; i++) { result = (result << 1) + (n & 1) n = n >> 1 } // 为什么要 >>> 0 呢，一位javascript没有无符号整数，全是有符号的 // 不>>>0的话，得进去的值是正数，然而无符号整数是没有符号的 // javascript 有符号转化为无符号的办法就是>>>0 return result >>> 0}失落的数字
给定一个蕴含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范畴内没有呈现在数组中的那个数。
进阶：
你是否实现线性工夫复杂度、仅应用额定常数空间的算法解决此问题?
示例 1：输出：nums = [3,0,1]输入：2解释：n = 3，因为有 3 个数字，所以所有的数字都在范畴 [0,3] 内。2 是失落的数字，因为它没有呈现在 nums 中。示例 2：输出：nums = [0,1]输入：2解释：n = 2，因为有 2 个数字，所以所有的数字都在范畴 [0,2] 内。2 是失落的数字，因为它没有呈现在 nums 中。这题很简略，就是用0-n的总和减去数组总和
0 - n 的总和用等差数列:（首数+尾数）* 项数 / 2 来求
var missingNumber = function(nums) { const len = nums.length let sum = ((1 + len) * len) / 2 for (let i = 0; i < len; i++) { sum -= nums[i] } return sum }的幂
题目如下：
给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。
整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3的x次方示例 1：输出：n = 27输入：true示例 2：输出：n = 0输入：false示例 3：输出：n = 9输入：true思路
- 咱们拿27来说：27 = 3 3 3，所以27是3的幂次方
- 咱们拿29来说：29 = 3 3 3点几
也就是说，如果是3的幂次方，始终除以3，除到最初就等于1比方27/3/3/3等于1 如果不是3的幂次方，除到最初就是3点几/3 等于1点几
代码就进去了判断是不是等于1即可
var isPowerOfThree = function(n) { while(n >= 3){ n /= 3; } return n === 1;};412. Fizz Buzz
这个题没啥好说的，就依照题目说的写代码就行，先看题目：
写一个程序，输入从 1 到 n 数字的字符串示意。
1.如果 n 是3的倍数，输入“Fizz”；
2.如果 n 是5的倍数，输入“Buzz”；
3.如果 n 同时是3和5的倍数，输入 “FizzBuzz”。
示例：n = 15,返回:[ "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"] var fizzBuzz = function (n) { const list = []; for (let i = 1; i <= n; i++) { const is3Times = i % 3 === 0; // 是否是3的倍数 const is5Times = i % 5 === 0; // 是否是5的倍数 const is15Times = is3Times && is5Times; // 是否是15的倍数 if (is15Times) { list.push('FizzBuzz'); continue; } if (is3Times) { list.push('Fizz'); continue; } if (is5Times) { list.push('Buzz'); continue; } list.push(`${i}`); } return list; };环问题
这类问题的特点就是，你要循环寻找，到底怎么循环寻找，看题便知。
环形链表
题目如下：
给定一个链表，判断链表中是否有环。
如果链表中有某个节点，能够通过间断跟踪 next 指针再次达到，则链表中存在环。为了示意给定链表中的环，咱们应用整数 pos 来示意链表尾连贯到链表中的地位（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。留神：pos 不作为参数进行传递，仅仅是为了标识链表的理论状况。
如果链表中存在环，则返回 true 。否则，返回 false 。
输出：head = [3,2,0,-4], pos = 1输入： true解释： 链表中有一个环，其尾部连贯到第二个节点。示例 2：
输出：head = [1,2], pos = 0输入： true解释： 链表中有一个环，其尾部连贯到第一个节点。咱们采纳标记法：
给遍历过的节点打记号，如果遍历过程中遇到有记号的阐明已环
var hasCycle = function(head) { let traversingNode = head; while(traversingNode){ if(traversingNode.isVistitd) return true traversingNode.isVistitd = true traversingNode = traversingNode.next } return false;};202. 高兴数
题目如下：编写一个算法来判断一个数 n 是不是高兴数。
「高兴数」定义为：
- 对于一个正整数，每一次将该数替换为它每个地位上的数字的平方和。
- 而后反复这个过程直到这个数变为 1，也可能是 有限循环 但始终变不到 1。
- 如果 能够变为 1，那么这个数就是高兴数。
- 如果 n 是高兴数就返回 true ；不是，则返回 false 。
高兴数怎么剖析呢？
咱们来看一个表，就会得出结论，一个数依照高兴数定义的形式别离每个数字平方，会有两种状况
1.失去1
2.有限循环
有限循环参照下图 - 有人会说会不会始终变大，答案是不会：咱们看上面列表，
能够看到如果你是13位，你的下一次高兴数算法会变为4位1053， - 如果你是9999, 4位，下一个高兴数是324
所以代码只有判断这两种就行了，代码如下：
// 封装获取高兴数的办法function getNext(n){ n = String(n); let sum = 0; for(let num of n){ sum = sum + Math.pow(+num, 2); } return sum;}var isHappy = function(n) { // 哈希表来看是否循环 const map = {}; while( n !== 1 ){ map[n] = true; n = getNext(n) if(map[n]) return false } return true};我还整顿了一份前端面试题，包含人事、我的项目、小程序、HTML5/CSS3、JS、HTTP、ES6、Vue、REACT 等面试题，咱们先一起看看题目。
人事+我的项目
这都是主观问题，列举进去的是能够参考下，人事面试也不能漫不经心，有的公司人事是有一票否决权
小程序
- 数据申请怎么封装
- 参数传值的办法
- 进步小程序的利用速度的办法
- 小程序的长处
- 小程序的毛病
- 简述小程序原理
- 怎么解决异步申请问题
- 小程序和 Vue 写法的区别
- 小程序的双向绑定和 vue 哪里不一样
- 几种跳转，小程序内的页面跳转
HTML5\CSS3
- Doctype 作用? 严格模式与混淆模式-如何触发这两种模式，辨别它们有何意义?
- 行内元素有哪些？块级元素有哪些？ 空(void)元素有那些？
- CSS 的盒子模型有几种？各有什么特点？
- link 和@import 的区别是?
- CSS 选择符有哪些？哪些属性能够继承？优先级算法如何计算？ CSS3 新增伪类有那些？
- 如何居中 div,如何居中一个浮动元素?
- 浏览器的内核别离是什么? 常常遇到的浏览器的兼容性有哪些？起因，解决办法是什么，罕用 hack 的技
- css 属性那些有继承性？哪些没有？
- 如果盒子都为浮动，父类会没有高度，如何解决
- isibility 和 display 的暗藏有什么区别？
JS
- 原型/原型链/构造函数/实例/继承
- 如何实现 new 运算符
- 有几种形式能够实现继承
- arguments
- 数据类型判断
- 作用域链、闭包、作用域
- Ajax 的原生写法
- 对象深拷贝、浅拷贝
- 图片懒加载、预加载
- 实现页面加载进度条
React
- 辨别 Real DOM 和 Virtual DOM
- React 有什么特点？
- 列出 React 的一些次要长处。
- React 有哪些限度？
- 什么是 JSX？
- 你理解 Virtual DOM 吗？解释一下它的工作原理。
- 为什么浏览器无奈读取 JSX？
- 与 ES5 相比，React 的 ES6 语法有何不同？
- 怎么解释 React 中 render() 的目标。
完整版的2021前端面试题精编PDF文档点击这里获取，还有面试题没有列举进去，小伙伴们到时能够好好看面试题。