tongtong-utils/lib/objectx.js

String类

"use strict";

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

require("./string");

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

Object.clone = function (obj) {
    var func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    if (!obj || !(obj instanceof Object) || typeof obj == "function") {
        if (typeof obj == "function" && func) {
            return null;
        }
        return obj;
    }
    var constructor = obj.constructor;
    var result = new constructor();
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
            result[key] = Object.clone(obj[key]);
        }
    }
    return result;
};

Object.extend = function (target, object1) {
    if (object1 && (typeof object1 === "undefined" ? "undefined" : _typeof(object1)) === "object") {
        for (var key in object1) {
            if (object1.hasOwnProperty(key)) {
                //判断ojb子元素是否为对象，如果是，递归复制
                if (object1[key] && _typeof(object1[key]) === "object" && !(object1[key] instanceof Array) && !(object1[key] instanceof Function) && !(object1[key] instanceof RegExp)) {
                    target[key] = Object.extend((target[key] instanceof Function ? {} : target[key]) || (object1[key] instanceof Array ? [] : {}), object1[key]);
                } else if (object1[key] instanceof Array) {
                    //如果不是，简单复制
                    target[key] = [].concat(_toConsumableArray(object1[key]));
                } else {
                    //如果不是，简单复制
                    target[key] = object1[key];
                }
            }
        }
    }
    for (var i = 2; i < arguments.length; i++) {
        Object.extend(target, arguments[i]);
    }
    return target;
};

var getValueX = function getValueX(object, field) {
    var repeat = [];
    var totalIndex = 0;
    var fields = field.split(".");
    var fs = fields.map(function (f, i) {
        return fields.slice(0, i + 1).join(".");
    });
    var variable = [];
    var maxIndex = 10;
    if (fields.every(function (f) {
        return f !== "*";
    })) {
        maxIndex = fields.length;
    }
    var getKeys = function getKeys(subObjects) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

        if (index > maxIndex || totalIndex > 10000) {
            return undefined;
        }
        variable[index] = {};
        for (var subObjectKey in subObjects) {
            var subObject = subObjects[subObjectKey];
            for (var key in subObject) {
                totalIndex++;
                try {
                    var val = subObject[key];
                    if ((subObjectKey ? field.includes('.') : true) && String.test(subObjectKey + key, field)) {
                        return val;
                    }
                    if (val instanceof Object && !repeat.includes(val) && String.testSome(subObjectKey + key, fs.slice(0, index))) {
                        repeat.push(val);
                        variable[index][subObjectKey + key + "."] = val;
                    }
                } catch (ex) {
                    continue;
                }
            }
        }
        return Object.isEmpty(variable[index]) || index > maxIndex ? undefined : getKeys(variable[index], index + 1);
    };
    return getKeys({ "": object });
};

