根据 Array.prototype.reduce 的特性进行封装

Link：特性

var a = 1; 如何让 a == a.value;

var a = 1;

//code

console.log(a == a.value); // true

计算多个区间的交集

区间用长度为2的数字数组表示，如[2, 5]表示区间2到5（包括2和5）；
区间不限定方向，如[5, 2]等同于[2, 5]；
实现getIntersection 函数
可接收多个区间，并返回所有区间的交集（用区间表示），如空集用null表示

示例：

getIntersection([5, 2], [4, 9], [3, 6]); // [4, 5]
getIntersection([1, 7], [8, 9]); // null

Cookie 和 Session 的诞生主要为了解决因为 http 是无状态的，导致同一站点下不能共享状态（例如登录状态）的问题。

当客户端发起http请求到服务端时，服务端接受到请求后会生成一个 Session 临时文件到服务端的内存中，并且会通过哈希函数生成一个唯一标识与之对应，就是 sessionId，然后发起一个http响应到客户端，并且会在响应头的Set-Cookie 携带这个唯一标识 sessionId ，客户端接收到响应头中 Set-Cookie 后会自动保存为 Cookie，待下次客户端发起请求时会在请求头中携带 Cookie 发送给服务端，服务端接收到请求后就会解析 Cookie，校验信息的 sessionId 准确性以及时效性后给客户端响应处理后的数据。

Cookie和Session的区别主要在于：

1. Cookie 储存在客户端，而 Session储存在服务端中；
2. Cookie 的安全性低于 Session，例如某些网站的登录状态是携带在Cookie中，如果我们拷贝一份Cookie粘贴到别的未登陆过浏览器后再访问这个站点时会处于登录状态；
3. 因为 Session 是保存在服务器的内存中，如果访问数量过多会影响到服务器性能；
4. 一个 Cookie 的最大保存容量为 4K，一个站点最多可以保存 20 个 Cookie，储存容量远小于 Session；

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，找出 这个重复的数 。

示例 1：

输入：nums = [1,3,4,2,2]
输出：2

示例 2：

输入：nums = [3,1,3,4,2]
输出：3

示例 3：

输入：nums = [1,1]
输出：1

示例 4：

输入：nums = [1,1,2]
输出：1

提示：

• 2 <= n <= 3 * 104
• nums.length == n + 1
• 1 <= nums[i] <= n
• nums 中 只有一个整数 出现 两次或多次 ，其余整数均只出现 一次

来源：力扣（LeetCode）

封装一个数组去重函数，不产生新数组，删除数组里的重复元素。

const removeDuplicate = function(nums){
    // show you code
    return nums;
}

let arr = [1,2,2,3];
let dupArray = removeDuplicate(arr)
console.log(dupArray,dupArray === arr); // [1,2,3]   true

数据结构中有线性表与非线性表之分，线性表主要有Array,Linked List,Queue,Stack，非线性表有Graph,Tree，其中 Array 与 Linked List 都属于数据结构线性表。
先说说Array与Linked List 的特性吧~

Array（数组）

什么是数组呢？
数组是一种线性数据结构，它用一组连续的内存空间来存储具有相同类型的数据。

• 线性数据结构
• 用一组连续的内存空间进行存储相同类型的值

因为有了第二点的支持，让数组有一个天然的优势就是支持任意访问，也就是可以通过索引直接获取到对应的储存数据，可以说是数组的杀手锏，但是这个杀手锏是数组的亮点的同时也暴露了数组的弊端，那就是如果要支持任意访问这一特性的话就得保证数据类型一致性和内存的连续性。这使得数组在删除或者插入数据的时候为了保证连续性而做大量的数据迁移工作；

假设有一个数组[1,2,3,4,5,6],我们对它分别进行插入，删除操作：

插入操作

1. 如果我们要把0插入到数组的第三个位置的话，就得把3,4,5,6都往后移动。
2. 如果我们在数组的第一个位置插入新的数据，那么原先数组的每个数组都得完后迁移。
3. 如果我们是在数组的尾部插入数据，此时因为新增元素后面没有元素存在，并不重要对数据进行迁移。

可以看出数组插入元素的复杂度是O(n)。

删除操作

删除操作同插入操作差不多，复杂度也是O(n)。

但是虽然数组的插入和删除复杂度是O(1),但是对于一些特殊的场景我们还是可以优化成O(1)。例如插入操作中，如果数组不看重有序度的话可以将新元素即将插入的位置中的原数组迁移到数组尾部后再进行插入，这样就不用进行大量的数据迁移啦；对于删除操作我们可以先标记删除的元素，待到数组储存个数即将到达上限时在一次性对删除的元素进行删除。

可以看出数组的优点在于它强大的任意访问，缺点在于插入和删除过于低效，所以这个时候就可以用到我们另外一个大兄嘚Linked List（链表）。

Linked List（链表）

相比数组而言，链表储存数据不需要连续的内存空间，链表的每个节点是一个内存块（JS中可以理解为对象）它比数组占用的内存会更大，但是可以通过节点中指针将一组散乱的内存块关联在一起，通过节点的指针进行遍历和访问所关联的节点。

常见的链表的类别：单链表，双向链表和循环链表。

因为链表的储存空间对内存连续性并没有要求，所以在插入和删除操作更为简单粗暴，复杂度是O(1),但是它有一个缺点，就是没有数组天然的任意访问特性，导致它的查找操作复杂度为O(n)。

对于大数据链来说如果频繁插入或者操作的话，链表比数组更为友好写，但是如果是任意访问的话，数组更为证据优势，不过链表也可以做一些优化提升的，例如可以使用跳表做到复杂度为O(logN)的访问，不过代价是空间复杂度是O(n),对内存的消耗会大一些。

