判断数据是否为空,对象是否存在某属性,属性值是否为空,对大数据进行换算,对单位进行转换.
目录
1.格式化数据
/**
* 格式化数据函数
* 该函数用于将给定的数据根据特定规则进行格式化，以确保数据以一致的方式展示
* @param {Object|number|string|array} data - 待格式化的数据，可以是对象、数字、字符串或对象数组
* @param {string} fieldName - 可选参数，指定对象中的字段名，如果未提供或字段不存在，则直接使用data
* @param {boolean} flag - 可选参数，指定对象中的字段名，表示是否保留两位小数
* @returns {string} - 格式化后的数据字符串，如果数据为空则返回'--'，如果数据是数字则保留两位小数
*/
export function formatData(data, fieldName = null,flag = true) {
// 获取实际需要处理的数据
let value;
if (Array.isArray(data)) {
// 如果 data 是一个数组，检查数组是否为空
if (data.length === 0) {
return '--';
}
// 假设我们需要处理数组的第一个元素
const firstItem = data[0];
if (firstItem && typeof firstItem === 'object') {
value = fieldName ? (firstItem[fieldName] !== undefined ? firstItem[fieldName] : null) : firstItem;
} else {
value = firstItem;
}
} else {
value = fieldName ? (data && data[fieldName] !== undefined ? data[fieldName] : null) : data;
}
// 判断数据是否为空
if (
value === null ||
value === undefined ||
value === '' || // 添加对空字符串的检查
(typeof value === 'object' && Object.keys(value).length === 0) // 添加对空对象的检查
) {
return '--';
}
// 将数值字符串转换为数字
if (typeof value === 'string' && !isNaN(value)) {
value = parseFloat(value);
}
// 如果数据是数字，保留两位小数
if (typeof value === 'number') {
if(flag){
return value.toFixed(2);
}else{
return value.toFixed(0);
}
}
// 其他情况，直接返回数据
return value;
}
以下是对
formatData函数的各种输入情况进行示例和结果展示：
数组为空
- 输入：
formatData([])- 结果：
--数组包含空对象
- 输入：
formatData([{}])- 结果：
--数组包含有效对象
- 输入：
formatData([{name: 'John Doe', age: 30}])- 结果：
{name: 'John Doe', age: 30}数组包含单个非对象值
- 输入：
formatData([42])- 结果：
42.00数组包含多个对象，处理第一个对象
- 输入：
formatData([{name: 'John Doe'}, {name: 'Jane Doe'}])- 结果：{ name: 'John Doe' }
传入单个对象，指定字段名
- 输入：
formatData({name: 'John Doe', age: 30}, 'name')- 结果：
John Doe传入单个对象，未指定字段名
- 输入：
formatData({name: 'John Doe', age: 30})- 结果：
{name: 'John Doe', age: 30}传入单个对象，指定字段名但字段不存在
- 输入：
formatData({name: 'John Doe', age: 30}, 'email')- 结果：--
传入单个空对象
- 输入：
formatData({})- 结果：
--传入单个字符串
- 输入：
formatData('Hello World')- 结果：
Hello World传入空字符串
- 输入：
formatData('')- 结果：
--传入数值字符串
- 输入：formatData('123.456',null,false)
- 结果
123- 输入：formatData('123.456')
- 结果
123.46传入空数组对象
- 输入：
formatData([{}, {}])- 结果：
--
2.判断值是否为空(包括对象、数组、字符串、数值类型)
（1）值是0不表示空
/**
* 判断给定值是否为空
*
* @param value 要判断的值
* @returns 如果值为空，返回 true；否则返回 false
*/
export function isEmpty(value) {
return (
value == null || // null 或 undefined
(typeof value === 'string' && value.trim() === '') || // 空字符串（包括空格的情况）
(Array.isArray(value) && value.length === 0) || // 空数组
(typeof value === 'object' && Object.keys(value).length === 0) // 空对象
);
}以下是对
isEmpty函数的各种输入情况进行示例和结果展示：
输入为
null
- 输入：
isEmpty(null)- 结果：
true输入为
undefined
- 输入：
isEmpty(undefined)- 结果：
true输入为空字符串
- 输入：
isEmpty('')- 结果：
true输入为仅包含空格的字符串
- 输入：
isEmpty(' ')- 结果：
true输入为非空字符串
- 输入：
isEmpty('Hello World')- 结果：
false输入为空数组
- 输入：
isEmpty([])- 结果：
true输入为非空数组
- 输入：
isEmpty([1, 2, 3])- 结果：
false输入为空对象
- 输入：
isEmpty({})- 结果：
true输入为非空对象
- 输入：
isEmpty({name: 'John Doe', age: 30})- 结果：
false输入为包含空对象的数组
- 输入：
isEmpty([{}, {}])- 结果：
false输入为包含空字符串的对象
- 输入：
isEmpty({name: '', age: 30})- 结果：
false输入为数值
0
- 输入：
isEmpty(0)- 结果：
true- 输入为数值为0的字符串
- 输入：
isEmpty('0')- 结果：false
（2）值是0表示空
/**
* 判断给定值是否为空
*
* @param value 要判断的值
* @returns 如果值为空或为0，返回 true；否则返回 false
*/
export function isEmpty2(value) {
return (
value == null || // null 或 undefined
(typeof value === 'number' && value === 0) || // 数值为0
(typeof value === 'string' && (value.trim() === '' || (parseFloat(value) === 0 && !isNaN(parseFloat(value)))) || // 空字符串或数值为0的字符串（包括"0.000"）
(Array.isArray(value) && value.length === 0) || // 空数组
(typeof value === 'object' && Object.keys(value).length === 0) // 空对象
));
}以下是对
isEmpty2函数的各种输入情况进行示例和结果展示：
输入为
null
- 输入：
isEmpty2(null)- 结果：
true输入为
undefined
- 输入：
isEmpty2(undefined)- 结果：
true输入为数值
0
- 输入：
isEmpty2(0)- 结果：
true输入为空字符串
- 输入：
isEmpty2('')- 结果：
true输入为仅包含空格的字符串
- 输入：
isEmpty2(' ')- 结果：
true输入为数值为0的字符串
- 输入：
isEmpty2('0')- 结果：
true输入为非空字符串
- 输入：
isEmpty2('Hello World')- 结果：
false输入为空数组
- 输入：
isEmpty2([])- 结果：
true输入为非空数组
- 输入：
isEmpty2([1, 2, 3])- 结果：
false输入为空对象
- 输入：
isEmpty2({})- 结果：
true输入为非空对象
- 输入：
isEmpty2({name: 'John Doe', age: 30})- 结果：
false输入为包含空对象的数组
- 输入：
isEmpty2([{}, {}])- 结果：
false输入为包含0的数组
- 输入：
isEmpty2([0])- 结果：false
输入为包含数值为0的字符串的对象
- 输入：
isEmpty2({value: '0'})- 结果：false
3. 检查对象是否具有指定名称的非空属性
/**
* 检查对象是否具有指定名称的非空属性
*
* @param obj 对象，用于检查属性
* @param propName 属性名称
* @returns 如果对象具有指定名称的非空属性，则返回true；否则返回false
*/
export function hasNonEmptyProperty(obj, propName) {
// 检查对象是否具有该属性
if (obj.hasOwnProperty(propName)) {
// 获取属性值
const propValue = obj[propName];
// 检查属性值是否不为空
// 这里我们考虑了几种“空”的情况：null, undefined, 空字符串
// 如果你还想考虑其他情况（如0，false等），请根据需要修改条件
if (propValue !== null && propValue !== undefined && propValue !== '') {
return true;
}
}
// 如果对象没有该属性，或者属性值为空，返回false
return false;
}
对象具有指定名称的非空属性
- 输入：
hasNonEmptyProperty({name: 'John Doe'}, 'name')- 结果：
true对象具有指定名称但属性值为空字符串
- 输入：
hasNonEmptyProperty({name: ''}, 'name')- 结果：
false对象具有指定名称但属性值为
null
- 输入：
hasNonEmptyProperty({name: null}, 'name')- 结果：
false对象具有指定名称但属性值为
undefined
- 输入：
hasNonEmptyProperty({name: undefined}, 'name')- 结果：
false对象没有指定名称的属性
- 输入：
hasNonEmptyProperty({age: 30}, 'name')- 结果：
false对象具有指定名称且属性值为非空字符串，但属性名称不匹配
- 输入：
hasNonEmptyProperty({name: 'John Doe'}, 'username')- 结果：
false对象具有指定名称且属性值为
0（根据函数当前逻辑，0被视为非空）
- 输入：
hasNonEmptyProperty({count: 0}, 'count')- 结果：
true对象具有指定名称且属性值为
false（根据函数当前逻辑，false被视为非空）
- 输入：
hasNonEmptyProperty({isActive: false}, 'isActive')- 结果：
true
4.判断值是否为空（包括字符串、数值类型）
//导出公共函数 判断是否为空
export function isNullorEmpty (str) {
return (str === '' || str == '--'|| str === null || str === undefined || isNaN(str));
}
以下是对
isNullorEmpty函数的各种输入情况进行示例和结果展示：
输入为空字符串
- 输入：
isNullorEmpty('')- 结果：
true输入为字符串'--'
- 输入：
isNullorEmpty('--')- 结果：
true输入为
null
- 输入：
isNullorEmpty(null)- 结果：
true输入为
undefined
- 输入：
isNullorEmpty(undefined)- 结果：
true输入为数字0
- 输入：
isNullorEmpty(0)- 结果：false
输入为布尔值
false
- 输入：
isNullorEmpty(false)- 结果：false
输入为字符串'0'
- 输入：
isNullorEmpty('0')- 结果：
false输入为有效数字字符串
- 输入：
isNullorEmpty('123')- 结果：
false输入为NaN
- 输入：
isNullorEmpty(NaN)- 结果：
true（因为isNaN(NaN)返回true）输入为有效数字
- 输入：
isNullorEmpty(123)- 结果：
false（因为123是一个有效的数字，且isNaN(123)返回false）
5.格式化数据-返回（值/1000）的值
//公共函数 判断是否为空
function isNullorEmpty (str) {
return (str === '' || str == '--'|| str === null || str === undefined || isNaN(str));
}
//公共函数 普通数据数值转换 保留两位小数 /1000
export function TransNumber (value) {
if (isNullorEmpty(value)) return '--';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if (t === '-') {
return '-' + Number(floatNum/1000).toFixed(2)
} else {
return Number(floatNum/1000).toFixed(2)
}
}对
TransNumber函数的各种可能性进行示例和结果展示
输入为空字符串
- 输入：
TransNumber('')- 结果：
'--'输入为特定标记字符串'--'
- 输入：
TransNumber('--')- 结果：
'--'输入为
null
- 输入：
TransNumber(null)- 结果：
'--'输入为
undefined
- 输入：
TransNumber(undefined)- 结果：
'--'输入为NaN
- 输入：
TransNumber(NaN)- 结果：
'--'输入为正整数字符串'1000'
- 输入：
TransNumber('1000')- 结果：
'1.00'输入为负整数字符串'-1000'
- 输入：
TransNumber('-1000')- 结果：
'-1.00'输入为浮点数字符串'1234.56'
- 输入：
TransNumber('1234.56')- 结果：
'1.23'输入为包含非数字字符的字符串'abc123'
- 输入：
TransNumber('abc123')- 结果：
'--'输入为数字0
- 输入：
TransNumber(0)- 结果：
'0.00'）输入为负数-1234
- 输入：
TransNumber(-1234)- 结果：
'-1.23'
6.数值转换用万、亿、做后缀
（1）保留两位小数
//公共函数 判断是否为空
function isNullorEmpty (str) {
return (str === '' || str == '--'|| str === null || str === undefined || isNaN(str));
}
//公共函数 普通数据数值转换 保留两位小数 /10000
export default function formatNumber (value) {
if (isNullorEmpty(value)) return '--';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if (floatNum < 10000) {
if (t === '-') {
return '-' + Number(floatNum).toFixed(2)
} else {
return Number(floatNum).toFixed(2)
}
} else if (floatNum < 100000000) {
if (t === '-') {
return '-' + (Number(floatNum) / 10000).toFixed(2) + '万'
} else {
return (Number(floatNum) / 10000).toFixed(2) + '万'
}
} else {
if (t === '-') {
return '-' + (Number(floatNum) / 100000000).toFixed(2) + '亿'
} else {
return (Number(floatNum) / 100000000).toFixed(2) + '亿'
}
}
}对
formatNumber函数的各种可能性进行示例和结果展示
输入为空字符串
- 输入：
formatNumber('')- 结果：
'--'输入为特定标记字符串'--'
- 假设
isNullorEmpty('--')返回true（注意：这个函数的实际实现并未给出，因此这里基于假设）- 输入：
formatNumber('--')- 结果：
'--'输入为
null
- 输入：
formatNumber(null)- 结果：
'--'输入为
undefined
- 输入：
formatNumber(undefined)- 结果：
'--'输入为正整数1234
- 输入：
formatNumber(1234)- 结果：
'1234.00'输入为负整数-12345
- 输入：
formatNumber(-12345)- 结果：
'-1.23万'输入为浮点数1234567.89
- 输入：
formatNumber(1234567.89)- 结果：
'123.46万'输入为极大整数987654321
- 输入：
formatNumber(987654321)- 结果：
'9.88亿'输入为极小负数-9876543210
- 输入：
formatNumber(-9876543210)- 结果：
'-98.77亿'
（2）不保留小数部分
//公共函数 判断是否为空
function isNullorEmpty (str) {
return (str === '' || str == '--'|| str === null || str === undefined || isNaN(str));
}
//公共函数 普通数据数值转换不保留小数 /10000
export function formatNumber2 (value) {
if (isNullorEmpty(value)) return '--';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if (floatNum < 10000) {
if (t === '-') {
return '-' + Number(floatNum).toFixed(0)
} else {
return Number(floatNum).toFixed(0)
}
} else if (floatNum < 100000000) {
if (t === '-') {
return '-' + (Number(floatNum) / 10000).toFixed(0)+ '万'
} else {
return (Number(floatNum) / 10000).toFixed(0)+ '万'
}
} else {
if (t === '-') {
return '-' + (Number(floatNum) / 100000000).toFixed(0) + '亿'
} else {
return (Number(floatNum) / 100000000).toFixed(0) + '亿'
}
}
}
formatNumber2函数，并列出所有可能性的示例和结果。
输入为空字符串
- 输入：
formatNumber2('')- 结果：
'--'输入为特定标记字符串'--'
- 输入：
formatNumber2('--')- 结果：
'--'输入为
null
- 输入：
formatNumber2(null)- 结果：
'--'输入为
undefined
- 输入：
formatNumber2(undefined)- 结果：
'--'输入为正整数小于10000
- 输入：
formatNumber2(5000)- 结果：
5000输入为负整数小于10000
- 输入：
formatNumber2(-5000)- 结果：
-5000输入为正整数大于等于10000且小于100000000
- 输入：
formatNumber2(50000000)- 结果：
5000万输入为负整数大于等于10000且小于100000000
- 输入：
formatNumber2(-50000000)- 结果：
-5000万输入为正整数大于等于100000000
- 输入：
formatNumber2(1234567890)- 结果：
12亿输入为负整数大于等于100000000
- 输入：
formatNumber2(-1234567890)- 结果：
-12亿
7.涉及三位数值以及单位转换
例如1t=1000kg 1MWh=1000kWh
//公共函数 判断是否为空
function isNullorEmpty (str) {
return (str === '' || str == '--'|| str === null || str === undefined || isNaN(str));
}
//公共函数 涉及电的数值转换 /1000
export function formatElectNumber (value) {
if (isNullorEmpty(value)) return '--';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if (floatNum < 1000) {
if (t === '-') {
return '-' + Number(floatNum).toFixed(2)
} else {
return Number(floatNum).toFixed(2)
}
} else if (floatNum < 1000000) {
if (t === '-') {
return '-' + (Number(floatNum) / 1000).toFixed(2)
} else {
return (Number(floatNum) / 1000).toFixed(2)
}
} else {
if (t === '-') {
return '-' + (Number(floatNum) / 1000000).toFixed(2)
} else {
return (Number(floatNum) / 1000000).toFixed(2)
}
}
}
//公共函数 涉及电的单位转换 /1000
export function formatElectUnit (value) {
if (isNullorEmpty(value)) return 'kW';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if (floatNum < 1000) {
return 'kW'
} else if (floatNum < 1000000) {
return 'MW'
} else {
return 'GW'
}
}
//公共函数 涉及电的单位转换 /1000
export function formatElect2Unit (value) {
if (isNullorEmpty(value)) return 'kWh';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if (floatNum < 1000) {
return 'kWh'
} else if (floatNum < 1000000) {
return 'MWh'
} else {
return 'GWh'
}
}
//公共函数 涉及装机容量的单位转换 /1000
export function formatElect3Unit (value) {
if (isNullorEmpty(value)) return 'kWp';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if (floatNum < 1000) {
return 'kWp'
} else if (floatNum < 1000000) {
return 'MWp'
} else {
return 'GWp'
}
}
formatElectNumber函数示例 1: 空值
输入：
formatElectNumber('')结果：
'--'示例 2: 特定值
输入：
formatElectNumber(2777664.7235)结果：2.78
示例 3: 小于1000的正数
输入：
formatElectNumber(500)结果：
500.00示例 4: 小于1000的负数
输入：
formatElectNumber(-500)结果：
-500.00示例 5: 大于等于1000且小于1000000的正数
输入：
formatElectNumber(123456)结果：123.46
示例 6: 大于等于1000000的数
输入：
formatElectNumber(1234567890)结果：
1234.57
formatElectUnit函数示例 1: 空值
输入：
formatElectUnit('')结果：
'kW'示例 2: 小于1000的数
输入：
formatElectUnit(500)结果：
'kW'示例 3: 大于等于1000且小于1000000的数
输入：
formatElectUnit(123456)结果：
'MW'示例 4: 大于等于1000000的数
输入：
formatElectUnit(1234567890)结果：
'GW'
formatElect2Unit函数示例 1: 空值
输入：
formatElect2Unit('')结果：
'kWh'示例 2: 小于1000的数
输入：
formatElect2Unit(500)结果：
'kWh'示例 3: 大于等于1000且小于1000000的数
输入：
formatElect2Unit(123456)结果：
'MWh'示例 4: 大于等于1000000的数
输入：
formatElect2Unit(1234567890)结果：
'GWh'
formatElect3Unit函数示例 1: 空值
输入：
formatElect3Unit('')结果：
'kWp'示例 2: 小于1000的数
输入：
formatElect3Unit(500)结果：
'kWp'示例 3: 大于等于1000且小于1000000的数
输入：
formatElect3Unit(123456)结果：
'MWp'示例 4: 大于等于1000000的数
输入：
formatElect3Unit(1234567890)结果：
'GWp'
8.根据传入type类型，数据直接转换。
//公共函数 判断是否为空
function isNullorEmpty (str) {
return (str === '' || str == '--'|| str === null || str === undefined || isNaN(str));
}
//公共函数 涉及电的数值转换 根据类型直接转换 /1000
export function formatMyElectNumber (value,type) {
if (isNullorEmpty(value)) return '--';
const t = String(value).charAt(0);
let floatNum = value;
if (t === '-') {
floatNum = Math.abs(floatNum)
}
if(type){
if(type=='1'){
if (t === '-') {
return '-' + Number(floatNum).toFixed(2)
} else {
return Number(floatNum).toFixed(2)
}
}else if(type=='2'){
if (t === '-') {
return '-' + (Number(floatNum) / 1000).toFixed(2)
} else {
return (Number(floatNum) / 1000).toFixed(2)
}
}else if(type=='3'){
if (t === '-') {
return '-' + (Number(floatNum) / 1000000).toFixed(2)
} else {
return (Number(floatNum) / 1000000).toFixed(2)
}
}
}else{
if (floatNum < 1000) {
if (t === '-') {
return '-' + Number(floatNum).toFixed(2)
} else {
return Number(floatNum).toFixed(2)
}
} else if (floatNum < 1000000) {
if (t === '-') {
return '-' + (Number(floatNum) / 1000).toFixed(2)
} else {
return (Number(floatNum) / 1000).toFixed(2)
}
} else {
if (t === '-') {
return '-' + (Number(floatNum) / 1000000).toFixed(2)
} else {
return (Number(floatNum) / 1000000).toFixed(2)
}
}
}
}formatMyElectNumber
type为'1'：
formatMyElectNumber(1234, '1')返回'1234.00'formatMyElectNumber(-5678, '1')返回'-5678.00'formatMyElectNumber('123.45', '1')返回'123.45'formatMyElectNumber(null, '1')返回'--'
type为'2'：
formatMyElectNumber(1234, '2')返回'1.23'formatMyElectNumber(-5678, '2')返回'-5.68'formatMyElectNumber('678.90', '2')返回'0.68'
type为'3'：
formatMyElectNumber(1234567, '3')返回'1.23'formatMyElectNumber(-8901234, '3')返回'-8.90'formatMyElectNumber('987654.32', '3')返回'0.99'type为'undefined'：
1. formatMyElectNumber(1234)返回'1.23'
2. formatMyElectNumber(-5678)返回'-5.68'
3. formatMyElectNumber('123.45')返回'123.45'
4.formatMyElectNumber(null)返回'--'
9.input输入框值的类型限制
/*只输入数字 包括小数点和负数*/
function inputFilter (value) {
let data = value.target.value;
const t = value.target.value.charAt(0);//判断输入是否以负号开始。
data = data.replace(/[^\d.]/g, '');//移除了所有非数字和非小数点的字符。
data = data.replace(/^\./g, ''); //验证第一个字符是数字而不是字符
data = data.replace(/\.{2,}/g, '.'); //只保留第一个.清除多余的
data = data.replace('.', '$#$').replace(/\./g, '').replace('$#$', '.'); //保证.只出现一次
if (t === '-')
{
data = '-' + data;
}
return data;
}<a-input
v-model="inputValue"
@input="event => inputValue = inputFilter(event)"
placeholder="请输入数字（包括小数点和负数）"
/>
扫一扫
8136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
