高级前端二面手写面试题（边面边更）1

解析 URL Params 为对象

 
let url = 'http://www.domain.com/?user=anonymous&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';
parseParam(url)
/* 结果
{ user: 'anonymous',
  id: [ 123, 456 ], // 重复出现的 key 要组装成数组，能被转成数字的就转成数字类型
  city: '北京', // 中文需解码
  enabled: true, // 未指定值得 key 约定为 true
}
*/
function parseParam(url) {
  const paramsStr = /.+\?(.+)$/.exec(url)[1]; // 将 ? 后面的字符串取出来
  const paramsArr = paramsStr.split('&'); // 将字符串以 & 分割后存到数组中
  let paramsObj = {};
  // 将 params 存到对象中
  paramsArr.forEach(param => {
    if (/=/.test(param)) { // 处理有 value 的参数
      let [key, val] = param.split('='); // 分割 key 和 value
      val = decodeURIComponent(val); // 解码
      val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字
 
      if (paramsObj.hasOwnProperty(key)) { // 如果对象有 key，则添加一个值
        paramsObj[key] = [].concat(paramsObj[key], val);
      } else { // 如果对象没有这个 key，创建 key 并设置值
        paramsObj[key] = val;
      }
    } else { // 处理没有 value 的参数
      paramsObj[param] = true;
    }
  })
 
  return paramsObj;
}

异步并发数限制

 
/**
 * 关键点
 * 1. new promise 一经创建，立即执行
 * 2. 使用 Promise.resolve().then 可以把任务加到微任务队列，防止立即执行迭代方法
 * 3. 微任务处理过程中，产生的新的微任务，会在同一事件循环内，追加到微任务队列里
 * 4. 使用 race 在某个任务完成时，继续添加任务，保持任务按照最大并发数进行执行
 * 5. 任务完成后，需要从 doingTasks 中移出
 */
function limit(count, array, iterateFunc) {
  const tasks = []
  const doingTasks = []
  let i = 0
  const enqueue = () => {
    if (i === array.length) {
      return Promise.resolve()
    }
    const task = Promise.resolve().then(() => iterateFunc(array[i++]))
    tasks.push(task)
    const doing = task.then(() => doingTasks.splice(doingTasks.indexOf(doing), 1))
    doingTasks.push(doing)
    const res = doingTasks.length >= count ? Promise.race(doingTasks) : Promise.resolve()
    return res.then(enqueue)
  };
  return enqueue().then(() => Promise.all(tasks))
}
 
// test
const timeout = i => new Promise(resolve => setTimeout(() => resolve(i), i))
limit(2, [1000, 1000, 1000, 1000], timeout).then((res) => {
  console.log(res)
})

解析 URL Params 为对象

 
let url = 'http://www.domain.com/?user=anonymous&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';
parseParam(url)
/* 结果{ user: 'anonymous',  id: [ 123, 456 ], // 重复出现的 key 要组装成数组，能被转成数字的就转成数字类型  city: '北京', // 中文需解码  enabled: true, // 未指定值得 key 约定为 true}*/
function parseParam(url) {
  const paramsStr = /.+\?(.+)$/.exec(url)[1]; // 将 ? 后面的字符串取出来
  const paramsArr = paramsStr.split('&'); // 将字符串以 & 分割后存到数组中
  let paramsObj = {};
  // 将 params 存到对象中
  paramsArr.forEach(param => {
    if (/=/.test(param)) { // 处理有 value 的参数
      let [key, val] = param.split('='); // 分割 key 和 value
      val = decodeURIComponent(val); // 解码
      val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字
      if (paramsObj.hasOwnProperty(key)) { // 如果对象有 key，则添加一个值
        paramsObj[key] = [].concat(paramsObj[key], val);
      } else { // 如果对象没有这个 key，创建 key 并设置值
        paramsObj[key] = val;
      }
    } else { // 处理没有 value 的参数
      paramsObj[param] = true;
    }
  })
  return paramsObj;
}

Array.prototype.filter()

 
Array.prototype.filter = function(callback, thisArg) {
  if (this == undefined) {
    throw new TypeError('this is null or not undefined');
  }
  if (typeof callback !== 'function') {
    throw new TypeError(callback + 'is not a function');
  }
  const res = [];
  // 让O成为回调函数的对象传递（强制转换对象）
  const O = Object(this);
  // >>>0 保证len为number，且为正整数
  const len = O.length >>> 0;
  for (let i = 0; i < len; i++) {
    // 检查i是否在O的属性（会检查原型链）
    if (i in O) {
      // 回调函数调用传参
      if (callback.call(thisArg, O[i], i, O)) {
        res.push(O[i]);
      }
    }
  }
  return res;
}

手写 new 操作符

在调用 new 的过程中会发生以上四件事情：

（1）首先创建了一个新的空对象

（2）设置原型，将对象的原型设置为函数的 prototype 对象。

（3）让函数的 this 指向这个对象，执行构造函数的代码（为这个新对象添加属性）