var getValue = function getValue(object, field) {
    var fields = field.split('.');
    var result = _extends({}, object);
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
        for (var _iterator = fields[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var key = _step.value;

            if (result !== undefined && result !== null && result[key] !== undefined) {
                result = result[key];
            } else {
                return undefined;
            }
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally {
        try {
            if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
            }
        } finally {
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }

    return result;
};

Object.getValue = function (object, field, defaultValue) {
    if (!field) {
        return object;
    }
    if (!object || !Object.keys(object).length || !field) {
        return defaultValue;
    }
    if (String.replaceAlls) {
        field = String.replaceAlls(field, ['[', ']', '"', "'"], ['.', '', '', '']);
    }
    var fields = field.split('|');
    var result = defaultValue;
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;

    try {
        for (var _iterator2 = fields[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
            var f = _step2.value;

            var res = ~f.indexOf('*') ? getValueX(object, f) : getValue(object, f);
            if (res !== undefined) {
                result = res;
                if (res !== null) {
                    break;
                }
            }
        }
    } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
    } finally {
        try {
            if (!_iteratorNormalCompletion2 && _iterator2.return) {
                _iterator2.return();
            }
        } finally {
            if (_didIteratorError2) {
                throw _iteratorError2;
            }
        }
    }

    return result === undefined || result === null ? defaultValue : result;
};

Object.setValue = function (object, field, value) {
    var force = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;

    if (!field) {
        object = value;
        return object;
    }
    if (!object) {
        object = {};
    }
    var fields = field.split ? field.split('.') : field;
    var result = object;
    for (var i = 0; i < fields.length - 1; i++) {
        var key = fields[i];
        if (_typeof(result[key]) === 'object') {
            result = result[key];
        } else {
            if (force) {
                result[key] = {};
                result = result[key];
            } else {
                break;
            }
        }
    }
    var lastField = fields.pop();
    var obj = Object.getValue(object, fields.join('.'));
    if (obj) {
        obj[lastField] = value;
    }
    return object;
};
// 判断对象是否为空，except为除外的属性, except为数组，支持字符串与正则匹配
Object.isEmpty = function (object) {
    var except = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

    if (!object) {
        return true;
    }

    var _loop = function _loop(key) {
        if (except && except.some(function (ex) {
            return typeof ex === "string" ? ex === key : ex.test(key);
        })) {
            return "continue";
        }
        if (object.hasOwnProperty(key)) {
            return {
                v: false
            };
        }
    };

    for (var key in object) {
        var _ret = _loop(key);

        switch (_ret) {
            case "continue":
                continue;

            default:
                if ((typeof _ret === "undefined" ? "undefined" : _typeof(_ret)) === "object") return _ret.v;
        }
    }
    return true;
};

Object.toStr = function (object) {
    return JSON.stringify(Object.clone(object));
};

Object.equal = function (object1, object2) {
    return Object.toStr(object1) === Object.toStr(object2);
};

Object.changeList = function (object1, object2) {
    if (!object1) {
        object1 = {};
    }
    if (!object2) {
        object2 = {};
    }
    var changes = [];
    for (var key in object1) {
        if (object1[key] !== object2[key]) {
            !changes.includes(key) && changes.push(key);
        }
    }
    for (var _key in object2) {
        if (object1[_key] !== object2[_key]) {
            !changes.includes(_key) && changes.push(_key);
        }
    }
    return changes;
};

Object.renderText = function (text, object, rewrite) {
    if (!text || Object.isEmpty(object)) {
        return text;
    }
    var fields = String.Resovles(text, '${', '}') || [];
    for (var i = 0; i < fields.length; i++) {
        var field = fields[i];
        var newField = field;
        if (rewrite) {
            for (var rewriteKey in rewrite) {
                newField = String.replaceAll(field, rewriteKey, rewrite[rewriteKey]);
            }
        }
        var result = Object.getValue(object, newField, '');
        if ('${' + field + '}' === text) {
            return result;
        }
        text = String.replaceAll(text, '${' + field + '}', String.toString(result));
    }
    return text;
};

Object.renderRecord = function (text, object, rewrite) {
    if (!text || Object.isEmpty(object)) {
        return text;
    }
    var expressions = String.Resovles(text, '[#', '#]') || [];
    if (expressions && expressions.length) {
        for (var i = 0; i < expressions.length; i++) {
            var expression = expressions[i];
            var exp = Object.renderText(expression, object, rewrite);
            try {
                exp = eval(exp);
                if ('[#' + expression + '#]' === text) {
                    return exp;
                }
                exp = exp === null || exp === undefined ? '' : String.toString(exp);
            } catch (ex) {
                console.log(exp, ex);
            }
            text = text.toString().replace('[#' + expression + '#]', exp);
        }
    }
    return Object.renderText(text, object, rewrite);
};
Object.renderObject = function (obj, object, rewrite) {
    for (var key in obj) {
        switch (_typeof(obj[key])) {
            case 'string':
                obj[key] = Object.renderRecord(obj[key], object, rewrite);
                break;
            case 'object':
                Object.renderObject(obj[key], object, rewrite);
                break;
        }
    }
    return obj;
};
Object.renderArray = function (arr, obj, object) {
    return arr.map(function (s, index) {
        return _extends({}, s, Object.renderObject(Object.clone(obj), _extends({}, object, { item: s }, s), { '[index]': "[" + index + "]" }));
    });
};