tools

工具函数

isFn()

function isFn(fn) { 
    return typeof fn === "function";
}

isArr()

function isArr(arr) {
    return Array.isArray(arr);
}

isStr()

function isStr(str) {
    return typeof str === "string";
}

isNum()

function isNum(num) {
    return typeof num === "number" && isFinite(num);
}

toBool()

// 转为布尔值 
function toBool(obj) {
    return !!obj;
}

isNumStr()

// 是否为数字字符  
function isNumStr(str) {
    return str.search(/^([1-9]\d*|0)(\.\d+)?$/) !== -1;
}

isSet()

// 是否为 Set 类型 
function isSet(data) {
    return data instanceof Set;
}

isMap()

// 是否为 Map 类型 
function isMap(data) {
    return data instanceof Map;
}

isNull()

// 是否为 null 类型  
function isNull(data) {
    return data === null;
}

trim()

// 字符去空格
// str : 被处理字符 
// isGlobal : false 前后去空
// isGlobal : true  完全去空
function trim(str, isGlobal = false) {
    var result;
    result = str.replace(/(^\s+)|(\s+$)/g, ""); 
    if (isGlobal) {
        result = result.replace(/\s/g, "");
    }
    return result;
}

isObj()

// 是否是对象 
function isObj(obj) {
    return typeof obj === "object";
}

isEven()

// 是否为奇数
function isEven(num) {
    return !!!(num % 2);
}

hasBrackets()

// 是否有括号 
function hasBrackets(str) {
    return str.search(/\(+|\)+/gim) !== -1;
}

emptyToNull()

// 将数据为空串的值替换为null
function emptyToNull(data) {
    if (data instanceof Array) {
        for (let item of data) {
            if (item instanceof Object) {
                emptyToNull(item);
            } else {
                if (new String(data[item]).trim() === "") {
                    data[item] = null;
                }
            }
        }
    } else {
        for (let prop in data) {
            if (prop instanceof Object) {
                emptyToNull(prop);
            } else {
                if (new String(data[prop]).trim() === "") {
                    data[prop] = null;
                }
            }
        }
    } 
    return data;
}

dbBrackets()

// 小括号匹配规则
// 小括号成对出现 且 以左括号为开始(非开头字符)
function dbBrackets(str) {
    const strArr = str.split("");
    const breacketNum = strArr.reduce((acc, next) => {
        if (next === "(") {
            acc += 1;
        }
        if (next === ")") {
            acc -= 1;
        }
        if (acc === -1) {
            acc = NaN;
        }
        return acc;
    }, 0);
    return breacketNum === 0 ? str : false;
}

warpFn()

// 事件方法绑定实例
// target    绑定实例
// fns       函数集
// warpData  附属参数, 将添加在函数参数末尾
function warpFn(target, fns, ...warpData) {
    const arrFn = isArr(fns) ? [] : {};

    try {
        return lMap(fns, {
            init: arrFn,

            /**
             * 包裹函数，将处理 object/array 重新赋值时需要区别对待
             */
            callback(acc, key, index) {
                // 获取标志
                let flag = isArr(fns) ? index : key;

                // 通过闭包绑定目标对象
                acc[flag] = (...args) => {
                    args = [...args, ...warpData];
                    return toBool(warpData)
                        ? fns[flag].apply(target, args)
                        : fns[flag](args);
                };
                return acc;
            },
        });
    } catch (e) {
        console.log("方法包装失败:", e);
        return fns;
    }
}