（4）判断函数的返回值类型，如果是值类型，返回创建的对象。如果是引用类型，就返回这个引用类型的对象。

 
function objectFactory() {
  let newObject = null;
  let constructor = Array.prototype.shift.call(arguments);
  let result = null;
  // 判断参数是否是一个函数
  if (typeof constructor !== "function") {
    console.error("type error");
    return;
  }
  // 新建一个空对象，对象的原型为构造函数的 prototype 对象
  newObject = Object.create(constructor.prototype);
  // 将 this 指向新建对象，并执行函数
  result = constructor.apply(newObject, arguments);
  // 判断返回对象
  let flag = result && (typeof result === "object" || typeof result === "function");
  // 判断返回结果
  return flag ? result : newObject;
}
// 使用方法
objectFactory(构造函数, 初始化参数);

Promise

 
// 模拟实现Promise
// Promise利用三大手段解决回调地狱：
// 1. 回调函数延迟绑定
// 2. 返回值穿透
// 3. 错误冒泡
 
// 定义三种状态
const PENDING = 'PENDING';      // 进行中
const FULFILLED = 'FULFILLED';  // 已成功
const REJECTED = 'REJECTED';    // 已失败
 
class Promise {
  constructor(exector) {
    // 初始化状态
    this.status = PENDING;
    // 将成功、失败结果放在this上，便于then、catch访问
    this.value = undefined;
    this.reason = undefined;
    // 成功态回调函数队列
    this.onFulfilledCallbacks = [];
    // 失败态回调函数队列
    this.onRejectedCallbacks = [];
 
    const resolve = value => {
      // 只有进行中状态才能更改状态
      if (this.status === PENDING) {
        this.status = FULFILLED;
        this.value = value;
        // 成功态函数依次执行
        this.onFulfilledCallbacks.forEach(fn => fn(this.value));
      }
    }
    const reject = reason => {
      // 只有进行中状态才能更改状态
      if (this.status === PENDING) {
        this.status = REJECTED;
        this.reason = reason;
        // 失败态函数依次执行
        this.onRejectedCallbacks.forEach(fn => fn(this.reason))
      }
    }
    try {
      // 立即执行executor
      // 把内部的resolve和reject传入executor，用户可调用resolve和reject
      exector(resolve, reject);
    } catch(e) {
      // executor执行出错，将错误内容reject抛出去
      reject(e);
    }
  }
  then(onFulfilled, onRejected) {
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    onRejected = typeof onRejected === 'function'? onRejected :
      reason => { throw new Error(reason instanceof Error ? reason.message : reason) }
    // 保存this
    const self = this;
    return new Promise((resolve, reject) => {
      if (self.status === PENDING) {
        self.onFulfilledCallbacks.push(() => {
          // try捕获错误
          try {
            // 模拟微任务
            setTimeout(() => {
              const result = onFulfilled(self.value);
              // 分两种情况：
              // 1. 回调函数返回值是Promise，执行then操作
              // 2. 如果不是Promise，调用新Promise的resolve函数
              result instanceof Promise ? result.then(resolve, reject) : resolve(result);
            })
          } catch(e) {
            reject(e);
          }
        });
        self.onRejectedCallbacks.push(() => {
          // 以下同理
          try {
            setTimeout(() => {
              const result = onRejected(self.reason);
              // 不同点：此时是reject
              result instanceof Promise ? result.then(resolve, reject) : resolve(result);
            })
          } catch(e) {
            reject(e);
          }
        })
      } else if (self.status === FULFILLED) {
        try {
          setTimeout(() => {
            const result = onFulfilled(self.value);
            result instanceof Promise ? result.then(resolve, reject) : resolve(result);
          });
        } catch(e) {
          reject(e);
        }
      } else if (self.status === REJECTED) {
        try {
          setTimeout(() => {
            const result = onRejected(self.reason);
            result instanceof Promise ? result.then(resolve, reject) : resolve(result);
          })
        } catch(e) {
          reject(e);
        }
      }
    });
  }
  catch(onRejected) {
    return this.then(null, onRejected);
  }
  static resolve(value) {
    if (value instanceof Promise) {
      // 如果是Promise实例，直接返回
      return value;
    } else {
      // 如果不是Promise实例，返回一个新的Promise对象，状态为FULFILLED
      return new Promise((resolve, reject) => resolve(value));
    }
  }
  static reject(reason) {
    return new Promise((resolve, reject) => {
      reject(reason);
    })
  }
  static all(promiseArr) {
    const len = promiseArr.length;
    const values = new Array(len);
    // 记录已经成功执行的promise个数
    let count = 0;
    return new Promise((resolve, reject) => {
      for (let i = 0; i < len; i++) {
        // Promise.resolve()处理，确保每一个都是promise实例
        Promise.resolve(promiseArr[i]).then(
          val => {
            values[i] = val;
            count++;
            // 如果全部执行完，返回promise的状态就可以改变了
            if (count === len) resolve(values);
          },
          err => reject(err),
        );
      }
    })
  }
  static race(promiseArr) {
    return new Promise((resolve, reject) => {
      promiseArr.forEach(p => {
        Promise.resolve(p).then(
          val => resolve(val),
          err => reject(err),
        )
      })
    })
  }
}

