面试题集合（HTML篇）

## 1. 两数之和

### 题目描述

给定一个整数数组 **nums** 和一个目标值 **target**，请你在该数组中找出和为目标值的那 **两个** 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

### 示例

``` javascript
给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
````

### 代码实现

``` javascript
const findTotal = (nums, target) => {
  for(let i = 0; i < nums.length; i++) {
    if (nums.includes(target-nums[i])) {
      return [i, nums.indexOf(target-nums[i])];
    }
  }
}
```

``` javascript
const twoSum = (nums, target) => {
  let preNums = {};
  for (let i = 0; i < nums.length; i++) {
    const targetNum = target - nums[i];
    if (preNums[targetNum]) {
      return [preNums[targetNum], i];
    }
    preNums[nums[i]] = i;
  }
}
```


## 2. 整数反转

### 题目描述

![reverse-integer](reverse-integer.jpeg)


### 代码实现

``` javascript
const reverse = (x) => {
  let result = 0;
  while (x !== 0) {
    result = result * 10 + (x % 10);
    x = Math.floor(x / 10);
  }

  if (result < -Math.pow(2, 31) || result > Math.pow(2, 31) - 1) {
    return 0;
  }
  return result;
};
```

## 3. 合并两个有序链表

### 题目描述

将两个升序链表合并为一个新的 **升序** 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

### 示例1

![merge-two-sorted-lists](merge-two-sorted-lists.jpeg)

``` javascript
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
```

### 示例2

``` javascript
输入：l1 = [], l2 = []
输出：[]
```

### 示例3

``` javascript
输入：l1 = [], l2 = [0]
输出：[0]
```

### 提示

- 两个链表的节点数目范围是 [0, 50]
- -100 <= Node.val <= 100
- l1 和 l2 均按 非递减顺序 排列

``` javascript
// 例如 现有两个链表
const ListNode1 = {
  value: 0,
  next: {
    value: 2,
    next: {
      value: 4,
      next: null
    }
  }
}

