项目中常用方法总结

常用时间方法

// 将时间格式转为时间戳
    formatTime(time) {
      return new Date(time).getTime();
    },
    // 将时间戳转为年月日
    formatYear(time) {
      const date = new Date(time);
      const year = date.getFullYear();
      const month = date.getMonth() + 1;
      const day = date.getDate();
      return `${year}-${month}-${day}`;
    },
    // 将时间戳转为年月日时分秒
    formatDateTime(time) {
      const date = new Date(time);
      const year = date.getFullYear();
      const month = date.getMonth() + 1;
      const day = date.getDate();
      const hour = date.getHours();
      const minute = date.getMinutes();
      const second = date.getSeconds();
      return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
    }

常用数组方法

// 判断是否是数组且不为空
    isNotEmptyArray(arr) {
      return Array.isArray(arr) && arr.length > 0;
    },
    isArray(arr) {
      return Array.isArray(arr);
    },
    // 数组深拷贝
    deepCopy(arr) {
      return JSON.parse(JSON.stringify(arr));
    },
    // 数组中删除指定下标的元素
    remove(arr, index) {
      return arr.splice(index, 1);
    },
    // 数组中截取指定位置开始下标和结束下标的元素且不影响原数组
    slice(arr, start, end) {
      return arr.slice(start, end);
    },
    // 数组去重
    unique(arr) {
      return Array.from(new Set(arr));
    },
    // 数组求和
    sum(arr) {
      return arr.reduce((prev, next) => prev + next);
    },
    // 数组中对象的某一属性求和
    sumBy(arr, key) {
      return arr.reduce((prev, next) => prev + next[key], 0);
    },
    // 数组求平均值
    average(arr) {
      return this.sum(arr) / arr.length;
    },
    // 数组最大值
    max(arr) {
      return Math.max(...arr);
    },
    // 数组最小值
    min(arr) {
      return Math.min(...arr);
    },
    // 数组排序
    sort(arr) {
      return arr.sort((a, b) => a - b);
    },
    // 数组乱序
    shuffle(arr) {
      return arr.sort(() => Math.random() - 0.5);
    },
    // 数组分组
    group(arr, size) {
      const result = [];
      for (let i = 0; i < arr.length; i += size) {
        result.push(arr.slice(i, i + size));
      }
      return result;
    },
    // 数组扁平化
    // 数组扁平化的意思就是将一个嵌套多层的数组 array (嵌套可以是任何层数)转换为只有一层的数组。
    flatten(arr) {
      return arr.reduce((prev, next) => prev.concat(Array.isArray(next) ? this.flatten(next) : next), []);
    },
    // 数组差集
    difference(arr1, arr2) {
      return arr1.filter(v => !arr2.includes(v));
    },
    // 数组交集
    intersection(arr1, arr2) {
      return arr1.filter(v => arr2.includes(v));
    },
    // 数组并集
    union(arr1, arr2) {
      return [...new Set([...arr1, ...arr2])];
    },
    // 数组对象去重
    uniqueObject(arr, key) {
      return [...new Map(arr.map(item => [item[key], item])).values()];
    },
    // 数组对象排序
    sortObject(arr, key) {
      return arr.sort((a, b) => a[key] - b[key]);
    },
    // 数组对象求和
    sumObject(arr, key) {
      return arr.reduce((prev, next) => prev + next[key], 0);
    },
    // 数组对象求平均值
    averageObject(arr, key) {
      return this.sumObject(arr, key) / arr.length;
    },
    // 数组对象最大值
    maxObject(arr, key) {
      return Math.max(...arr.map(item => item[key]));
    },
    // 数组对象最小值
    minObject(arr, key) {
      return Math.min(...arr.map(item => item[key]));
    },
    // 数组对象分组
    groupObject(arr, key) {
      return arr.reduce((prev, next) => {
        (prev[next[key]] ? prev[next[key]] : prev[next[key]] = []).push(next);
        return prev;
      }, {});
    },
    // 数组对象扁平化
    flattenObject(arr, key) {
      return arr.reduce((prev, next) => prev.concat(next[key]), []);
    },
    // 数组对象差集
    differenceObject(arr1, arr2, key) {
      return arr1.filter(v => !arr2.some(item => item[key] === v[key]));
    },
    // 数组对象交集
    intersectionObject(arr1, arr2, key) {
      return arr1.filter(v => arr2.some(item => item[key] === v[key]));
    },
    // 数组对象并集
    unionObject(arr1, arr2, key) {
      return [...new Set([...arr1, ...arr2])];
    }

常用对象方法