实现防抖函数（debounce）

防抖函数原理：把触发非常频繁的事件合并成一次去执行 在指定时间内只执行一次回调函数，如果在指定的时间内又触发了该事件，则回调函数的执行时间会基于此刻重新开始计算

防抖动和节流本质是不一样的。防抖动是将多次执行变为最后一次执行，节流是将多次执行变成每隔一段时间执行

eg. 像百度搜索，就应该用防抖，当我连续不断输入时，不会发送请求；当我一段时间内不输入了，才会发送一次请求；如果小于这段时间继续输入的话，时间会重新计算，也不会发送请求。

手写简化版:

 
// func是用户传入需要防抖的函数
// wait是等待时间
const debounce = (func, wait = 50) => {
  // 缓存一个定时器id
  let timer = 0
  // 这里返回的函数是每次用户实际调用的防抖函数
  // 如果已经设定过定时器了就清空上一次的定时器
  // 开始一个新的定时器，延迟执行用户传入的方法
  return function(...args) {
    if (timer) clearTimeout(timer)
    timer = setTimeout(() => {
      func.apply(this, args)
    }, wait)
  }
}

适用场景：

文本输入的验证，连续输入文字后发送 AJAX 请求进行验证，验证一次就好
按钮提交场景：防止多次提交按钮，只执行最后提交的一次
服务端验证场景：表单验证需要服务端配合，只执行一段连续的输入事件的最后一次，还有搜索联想词功能类似

实现发布-订阅模式

 
class EventCenter{
  // 1. 定义事件容器，用来装事件数组
    let handlers = {}
 
  // 2. 添加事件方法，参数：事件名 事件方法
  addEventListener(type, handler) {
    // 创建新数组容器
    if (!this.handlers[type]) {
      this.handlers[type] = []
    }
    // 存入事件
    this.handlers[type].push(handler)
  }
 
  // 3. 触发事件，参数：事件名 事件参数
  dispatchEvent(type, params) {
    // 若没有注册该事件则抛出错误
    if (!this.handlers[type]) {
      return new Error('该事件未注册')
    }
    // 触发事件
    this.handlers[type].forEach(handler => {
      handler(...params)
    })
  }
 
  // 4. 事件移除，参数：事件名 要删除事件，若无第二个参数则删除该事件的订阅和发布
  removeEventListener(type, handler) {
    if (!this.handlers[type]) {
      return new Error('事件无效')
    }
    if (!handler) {
      // 移除事件
      delete this.handlers[type]
    } else {
      const index = this.handlers[type].findIndex(el => el === handler)
      if (index === -1) {
        return new Error('无该绑定事件')
      }
      // 移除事件
      this.handlers[type].splice(index, 1)
      if (this.handlers[type].length === 0) {
        delete this.handlers[type]
      }
    }
  }
}

Object.assign

Object.assign()方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象（请注意这个操作是浅拷贝）

 
Object.defineProperty(Object, 'assign', {
  value: function(target, ...args) {
    if (target == null) {
      return new TypeError('Cannot convert undefined or null to object');
    }
 
    // 目标对象需要统一是引用数据类型，若不是会自动转换
    const to = Object(target);
 
    for (let i = 0; i < args.length; i++) {
      // 每一个源对象
      const nextSource = args[i];
      if (nextSource !== null) {
        // 使用for...in和hasOwnProperty双重判断，确保只拿到本身的属性、方法（不包含继承的）
        for (const nextKey in nextSource) {
          if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
            to[nextKey] = nextSource[nextKey];
          }
        }
      }
    }
    return to;
  },
  // 不可枚举
  enumerable: false,
  writable: true,
  configurable: true,
})

数组扁平化

数组扁平化是指将一个多维数组变为一个一维数组

 
const arr = [1, [2, [3, [4, 5]]], 6];
// => [1, 2, 3, 4, 5, 6]

方法一：使用flat()


const res1 = arr.flat(Infinity);

方法二：利用正则


const res2 = JSON.stringify(arr).replace(/\[|\]/g, '').split(',');

但数据类型都会变为字符串

方法三：正则改良版本


const res3 = JSON.parse('[' + JSON.stringify(arr).replace(/\[|\]/g, '') + ']');

方法四：使用reduce

 
const flatten = arr => {
  return arr.reduce((pre, cur) => {
    return pre.concat(Array.isArray(cur) ? flatten(cur) : cur);
  }, [])
}
const res4 = flatten(arr);

方法五：函数递归

 
const res5 = [];
const fn = arr => {
  for (let i = 0; i < arr.length; i++) {
    if (Array.isArray(arr[i])) {
      fn(arr[i]);
    } else {
      res5.push(arr[i]);
    }
  }
}
fn(arr);

实现数组去重

给定某无序数组，要求去除数组中的重复数字并且返回新的无重复数组。

ES6方法（使用数据结构集合）：

 
const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];
 
Array.from(new Set(array)); // [1, 2, 3, 5, 9, 8]

ES5方法：使用map存储不重复的数字

 
const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];
 
uniqueArray(array); // [1, 2, 3, 5, 9, 8]
 
