js数据处理总结

数据处理方法

数组：

1、数值保留多少位

/**
 * 数值保留多少位
 * @param {Number} num 数值
 * @param {Number} pointLen 保留位数
 */
export const toFixed = (num, pointLen) => { //num---要处理的值   pointLen----需要保留的小数位
    if (!num) return num;
    if (num.toString().indexOf('.') < 0) return parseFloat(num); // 是整数直接返回
    return parseFloat(num).toFixed(pointLen);
};

2、js字符串与数字混合的字符串排序要求先字符后数字

var list = ['abc123', 'abc11', 'abc2']
var list2 = []
list2 = list.sort(function(a, b) {
  return a.localeCompare(b, 'zh-CN', { numeric: true })
})
console.log(list2) //["abc2", "abc11", "abc123"]

对象

1、删除对象中的空键值对

export function trimObject(object) {
  var newParams = {};
  _.forEach(object, function (val, key) {
    // eslint-disable-next-line no-param-reassign
    if (typeof val === 'string') val = val.trim();
    if (val === '' || val == null) return;
    newParams[key] = val;
  });
  return newParams;
}

2、判断两个对象是否相等

export function deepCompare(x, y) {
    var i, l, leftChain, rightChain;

    function compare2Objects(x, y) {
        var p;
        if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
            return true;
        }
        if (x === y) {
            return true;
        }
        if ((typeof x === 'function' && typeof y === 'function') ||
            (x instanceof Date && y instanceof Date) ||
            (x instanceof RegExp && y instanceof RegExp) ||
            (x instanceof String && y instanceof String) ||
            (x instanceof Number && y instanceof Number)) {
            return x.toString() === y.toString();
        }
        if (!(x instanceof Object && y instanceof Object)) {
            return false;
        }

        if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
            return false;
        }

        if (x.constructor !== y.constructor) {
            return false;
        }

        if (x.prototype !== y.prototype) {
            return false;
        }

        if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
            return false;
        }
        for (p in y) {
            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
                return false;
            } else if (typeof y[p] !== typeof x[p]) {
                return false;
            }
        }

        for (p in x) {
            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
                return false;
            } else if (typeof y[p] !== typeof x[p]) {
                return false;
            }

            switch (typeof(x[p])) {
                case 'object':
                case 'function':

                    leftChain.push(x);
                    rightChain.push(y);

                    if (!compare2Objects(x[p], y[p])) {
                        return false;
                    }

                    leftChain.pop();
                    rightChain.pop();
                    break;

                default:
                    if (x[p] !== y[p]) {
                        return false;
                    }
                    break;
            }
        }

        return true;
    }

    if (arguments.length < 1) {
        return true; 
    }

    for (i = 1, l = arguments.length; i < l; i++) {

        leftChain = []; //Todo: this can be cached
        rightChain = [];

        if (!compare2Objects(arguments[0], arguments[i])) {
            return false;
        }
    }

    return true;
}

… …