const ListNode2 = {
  value: 1,
  next: {
    value: 3,
    next: {
      value: 5,
      next: null
    }
  }
}
```

### 实现

``` javascript
const mergeTwoLists = (l1, l2) => {
  if (l1 === null) {
    return l2
  }
  if (l2 === null) {
    return l1
  }
  if (l1.value < l2.value) {
    l1.next = mergeTwoLists(l1.next, l2)
    return l1
  }
  if (l2.value < l1.value) {
    l2.next = mergeTwoLists(l2.next, l1)
    return l2
  }
}
```

## 4. 最大子序和

### 题目描述

给定一个整数数组 **nums** ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

### 示例1

``` javascript
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
```

### 示例2

``` javascript
输入：nums = [1]
输出：1
```

### 示例3

``` javascript
输入：nums = [0]
输出：0
```

### 示例4

``` javascript
输入：nums = [-1]
输出：-1
```

### 示例5

``` javascript
输入：nums = [-100000]
输出：-100000
```

### 提示
- 1 <= nums.length <= 3 * 104
- -105 <= nums[i] <= 105

``` javascript
const maxSubArray = (nums) => {
  let pre = 0;
  let max = nums[0];
  nums.forEach(x => {
    pre = Math.max(pre + x, x);
    max = Math.max(max, pre);
  });
  return max;
};
```

## 5. 反转链表

### 题目描述

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

### 示例:

``` javascript
const ListNode = {
  value: 1,
  next: {
    value: 2,
    next: {
      value: 3,
      next: {
        value: 4,
        next: {
          value: 5,
          next: null
        }
      }
    }
  }
}

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
```

### 限制：

``` javascript
0 <= 节点个数 <= 5000
```

``` javascript
const reverseList = (head) => {
  let pre = null;
  let cur = head;
  while(cur) {
    const next = cur.next;
    cur.next = pre;
    pre = cur;
    cur = next;
  }
  return pre;
}
```

## 6. 二叉树的最大深度

### 题目描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

**说明： 叶子节点是指没有子节点的节点。**

### 示例

给定二叉树 **[3,9,20,null,null,15,7]**

![maximum-depth-of-binary-tree](maximum-depth-of-binary-tree.jpeg)

返回它的最大深度 3 。

``` javascript
const maxDepth = tree => {
  if (!tree) {
    return 0;
  }
  const maxLeft = maxDepth(tree.left);
  const maxRight = maxDepth(tree.right);
  return Math.max(maxLeft, maxRight) + 1;
}
```

## 7. 环形链表

### 题目描述

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

### 思路

给遍历过的节点打记号，如果遍历过程中遇到有记号的说明已环🤓

``` javascript
const hasCycle = head => {
  while(head) {
    if (head.tag) {
      return true;
    }
    head.tag = true;
    head = head.next;
  }
  return false;
}
```


## 8. 合并二叉树

### 题目描述

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

### 示例

![merge-two-binary-trees](merge-two-binary-trees.jpeg)

**注意：合并必须从两个树的根节点开始。**

``` javascript
const mergeTrees = (t1, t2) => {
  if (!t1 || !t2) {
    return t1 || t2;
  }
  t1.value = t1.value + t2.value;
  t1.left = mergeTrees(t1.left, t2.left);
  t1.right = mergeTrees(t1.right, t2.right);
  return t1;
}
```

## 9. 有效的括号

### 题目描述
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

### 示例 1：
``` javascript
输入：s = "()"
输出：true
```

### 示例 2：
``` javascript
输入：s = "()[]{}"
输出：true
```

### 示例 3：
``` javascript
输入：s = "(]"
输出：false
```

### 示例 4：
``` javascript
输入：s = "([)]"
输出：false
```

### 示例 5：
``` javascript
输入：s = "{[]}"
输出：true
```

### 提示：

![valid-parentheses-alert](valid-parentheses-alert.jpeg)

``` javascript
const isValid = (str) => {
  const { length } = str;
  if (length % 2 !== 0) return false;
  let arr = [];
  for (let item of str) {
    switch (item) {
      case "(":
      case "{":
      case "[":
        arr.push(item);
        break;
      case ")":
        if (arr.pop() !== "(") return false;
        break;
      case "}":
        if (arr.pop() !== "{") return false;
        break;
      case "]":
        if (arr.pop() !== "[") return false;
        break;
    }
  }

  return arr.length === 0
};
```

## 10. 爬楼梯

### 题目描述

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

### 示例 1：

``` javascript
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶
```

### 示例 2：

``` javascript
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶
```

``` javascript
const climbStairs = (n) => {
  if (n < 1) return 0;
  const dp = [];
  dp[1] = 1;
  dp[2] = 2;
  for (let i = 0; i < n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  return dp[n];
};
```

## 11. 二叉树的中序遍历

### 题目描述

给定一个二叉树的根节点 root ，返回它的 中序 遍历。

### 示例 1：

![binary-tree-inorder-traversal1](binary-tree-inorder-traversal1.jpeg)

``` javascript
输入：root = [1,null,2,3]
输出：[1,3,2]
```

### 示例 2：

``` javascript
输入：root = []
输出：[]
```

### 示例 3：

``` javascript
输入：root = [1]
输出：[1]
```

### 示例 4：

![binary-tree-inorder-traversal2](binary-tree-inorder-traversal2.jpeg)

``` javascript
输入：root = [1,null,2]
输出：[1,2]
```

### 示例 5：

![binary-tree-inorder-traversal3](binary-tree-inorder-traversal3.jpeg)

``` javascript
输入：root = [1,null,2]
输出：[1,2]
```

### 提示：

![binary-tree-inorder-traversal-alert](binary-tree-inorder-traversal-alert.jpeg)

``` javascript
const inorderTraversal = (root) => {
  const res = [];
  const inorder = (root) => {
    if (!root) return;
    inorder(root.left);
    res.push(root.val);
    inorder(root.right);
  }
  inorder(root)
  return res;
};
```

## 12. 对称二叉树

### 题目描述

给定一个二叉树，检查它是否是镜像对称的。

![symmetric-tree](symmetric-tree.jpeg)



## 13. 买卖股票的最佳时机

### 题目描述

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

### 示例 1：

``` javascript
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
```

### 示例 2：

``` javascript
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
```

### 提示：

![best-time-to-buy-and-sell-stock-alert](best-time-to-buy-and-sell-stock-alert.jpeg)


## 14. 只出现一次的数字

### 题目描述

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

### 说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

### 示例 1:

``` javascript
输入: [2,2,1]
输出: 1
```

### 示例 2:

``` javascript
输入: [4,1,2,1,2]
输出: 4
```

``` javascript
const singleNumber = (nums) => {
  let obj = {};
  for(const num of nums) {
    if (!obj[num]) {
      obj[num] = true;
    } else {
      delete obj[num]
    }
  }
  return Number(Object.keys(obj)?.[0])
};
```

## 15. 最小栈

### 题目描述

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

  - push(x) —— 将元素 x 推入栈中。
  - pop() —— 删除栈顶的元素。
  - top() —— 获取栈顶元素。
  - getMin() —— 检索栈中的最小元素。

### 示例:

``` javascript
  输入：
  ["MinStack","push","push","push","getMin","pop","top","getMin"]
  [[],[-2],[0],[-3],[],[],[],[]]

  输出：
  [null,null,null,null,-3,null,0,-2]

  解释：
  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 操作总是在 非空栈 上调用。

``` javascript
var MinStack = function() {
    this.x_stack = [];
    this.min_stack = [Infinity];
};

MinStack.prototype.push = function(x) {
    this.x_stack.push(x);
    this.min_stack.push(Math.min(this.min_stack[this.min_stack.length - 1], x));
};

MinStack.prototype.pop = function() {
    this.x_stack.pop();
    this.min_stack.pop();
};

MinStack.prototype.top = function() {
    return this.x_stack[this.x_stack.length - 1];
};

MinStack.prototype.getMin = function() {
    return this.min_stack[this.min_stack.length - 1];
};
```

## 16. 相交链表

### 题目描述

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

![intersection-of-two-linked-lists1](intersection-of-two-linked-lists1.jpeg)

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

### 示例 1：

![intersection-of-two-linked-lists2](intersection-of-two-linked-lists2.jpeg)

``` javascript
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
```

### 示例 2：

![intersection-of-two-linked-lists3](intersection-of-two-linked-lists3.jpeg)

``` javascript
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
```

### 示例 3：

![intersection-of-two-linked-lists4](intersection-of-two-linked-lists4.jpeg)

``` javascript
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
```

### 提示：

![intersection-of-two-linked-lists-alert](intersection-of-two-linked-lists-alert.jpeg)

算法题（简单系列）


## 1. 对HTML语义化的一些理解

- 标签语义化有助于构架良好的HTML结构，有利于搜索引擎的建立索引、抓取。SEO
- 有利于构建清晰的机构，有利于团队的开发、维护。

## 2. 讲讲HTML5加了哪些东西

- 语义化标签（header，footer等）
- audio，video
- Canvas
- 本地存储，各种storage
- Web Worker多线程

## 3. 那些你不知道的meta标签

- name 属性
  
  用于描述页面信息（内容，关键词，作者等）
  - author
  - description
  - keywords
  - viewport

- http-equiv
  
  用于描述HTTP头部

  - content-type
  - content-security-policy（内容策略）


## 1. infinity代表什么数据

  在JS中Infinity用于表示无穷大的数值，且不是常量，即无法明确表示它到底有多大。可以通过isFinite(val)判断当前数字是否是无穷大，函数返回true表示不是无穷大，返回false表示是无穷大。


## 2. 如何计算动画的帧率（FPS）

- 可以借助requestAnimationFrame API，requestAnimationFrame 使用一个回调函数作为参数。这个回调函数会在浏览器重绘之前调用。

- requestAnimationFrame的回调函数执行次数通常与浏览器屏幕刷新次数相匹配，而利用这个API实现动画的原理就是回调函数内再次调用requestAnimationFrame，所以页面不断重绘时，然后检测1秒内requestAnimationFrame调用的次数，就是当前的FPS


## 3. 请说说new String("A")和String("A")分别返回的结果，请解释为什么

- new String("A") :
  
  返回类型：引用类型，堆内存存储
  返回值：字符串对象

- String("A”) ：
  
  返回类型：基本类型，栈内存存储
  返回值：字符串值

## 4. 请通过reduce函数实现一维数组的求和

``` javascript
const sum = arr => arr.reduce((a, b) => a + b)
```

## 5. 请说说严格模式下的this指向

- 在严格模式下，在全局作用域中，this指向window对象
- 在严格模式下，函数中的this等于undefined
- 在严格模式下，对象的函数中的this指向调用函数的对象实例
- 在严格模式下，构造函数中的this指向构造函数创建的对象实例。
- 在严格模式下，在事件处理函数中，this指向触发事件的目标对象。

## 6. 图片懒加载原理
   
  图片懒加载的原理主要是判断当前图片是否到了可视区域这一核心逻辑实现的

- 拿到所有的图片 dom 。
- 遍历每个图片判断当前图片是否到了可视区范围内。
- 如果到了就设置图片的 src 属性。
- 绑定 window 的 scroll 事件，对其进行事件监听（搭配节流）。

``` js
let imgList = [...document.querySelectorAll('img')]
let length = imgList.length

// 修正错误，需要加上自执行
- const imgLazyLoad = function() {
+ const imgLazyLoad = (function() {
    let count = 0
    
   return function() {
        let deleteIndexList = []
        imgList.forEach((img, index) => {
            let rect = img.getBoundingClientRect()
            if (rect.top < window.innerHeight) {
                img.src = img.dataset.src
                deleteIndexList.push(index)
                count++
                if (count === length) {
                    document.removeEventListener('scroll', imgLazyLoad)
                }
            }
        })
        imgList = imgList.filter((img, index) => !deleteIndexList.includes(index))
   }
- }
+ })()

// 这里最好加上节流处理
document.addEventListener('scroll', imgLazyLoad)

```

## 7. 懒加载和预加载

  两者都是提高页面性能有效的办法，两者主要区别是一个是提前加载，一个是迟缓甚至不加载。懒加载对服务器前端有一定的缓解压力作用，预加载则会增加服务器前端压力。

## 8. 如何区分返回内容是文件流还是json数据

``` javascript
await (await fetch(url)).blob();
// Blob {size: 100, type: "application/json"}
// Blob {size: 73226, type: "image/jpeg"}
```

## 9. 写一个方法判断js的方法是内置的还是自定义的

toString一下
``` javascript
function isNative (f) {
    return typeof f === 'function' && /native code/.test(f.toString())
}
```

## 10. 微任务与宏任务

- JavaScript是单线程的语言
- Event Loop是javascript的执行机制

![interview-js-event-loop](interview-js-event-loop.jpeg)

- 同步和异步任务分别进入不同的执行"场所"，同步的进入主线程，异步的进入Event Table并注册函数
- 当指定的事情完成时，Event Table会将这个函数移入Event Queue。
- 主线程内的任务执行完毕为空，会去Event Queue读取对应的函数，进入主线程执行。
- 上述过程会不断重复，也就是常说的Event Loop(事件循环)。

  js异步有一个机制，就是遇到宏任务，先执行宏任务，将宏任务放入eventqueue，然后在执行微任务，将微任务放入eventqueue最骚的是，这两个queue不是一个queue。当你往外拿的时候先从微任务里拿这个回掉函数，然后再从宏任务的queue上拿宏任务的回掉函数，也就是说‘同一层’既有微任务也有宏任务的时候，先执行微任务

``` javascript
console.log('1');

setTimeout(function() {
    console.log('2');
    process.nextTick(function() {
        console.log('3');
    })
    new Promise(function(resolve) {
        console.log('4');
        resolve();
    }).then(function() {
        console.log('5')
    })
})
process.nextTick(function() {
    console.log('6');
})
new Promise(function(resolve) {
    console.log('7');
    resolve();
}).then(function() {
    console.log('8')
})

setTimeout(function() {
    console.log('9');
    process.nextTick(function() {
        console.log('10');
    })
    new Promise(function(resolve) {
        console.log('11');
        resolve();
    }).then(function() {
        console.log('12')
    })
})
```

## 11. 函数的方法 call()、apply()、bind()的区别

### 改变函数执行上下文，也就是改变this的指向

- call和apply改变了函数的this上下文后便执行该函数,而bind则是返回改变了上下文后的一个函数。
- call和apply的第一个参数都是要改变上下文的对象，而call从第二个参数开始以参数列表的形式展现，apply则是把除了改变上下文对象的参数放在一个数组里面作为它的第二个参数。


## 12. 前端性能优化
- 减少 HTTP 请求
- 使用 HTTP2
- 使用服务端渲染
  
  客户端渲染: 获取 HTML 文件，根据需要下载 JavaScript 文件，运行文件，生成 DOM，再渲染。
  服务端渲染：服务端返回 HTML 文件，客户端只需解析 HTML。

- 静态资源使用 CDN
- 将 CSS 放在文件头部，JavaScript 文件放在底部
- 使用字体图标 iconfont 代替图片图标
- 善用缓存，不重复加载相同的资源
- 压缩文件（js，css，图片）
- 图片优化（懒加载，base64）
- 分chunk，大的库考虑用CDN（react，router等）
- 使用事件委托
- if-else 对比 switch
  
  当判断条件数量越来越多时，越倾向于使用 switch 而不是 if-else。
- 使用 Web Workers
- 降低 CSS 选择器的复杂性（勿嵌套多层）

## 13. 什么是防抖和节流，应用场景是啥
    
### 都是用于限制函数被频繁调用

**防抖：任务频繁触发的情况下，只有任务触发的间隔超过指定间隔的时候，任务才会执行。**

场景：有个输入框，输入之后会调用接口，获取联想词。但是，因为频繁调用接口不太好，所以我们在代码中使用防抖功能，只有在用户输入完毕的一段时间后，才会调用接口，出现联想词。

**节流：任务频繁触发的情况下，指定时间间隔内只会执行一次任务。**

场景：懒加载要监听计算滚动条的位置，使用节流按一定时间的频率获取；双十一抢商品

## 14. 实现链式调用
    
链式调用的核心就在于调用完的方法将自身实例返回

``` javascript
function Class1() {
    console.log('初始化')
}
Class1.prototype.method = function(param) {
    console.log(param)
    return this
}
let cl = new Class1()
//由于new 在实例化的时候this会指向创建的对象， 所以this.method这个方法会在原型链中找到。
cl.method('第一次调用').method('第二次链式调用').method('第三次链式调用')
```
    
## 15. 继承
    
**原型链继承**

``` javascript
function Animal() {
    this.colors = ['black', 'white']
}
Animal.prototype.getColor = function() {
    return this.colors
}
function Dog() {}
Dog.prototype =  new Animal()

let dog1 = new Dog()
dog1.colors.push('brown')
let dog2 = new Dog()
console.log(dog2.colors)  // ['black', 'white', 'brown']
```

**问题**

- 原型中的属性会被共享
- 实例化时无法给父类构造函数传参
  
**借用构造函数实现继承**

``` javascript
function Animal(name) {
    this.name = name
    this.getName = function() {
        return this.name
    }
}
function Dog(name) {
    Animal.call(this, name)
}
```
借用构造函数实现继承解决了原型链继承的 2 个问题：引用类型共享问题以及传参问题。但是由于方法必须定义在构造函数中，所以**会导致每次创建子类实例都会创建一遍方法**。

**组合继承**

组合继承结合了原型链和盗用构造函数，将两者的优点集中了起来。基本的思路是使用原型链继承原型上的属性和方法，而通过盗用构造函数继承实例属性。这样既可以把方法定义在原型上以实现重用，又可以让每个实例都有自己的属性。

``` javascript
function Animal(name) {
    this.name = name
    this.colors = ['black', 'white']
}
Animal.prototype.getName = function() {
    return this.name
}
function Dog(name, age) {
    Animal.call(this, name)
    this.age = age
}
Dog.prototype =  new Animal()
Dog.prototype.constructor = Dog

let dog1 = new Dog('奶昔', 2)
dog1.colors.push('brown')
let dog2 = new Dog('哈赤', 1)
console.log(dog2) // { name: "哈赤", colors: ["black", "white"], age: 1 }
```

## 16. js中的堆栈
    
### 栈数据结构

- 栈是一种特殊的列表，栈内的元素只能通过列表的一端访问，这一端称为栈顶。
- 栈被称为是一种后入先出（LIFO，last-in-first-out）的数据结构。

### 堆数据结构

- 堆是一种经过排序的树形数据结构，每个结点都有一个值。
- 堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。

### 变量类型与内存的关系

#### 基本数据类型

Sting、Number、Boolean、null、undefined、Symbol

- 基本数据类型保存在栈内存中，因为基本数据类型占用空间小、大小固定，通过按值来访问，属于被频繁使用的数据。
- 引用数据类型存储在堆内存中，因为引用数据类型占据空间大、大小不固定；引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址


## 17. Proxy的理解

### 回答要点
- Proxy的作用（拦截读取，写入等操作，可以覆盖原生操作）
- Proxy和Object.defineProperty的区别（优势，Vue3用Proxy取代2版的defineProperty）
- Reflect的用法（了解）

### 链接
[Proxy 和 Reflect](https://juejin.cn/post/6844904090116292616)

## 18. Generator详解

- 可控制的异步流程
- async是Generator的实现（语法糖）

## 19. 搞懂prototype和 __proto__

### javascript继承的本质

一个对象 A的__proto__属性指向的那个对象B，B就是 A 的原型对象（或者叫父对象），对象 A 可以使用对象 B 中的属性和方法，同时也可以使用对象 B 的 原型对象C 上的属性和方法，以此递归，就是所谓的原型链。

### new 操作到底做了什么

## 20. script标签中defer和async的区别

都是异步加载 script 脚本
- 如果脚本无需等待页面解析，且无依赖独立运行，那么应使用 async。
- 如果脚本需要等待页面解析，且依赖于其它脚本，调用这些脚本时应使用 defer，将关联的脚本按所需顺序置于 HTML 中。

## 21. CommonJs和Es Module的区别

### CommonJs

- CommonJs可以动态加载语句，代码发生在运行时
- CommonJs导出值是拷贝，可以修改导出的值

### Es Module

- Es Module是静态的，不可以动态加载语句，只能声明在该文件的最顶部，代码发生在编译时
- Es Module混合导出，单个导出，默认导出，完全互不影响
- Es Module导出是引用值之前都存在映射关系，并且值都是可读的，不能修改

### 题外话

webpack treeshaking 是基于静态检查，所以尽量使用 Es Module。


## 22. getSnapshotBeforeUpdate

## 23. target和currentTarget

## 24. 常用的hooks