function uniqueArray(array) {
  let map = {};
  let res = [];
  for(var i = 0; i < array.length; i++) {
    if(!map.hasOwnProperty([array[i]])) {
      map[array[i]] = 1;
      res.push(array[i]);
    }
  }
  return res;
}

实现双向数据绑定

 
let obj = {}
let input = document.getElementById('input')
let span = document.getElementById('span')
// 数据劫持
Object.defineProperty(obj, 'text', {
  configurable: true,
  enumerable: true,
  get() {
    console.log('获取数据了')
  },
  set(newVal) {
    console.log('数据更新了')
    input.value = newVal
    span.innerHTML = newVal
  }
})
// 输入监听
input.addEventListener('keyup', function(e) {
  obj.text = e.target.value
})

深拷贝

递归的完整版本（考虑到了Symbol属性）：

 
const cloneDeep1 = (target, hash = new WeakMap()) => {
  // 对于传入参数处理
  if (typeof target !== 'object' || target === null) {
    return target;
  }
  // 哈希表中存在直接返回
  if (hash.has(target)) return hash.get(target);
 
  const cloneTarget = Array.isArray(target) ? [] : {};
  hash.set(target, cloneTarget);
 
  // 针对Symbol属性
  const symKeys = Object.getOwnPropertySymbols(target);
  if (symKeys.length) {
    symKeys.forEach(symKey => {
      if (typeof target[symKey] === 'object' && target[symKey] !== null) {
        cloneTarget[symKey] = cloneDeep1(target[symKey]);
      } else {
        cloneTarget[symKey] = target[symKey];
      }
    })
  }
 
  for (const i in target) {
    if (Object.prototype.hasOwnProperty.call(target, i)) {
      cloneTarget[i] =
        typeof target[i] === 'object' && target[i] !== null
        ? cloneDeep1(target[i], hash)
        : target[i];
    }
  }
  return cloneTarget;
}

实现简单路由

 
// hash路由
class Route{
  constructor(){
    // 路由存储对象
    this.routes = {}
    // 当前hash
    this.currentHash = ''
    // 绑定this，避免监听时this指向改变
    this.freshRoute = this.freshRoute.bind(this)
    // 监听
    window.addEventListener('load', this.freshRoute, false)
    window.addEventListener('hashchange', this.freshRoute, false)
  }
  // 存储
  storeRoute (path, cb) {
    this.routes[path] = cb || function () {}
  }
  // 更新
  freshRoute () {
    this.currentHash = location.hash.slice(1) || '/'
    this.routes[this.currentHash]()
  }
}

实现千位分隔符

 
// 保留三位小数
parseToMoney(1234.56); // return '1,234.56'
parseToMoney(123456789); // return '123,456,789'
parseToMoney(1087654.321); // return '1,087,654.321'
function parseToMoney(num) {
  num = parseFloat(num.toFixed(3));
  let [integer, decimal] = String.prototype.split.call(num, '.');
  integer = integer.replace(/\d(?=(\d{3})+$)/g, '$&,');
  return integer + '.' + (decimal ? decimal : '');
}

正则表达式(运用了正则的前向声明和反前向声明):

 
function parseToMoney(str){
    // 仅仅对位置进行匹配
    let re = /(?=(?!\b)(\d{3})+$)/g; 
   return str.replace(re,','); 
}

图片懒加载

可以给img标签统一自定义属性data-src='default.png'，当检测到图片出现在窗口之后再补充src属性，此时才会进行图片资源加载。

 
function lazyload() {
  const imgs = document.getElementsByTagName('img');
  const len = imgs.length;
  // 视口的高度
  const viewHeight = document.documentElement.clientHeight;
  // 滚动条高度
  const scrollHeight = document.documentElement.scrollTop || document.body.scrollTop;
  for (let i = 0; i < len; i++) {
    const offsetHeight = imgs[i].offsetTop;
    if (offsetHeight < viewHeight + scrollHeight) {
      const src = imgs[i].dataset.src;
      imgs[i].src = src;
    }
  }
}
 
// 可以使用节流优化一下
window.addEventListener('scroll', lazyload);

模拟new

new操作符做了这些事：

它创建了一个全新的对象
它会被执行[Prototype]（也就是proto）链接
它使this指向新创建的对象
通过new创建的每个对象将最终被[Prototype]链接到这个函数的prototype对象上
如果函数没有返回对象类型Object(包含Functoin, Array, Date, RegExg, Error)，那么new表达式中的函数调用将返回该对象引用

 
// objectFactory(name, 'cxk', '18')
function objectFactory() {
  const obj = new Object();
  const Constructor = [].shift.call(arguments);
 
  obj.__proto__ = Constructor.prototype;
 
  const ret = Constructor.apply(obj, arguments);
 
  return typeof ret === "object" ? ret : obj;
}

实现prototype继承

所谓的原型链继承就是让新实例的原型等于父类的实例：

 
//父方法
function SupperFunction(flag1){
    this.flag1 = flag1;
}
 
//子方法
function SubFunction(flag2){
    this.flag2 = flag2;
}
 
//父实例
var superInstance = new SupperFunction(true);
 
