因为懒所以俺不用 lodash lodash 直通车 ✈️

常用

关于本地缓存

已有的缓存库 store.js

下载 npm i -S store

import store from 'store'
/**
 * 获取 store
 * @param {String} key 需要缓存的key 
 * @returns 
 */
export const getStore = (key) => store.get(key);

/**
 * 设置 store
 * @param {String} key 需要设置缓存的 key
 * @param {*} value 需要设置缓存的 value
 * @returns 
 */
export const setStore = (key, value) => store.set(key, value);

睡眠函数

/**
 * 睡眠函数
 * @param {Number} time 默认 1500 毫秒
 * @returns 
 */
export const sleep = (time = 1500) => new Promise(resolve => setTimeout(resolve, time))

关于时间操作

已有的相关库 date.js

俺们旮旯用最多的

/**
 * 日期时间
 * @param {Date} 日期对象
 * @param {String} 格式
 */
export const timeFmt = (date, fmt = 'yyyy/MM/dd') => {
    var o = {
        "M+": date.getMonth() + 1,
        "d+": date.getDate(),
        "h+": date.getHours(),
        "m+": date.getMinutes(),
        "s+": date.getSeconds(),
        "q+": Math.floor((date.getMonth() + 3) / 3),
        "S": date.getMilliseconds()
    };
    if (/(y+)/.test(fmt)) {
        fmt = fmt.replace(RegExp.$1, (date.getFullYear() + "").substr(4 - RegExp.$1.length));
    }
    for (var k in o) {
        if (new RegExp("(" + k + ")").test(fmt)) {
            fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
        }
    }
    return fmt;
}

倒计时

/**
 * 倒计时
 * @param {Date} endTime 目标时间戳
 * @param {String} fmt 格式 
 * @param {String} prevText 前置文案
 * @param {String} lastText 后置文案
 */
const countDown = (endTime, fmt = 'dd天hh时mm分ss秒', prevText = "", lastText = "") => {
    var diffTime = parseInt((endTime.getTime() - (new Date()).getTime()) / 1000);
    var day = ~~(diffTime / (60 * 60 * 24)),
        hour = ~~((diffTime - day * 24 * 60 * 60) / 3600),
        minute = ~~((diffTime - day * 24 * 60 * 60 - hour * 3600) / 60),
        second = ~~((diffTime - day * 24 * 60 * 60 - hour * 3600 - minute * 60));
    var o = {
        "d+": day,
        "h+": hour,
        "m+": minute,
        "s+": second
    };
    for (var k in o) {
        if (new RegExp("(" + k + ")").test(fmt)) {
            fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)))
        }
    }
    return (prevText + fmt + lastText);
}

关于数组|对象操作

去重

/**
 * 唯一值｜关于数组
 * @param {*} array 源数据
 * @param {*} keyName 判断key
 * @returns 
 */
export const uniqueWithArrayObject = function (array, keyName) {
  let targetKeys = {};
  return array.reduce((totalA, curr) => {
    if (!targetKeys[curr[keyName]]) {
      totalA.push(curr)
      targetKeys[curr[keyName]] = true
    }
    return totalA;
  }, [])
}

 /**
 * 对象扁平化处理 {a:{x:1,z:2},c:3} => {x:1,z:2,c:3}
 * @param {Object} source 
 * @returns 
 */
export const flattenWithObject = function (source) {
  let result = {};

  function recurse(obj, prop) {
    let toString = Object.prototype.toString;
    if (toString.call(obj) == '[object Object]') {
      let isEmpty = true;
      for (let p in obj) {
        isEmpty = false;
        // recurse(obj[p], prop ? `${prop }.${p}` : p)
        recurse(obj[p], prop ? `${p}` : p)
      }
      if (isEmpty && prop) {
        result[prop] = {};
      }
    } else {
      result[prop] = obj;
    }
  }
  recurse(source, '');
  return result;
}

乱序

/**
 * 数组乱序
 * @param {Array} 源数组
 */
export const arrDisorder = (arr) => {
    let t, j, i = arr.length;
    for (; i;) {
        j = ~~(Math.random() * i);
        t = arr[--i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    return arr
}

拷贝

/**
 * 深度拷贝
 * @param {Object} 源对象
 */
export const cloneJSON = source => JSON.parse(JSON.stringify(source));

export const deepClone = (obj, hash = new WeakMap()) => {
    if (!isObject(obj)) return obj;
    if (hash.has(obj)) return hash.get(obj);
    let isArray = Array.isArray(obj);
    let cloneObj = isArray ? [] : {};
    hash.set(obj, cloneObj);
    let allDesc = Object.getOwnPropertyDescriptors(obj);
    let symKeys = Object.getOwnPropertySymbols(obj);
    if (symKeys.length > 0) {
        symKeys.forEach(symKey => {
            cloneObj[symKey] = isObject(obj[symKey]) ? deepClone(obj[symKey], hash) : obj[symKey];
        })
    }
    cloneObj = Object.create(
        Object.getPrototypeOf(cloneObj),
        allDesc
    )
    for (let key in obj) {
        cloneObj[key] = isObject(obj[key]) ? deepClone(obj[key], hash) : obj[key];
    }
    return cloneObj;
}
//  判断一个值是不是对象
function isObject(o) {
    return (typeof o === 'object' || typeof o === 'function') && o !== null;
}

关于字符串操作

截取（替换）字符串

/**
 * 截取指定字节的字符串
 * @param str 要截取的字符穿
 * @param len 要截取的长度，根据字节计算
 * @param suffix 截取前len个后，其余的字符的替换字符，一般用“…”
 */
export const cutString = (str, len, suffix = "") => {
    if (!str || len <= 0) return "";
    let tempLen = 0;
    for (let i = 0, length = str.length; i < length; i++) {
        if (str.charCodeAt(i) > 255) {
            tempLen += 2;
        } else {
            tempLen++;
        }
        if (tempLen == len) {
            return str.substring(0, i + 1) + suffix;
        } else if (tempLen > len) {
            return str.substring(0, i) + suffix;
        }
    }
    return str;
}

生成随机字符串

export const randomStr = (len = 8, str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') => {
    let strLen = str.length,
        tempStr = '';
    for (let i = 0; i < len; i++) {
        tempStr += str.charAt(randomInt(0, strLen));
    }
    return tempStr;
}

// 生成范围内随机整数
export function randomInt(min, max) {
    return ~~(Math.random() * (max - min + 1) + min);
}

关于判断操作

空值判断

/**
 * 判断值是否为空
 * @param {*} value 
 */
export const isEmpty = value => {
    return (
        value === undefined ||
        value === null ||
        (typeof value === "object" && Object.keys(value).length === 0) ||
        (typeof value === "string" && value.trim().length === 0)
    );
}

关于结语

有大神写的，也有参考大神后重新写的，随便看看就好，别太当真。