SOURCE

/**
 * @description 从B开始换算单位
 * @param limit 字节大小
 * @returns {string|{size: string, units: string, lowerUnits: string}}
 */
function sizeUnitsConversion(limit) {
    if (Number(limit) === 0) return { size: '', units: '' }
    let size = '' // 容量
    let units = '' // 单位 大写
    let lowerUnits = '' // 单位 小写
    if (Number(limit) < 0.1 * 1024) { // 小于0.1KB，则转化成B
        size = Number(limit).toFixed(2)
        units = 'B'
    } else if (Number(limit) < 0.1 * 1024 * 1024) { // 小于0.1MB，则转化成KB
        size = (Number(limit) / 1024).toFixed(2)
        units = 'KB'
        lowerUnits = 'kb'
    } else if (Number(limit) < 0.1 * 1024 * 1024 * 1024) { // 小于0.1GB，则转化成MB
        size = (Number(limit) / (1024 * 1024)).toFixed(2)
        units = 'MB'
        lowerUnits = 'mb'
    } else { // 其他转化成GB
        size = (Number(limit) / (1024 * 1024 * 1024)).toFixed(2)
        units = 'GB'
        lowerUnits = 'gb'
    }
    const sizeStr = size + '' // 转成字符串
    const index = sizeStr.indexOf('.') // 获取小数点处的索引
    const dou = sizeStr.substr(index + 1, 2) // 获取小数点后两位的值
    if (dou === '00') { // 判断后两位是否为00，如果是则删除00
        return sizeStr.substring(0, index) + sizeStr.substr(index + 3, 2)
    }
    return { size, units, lowerUnits }
}

// console.log(sizeUnitsConversion(99999999))

/**
 * @description 数据单位之间转换
 * @param original 原始单位
 * @param transform 转换单位
 * @param size 大小
 * @returns {number}
 */
function sizeUnitsTransform(original, transform, size) {
    if (original.toUpperCase() === transform.toUpperCase()) { // 单位一致情况
        return { size: Number(size), original }
    }
    const k = 1024
    const sizeArr = [
        'B', 'KB', 'MB', 'GB', 'TB'
    ]
    const fIndex = sizeArr.findIndex(item => item === original.toUpperCase())
    const tIndex = sizeArr.findIndex(item => item === transform.toUpperCase())
    if (fIndex < tIndex) {
        return { size: Number(size / Math.pow(k, tIndex - fIndex)), original }
    } else if (tIndex < fIndex) {
        return { size: Number(size * Math.pow(k, fIndex - tIndex)), original }
    }
}

// console.log(sizeUnitsTransform('b', 'b', 1024))

/**
 * @description 将监控项的数据进行数据和单位转换
 * @param type 数据的类型 必填
 * @param size 数据 必填
 * @param unit 单位 可选
 * @returns {any}
 */
function conversionData(type, size, unit) {
  let suffix = ''
  if (type === 'data') { // 数据单位转换
    let activeUnit = unit
    if (unit.indexOf('ps') !== -1) {
      activeUnit = unit.split('ps')[0]
      suffix = `ps`
    }
    if (unit.indexOf('/') !== -1) {
      activeUnit = unit.split('/')[0]
      suffix = `/${unit.split('/')[1]}`
    }
    // 将数据大小转成b
    const sizeUnitsTransformResult = sizeUnitsTransform(`${activeUnit}`, 'b', size).size
    return { ...sizeUnitsConversion(sizeUnitsTransformResult), suffix, original: activeUnit }
  } else if (type === 'time') { // 数据单位转换
    const date = new Date(size * 1000)
    return date.getDay()
  } else if (type === 'status') { // 状态数据转换
    return size === 1 ? '正常' : '异常'
  }
}

console.log(conversionData('data', 99999999, 'kb/s'))
console.log(conversionData('time', 99999999))
console.log(conversionData('status', 1))

function transformNewData(unit, value) {
    const activeUnit = unit.toUpperCase()
    const unitS = [ 'B', 'KB', 'MB', 'GB', 'TB' ]
    const idx = unitS.findIndex(item => item === activeUnit)
    if (idx !== -1) {
        return conversionData('data', value, activeUnit)
    }
}

console.log(transformNewData('b', 99999999))