// 判断是否是对象且不为空
    isNotEmptyObject(obj) {
      return Object.prototype.toString.call(obj) === '[object Object]' && Object.keys(obj).length > 0;
    },
    // 对象深拷贝
    deepClone(obj) {
      return JSON.parse(JSON.stringify(obj));
    },
    // 判断是否是对象
    isObject(obj) {
      return Object.prototype.toString.call(obj) === '[object Object]';
    },
    // 对象转数组
    objectToArray(obj) {
      return Object.keys(obj).map(key => obj[key]);
    },
    // 对象key排序
    objectKeySort(obj) {
      return Object.keys(obj).sort().reduce((prev, next) => {
        prev[next] = obj[next];
        return prev;
      }, {});
    },
    // 对象转查询字符串
    objectToQueryString(obj) {
      return Object.keys(obj).map(key => `${key}=${obj[key]}`).join('&');
    },
    // 对象深拷贝
    deepClone(obj) {
      return JSON.parse(JSON.stringify(obj));
    },
    // 对象合并
    mergeObject(obj1, obj2) {
      return Object.assign(obj1, obj2);
    },
    // 对象深合并
    deepMergeObject(obj1, obj2) {
      for (const key in obj2) {
        obj1[key] = obj1.hasOwnProperty(key) && obj1[key].toString() === '[object Object]' ? this.deepMergeObject(obj1[key], obj2[key]) : obj1[key] = obj2[key];
      }
      return obj1;
    },
    // 对象深比较 两个对象是否相等
    deepCompareObject(obj1, obj2) {
      if (obj1 === obj2) return true;
      if (obj1.length !== obj2.length) return false;
      for (const key in obj1) {
        if (!obj2.hasOwnProperty(key)) return false;
        if (obj1[key] !== obj2[key]) return false;
      }
      return true;
    },
    // 对象深查找 指定key的值
    deepFindObject(obj, key) {
      for (const k in obj) {
        if (k === key) return obj[k];
        if (obj[k] && typeof obj[k] === 'object') {
          const result = this.deepFindObject(obj[k], key);
          if (result) return result;
        }
      }
    },
    // 对象深查找并删除
    deepFindAndDeleteObject(obj, key) {
      for (const k in obj) {
        if (k === key) {
          delete obj[k];
          return true;
        }
        if (obj[k] && typeof obj[k] === 'object') {
          const result = this.deepFindAndDeleteObject(obj[k], key);
          if (result) return true;
        }
      }
    },
    // 对象深查找并修改
    deepFindAndModifyObject(obj, key, value) {
      for (const k in obj) {
        if (k === key) {
          obj[k] = value;
          return true;
        }
        if (obj[k] && typeof obj[k] === 'object') {
          const result = this.deepFindAndModifyObject(obj[k], key, value);
          if (result) return true;
        }
      }
    },
    // 对象深查找并添加
    deepFindAndAddObject(obj, key, value) {
      for (const k in obj) {
        if (k === key) {
          obj[k] = value;
          return true;
        }
        if (obj[k] && typeof obj[k] === 'object') {
          const result = this.deepFindAndAddObject(obj[k], key, value);
          if (result) return true;
        }
      }
    },
    // 对象深查找并替换
    deepFindAndReplaceObject(obj, key, value) {
      for (const k in obj) {
        if (k === key) {
          obj[k] = value;
          return true;
        }
        if (obj[k] && typeof obj[k] === 'object') {
          const result = this.deepFindAndReplaceObject(obj[k], key, value);
          if (result) return true;
        }
      }
    }

常用字符串方法

// 字符串转数组
    stringToArray(str) {
      return str.split('');
    },
    // 字符串转对象
    stringToObject(str) {
      return JSON.parse(str);
    },
    // 字符串转查询字符串
    stringToQueryString(str) {
      return str.replace(/&/g, '%26').replace(/=/g, '%3D');
    },
    // 字符串转驼峰
    stringToHump(str) {
      return str.replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
    },
    // 字符串转下划线
    stringToLine(str) {
      return str.replace(/([A-Z])/g, '-$1').toLowerCase();
    },
    // 字符串转大写
    stringToUpperCase(str) {
      return str.toUpperCase();
    },
    // 字符串转小写
    stringToLowerCase(str) {
      return str.toLowerCase();
    },
    // 字符串转首字母大写
    stringToFirstUpperCase(str) {
      return str.replace(/( |^)[a-z]/g, L => L.toUpperCase());
    },
    // 字符串转首字母小写
    stringToFirstLowerCase(str) {
      return str.replace(/( |^)[A-Z]/g, L => L.toLowerCase());
    }

常用文件流处理方法

    // 接口返回blob文件流 前端下载  下载和导出是一样的
    downloadFile(res, fileName) {
      const blob = new Blob([res]);
      if ('download' in document.createElement('a')) {
        const elink = document.createElement('a');
        elink.download = fileName;
        elink.style.display = 'none';
        elink.href = URL.createObjectURL(blob);
        document.body.appendChild(elink);
        elink.click();
        URL.revokeObjectURL(elink.href);
        document.body.removeChild(elink);
      } else {
        navigator.msSaveBlob(blob, fileName);
      }
    }