js部分方法的模拟

1、公用方法：

// 简单空检测
export function isNull (v) {
    return v === null || v === undefined;
}
// 检测自有属性
export function hasOwnProperty (v, key) {
    return Object.prototype.hasOwnProperty.call(v, key);
}

2、Object.assign(target, ...from)方法：

1) 描述：该方法合并了from对象(对象集合)属性至target对象中去，且属性的enumerable为false；
2) 实现：
    // 简单Object.assign操作
    export default function Assign (target) {
        if (isNull(target)) {
            throw new Error('arguments can not be empty！');
        }
        // 简单转一下
        let to = Object(target);
        let len, from;
        if ((len = arguments.length) > 1) {
            for (let i = 1; i < len; i++) {
                // 对象(集合)
                if (!isNull((from = arguments[i]))) {
                    for (let key in from) {
                        // 检测自有属性
                        if (hasOwnProperty(from, key)) {
                            Object.defineProperty(to, key, {
                                value: from[key],
                                writable: true,
                                enumerable: false,// 默认false
                                configurable: true
                            });
                        }
                    }
                }
            }
        }
        return to;
    }

3、Array.concat(target, ...sources)方法：

1) 描述：该方法合并了source数组对象(集合)元素至target数组对象中去；
2) 实现：
    // 简单array的concat操作
    export default function arrConcat (target, ...sources) {
        let res;
        if (target instanceof Array) {
            res = [];
            target.forEach((v) => {
                res.push(v);
            });
            sources.forEach((s) => {
                if (s instanceof Array) {
                    s.forEach((v) => {
                        res.push(v);
                    });
                } else {
                    res.push(s);
                }
            });
        } else {
            throw new Error('target is not a array!');
        }
        return res;
    }

4、String.concat(target, ...sources)方法：

1) 描述：该方法合并了source字符串对象(集合)元素至target字符串对象中去;
2) 实现：
    // 简单string的concat操作
    export default function strConcat (target, ...sources) {
        let res;
        if (typeof target === 'string') {
            res = target;
            sources.forEach((v) => {
                res += typeof v === 'string' ? v : Object(v).toString();
            });
        } else {
            throw new Error('target is not a string!');
        }
        return res;
    }

5、Array.splice(arr, index, length, ...values)方法：

1) 描述：该方法对arr数组实现从index位置开始，截取或替换length长度的元素(values)；
2) 实现：
    // 简单Array.splice方法，很多方法未考虑
    export default function Splice (arr, index, length, ...values) {
        if (!(arr instanceof Array)) {
            throw new Error('arr is not array!');
        }
        // 原有个数
        let aLen = arr.length;
        let vLen = values.length;
        let res = [];
        length = length < 0 ? 0 : length;
        index = index < 0 ? index + aLen : index;
        // 替换
        if (vLen > 0) {
            arr.length = aLen + vLen - length;
            // 填充
            for (let i = index; i < index + vLen; i++) {
                res.push(arr[i]);
                arr[i] = values[i - index];
            }
            if (vLen > length) {
                // 拷贝
                let move = arr.slice(index + length);
                // 移动
                for (let i = index + vLen; i < aLen + vLen - length; i++) {
                    res.push(arr[i]);
                    arr[i] = move[i - index - vLen];
                }
            } else {
                // 移动
                for (let i = index + vLen; i < aLen + length - vLen; i++) {
                    res.push(arr[i]);
                    arr[i] = arr[i - length + vLen];
                }
            }
        } else if (length > 0) {
            if (aLen > 0) {
                // index+length大于总长度
                if (aLen - length < index) {
                    res = arr.slice(index);
                    arr.length = index;
                } else {
                    // 拷贝
                    let move = arr.slice(index + length);
                    // 移动
                    for (let i = index; i < index + move.length; i++) {
                        res.push(arr[i]);
                        arr[i] = move[i - index];
                    }
                    arr.length = aLen - length;
                }
            }
        } else {
            if (aLen > 0 && index > 0) {
                let newLen = aLen > index ? index : aLen;
                res = arr.slice(newLen);
                arr.length = newLen;
            }
        }
        return res;
    }