前端常用对象处理工具(含getOwnPropertyDescriptor)

/**
 * 给定一个指定对象和多源对象
 * 将源对象中的所有特性复制到目标对象中
 * 最后一个给定的源对象将覆盖上一个源对象的属性
 * source objects.
 * @param {Object} dest destination object
 * @param {...Object} 从 sources中提取属性的源
 * @returns {Object} dest
 * @private
 */
export function extend(dest) {
    for (let i = 1; i < arguments.length; i++) {
        let src = arguments[i]
        for (let k in src) {
            dest[k] = src[k]
        }
    }
    return dest
}

/**
 * 使用src对象的所有属性扩展目标对象
 * 使用defineProperty代替简单赋值.
 * @param {Object} dest
 * @param {Object} src
 * @returns {Object} dest
 * @private
 */
export function extendAll(dest, src) {
    for (let i in src) {
        Object.defineProperty(dest, i, Object.getOwnPropertyDescriptor(src, i))
    }
    return dest
}

/**
 * 使用属性中的所有属性扩展父对象的原型
 * object.
 *
 * @param {Object} parent
 * @param {Object} props
 * @returns {Object}
 * @private
 */
export function inherit (parent, props) {
    let parentProto = typeof parent === 'function' ? parent.prototype : parent,
        proto = Object.create(parentProto)
    extendAll(proto, props)
    return proto
}

/**
 * 通过映射现有对象的所有值创建对象，同时保存key
 *
 * @param {Object} input
 * @param {Function} iterator
 * @returns {Object}
 * @private
 */
export function mapObject (input, iterator, context) {
    let output = {}
    for (let key in input) {
        output[key] = iterator.call(context || this, input[key], key, input)
    }
    return output
}

/**
 * 通过过滤掉现有对象的值来创建对象
 * @param {Object} input
 * @param {Function} iterator
 * @returns {Object}
 * @private
 */
export function filterObject (input, iterator, context) {
    let output = {};
    for (let key in input) {
        if (iterator.call(context || this, input[key], key, input)) {
            output[key] = input[key]
        }
    }
    return output
}

/**
 * 深度克隆两个对象.
 * @param {Object} obj1
 * @param {Object} obj2
 * @returns {boolean}
 * @private
 */
export function deepClone(input) {
    if (Array.isArray(input)) {
        return input.map(deepClone)
    } else if (typeof input === 'object') {
        return mapObject(input, deepClone)
    } else {
        return input
    }
}



// @function isArray(obj): Boolean
export const isArray = Array.isArray || function (obj) {
  return (Object.prototype.toString.call(obj) === '[object Array]');
};