常用 utils

已于 2023-08-15 11:29:27 修改
阅读量1k 收藏 1
点赞数
分类专栏： 笔记 日中杂记 文章标签： javascript 前端 typescript
于 2023-08-10 17:29:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huchaoyue_/article/details/132214158
版权

常用工具函数

General

isEmpty

export function isEmpty(data: any) {
  if (data === '' || data === null || data === undefined) {
    return true;
  }
  // [] {} 0 false/true
  else {
    const typeofs = Object.prototype.toString.call(data);
    // 数组
    if (typeofs === '[object Array]') {
      if (data.length > 0) {
        return false;
      } else {
        return true;
      }
    }
    // 对象
    else if (typeofs === '[object Object]') {
      if (Object.keys(data).length > 0) {
        return false;
      } else {
        return true;
      }
    } else {
      // 不为空
      return false;
    }
  }
}

getType

type Types =
  | 'Number'
  | 'String'
  | 'Boolean'
  | 'Null'
  | 'Undefined'
  | 'Array'
  | 'Object';

export const getType = function (value: any): Types {
  const typeofs = Object.prototype.toString.call(value);

  switch (typeofs) {
    case '[object Number]':
      return 'Number'; // NaN Infinity 也是Number类型

    case '[object String]':
      return 'String';

    case '[object Boolean]':
      return 'Boolean';

    case '[object Null]':
      return 'Null';

    case '[object Undefined]':
      return 'Undefined';

    case '[object Array]':
      return 'Array';

    case '[object Object]':
      return 'Object';

    default:
      return typeofs as any;
  }
};

is

import { getType } from './get-type';

const typeCheck = function (type: string, val: any): boolean {
  if (getType(val) === type) {
    return true;
  } else {
    return false;
  }
};

type TypeChecking = {
  number: (val: any) => boolean;
  string: (val: any) => boolean;
  array: (val: any) => boolean;
  object: (val: any) => boolean;
};

export const is: TypeChecking = {
  number: (val: any) => {
    return Number.isFinite(val);
  },
  string: (val: any) => {
    return typeCheck('String', val);
  },
  array: (val: any) => {
    return typeCheck('Array', val);
  },
  object: (val: any) => {
    return typeCheck('Object', val);
  },
};

isEqual

isEqual：判断两个数据是否相等
isObjectEqual：判断两个对象是否相等
isArrayEqual：判断两个数组是否相等

import { isEmpty } from './isEmpty';

type IndexKey = string | number | symbol;
interface AnyObject {
  [propName: IndexKey]: any;
}

/**
 * @description 判断两个对象是否相等
 * @param {AnyObject} obj1
 * @param {AnyObject} obj2
 * @param {boolean} omitEmpty 默认为false，当为true时，为空的值判断为相等
 * @return {boolean}
 */
export const isObjectEqual = function (
  obj1: AnyObject,
  obj2: AnyObject,
  omitEmpty = false
) {
  const keys1 = Object.keys(obj1);
  const keys2 = Object.keys(obj2);

  if (keys1.length === keys2.length) {
    const sortKeys1 = keys1.sort();
    const sortKeys2 = keys2.sort();

    const sortStr1 = JSON.stringify(sortKeys1);
    const sortStr2 = JSON.stringify(sortKeys2);

    // 对象的key值都相等
    if (sortStr1 === sortStr2) {
      let flag = true;
      for (const key1 in obj1) {
        const value1 = obj1[key1];
        const value2 = obj2[key1];
        const typeofs = Object.prototype.toString.call(value1);
        const typeofs2 = Object.prototype.toString.call(value2);

        // 如果两个都为空，判断为相等
        if (omitEmpty && isEmpty(value1) && isEmpty(value2)) {
          // flag = true;
        } else {
          if (typeofs === '[object Object]' && typeofs2 === '[object Object]') {
            const _flag = isObjectEqual(value1, value2, omitEmpty);
            if (!_flag) {
              flag = false;
              break;
            }
          } else if (
            typeofs === '[object Array]' &&
            typeofs2 === '[object Array]'
          ) {
            const _flag = isArrayEqual(value1, value2, omitEmpty);
            if (!_flag) {
              flag = false;
              break;
            }
          } else if (typeofs === typeofs2) {
            // string number boolean null undefined
            if (value1 !== value2) {
              flag = false;
              break;
            }
          } else {
            // 类型不同，不相等
            flag = false;
            break;
          }
        }
      }
      return flag;
    } else {
      return false;
    }
  } else {
    return false;
  }
};

