方法收录

实用方法收录

wujiawen 发布于

阅读量

实用方法收录

  • （一）深拷贝 JSON.parse()实现

    1
    2
    3
    4
    5
    6
    7
    /**
     * 深拷贝 JSON.parse()实现
     * @param {Object} obj 被拷贝的对象
     */
    export function deepClone(obj) {
      return JSON.parse(JSON.stringify(obj))
    }

  • （二）从对象中挑选需要的部分属性

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * 从对象中挑选需要的部分属性
     * @param {Object} obj 被挑选的对象
     * @param {Array} arr 需要的属性列表
     */
    export function pick(obj, arr) {
      return arr.reduce((pre, cur) => {
        cur in obj && (pre[cur] = obj[cur])
        return pre
      }, {})
    }

  • （三）模糊搜索

    1
    2
    3
    4
    5
    6
    7
    8
    /**
     * 模糊搜索
     * @param {String} queryStr 输入的搜索关键字
     * @param {Array} sourceArr 数据源
     */
    export function like(queryStr, sourceArr) {
      return queryStr ? sourceArr.filter(item => item.toLowerCase().includes(queryStr.toLowerCase())) : sourceArr
    }

  • （四）数组去重 基本数据类型数组

    1
    2
    3
    4
    5
    6
    7
    /**
     * 数组去重 基本数据类型数组
     * @param {Array} arr 
     */
    export function baseUniq(arr) {
      return Array.from(new Set(arr))
    }

  • （五）数组去重 filter结合indexof实现去重

    1
    2
    3
    4
    5
    6
    7
    /**
     * 数组去重 filter结合indexof实现去重
     * @param {Array} arr
     */
    export function noRepeat(arr) {
      return arr.filter((item, index, self) => self.indexOf(item) === index)
    }

  • （六）数组去重 reduce

    1
    2
    3
    4
    5
    6
    7
    8
    9
    /**
     * 数组去重 reduce
     * @param {Array} arr 
     */
    export function Uniq(arr) {
      return arr.redude((pre, cur) => {
        return pre.includes(cur) ? pre : [...pre, cur]
      }, [])
    }

  • （七）数组分割 将一维数组分割成二维数组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * 数组分割 将一维数组分割成二维数组
     * @param {Array} arr 
     * @param {Number} size 
     */
    export function Chunk(arr, size = 1) {
      return arr.length ? arr.reduce((pre, cur) => {
        pre[pre.length - 1].length === size ? pre.push([cur]) : pre[pre.length - 1].push(cur)
        return pre
      }, [[]]) : []
    }

  • （八）数组降维 (任意维度)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    /**
     * 数组降维 (任意维度)
     * @param {Array} arr 
     */
    export function Flat(arr = []) {
      return arr.reduce((pre, cur) => {
        return pre.concat(Array.isArray(cur) ? Flat(cur) : cur)
      }, [])
    }

  • （九）数组过滤

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * 数组过滤
     * @param {Array} target 
     * @param {Array} unNeedAttributes 
     */
    export function Difference(target, unNeedAttributes) {
      return target.reduce((pre, cur) => {
        !unNeedAttributes.includes(cur) && pre.push(cur)
        return pre
      }, [])
    }

  • （十）数组成员特性分组 按某个key值 如: 按地区分组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    /**
     * 数组成员特性分组 按某个key值 如: 按地区分组
     * @param {Array} arr 
     * @param {String} key 
     */
    export function Group(arr, key) {
      return key ? arr.reduce((pre, cur) => {
        !pre[cur[key]] && (pre[cur[key]] = [])
        pre[cur[key]].push(cur)
        return pre
      }, {}) : {}
    }

  • （十一）字符串翻转

    1
    2
    3
    4
    5
    6
    7
    /**
     * 字符串翻转
     * @param {String} str
     */
    export function ReverseStr(str = '') {
      return str.split('').reduceRight((pre, cur) => pre + cur)
    }

  • （十二）斐波那契数列 从第3个数开始 每个数都是前2个的和

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    /**
     * 斐波那契数列 从第3个数开始 每个数都是前2个的和
     * @param {Number} first 
     * @param {Number} second 
     * @param {Number} len 
     */
    export function Fibonacci(first = 0, second = 1, len = 2) {
      const arr = [...new Array(len).keys()]
      return arr.reduce((pre, cur) => {
        cur > 1 && pre.push(pre[cur - 1] + pre[cur - 2])
      }, [first, second])
    }