//子继承父
SubFunction.prototype = superInstance;
 
//子实例
var subInstance = new SubFunction(false);
//子调用自己和父的属性
subInstance.flag1;   // true
subInstance.flag2;   // false

渲染几万条数据不卡住页面

渲染大数据时，合理使用createDocumentFragment和requestAnimationFrame，将操作切分为一小段一小段执行。

 
setTimeout(() => {
  // 插入十万条数据
  const total = 100000;
  // 一次插入的数据
  const once = 20;
  // 插入数据需要的次数
  const loopCount = Math.ceil(total / once);
  let countOfRender = 0;
  const ul = document.querySelector('ul');
  // 添加数据的方法
  function add() {
    const fragment = document.createDocumentFragment();
    for(let i = 0; i < once; i++) {
      const li = document.createElement('li');
      li.innerText = Math.floor(Math.random() * total);
      fragment.appendChild(li);
    }
    ul.appendChild(fragment);
    countOfRender += 1;
    loop();
  }
  function loop() {
    if(countOfRender < loopCount) {
      window.requestAnimationFrame(add);
    }
  }
  loop();
}, 0)

实现apply方法

apply原理与call很相似，不多赘述

 
// 模拟 apply
Function.prototype.myapply = function(context, arr) {
  var context = Object(context) || window;
  context.fn = this;
 
  var result;
  if (!arr) {
    result = context.fn();
  } else {
    var args = [];
    for (var i = 0, len = arr.length; i < len; i++) {
      args.push("arr[" + i + "]");
    }
    result = eval("context.fn(" + args + ")");
  }
 
  delete context.fn;
  return result;
};

	let url = 'http://www.domain.com/?user=anonymous&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';
	parseParam(url)
	/* 结果
	{ user: 'anonymous',
	id: [ 123, 456 ], // 重复出现的 key 要组装成数组，能被转成数字的就转成数字类型
	city: '北京', // 中文需解码
	enabled: true, // 未指定值得 key 约定为 true
	}
	*/
	function parseParam(url) {
	const paramsStr = /.+\?(.+)$/.exec(url)[1]; // 将 ? 后面的字符串取出来
	const paramsArr = paramsStr.split('&'); // 将字符串以 & 分割后存到数组中
	let paramsObj = {};
	// 将 params 存到对象中
	paramsArr.forEach(param => {
	if (/=/.test(param)) { // 处理有 value 的参数
	let [key, val] = param.split('='); // 分割 key 和 value
	val = decodeURIComponent(val); // 解码
	val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字

	if (paramsObj.hasOwnProperty(key)) { // 如果对象有 key，则添加一个值
	paramsObj[key] = [].concat(paramsObj[key], val);
	} else { // 如果对象没有这个 key，创建 key 并设置值
	paramsObj[key] = val;
	}
	} else { // 处理没有 value 的参数
	paramsObj[param] = true;
	}
	})

	return paramsObj;
	}

	/**
	* 关键点
	* 1. new promise 一经创建，立即执行
	* 2. 使用 Promise.resolve().then 可以把任务加到微任务队列，防止立即执行迭代方法
	* 3. 微任务处理过程中，产生的新的微任务，会在同一事件循环内，追加到微任务队列里
	* 4. 使用 race 在某个任务完成时，继续添加任务，保持任务按照最大并发数进行执行
	* 5. 任务完成后，需要从 doingTasks 中移出
	*/
	function limit(count, array, iterateFunc) {
	const tasks = []
	const doingTasks = []
	let i = 0
	const enqueue = () => {
	if (i === array.length) {
	return Promise.resolve()
	}
	const task = Promise.resolve().then(() => iterateFunc(array[i++]))
	tasks.push(task)
	const doing = task.then(() => doingTasks.splice(doingTasks.indexOf(doing), 1))
	doingTasks.push(doing)
	const res = doingTasks.length >= count ? Promise.race(doingTasks) : Promise.resolve()
	return res.then(enqueue)
	};
	return enqueue().then(() => Promise.all(tasks))
	}

	// test
	const timeout = i => new Promise(resolve => setTimeout(() => resolve(i), i))
	limit(2, [1000, 1000, 1000, 1000], timeout).then((res) => {
	console.log(res)
	})

	let url = 'http://www.domain.com/?user=anonymous&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';
	parseParam(url)
	/* 结果{ user: 'anonymous', id: [ 123, 456 ], // 重复出现的 key 要组装成数组，能被转成数字的就转成数字类型 city: '北京', // 中文需解码 enabled: true, // 未指定值得 key 约定为 true}*/
	function parseParam(url) {
	const paramsStr = /.+\?(.+)$/.exec(url)[1]; // 将 ? 后面的字符串取出来
	const paramsArr = paramsStr.split('&'); // 将字符串以 & 分割后存到数组中
	let paramsObj = {};
	// 将 params 存到对象中
	paramsArr.forEach(param => {
	if (/=/.test(param)) { // 处理有 value 的参数
	let [key, val] = param.split('='); // 分割 key 和 value
	val = decodeURIComponent(val); // 解码
	val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字
	if (paramsObj.hasOwnProperty(key)) { // 如果对象有 key，则添加一个值
	paramsObj[key] = [].concat(paramsObj[key], val);
	} else { // 如果对象没有这个 key，创建 key 并设置值
	paramsObj[key] = val;
	}
	} else { // 处理没有 value 的参数
	paramsObj[param] = true;
	}
	})
	return paramsObj;
	}

	Array.prototype.filter = function(callback, thisArg) {
	if (this == undefined) {
	throw new TypeError('this is null or not undefined');
	}
	if (typeof callback !== 'function') {
	throw new TypeError(callback + 'is not a function');
	}
	const res = [];
	// 让O成为回调函数的对象传递（强制转换对象）
	const O = Object(this);
	// >>>0 保证len为number，且为正整数
	const len = O.length >>> 0;
	for (let i = 0; i < len; i++) {
	// 检查i是否在O的属性（会检查原型链）
	if (i in O) {
	// 回调函数调用传参
	if (callback.call(thisArg, O[i], i, O)) {
	res.push(O[i]);
	}
	}
	}
	return res;
	}

	function objectFactory() {
	let newObject = null;
	let constructor = Array.prototype.shift.call(arguments);
	let result = null;
	// 判断参数是否是一个函数
	if (typeof constructor !== "function") {
	console.error("type error");
	return;
	}
	// 新建一个空对象，对象的原型为构造函数的 prototype 对象
	newObject = Object.create(constructor.prototype);
	// 将 this 指向新建对象，并执行函数
	result = constructor.apply(newObject, arguments);
	// 判断返回对象
	let flag = result && (typeof result === "object" \|\| typeof result === "function");
	// 判断返回结果
	return flag ? result : newObject;
	}
	// 使用方法
	objectFactory(构造函数, 初始化参数);

	// 模拟实现Promise
	// Promise利用三大手段解决回调地狱：
	// 1. 回调函数延迟绑定
	// 2. 返回值穿透
	// 3. 错误冒泡

	// 定义三种状态
	const PENDING = 'PENDING'; // 进行中
	const FULFILLED = 'FULFILLED'; // 已成功
	const REJECTED = 'REJECTED'; // 已失败

	class Promise {
	constructor(exector) {
	// 初始化状态
	this.status = PENDING;
	// 将成功、失败结果放在this上，便于then、catch访问
	this.value = undefined;
	this.reason = undefined;
	// 成功态回调函数队列
	this.onFulfilledCallbacks = [];
	// 失败态回调函数队列
	this.onRejectedCallbacks = [];

	const resolve = value => {
	// 只有进行中状态才能更改状态
	if (this.status === PENDING) {
	this.status = FULFILLED;
	this.value = value;
	// 成功态函数依次执行
	this.onFulfilledCallbacks.forEach(fn => fn(this.value));
	}
	}
	const reject = reason => {
	// 只有进行中状态才能更改状态
	if (this.status === PENDING) {
	this.status = REJECTED;
	this.reason = reason;
	// 失败态函数依次执行
	this.onRejectedCallbacks.forEach(fn => fn(this.reason))
	}
	}
	try {
	// 立即执行executor
	// 把内部的resolve和reject传入executor，用户可调用resolve和reject
	exector(resolve, reject);
	} catch(e) {
	// executor执行出错，将错误内容reject抛出去
	reject(e);
	}
	}
	then(onFulfilled, onRejected) {
	onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
	onRejected = typeof onRejected === 'function'? onRejected :
	reason => { throw new Error(reason instanceof Error ? reason.message : reason) }
	// 保存this
	const self = this;
	return new Promise((resolve, reject) => {
	if (self.status === PENDING) {
	self.onFulfilledCallbacks.push(() => {
	// try捕获错误
	try {
	// 模拟微任务
	setTimeout(() => {
	const result = onFulfilled(self.value);
	// 分两种情况：
	// 1. 回调函数返回值是Promise，执行then操作
	// 2. 如果不是Promise，调用新Promise的resolve函数
	result instanceof Promise ? result.then(resolve, reject) : resolve(result);
	})
	} catch(e) {
	reject(e);
	}
	});
	self.onRejectedCallbacks.push(() => {
	// 以下同理
	try {
	setTimeout(() => {
	const result = onRejected(self.reason);
	// 不同点：此时是reject
	result instanceof Promise ? result.then(resolve, reject) : resolve(result);
	})
	} catch(e) {
	reject(e);
	}
	})
	} else if (self.status === FULFILLED) {
	try {
	setTimeout(() => {
	const result = onFulfilled(self.value);
	result instanceof Promise ? result.then(resolve, reject) : resolve(result);
	});
	} catch(e) {
	reject(e);
	}
	} else if (self.status === REJECTED) {
	try {
	setTimeout(() => {
	const result = onRejected(self.reason);
	result instanceof Promise ? result.then(resolve, reject) : resolve(result);
	})
	} catch(e) {
	reject(e);
	}
	}
	});
	}
	catch(onRejected) {
	return this.then(null, onRejected);
	}
	static resolve(value) {
	if (value instanceof Promise) {
	// 如果是Promise实例，直接返回
	return value;
	} else {
	// 如果不是Promise实例，返回一个新的Promise对象，状态为FULFILLED
	return new Promise((resolve, reject) => resolve(value));
	}
	}
	static reject(reason) {
	return new Promise((resolve, reject) => {
	reject(reason);
	})
	}
	static all(promiseArr) {
	const len = promiseArr.length;
	const values = new Array(len);
	// 记录已经成功执行的promise个数
	let count = 0;
	return new Promise((resolve, reject) => {
	for (let i = 0; i < len; i++) {
	// Promise.resolve()处理，确保每一个都是promise实例
	Promise.resolve(promiseArr[i]).then(
	val => {
	values[i] = val;
	count++;
	// 如果全部执行完，返回promise的状态就可以改变了
	if (count === len) resolve(values);
	},
	err => reject(err),
	);
	}
	})
	}
	static race(promiseArr) {
	return new Promise((resolve, reject) => {
	promiseArr.forEach(p => {
	Promise.resolve(p).then(
	val => resolve(val),
	err => reject(err),
	)
	})
	})
	}
	}

	// func是用户传入需要防抖的函数
	// wait是等待时间
	const debounce = (func, wait = 50) => {
	// 缓存一个定时器id
	let timer = 0
	// 这里返回的函数是每次用户实际调用的防抖函数
	// 如果已经设定过定时器了就清空上一次的定时器
	// 开始一个新的定时器，延迟执行用户传入的方法
	return function(...args) {
	if (timer) clearTimeout(timer)
	timer = setTimeout(() => {
	func.apply(this, args)
	}, wait)
	}
	}

	class EventCenter{
	// 1. 定义事件容器，用来装事件数组
	let handlers = {}

	// 2. 添加事件方法，参数：事件名事件方法
	addEventListener(type, handler) {
	// 创建新数组容器
	if (!this.handlers[type]) {
	this.handlers[type] = []
	}
	// 存入事件
	this.handlers[type].push(handler)
	}

	// 3. 触发事件，参数：事件名事件参数
	dispatchEvent(type, params) {
	// 若没有注册该事件则抛出错误
	if (!this.handlers[type]) {
	return new Error('该事件未注册')
	}
	// 触发事件
	this.handlers[type].forEach(handler => {
	handler(...params)
	})
	}

	// 4. 事件移除，参数：事件名要删除事件，若无第二个参数则删除该事件的订阅和发布
	removeEventListener(type, handler) {
	if (!this.handlers[type]) {
	return new Error('事件无效')
	}
	if (!handler) {
	// 移除事件
	delete this.handlers[type]
	} else {
	const index = this.handlers[type].findIndex(el => el === handler)
	if (index === -1) {
	return new Error('无该绑定事件')
	}
	// 移除事件
	this.handlers[type].splice(index, 1)
	if (this.handlers[type].length === 0) {
	delete this.handlers[type]
	}
	}
	}
	}

	Object.defineProperty(Object, 'assign', {
	value: function(target, ...args) {
	if (target == null) {
	return new TypeError('Cannot convert undefined or null to object');
	}

	// 目标对象需要统一是引用数据类型，若不是会自动转换
	const to = Object(target);

	for (let i = 0; i < args.length; i++) {
	// 每一个源对象
	const nextSource = args[i];
	if (nextSource !== null) {
	// 使用for...in和hasOwnProperty双重判断，确保只拿到本身的属性、方法（不包含继承的）
	for (const nextKey in nextSource) {
	if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
	to[nextKey] = nextSource[nextKey];
	}
	}
	}
	}
	return to;
	},
	// 不可枚举
	enumerable: false,
	writable: true,
	configurable: true,
	})

	const arr = [1, [2, [3, [4, 5]]], 6];
	// => [1, 2, 3, 4, 5, 6]

	const flatten = arr => {
	return arr.reduce((pre, cur) => {
	return pre.concat(Array.isArray(cur) ? flatten(cur) : cur);
	}, [])
	}
	const res4 = flatten(arr);

	const res5 = [];
	const fn = arr => {
	for (let i = 0; i < arr.length; i++) {
	if (Array.isArray(arr[i])) {
	fn(arr[i]);
	} else {
	res5.push(arr[i]);
	}
	}
	}
	fn(arr);

	const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];

	Array.from(new Set(array)); // [1, 2, 3, 5, 9, 8]

	const array = [1, 2, 3, 5, 1, 5, 9, 1, 2, 8];

	uniqueArray(array); // [1, 2, 3, 5, 9, 8]

	function uniqueArray(array) {
	let map = {};
	let res = [];
	for(var i = 0; i < array.length; i++) {
	if(!map.hasOwnProperty([array[i]])) {
	map[array[i]] = 1;
	res.push(array[i]);
	}
	}
	return res;
	}

	let obj = {}
	let input = document.getElementById('input')
	let span = document.getElementById('span')
	// 数据劫持
	Object.defineProperty(obj, 'text', {
	configurable: true,
	enumerable: true,
	get() {
	console.log('获取数据了')
	},
	set(newVal) {
	console.log('数据更新了')
	input.value = newVal
	span.innerHTML = newVal
	}
	})
	// 输入监听
	input.addEventListener('keyup', function(e) {
	obj.text = e.target.value
	})

	const cloneDeep1 = (target, hash = new WeakMap()) => {
	// 对于传入参数处理
	if (typeof target !== 'object' \|\| target === null) {
	return target;
	}
	// 哈希表中存在直接返回
	if (hash.has(target)) return hash.get(target);

	const cloneTarget = Array.isArray(target) ? [] : {};
	hash.set(target, cloneTarget);

	// 针对Symbol属性
	const symKeys = Object.getOwnPropertySymbols(target);
	if (symKeys.length) {
	symKeys.forEach(symKey => {
	if (typeof target[symKey] === 'object' && target[symKey] !== null) {
	cloneTarget[symKey] = cloneDeep1(target[symKey]);
	} else {
	cloneTarget[symKey] = target[symKey];
	}
	})
	}

	for (const i in target) {
	if (Object.prototype.hasOwnProperty.call(target, i)) {
	cloneTarget[i] =
	typeof target[i] === 'object' && target[i] !== null
	? cloneDeep1(target[i], hash)
	: target[i];
	}
	}
	return cloneTarget;
	}

	// hash路由
	class Route{
	constructor(){
	// 路由存储对象
	this.routes = {}
	// 当前hash
	this.currentHash = ''
	// 绑定this，避免监听时this指向改变
	this.freshRoute = this.freshRoute.bind(this)
	// 监听
	window.addEventListener('load', this.freshRoute, false)
	window.addEventListener('hashchange', this.freshRoute, false)
	}
	// 存储
	storeRoute (path, cb) {
	this.routes[path] = cb \|\| function () {}
	}
	// 更新
	freshRoute () {
	this.currentHash = location.hash.slice(1) \|\| '/'
	this.routes[this.currentHash]()
	}
	}

	// 保留三位小数
	parseToMoney(1234.56); // return '1,234.56'
	parseToMoney(123456789); // return '123,456,789'
	parseToMoney(1087654.321); // return '1,087,654.321'
	function parseToMoney(num) {
	num = parseFloat(num.toFixed(3));
	let [integer, decimal] = String.prototype.split.call(num, '.');
	integer = integer.replace(/\d(?=(\d{3})+$)/g, '$&,');
	return integer + '.' + (decimal ? decimal : '');
	}

	function parseToMoney(str){
	// 仅仅对位置进行匹配
	let re = /(?=(?!\b)(\d{3})+$)/g;
	return str.replace(re,',');
	}

	function lazyload() {
	const imgs = document.getElementsByTagName('img');
	const len = imgs.length;
	// 视口的高度
	const viewHeight = document.documentElement.clientHeight;
	// 滚动条高度
	const scrollHeight = document.documentElement.scrollTop \|\| document.body.scrollTop;
	for (let i = 0; i < len; i++) {
	const offsetHeight = imgs[i].offsetTop;
	if (offsetHeight < viewHeight + scrollHeight) {
	const src = imgs[i].dataset.src;
	imgs[i].src = src;
	}
	}
	}

	// 可以使用节流优化一下
	window.addEventListener('scroll', lazyload);

	// objectFactory(name, 'cxk', '18')
	function objectFactory() {
	const obj = new Object();
	const Constructor = [].shift.call(arguments);

	obj.__proto__ = Constructor.prototype;

	const ret = Constructor.apply(obj, arguments);

	return typeof ret === "object" ? ret : obj;
	}

	//父方法
	function SupperFunction(flag1){
	this.flag1 = flag1;
	}

	//子方法
	function SubFunction(flag2){
	this.flag2 = flag2;
	}

	//父实例
	var superInstance = new SupperFunction(true);

	//子继承父
	SubFunction.prototype = superInstance;

	//子实例
	var subInstance = new SubFunction(false);
	//子调用自己和父的属性
	subInstance.flag1; // true
	subInstance.flag2; // false

	setTimeout(() => {
	// 插入十万条数据
	const total = 100000;
	// 一次插入的数据
	const once = 20;
	// 插入数据需要的次数
	const loopCount = Math.ceil(total / once);
	let countOfRender = 0;
	const ul = document.querySelector('ul');
	// 添加数据的方法
	function add() {
	const fragment = document.createDocumentFragment();
	for(let i = 0; i < once; i++) {
	const li = document.createElement('li');
	li.innerText = Math.floor(Math.random() * total);
	fragment.appendChild(li);
	}
	ul.appendChild(fragment);
	countOfRender += 1;
	loop();
	}
	function loop() {
	if(countOfRender < loopCount) {
	window.requestAnimationFrame(add);
	}
	}
	loop();
	}, 0)

	// 模拟 apply
	Function.prototype.myapply = function(context, arr) {
	var context = Object(context) \|\| window;
	context.fn = this;

	var result;
	if (!arr) {
	result = context.fn();
	} else {
	var args = [];
	for (var i = 0, len = arr.length; i < len; i++) {
	args.push("arr[" + i + "]");
	}
	result = eval("context.fn(" + args + ")");
	}

	delete context.fn;
	return result;
	};