Array 和 Linked List 都更有自己的优点和缺点，如果对内存允许的情况下可以考虑空间换时间，如果内存比较紧缺的时候可以考虑时间换空间，每一种方案都有自己的亮点。

复杂度对比

另外注意一点就是随意访问并非是查找，你就算要查找并且访问元素，用二分法的复杂度也得O(logN)，访问数组中的某个元素必须找到它的位置的前提，虽然说数组的随机访问为O(1)，不过查找某个元素之前得明确它在数组中的位置才可以通过寻址地址访问到对应的元素呀。

Vuex是一个专为Vue服务，用于管理页面数据状态、提供统一数据操作的生态系统。它集中于MVC模式中的Model层，规定所有的数据操作必须通过 action - mutation - state change 的流程来进行，再结合Vue的数据视图双向绑定特性来实现页面的展示更新。统一的页面状态管理以及操作处理，可以让复杂的组件交互变得简单清晰。那么如何实现一个 Mini Vuex呢？
Please start your performance.

实现一个字符串反转：输入：www.toutiao.com.cn 输出：cn.com.toutiao.www
可以先暴力解决问题，最终看看是否能否根据以下要求优化。

要求：
1.不使用字符串处理函数
2.空间复杂度尽可能小

通过下列的输出说说 isNaN 和 Number.isNaN 函数的区别

isNaN(NaN); 

isNaN('String');

isNaN(undefined); 

isNaN({}); 

Number.isNaN(NaN);

Number.isNaN('String'); 

Number.isNaN(undefined); 

Number.isNaN({}); 

假设我们现在需要对 [D,a,2,F,B,1,c,5,A,z ]进行排序，要求将其中所有小写字母都排在大写字母的前面，数字排中间，数组小写字母内部和大写字母内部以及数字不要求有序, 最终排序之后为 [a,c,z,2,1,5,D,F,B,A]。

ps: 数字也无需顺序，只需要符合在小写与大写字母之间即可

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

示例 2：

输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。

提示：

0 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成

来源：LeetCode

插入排序和冒泡排序的空间，时间复杂度都一样，也是属于原地排序的稳定排序算法,为何插入排序比冒泡排序更受欢迎？

对于排序算法的执行效率主要可以通过以下3方面解析：

1. 最好，最坏，平均情况时间复杂度；
2. 时间复杂度的系数，常熟和阶数；
3. 比较，交换（移动）的次数；

可以看看插入排序与冒泡排序的元素交换区别：

插入排序

if (array[j] > value) {
  array[j + 1] = array[j];
} else {
  // 因为左边是排序区间，如果与最后的元素已经处于有序的话则说明该元素不用在单轮循环与其他元素进行排序了。
  break;
}

冒泡排序

 if (arr[j] > arr[j + 1]) {
  isChange = true;
  // Core code
  let  tmp = arr[i];
  arr[i] = arr[j];
  arr[j] = tmp;
  // [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; ES 新语法，同上效果一致
}

可以明显看出冒泡排序的元素交换次数是排序排序的3倍交换次数，假设在对 K 哥元素进行排序，每次交换操作耗时单位为 ut，那么冒泡排序在交换元素上就是 3K * ut，而插入则是 K * ut。

实现一个 task 函数，支持 task().eat().sleep(2000).eat().sleep(2000)。

const task = function(){
    // codeing
}
task().eat().sleep(2000).eat().sleep(2000);
// 输出 => eat
// 等待两秒
// 输出 => eat
// 等待两秒

实现 Redux 中的 compose 合并函数。

compose 函数的作用就是接收多个回调函数并将其整合为一个函数，并且函数由内而外嵌套在一起，内层函数如果返回值则作为实参传递给外层函数；
如

const a = (n) => 6 + n;
const b = (k) => k * 3;
const wrap = compose(a,b); // 等价于 (arg) => b(a(k));
wrap(2); // 24

随着技术的不断更新和进步，提升性能随处可见，其中缓存就是性能优化的一种方案，Http 强缓存和协商缓存基本都会用到，借此分析它们给我们带来了哪一些好处，适用于哪一些场景呢？

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

map() 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。点击查看具体

给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

示例 1:

输入: "aba"
输出: True

示例 2:

输入: "abca"
输出: True
解释: 你可以删除c字符。

注意:
字符串只包含从 a-z 的小写字母。字符串的最大长度是50000。

来源：力扣（LeetCode）

字符串压缩。利用字符重复出现的次数，编写一种方法，实现基本的字符串压缩功能。比如，字符串aabcccccaaa会变为a2b1c5a3。若“压缩”后的字符串没有变短，则返回原先的字符串。你可以假设字符串中只包含大小写英文字母（a至z）。

示例1:

 输入："aabcccccaaa"
 输出："a2b1c5a3"

示例2:

 输入："abbccd"
 输出："abbccd"

解释："abbccd"压缩后为"a1b2c2d1"，比原字符串长度更长。

来源：LeetCode - 字符串压缩

例如

function add(){//...}

add(1)(2,3)(4).value()   
输出： 10

我们在写 Vue 组件时，他们都是从 VNode 转变成真实 DOM 后再进行渲染的，再此期间 Vue 是如何将 VNode 转变为真实的 DOM 呢？

当我们要访问或者设置一个变量时，发现在当前作用域并未声明该变量却可以正常操作，有的时候却会报错，这些都和作用域链查找机制有关，作用域链是怎么回事呢，它又是如何进行查找的呢？

Redux 是目前 React 框架最火的状态管理工具，但是它与 React 没有任何关系，我们可以通过阅读源码并且模仿实现它才可以更为深刻的了解 Redux 的迷人之处，并且从源码中找出它的不足之处并尝试优化，为此你会如何实现它呢？