inferno-utils/src/utils.js

常用方法

const _ = require('lodash');

/**
 * 添加分割符
 * @param {* 分割目标，类型： String ，必选参数 } target
 * @param {* 分割方向，类型： Boolean ，可选参数，备选值：从左到右 true 或从右到左 false ，默认值：从左到右 true } direction 
 * @param {* 分割符，类型： String ，可选参数 } delimiter 
 * @param {* 间隔，类型： Number ，可选参数 } interval 
 */

const addDelimiter = function () {

    let _opts = {
        target: null, // 分割目标，类型： String，必选参数
        direction: true, // 分割方向，类型： Boolean ，可选参数，备选值：从左到右 true 或从右到左 false ，默认值：从左到右 true
        delimiter: ' ', // 分割符，类型： String ，可选参数
        interval: 5 // 间隔，类型： Number ，可选参数
    }
    _.assign(_opts, arguments[0] || {});

    return function () {

        _.assign(_opts, arguments[0] || {});

        // 若未传入分割目标，则停止
        if (!_opts.target) {
            console.error('未传入必须参数：分割目标 target ');
            return false;
        }

        let _targetType = typeof _opts.target,
            _targetArr = _targetType === 'number'
                ? _opts.target.toString().split('') : _opts.target.split(''),
            _targetArrLen = _targetArr.length;
        let _q = _targetArrLen / _opts.interval;

        let _resArr = [], _resStr = '';

        // 根据传入分割方向，处理原始数组
        _targetArr = _opts.direction ? _targetArr : _targetArr.reverse();

        // 根据传入间隔，分割原始数组并连接为返回数组
        for (let _i = 0; _i < _q; _i++) {
            _resArr = _resArr.concat(_targetArr.splice(0, _opts.interval)).concat(_opts.delimiter);
        }

        // 末尾不添加分割符
        _resArr.pop();

        // 根据传入分割方向，处理返回数组
        _resArr = _opts.direction ? _resArr : _resArr.reverse();

        // 将返回数组转化为字符串
        _resStr = _resArr.join('');
        return _resStr;
    };
}

/**
 * 格式化金额
 * @param {* 分割目标，类型： String ，必选参数 } target
 * @param {* 是否千分位添加逗号，类型： Boolean ，可选参数，备选值：开启 true 或关闭 false ，默认值：开启 true } addComma
 * @param {* 保留小数位数，类型： Number ，可选参数 } decimal
 * @param {* 是否四舍五入，类型： Boolean ，可选参数，备选值：四舍五入 true 或非四舍五入 false ，默认值：四舍五入 true } round 
 */

const formatAmount = function () {

    let _opts = {
        target: null, // 分割目标，类型： String ，必选参数
        addComma: true, // 是否千分位添加逗号，类型： Boolean ，可选参数，备选值：开启 true 或关闭 false ，默认值：开启 true
        decimal: 2, // 保留小数位数，类型： Number ，可选参数
        round: true // 是否四舍五入，类型： Boolean ，可选参数，备选值：四舍五入 true 或非四舍五入 false ，默认值：四舍五入 true
    }
    _.assign(_opts, arguments[0] || {});

    return function () {

        _.assign(_opts, arguments[0] || {});

        // 若未传入分割目标，则停止
        if (!_opts.target) {
            console.error('未传入必须参数：分割目标 target ');
            return false;
        }

        let _resArr = [], _i, _d, _resIntStr, _resDecStr, _resStr;

        // 检查传入金额是否存在小数部分，分离整数和小数
        _resArr = _opts.target.split('.');
        _i = _resArr[0];
        _d = _resArr[1] ? `0.${_resArr[1]}` : `0.`;

        // 检查整数部分是否符合规范
        if (!_i || _i.length > 1 && _i.indexOf('0') === 0) {
            console.error('请传入符合规范的金额');
            return false;
        }

        // 根据传入是否千分位添加逗号，处理整数部分
        _resIntStr = _opts.addComma ? _addComma({ target: _i }) : _i;

        // 根据传入保留小数位数和保留小数类型，处理小数部分
        _resDecStr = _opts.round ? Number(_d).toFixed(_opts.decimal).toString() : _zeroFill(_d, _opts.decimal).substr(0, _opts.decimal + 2);


        // 将整数部分和小数部分连接并返回
        _resStr = `${_resIntStr}${_resDecStr.substr(1)}`;
        return _resStr;
    };
}

/**
 * 千分位添加逗号
 */
const _addComma = addDelimiter({
    direction: false,
    delimiter: ', ',
    interval: 3
});

/**
 * 末尾补足零
 */
const _zeroFill = function (_target, _number) {

    if (!_target || !_number) {
        console.error('请传入补足目标和位数')
        return false;
    }

    for (let _i = 0; _i < _number; _i++) {
        _target = _target.concat('0');
    }

    return _target;
}

module.exports = { addDelimiter, formatAmount };