util.js

  1. /* eslint-disable no-unused-vars */
  2. /**
  3.  * 通用函数。
  4.  * @module common
  5.  */
  7. /**
  8.  * @static
  9.  * @description 函数柯里化。
  10.  * @example
  11.  * function add(a, b) {
  12.  *  return a + b
  13.  * }
  14.  * var curriedAdd = curry(add)
  15.  * var addFive = curriedAdd(5)
  16.  * var result = [0, 1, 2, 3, 4, 5].map(addFive)
  17.  * // [5, 6, 7, 8, 9, 10]
  18.  * @param {function} fn 需要柯里化的函数，函数“无默认值的参数”个数不为0。
  19.  * @return {function} 柯里化后的函数。
  20.  */
  22. function curry (fn) {
  23.     // fn的无默认值参数的个数
  24.     if (fn.length === 0) {
  25.         return fn
  26.     }
  28.     function _curried (depth, args) {
  29.         return function (newArgument) {
  30.             // 需要传入fn需要的参数个数，才会返回值
  31.             if (depth - 1 === 0) {
  32.                 return fn(...args, newArgument)
  33.             }
  34.             return _curried(depth - 1, [...args, newArgument])
  35.         }
  36.     }
  38.     return _curried(fn.length, [])
  39. }
  41. /**
  42.  * @static
  43.  * @description 最大重复数数量
  44.  * @example
  45.  * countMaxDuplicateNumber([1,2,2,5,5,5])
  46.  * // 3
  47.  * @param {Array<Number>} array 数字数组
  48.  * @return {Number} 数量
  49.  */
  51. function countMaxDuplicateNumber (array) {
  52.     if (!array.length) {
  53.         return 0
  54.     }
  55.     const sortedAry = array.sort((a, b) => {
  56.         return a - b
  57.     })
  58.     let count = 1
  59.     let max = 1
  61.     for (let i = 1; i < sortedAry.length; i++) {
  62.         if (sortedAry[i - 1] === sortedAry[i]) {
  63.             max++
  64.         } else {
  65.             if (max > count) {
  66.                 count = max
  67.             }
  68.             max = 1
  69.         }
  70.     }
  71.     return count
  72. }
  74. /**
  75.  * @static
  76.  * @description requestAnimationFrame 节流函数。
  77.  * @param {Function} fn 数字数组。
  78.  * @return {Function} 节流函数。
  79.  */
  81. function throttle (fn) {
  82.     let curTick = false
  83.     const that = this
  84.     const params = [...arguments]
  86.     params.shift()
  87.     return function () {
  88.         const curParams = [...arguments]
  90.         if (!curTick) {
  91.             curTick = true
  92.             requestAnimationFrame(() => {
  93.                 fn.apply(that, [...curParams, params])
  94.                 curTick = false
  95.             })
  96.         }
  97.     }
  98. }
  100. /**
  101.  * @static
  102.  * @description 依次按序执行 promise，全部调用完毕后返回一个新的 promise。
  103.  * @example
  104.  * function getA() {
  105.  *     return new Promise((resolve, reject) => {
  106.  *         get('/user/a', (status, res) => {
  107.  *             if (status == 200) {
  108.  *                 resolve(res)
  109.  *             } else {
  110.  *                 reject('error')
  111.  *             }
  112.  *         })
  113.  *     })
  114.  * }
  115.  *
  116.  * function getB(dataA) {
  117.  *     return new Promise((resolve, reject) => {
  118.  *         get('/user/b', dataA, (status, res) => {
  119.  *             if (status == 200) {
  120.  *                 resolve(res)
  121.  *             } else {
  122.  *                 reject('error')
  123.  *             }
  124.  *         })
  125.  *
  126.  *     })
  127.  * }
  128.  *
  129.  * function getC(dataB) {
  130.  *     return new Promise((resolve, reject) => {
  131.  *         get('/user/c', dataB, (status, res) => {
  132.  *             if (status == 200) {
  133.  *                 resolve(res)
  134.  *             } else {
  135.  *                 reject('error')
  136.  *             }
  137.  *         })
  138.  *
  139.  *     })
  140.  * }
  141.  *
  142.  * promiseOrder([getA,getB,getC]).then((res)=>{
  143.  *     console.log('success');
  144.  *     console.log(res);
  145.  * })
  146.  * @param {Arry} pFAry 数组，元素是函数，函数返回 promise 对象。
  147.  * 函数接收上一次 promise resolve 的参数。
  148.  * @returns {Promise} 新的 fulfilled 状态 promise 对象。
  149.  * 传递最后一次 promise resolve 的参数。
  150.  */
  152. function promiseOrder (pFAry) {
  153.     return new Promise((resolve, reject) => {
  154.         let promise = Promise.resolve()
  156.         // 由于要最后一个promise执行完毕，才resolve，这里需要pFAry.length + 1
  157.         for (let i = 0; i < pFAry.length + 1; i++) {
  158.             promise = promise
  159.                 .then((res) => {
  160.                     if (i === pFAry.length) {
  161.                         resolve(res)
  162.                     } else {
  163.                         return pFAry[i](res)
  164.                     }
  165.                 })
  166.                 .catch((error) => {
  167.                     reject(error)
  168.                     // 捕获错误后由于下一次循环依然会添加then，需要返回一个pending状态的promise来中断后面的所有操作
  169.                     return new Promise(() => {})
  170.                 })
  171.         }
  172.     })
  173. }
  175. export {
  176.     curry,
  177.     throttle,
  178.     countMaxDuplicateNumber,
  179.     promiseOrder
  180. }