/**
 * @description 判断两个数组是否相等
 * @param {any[]} arr1
 * @param {any[]} arr2
 * @param {boolean} omitEmpty 默认为false，当为true时，为空的值判断为相等
 * @return {boolean}
 */
export const isArrayEqual = function (
  arr1: any[],
  arr2: any[],
  omitEmpty = false
) {
  if (arr1.length === arr2.length) {
    let flag = true;
    let i = 0;
    for (const item of arr1) {
      const value1 = item;
      const value2 = arr2[i];
      const typeofs = Object.prototype.toString.call(value1);
      const typeofs2 = Object.prototype.toString.call(value2);

      // 如果两个都为空，判断为相等
      if (omitEmpty && isEmpty(value1) && isEmpty(value2)) {
        // flag = true;
      } else {
        if (typeofs === '[object Object]' && typeofs2 === '[object Object]') {
          const _flag = isObjectEqual(value1, value2, omitEmpty);
          if (!_flag) {
            flag = false;
            break;
          }
        } else if (
          typeofs === '[object Array]' &&
          typeofs2 === '[object Array]'
        ) {
          const _flag = isArrayEqual(value1, value2, omitEmpty);
          if (!_flag) {
            flag = false;
            break;
          }
        } else if (typeofs === typeofs2) {
          // string number boolean null undefined
          if (value1 !== value2) {
            flag = false;
            break;
          }
        } else {
          // 类型不同，不相等
          flag = false;
          break;
        }
      }

      i++;
    }
    return flag;
  } else {
    return false;
  }
};

/**
 * @description 判断两个数据是否相等
 * @param {any} data1
 * @param {any} data2
 * @param {boolean} omitEmpty 默认为false，当为true时，为空的值判断为相等
 * @return {boolean}
 */
export const isEqual = function (data1: any, data2: any, omitEmpty = false) {
  let flag = true;
  // 如果两个都为空，判断为相等
  if (omitEmpty && isEmpty(data1) && isEmpty(data2)) {
    // flag = true;
  } else {
    const typeofs = Object.prototype.toString.call(data1);
    const typeofs2 = Object.prototype.toString.call(data2);

    if (typeofs === '[object Object]' && typeofs2 === '[object Object]') {
      const _flag = isObjectEqual(data1, data2, omitEmpty);
      if (!_flag) {
        flag = false;
      }
    } else if (typeofs === '[object Array]' && typeofs2 === '[object Array]') {
      const _flag = isArrayEqual(data1, data2, omitEmpty);
      if (!_flag) {
        flag = false;
      }
    } else if (typeofs === typeofs2) {
      // string number boolean null undefined
      if (data1 !== data2) {
        flag = false;
      }
    } else {
      // 类型不同，不相等
      flag = false;
    }
  }

  return flag;
};

isBasicData

/**
 * @description 是否是基本数据类型
 * @param {any} data
 * @return {boolean}
 */
export function isBasicData(data: any) {
  const basicDataTypes = [
    '[object String]',
    '[object Number]',
    '[object Boolean]',
    '[object Null]',
    '[object Undefined]',
  ];
  const typeofs = Object.prototype.toString.call(data);

  return basicDataTypes.includes(typeofs);
}

getEnumMap

export function getEnumMap(list: any[], key = 'name') {
  const typeofs = Object.prototype.toString.call(list);
  const isArray = typeofs === '[object Array]';
  const newObj: any = {};
  if (isArray && list.length > 0) {
    for (const item of list) {
      newObj[item[key]] = item;
    }
  }
  return newObj;
}

getRandomInt

返回了一个在指定值之间的随机整数

/**
 * 返回了一个在指定值之间的随机整数
 * @param min 这个值不小于 min （如果 min 不是整数，则不小于 min 的向上取整数）
 * @param max 这个值小于（不等于）max
 * @returns [min ,max )
 */
export const getRandomInt = function (min: number, max: number) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min; // 不含最大值，含最小值
};

getAngle

/**
 * 计算从x1y1到x2y2的直线，与水平线形成的夹角
 * 计算规则为顺时针从左侧0°到与该直线形成的夹角
 * @param {Object} x1
 * @param {Object} y1
 * @param {Object} x2
 * @param {Object} y2
 * @param {Boolean} toAngle 是否转换为角度值，默认false
 */
