index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
async function delay(timeSecond) {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve();
        }, timeSecond * 1000);
    });
}
exports.delay = delay;
function deepCopy(obj) {
    return JSON.parse(JSON.stringify(obj));
}
exports.deepCopy = deepCopy;
function deepFreeze(obj) {
    let propNames = Object.getOwnPropertyNames(obj);
    propNames.forEach((name) => {
        let prop = obj[name];
        if (typeof prop == 'object' && prop !== null)
            deepFreeze(prop);
    });
    return Object.freeze(obj);
}
exports.deepFreeze = deepFreeze;
// 这个函数实际上是Object.is()的polyfill
function is(x, y) {
    if (x === y) {
        return x !== 0 || y !== 0 || 1 / x === 1 / y;
    }
    else {
        return x !== x && y !== y;
    }
}
function shallowEqual(objA, objB) {
    // 首先对基本数据类型的比较
    if (is(objA, objB))
        return true;
    // 由于Obejct.is()可以对基本数据类型做一个精确的比较， 所以如果不等
    // 只有一种情况是误判的，那就是object,所以在判断两个对象都不是object
    // 之后，就可以返回false了
    if (typeof objA !== 'object' || objA === null ||
        typeof objB !== 'object' || objB === null) {
        return false;
    }
    // 过滤掉基本数据类型之后，就是对对象的比较了
    // 首先拿出key值，对key的长度进行对比
    const keysA = Object.keys(objA);
    const keysB = Object.keys(objB);
    // 长度不等直接返回false
    if (keysA.length !== keysB.length)
        return false;
    // key相等的情况下，在去循环比较
    for (let i = 0; i < keysA.length; i++) {
        // key值相等的时候
        // 借用原型链上真正的 hasOwnProperty 方法，判断ObjB里面是否有A的key的key值
        // 属性的顺序不影响结果也就是{name:'daisy', age:'24'} 跟{age:'24'，name:'daisy' }是一样的
        // 最后，对对象的value进行一个基本数据类型的比较，返回结果
        if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
            !is(objA[keysA[i]], objB[keysA[i]])) {
            return false;
        }
    }
    return true;
}
exports.shallowEqual = shallowEqual;
function deepEqual(x, y) {
    if (x === y) {
        return true;
    }
    else if ((typeof x == "object" && x != null) && (typeof y == "object" && y != null)) {
        if (Object.keys(x).length != Object.keys(y).length)
            return false;
        for (var prop in x) {
            if (y.hasOwnProperty(prop)) {
                if (!deepEqual(x[prop], y[prop]))
                    return false;
            }
            else
                return false;
        }
        return true;
    }
    else
        return false;
}
exports.deepEqual = deepEqual;
/**
   * @param  [wait] -          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
   * @param  [noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds while the
   *                                    throttled-function is being called. If noTrailing is false or unspecified, callback will be executed one final time
   *                                    after the last throttled-function call. (After the throttled-function has not been called for `delay` milliseconds,
   *                                    the internal counter is reset).
    */
function throttle(func, wait = 100, immediate = false, noTrailing = false) {
    let timeoutID;
    let cancelled = false;
    let lastExec = 0;
    function clearExistingTimeout() {
        if (timeoutID) {
            clearTimeout(timeoutID);
            timeoutID = undefined;
        }
    }
    function cancel() {
        clearExistingTimeout();
        cancelled = true;
    }
    if (!noTrailing) {
    }
    let wrapper = function (...arguments_) {
        let self = this;
        let elapsed = lastExec ? Date.now() - lastExec : 0;
        if (cancelled)
            return;
        function exec() {
            lastExec = Date.now();
            func.apply(self, arguments_);
        }
        function clear() {
            timeoutID = undefined;
        }
        if (immediate) {
            if (!timeoutID) {
                exec();
                timeoutID = setTimeout(clear, wait);
            }
            else {
                clearExistingTimeout();
                if (noTrailing) {
                    timeoutID = setTimeout(clear, wait - elapsed);
                }
                else {
                    timeoutID = setTimeout(() => { exec(); timeoutID = setTimeout(clear, wait); }, wait - elapsed);
                }
            }
        }
        else {
            if (!timeoutID) {
                lastExec = Date.now();
                timeoutID = setTimeout(exec, wait);
            }
            else {
                clearExistingTimeout();
                timeoutID = setTimeout(exec, wait - elapsed);
            }
        }
    };
    wrapper.cancel = cancel;
    return wrapper;
}
exports.throttle = throttle;
function debounce(func, wait = 100, immediate = false) {
    let timer, args, context, timestamp, result;
    function later() {
        let last = Date.now() - timestamp;
        if (last < wait && last >= 0) {
            timer = setTimeout(later, wait - last);
        }
        else {
            timer = null;
            if (!immediate) {
                result = func.apply(context, args);
                context = args = null;
            }
        }
    }
    ;
    let debounced = function () {
        context = this;
        args = arguments;
        timestamp = Date.now();
        let callNow = immediate && !timer;
        if (!timer)
            timer = setTimeout(later, wait);
        if (callNow) {
            result = func.apply(context, args);
            context = args = null;
        }
        return result;
    };
    debounced.clear = function () {
        if (timer) {
            clearTimeout(timer);
            timer = null;
        }
    };
    debounced.flush = function () {
        if (timer) {
            result = func.apply(context, args);
            context = args = null;
            clearTimeout(timer);
            timer = null;
        }
    };
    return debounced;
}
exports.debounce = debounce;
function uniqArray(array) {
    let temp = [];
    for (var i = 0; i < array.length; i++) {
        if (temp.indexOf(array[i]) == -1) {
            temp.push(array[i]);
        }
    }
    return temp;
}
exports.uniqArray = uniqArray;
//合并两个对象到一起.
function assign(object, obj2) {
    object = object || {};
    if (!object.assign) {
        Object.defineProperty(object, "assign", {
            enumerable: false,
            configurable: true,
            writable: true,
            value: function (target, firstSource) {
                "use strict";
                if (target === undefined || target === null)
                    throw new TypeError("Cannot convert first argument to object");
                var to = Object(target);
                for (var i = 1; i < arguments.length; i++) {
                    var nextSource = arguments[i];
                    if (nextSource === undefined || nextSource === null)
                        continue;
                    var keysArray = Object.keys(Object(nextSource));
                    for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
                        var nextKey = keysArray[nextIndex];
                        var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
                        if (desc !== undefined && desc.enumerable)
                            to[nextKey] = nextSource[nextKey];
                    }
                }
                return to;
            }
        });
    }
    if (!obj2) {
        return object;
    }
    return object.assign(object, obj2);
}
exports.assign = assign;
//合并多个对象到一起.
function assignM(object, ...objs) {
    console.log("合并对象:", objs);
    let ret = object;
    for (let i in objs) {
        ret = assign(ret, objs[i]);
    }
    return ret;
}
exports.assignM = assignM;
function md5(str) {
    return require("./Md5")(str);
}
exports.md5 = md5;