数据过滤

import filterMethods from './filter.js’

filters: {
formatData (value, types) {
if (types) {
console.log(’types或者value', types, value)
return filterMethods[types](value)
}
}
}

// 展示整数不保留小数,格式 XX万, XX 亿, XX 亿, 1万 --- int1

// 展示整数保留一位小数,格式 XX.0万, XX.0亿, XX.0亿, 1.0万 --- int2

// 展示整数不保留小数,展示到个位数,格式 15,000 250,000 34,234,904 (不展示单位,纯千分位展示) --- int3

// 展示整数保留小数,展示到个位数,格式 15,000.0 250,000.0 34,234,904.0 (不展示单位,纯千分位展示) --- int4

// 展示小数不保留小数点, 格式 0.66677 => 67 --- float1

// 展示小数保留一位小数, 格式 0.66677 => 66.7 --- float2

// 展示小数保留两位小数, 格式 0.66677 => 66.68 --- float3
/**
* toFixed 四舍五入不精准的问题
* @params: num 数值，类型 number，string
* @params: s, 保留小数的位数，默认时1位
* @params: f, 四舍五入后是整数，是否再保留小数位。默认是保留。
* @return: 返回值类型是string
*/
function toFixed (num, s, f = true) {
let times = Math.pow(10, s)
let des = num * times + 0.5
des = parseInt(des, 10) / times
if (f) {
des = des.toFixed(s)
}
return des + ''
}
const filters = {
// 展示整数不保留小数,展示到个位数,格式 15,000 250,000 34,234,904
// 千分位不保留小数
numerify0: (count) => {
if (count === '0' || count === 0) {
return '0'
}
if (!count || count === 'undefined') {
return '--'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--'
}
if (counter < 0) {
counter = Math.abs(counter)
}
if (counter < 100000) {
// replace(/(\d)(?=(\d{3})+\.)/g, '$1,') 此方式针对不是小数的数据格式化成千分位不成功 13233.3
// replace(/(?=(?!(\b))(\d{3})+$)/g, ',') 此方法针对没有小数的数据格式化成千分位 12345
let counterStr = counter.toFixed(0).toString()
let len = counterStr.length
if (len % 3 === 0) {
counterStr = counterStr.replace(/(\d{3})/g, ',$1').slice(1)
} else {
counterStr = counterStr.slice(0, len % 3) + counterStr.slice(len % 3).replace(/(\d{3})/g, ',$1')
}
return Number(count) >= 0 ? counterStr : '-' + counterStr
} else {
if (counter < 100000000) {
let n = counter / 10000
counter = toFixed(n, 1)
if (Number(count) >= 0) {
return counter + '万'
} else {
return '-' + counter + '万'
}
} else {
let n = counter / 100000000
counter = toFixed(n, 1)
if (Number(count) >= 0) {
return counter + '亿'
} else {
return '-' + counter + '亿'
}
}
}
},
// 展示整数保留小数,展示到个位数
// 格式 15,000.0 250,000.0 34,234,904.0
// count 参数
// s 保留小数位数,默认保留1位
// 大于10万，保留一位小数
// 千分位保留一位小数
numerify1: (count, s = 1) => {
if (count === '0' || count === 0) {
let number = ''
for (var i = 0; i < s; i++) {
number += '0'
}
return '0.' + number
}
if (!count || count === 'undefined') {
return '--'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--'
}
if (counter < 100000) {
counter = toFixed(counter, s)
if (Number(count) >= 0) {
return counter.toString().replace(/(\d)(?=(\d{3})+\.)/g, '$1,')
} else {
return '-' + counter.toString().replace(/(\d)(?=(\d{3})+\.)/g, '$1,')
}
} else {
if (counter < 100000000) {
let n = counter / 10000
counter = toFixed(n, 1)
if (Number(count) >= 0) {
return counter + '万'
}
return '-' + counter + '万'
} else {
let n = counter / 100000000
counter = toFixed(n, 1)
if (Number(count) >= 0) {
return counter + '亿'
}
return '-' + counter + '亿'
}
}
},
// s 保留小数位数,默认保留1位
// 大于10万，保留两位小数
// 千分位保留两位小数
numerify2: (count, s = 2) => {
if (count === '0' || count === 0) {
let number = ''
for (var i = 0; i < s; i++) {
number += '0'
}
return '0.' + number
}
if (!count || count === 'undefined') {
return '--'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--'
}
if (counter < 100000) {
counter = toFixed(counter, s)
return counter.toString().replace(/(\d)(?=(\d{3})+\.)/g, '$1,')
} else {
if (counter < 100000000) {
let n = counter / 10000
counter = toFixed(n, 1)
return counter + '万'
} else {
let n = counter / 100000000
counter = toFixed(n, 1)
return counter + '亿'
}
}
},
/*
整数部分
*/
// 展示整数不保留小数,格式 XX万, XX 亿, XX 亿, 1万
// 整数不保留小数
numerify3: (count) => {
if (count === '0' || count === 0) {
return '0'
}
if (!count || count === 'undefined') {
return '--'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--'
}
// 将数值绝对化
counter = Math.abs(parseFloat(count))
// 判断数值绝对化后是不是number，不是就返回
if (typeof counter !== 'number' || isNaN(counter)) {
return count
}
if (counter < 10000) {
return toFixed(counter, 0)
} else if (counter >= 10000 && counter < 100000000) {
let m = (counter / 10000).toFixed(0) - 10000
// 如果保留后还可以保留成亿再处理一次
if (m >= 0) {
counter = (counter / 100000000).toFixed(0)
return counter + '亿'
} else {
counter = (counter / 10000).toFixed(0)
return counter + '万'
}
} else if (counter >= 100000000) {
counter = (counter / 100000000).toFixed(0)
return counter + '亿'
}
},
// 展示整数保留一位小数,格式 XX.0万, XX.0亿, XX.0亿, 1.0万
// 特殊情况：：：小于一万，不保留小数位;默认是保留一位小数
// 不保留，参数 flag = false
// 整数保留一位小数
numerify4: (count, flag = true) => {
if (count === '0' || count === 0) {
return '0'
}
if (!count || count === 'undefined') {
return '--'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--'
}
// 将数值绝对化
counter = Math.abs(parseFloat(count))
// 判断数值绝对化后是不是number，不是就返回
if (typeof counter !== 'number' || isNaN(counter)) {
return count
}
if (counter < 10000) {
return flag ? counter.toFixed(1) : counter.toFixed(0)
} else if (counter >= 10000 && counter < 100000000) {
let n = counter / 10000
let m = toFixed(n, 1) - 10000
// 如果保留后还可以保留成亿再处理一次
if (m >= 0) {
let n = counter / 100000000
counter = toFixed(n, 1)
if (Number(count) >= 0) {
return counter + '亿'
}
return '-' + counter + '亿'
} else {
counter = (counter / 10000).toFixed(1)
if (Number(count) >= 0) {
return counter + '万'
}
return '-' + counter + '万'
}
} else if (counter >= 100000000) {
let n = counter / 100000000
counter = toFixed(n, 1)
if (Number(count) >= 0) {
return counter + '亿'
}
return '-' + counter + '亿'
}
},
// 整数保留两位小数
numerify5: (count) => {
if (count === '0' || count === 0) {
return '0'
}
if (!count || count === 'undefined') {
return '--'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--'
}
// 将数值绝对化
counter = Math.abs(parseFloat(count))
// 判断数值绝对化后是不是number，不是就返回
if (typeof counter !== 'number' || isNaN(counter)) {
return count
}
if (counter < 10000) {
return counter.toFixed(1)
} else if (counter >= 10000 && counter < 100000000) {
let n = counter / 10000
let m = toFixed(n, 1) - 10000
// 如果保留后还可以保留成亿再处理一次
if (m >= 0) {
let n = counter / 100000000
counter = toFixed(n, 1)
if (Number(count) < 0) {
return '-' + counter + '亿'
}
return counter + '亿'
} else {
counter = (counter / 10000).toFixed(1)
if (Number(count) < 0) {
return '-' + counter + '万'
}
return counter + '万'
}
} else if (counter >= 100000000) {
let n = counter / 100000000
counter = toFixed(n, 1)
if (Number(count) < 0) {
return '-' + counter + '亿'
}
return counter + '亿'
}
},
/*
小数百分比部分
*/
// 展示小数不保留小数点,区分正负数 格式 0.66677 => 67 --- float1
percent0: (count) => {
if (count === '0' || count === 0) {
return '0' + '%'
}
if (!count || count === 'undefined') {
return '--' + '%'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--' + '%'
}
if (counter < 0) {
counter = Math.abs(counter)
return '-' + (counter.toFixed(2) * 100) + '%'
} else {
return (counter.toFixed(2) * 100) + '%'
}
},
// 保留一位小数百分比
percent1: count => {
if (count === '0' || count === 0) {
return count + '.0' + '%'
}
if (!count || count === '--') {
return '--' + '%'
}
let counter = Number(count)
if (counter === 0) {
return '0.0' + '%'
}
if (count < 0) {
console.log('123123====', count)
let counter = -Number(count)
counter = (counter.toFixed(3) * 100).toFixed(1)
return counter + '%'
} else if (count > 0) {
let counter = Number(count)
counter = (counter.toFixed(3) * 100).toFixed(1)
return counter + '%'
}
},
// 保留一位小数百分比 保留负号
percent4: count => {
if (count === '0' || count === 0) {
return count + '.0' + '%'
}
if (!count || count === '--') {
return '--' + '%'
}
let counter = Number(count)
if (counter === 0) {
return '0.0' + '%'
}
if (count < 0) {
console.log('123123====', count)
let counter = -Number(count)
counter = (counter.toFixed(3) * 100).toFixed(1)
return '-' + counter + '%'
} else if (count > 0) {
let counter = Number(count)
counter = (counter.toFixed(3) * 100).toFixed(1)
return counter + '%'
}
},
// 展示小数保留两位小数,区分正负数 格式 0.66677 => 66.68 --- float3
percent2: (count) => {
if (count === '0' || count === 0) {
return '0.00' + '%'
}
if (!count || count === 'undefined') {
return '--' + '%'
}
let counter = Number(count)
if (Number.isNaN(counter)) {
return '--' + '%'
}
if (counter < 0) {
counter = Math.abs(counter)
counter = toFixed(counter, 4) * 100
counter = toFixed(counter, 2)
return counter + '%'
} else {
counter = toFixed(counter, 4) * 100
counter = toFixed(counter, 2)
return counter + '%'
}
},
percent: count => { // 取绝对值
if (count === '0' || count === 0) {
return '0.0' + '%'
}
if (!count) {
return '--' + '%'
}
const counter = Math.abs(parseFloat(count))
if (typeof counter === 'number' && !isNaN(counter)) {
return String((counter.toFixed(3) * 100).toFixed(1) + '%')
} else {
return String(count + '%')
}
}
}

export default filters

之后直接在页面进行过滤引入方法名就好