export const getAngle = function (
  x1: number,
  y1: number,
  x2: number,
  y2: number,
  toAngle = false
) {
  const x = x1 - x2;
  const y = y1 - y2;
  if (!x && !y) {
    return 0;
  }

  // 弧度 radian = 角度 * Math.PI / 180
  // 角度 angle = 弧度 * 180 / Math.PI

  let res;

  // 角度
  const angle = (180 + (Math.atan2(-y, -x) * 180) / Math.PI + 360) % 360;
  res = 360 - angle;

  if (!toAngle) {
    res = (res * Math.PI) / 180;
  }
  return res;
};

omitEmpty

去除对象中为空的属性值 返回一个新对象

import { isEmpty } from './isEmpty';

type IndexKey = string | number | symbol;
interface AnyObject {
  [propName: IndexKey]: any;
}

/**
 * @description 去除对象中为空的属性值 返回一个新对象
 * @param {AnyObject} data
 * @return 返回一个新对象
 */
export const omitEmpty = function (data: AnyObject) {
  const typeofs = Object.prototype.toString.call(data);
  if (typeofs === '[object Object]') {
    const obj: AnyObject = {};
    for (const key in data) {
      if (!isEmpty(data[key])) {
        obj[key] = data[key];
      }
    }
    return obj;
  } else {
    console.error(`Expect type [object Object], but get type ${typeofs}`);
    return data;
  }
};

Custom

useWhere

export function useWhere(
  columns: { wustOper: string; wustField: string }[] = [],
  value: any = {}
) {
  const newObj: any = {};

  for (const key in value) {
    let newValue = value[key];
    if (!isEmpty(newValue)) {
      const ta = columns.find((item) => item.wustField == key);
      if (ta) {
        const taOper = ta.wustOper;
        const newKey = key + '@' + taOper;
        if (taOper == 'like' || taOper == 'ilike') {
          newValue = '%' + <string>newValue + '%';
        }

        newObj[newKey] = newValue;
      }
    }
  }

  return newObj;
}

stringToArr（字符串转数组）

export const isArrEmpty = function (data: any) {
  if (isEmpty(data)) {
    return true;
  } else {
    if (data == 'None' || data == '[]' || data === '{}') {
      return true;
    } else {
      return false;
    }
  }
};

// 字符串转数组
export const stringToArr = function (data: any) {
  let res = [];
  if (!isArrEmpty(data)) {
    const typeofs = Object.prototype.toString.call(data);
    if (typeofs === '[object String]') {
      const start = data.slice(0, 1);
      const end = data.slice(-1);

      if ((start === '{' && end === '}') || (start === '[' && end === ']')) {
        res = JSON.parse(data);
      } else {
        console.warn('字符串' + '【' + data + '】' + '不能解析为数组');
        res.push(data);
      }
    } else {
      console.error('【' + data + '】' + '的数据类型不是字符串');
    }
  }

  return res;
};

arrToString（数组转字符串）

// 数组转字符串
export const arrToString = function (data: any) {
  let res = '';
  const typeofs = Object.prototype.toString.call(data);
  if (typeofs === '[object Array]') {
    if (!isEmpty(data)) {
      res = JSON.stringify(data);
    }
  } else {
    console.error('数据类型【' + typeofs + '】错误');
  }

  return res;
};

未完待续…

