astuteweb-utils/src/object/index.js

机敏web开发常用工具函数

/**
 * 浅克隆
 *
 * @export
 * @param {*} origin
 * @param {*} target
 * @return {*} target
 */
export function shallowClone(origin, target) {
    for(let prop in origin) {
        if(origin.hasOwnProperty(prop)) {
            target[prop] = origin[prop];
        }
    }
    return target;
}


/**
 * 深克隆
 *
 * @export
 * @param {*} origin
 * @param {*} target
 * @return {*} target
 */
export function deepClone(origin, target) {
    let tar = target || {};
    const toStr = Object.prototype.toString();
    const arrStr = '[object Array]';
    for(let prop in origin) {
        if(origin.hasOwnProperty(prop)) {
            if(origin[prop] !== null && typeof(origin[prop] == 'object')) {
                tar[prop] = toStr.call(origin[prop]) == arrStr ? [] : {};
                deepClone(origin[prop], tar[prop]);
            } else {
                tar[prop] = origin[prop];
            }
        }
    }

    return tar;
}


/**
 *检验是否为对象
 *
 * @export
 * @param {*} obj
 * @return {*} 
 */
export function isObject(obj) {
    return obj !== null && typeof obj === 'object';
}

/**
 *检验是否为对象
 *
 * @export
 * @param {*} obj
 * @return {*} 
 */
const toString = Object.prototype.toString;
const OBJECT_STRING = '[object Object]';
export function isPlainObject(obj) {
    return toString.call(obj) === OBJECT_STRING;
}

export function parseArgs(...args) {
    let locale = null;
    let params = null;
    if(args.length === 1) {
        if(isObject(args[0] || Array.isArray(args[0]))) {
            params = args[0];
        } else if(typeof args[0] === 'string') {
            locale = args[0];
        }
    } else if(args.length === 2) {
        if(typeof args[0] === 'string') {
            locale = args[0];
        }
        if(isObject(args[1] || Array.isArray(args[1]))) {
            params = args[1];
        }
    }
    return {
        locale,
        params
    }
}

/**
 * 对象是否某含某个非集成属性
 *
 * @export
 * @param {*} obj
 * @param {*} key
 * @return {*} 
 */
const hasOwnProperty = Object.prototype.hasOwnProperty;
export function hasOwn(obj, key) {
    return hasOwnProperty.call(obj, key);
}


/**
 *合并对象
 *
 * @export
 * @param {*} target
 * @return {*} 
 */
export function merge(target) {
    const output = Object(target);
    for(let i = 1; i < arguments.length; i++) {
        const source = arguments[i];
        if(source !== undefined && source !== null) {
            let key;
            for(key in source) {
                if(hasOwn(source, key)) {
                    if(isObject(source(key))) {
                        output[key] = merge(output[key], source[key]);
                    } else {
                        output[key] = source[key];
                    }
                }
            }
        }
    }

    return output;
}