傲来小神仙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
常用Utils
qq_43306376的博客
10-08 747
转载：https://github.com/Blankj/AndroidUtilCode/blob/master/lib/utilcode/README-CN.md Download Gradle: implementation ‘com.blankj:utilcode:1.29.0’ // if u use AndroidX, use the following implementation ‘com.blankj:utilcodex:1.29.0’ APIs Activity 相关 -> Acti
这些年整理的一些常用Utils工具类 , 希望对大家开发有所裨益
08-31
各种各样的工具 , 总有一个适合你 , 常用Utils工具类 , 希望对大家开发有所裨益 . 佛祖保佑 , 没有bug
Utils常用类
12-22
AsyncTaskAssistant异步任务类 CacheUtil缓存 DateUtil日期转换 DensityUtil分辨率转换 FileOperate文件 HideSoftKeyBoard软键盘 LogUtil日志打印 MyTask线程 NetUtil网络判断 SPUtilsp存储 StorageUtils文件 ToastUtil 弹出
utils
HeMister的博客
12-25 409
生成uuid 判断是否相等 其他类型转数组 判断是否是PC端 判断是否是某种设备或浏览器 为css样式添加浏览器内核头 驼峰转横杆 格式化时间 常用键位映射表 判断两个对象或数组是否相等（简单对象） 判空 首字母大写 判断两个简单对象是否相等 判断数组是否相等 劫持Vue的data，请勿乱用 金额千分位加逗号 数字转中文大写 深拷贝对象 日期格式化 判断是否是自身属性 遍历对象 数组转对象 默认警...
UtilsDemo:项目常用Utils工具类
05-15
项目常用Utils工具类,主要包括： 1.Activity栈统一管理类 主要功能有： activity跳转 avticity销毁 程序退出销毁所有Activity public class ActivityManager { private static Stack<Activity> activityStack = ...
utils.js:前端开发常用的js方法封装
05-08
utils.js 前端开发常用的js方法封装 例如： // 输入身份证号码获取生日 export const getBirthday = idcard => idcard.substring(6, 10) + "-" + idcard.substring(10, 12) + "-" + idcard.substring(12, 14); // ...
个人总结常用经典Utils工具类
06-25
1、Utils工具类有String工具类、XmlNode节点工具类、BeanFactory相关、Common工具类、Cookie工具类、Date工具类、Http工具类、JDBC工具类、日志Log工具类、Servlet相关等。2、工具类省了重复造轮子的工作，可以直接...
utils:常见的
03-26
utils:常见的
Utils
MRzhenglea的博客
08-20 383
#KafkaUtil import org.apache.flink.api.common.serialization.SimpleStringSchema; import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer; import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer; import org.apache.flink.streaming.
Android开发人员不得不收集的代码(持续更新中)
weixin_30613343的博客
09-13 116
原文链接：https://github.com/passiontim/AndroidUtilCode App相关→AppUtils.java 安装App installApp 卸载指定包名的App uninstallApp 获取当前App信息 getAppInfo 获取所有已安装App信息 getAllAppsInfo 根据包名判断A...
Python Utils
ScorpC的博客
05-05 6330
官方文档：Welcome to Python Utils’s documentation! Python Utils is a collection of small Python functions and classes which make common patterns shorter and easier. It is by no means a complete collec
Utils（一） 介绍
热门推荐
04-12 1万+
Utils是一个常用Java工具类的集成包。优秀的工具类库已经很多了，例如commons-lang3、guava等，但Utils并非是在造轮子，团队内使用工具类库的方式及风格都不一致，将会导致出现代码阅读困难和一些完全可以避免的问题，因此Utils是为了统一团队内部工具类使用而产生的，为各类工...
utils工具
weixin_33796177的博客
04-09 932
小程序云开发 数据库的增、删、改、查（operateDatabase.js） 其他 规定时间格式（formatTime.js） 数组的随机抽取...（operateArray.js） Cookie的增、删、改、查（operateCookie.js） 转载于:https://juejin.im/post/5cac61b4e51d456e537ef2aa...
常用工具类 Utils
Anson的博客
09-08 2301
map与javabean对象转换 package cn.com.services.app.utils; import com.google.common.collect.Maps; import org.springframework.cglib.beans.BeanMap; import java.util.List; import java.util.Map; public class BeanUtils { /** * 将对象转换为map * @param bea
httpUtils
我要飞翔
01-14 356
package com.topsec.ws.util; import com.topsec.ws.constant.Constant; import org.apache.http.*; import org.apache.http.client.ClientProtocolException; import org.apache.http.client.HttpClient; import ...
java常用utils
最新发布
09-27
常用的Java工具类有很多，其中一些常见的包括： 1. StringUtils：用于处理字符串的工具类，提供了各种字符串操作方法，如判断字符串是否为空、去除字符串中的空格、字符串拼接等。 2. DateUtils：用于处理日期和时间的工具类，提供了各种日期和时间操作方法，如日期格式化、日期比较、日期加减等。 3. FileUtil：用于文件操作的工具类，提供了文件的读取、写入、复制、移动等方法。 4. MathUtils：用于数学计算的工具类，提供了各种数学操作方法，如取绝对值、四舍五入、求平方根等。 5. CollectionUtils：用于集合操作的工具类，提供了各种集合操作方法，如集合合并、集合比较、集合筛选等。 6. JsonUtils：用于JSON数据处理的工具类，提供了JSON数据转换、解析、序列化等方法。 以上只是一些常见的Java工具类，还有很多其他的工具类可以根据具体需求选择使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值