字符串工具類

/**
 * @author: 苗士軍
 * @description 字符串工具類
 */
StringUtils = {
    /**
     * @description 判斷字符串是否爲空
     * @param input
     * @return {boolean}
     */
    isEmpty: function(input) {
        return input == null || input == '';
    },
    /**
     * @description 判斷字符串是否不爲空
     * @param input
     * @return {boolean}
     */
    isNotEmpty: function(input) {
        return !this.isEmpty(input);
    },
    /**
     * @description 判斷字符串是否全是空格
     * @param input
     * @return {boolean}
     */
    isBlank: function(input) {
        return input == null || /^\s*$/.test(input);
    },
    /**
     * @description 判斷字符串是否不全是空格
     * @param input
     * @return {boolean}
     */
    isNotBlank: function(input) {
        return !this.isBlank(input);
    },
    /**
     * @description 去除字符串首尾空格
     * @param input
     * @return {void|string|XML}
     */
    trim: function(input) {
        return input.replace(/^\s+|\s+$/g, '');
    },
    /**
     * @description 輸入去掉首尾空格
     * @param input
     * @return {*}
     */
    trimToEmpty: function(input) {
        return input == null ? "" : this.trim(input);
    },
    /**
     * @description 字符串是否以字符串開頭
     * @param input
     * @param prefix
     * @return {boolean}
     */
    startsWith: function(input, prefix) {
        return input.indexOf(prefix) === 0;
    },
    /**
     * @description 字符串是否以字符串結尾
     * @param input
     * @param prefix
     * @return {boolean}
     */
    endsWith: function(input, suffix) {
        return input.lastIndexOf(suffix) === 0;
    },
    /**
     * @description 字符串是否包含某些字符串
     * @param input
     * @param searchSeq
     * @return {boolean}
     */
    contains: function(input, searchSeq) {
        return input.indexOf(searchSeq) >= 0;
    },
    /**
     * @description 判斷字符串是否相等
     * @param input1
     * @param input2
     * @return {boolean}
     */
    equals: function(input1, input2) {
        return input1 == input2;
    },
    /**
     * @description 字符串忽略大小寫比較是否相等
     * @param input1
     * @param input2
     * @return {boolean}
     */
    equalsIgnoreCase: function(input1, input2) {
        return input1.toLocaleLowerCase() == input2.toLocaleLowerCase();
    },
    /**
     * @description 判斷字符串是否包含空格
     * @param input
     * @return {*|boolean}
     */
    containsWhitespace: function(input) {
        return this.contains(input, ' ');
    },
    /**
     * @description 生成指定個數的字符
     * @param ch
     * @param repeatTimes
     * @return {string}
     */
    repeat: function(ch, repeatTimes) {
        var result = "";
        for(var i = 0; i < repeatTimes; i++) {
            result += ch;
        }
        return result;
    },
    /**
     * @description 去除所有空格
     * @param input
     * @return {void|string|XML}
     */
    deleteWhitespace: function(input) {
        return input.replace(/\s+/g, '');
    },
    /**
     * @description 字符串右邊添加劇復幾回的固定字符串
     * @param input
     * @param size
     * @param padStr
     * @return {*}
     */
    rightPad: function(input, size, padStr) {
        return input + this.repeat(padStr, size);
    },
    /**
     * @description 字符串左邊添加劇復幾回的固定字符串
     * @param input
     * @param size
     * @param padStr
     * @return {*}
     */
    leftPad: function(input, size, padStr) {
        return this.repeat(padStr, size) + input;
    },
    /**
     * @description  首小寫字母轉大寫
     * @param input
     * @return {*}
     */
    capitalize: function(input) {
        var strLen = 0;
        if(input == null || (strLen = input.length) == 0) {
            return input;
        }
        return input.replace(/^[a-z]/, function(matchStr) {
            return matchStr.toLocaleUpperCase();
        });
    },
    /**
     * @description 首大寫字母轉小寫
     * @param input
     * @return {*}
     */
    uncapitalize: function(input) {
        var strLen = 0;
        if(input == null || (strLen = input.length) == 0) {
            return input;
        }
        return input.replace(/^[A-Z]/, function(matchStr) {
            return matchStr.toLocaleLowerCase();
        });
    },
    /**
     * @description 大寫轉小寫，小寫轉大寫
     * @param input
     * @return {void|string|XML}
     */
    swapCase: function(input) {
        return input.replace(/[a-z]/ig, function(matchStr) {
            if(matchStr >= 'A' && matchStr <= 'Z') {
                return matchStr.toLocaleLowerCase();
            } else if(matchStr >= 'a' && matchStr <= 'z') {
                return matchStr.toLocaleUpperCase();
            }
        });
    },
    /**
     * @description 統計含有的子字符串的個數
     * @param input
     * @param sub
     * @return {number}
     */
    countMatches: function(input, sub) {
        if(this.isEmpty(input) || this.isEmpty(sub)) {
            return 0;
        }
        var count = 0;
        var index = 0;
        while((index = input.indexOf(sub, index)) != -1) {
            index += sub.length;
            count++;
        }
        return count;
    },
    /**
     * @description 只包含字母
     * @param input
     * @return {boolean}
     */
    isAlpha: function(input) {
        return /^[a-z]+$/i.test(input);
    },
    /**
     * @description 只包含字母、空格
     * @param input
     * @return {boolean}
     */
    isAlphaSpace: function(input) {
        return /^[a-z\s]*$/i.test(input);
    },
    /**
     * @description 只包含字母、數字
     * @param input
     * @return {boolean}
     */
    isAlphanumeric: function(input) {
        return /^[a-z0-9]+$/i.test(input);
    },
    /**
     * @description 只包含字母、數字和空格
     * @param input
     * @return {boolean}
     */
    isAlphanumericSpace: function(input) {
        return /^[a-z0-9\s]*$/i.test(input);
    },
    /**
     * @description 數字
     * @param input
     * @return {boolean}
     */
    isNumeric: function(input) {
        return /^(?:[1-9]\d*|0)(?:\.\d+)?$/.test(input);
    },
    /**
     * @description 小數
     * @param input
     * @return {boolean}
     */
    isDecimal: function(input) {
        return /^[-+]?(?:0|[1-9]\d*)\.\d+$/.test(input);
    },
    /**
     * @description 小數(只能出現-)
     * @param input
     * @return {boolean}
     */
    isNegativeDecimal: function(input) {
        return /^\-?(?:0|[1-9]\d*)\.\d+$/.test(input);
    },
    /**
     * @description 小數(只能出現+)
     * @param input
     * @return {boolean}
     */
    isPositiveDecimal: function(input) {
        return /^\+?(?:0|[1-9]\d*)\.\d+$/.test(input);
    },
    /**
     * @description 整數
     * @param input
     * @return {boolean}
     */
    isInteger: function(input) {
        return /^[-+]?(?:0|[1-9]\d*)$/.test(input);
    },
    /**
     * @description 整數（+）
     * @param input
     * @return {boolean}
     */
    isPositiveInteger: function(input) {
        return /^\+?(?:0|[1-9]\d*)$/.test(input);
    },
    /**
     * @description 整數（-）
     * @param input
     * @return {boolean}
     */
    isNegativeInteger: function(input) {
        return /^\-?(?:0|[1-9]\d*)$/.test(input);
    },
    /**
     * @description 只包含數字和空格
     * @param input
     * @return {boolean}
     */
    isNumericSpace: function(input) {
        return /^[\d\s]*$/.test(input);
    },
    /**
     * @description 碰到字符串是不是空格
     * @param input
     * @return {boolean}
     */
    isWhitespace: function(input) {
        return /^\s*$/.test(input);
    },
    /**
     * @description 判斷字符串是否全是小寫
     * @param input
     * @return {boolean}
     */
    isAllLowerCase: function(input) {
        return /^[a-z]+$/.test(input);
    },
    /**
     * @description 判斷字符串是否全是大寫
     * @param input
     * @return {boolean}
     */
    isAllUpperCase: function(input) {
        return /^[A-Z]+$/.test(input);
    },
    /**
     * @description 字符串初始化
     * @param input
     * @param defaultStr
     * @return {*}
     */
    defaultString: function(input, defaultStr) {
        return input == null ? defaultStr : input;
    },
    /**
     * @description 字符串初始化
     * @param input
     * @param defaultStr
     * @return {*}
     */
    defaultIfBlank: function(input, defaultStr) {
        return this.isBlank(input) ? defaultStr : input;
    },
    /**
     * @description 字符串初始化
     * @param input
     * @param defaultStr
     * @return {*}
     */
    defaultIfEmpty: function(input, defaultStr) {
        return this.isEmpty(input) ? defaultStr : input;
    },
    /**
     * @description 字符串反轉
     * @param input
     * @return {string}
     */
    reverse: function(input) {
        if(this.isBlank(input)) {
            input;
        }
        return input.split("").reverse().join("");
    },
    /**
     * @description 刪掉特殊字符(英文狀態下)
     * @param input
     * @return {string|XML|void}
     */
    removeSpecialCharacter: function(input) {
        return input.replace(/[!-/:-@\[-`{-~]/g, "");
    },
    /**
     * @description 只包含特殊字符、數字和字母（不包括空格，若想包括空格，改成[ -~]）
     * @param input
     * @return {boolean}
     */
    isSpecialCharacterAlphanumeric: function(input) {
        return /^[!-~]+$/.test(input);
    },
    /**
     * @description 校驗時排除某些字符串，即不能包含某些字符串
     * @param input
     * @param conditions {Object} conditions:裏面有多個屬性，以下：
     *  @param {String} matcherFlag 匹配標識
     * 0:數字；1：字母；2：小寫字母；3:大寫字母；4：特殊字符,指英文狀態下的標點符號及括號等；5:中文;
     * 6:數字和字母；7：數字和小寫字母；8：數字和大寫字母；9：數字、字母和特殊字符；10：數字和中文；
     * 11：小寫字母和特殊字符；12：大寫字母和特殊字符；13：字母和特殊字符；14：小寫字母和中文；15：大寫字母和中文；
     * 16：字母和中文；17：特殊字符、和中文；18：特殊字符、字母和中文；19：特殊字符、小寫字母和中文；20：特殊字符、大寫字母和中文；
     * 100：全部字符;
     * @param {Array} excludeStrArr 排除的字符串，數組格式
     * @param {String} length 長度，可爲空。1,2表示長度1到2之間；10，表示10個以上字符；5表示長度爲5
     * @param {Boolean} ignoreCase 是否忽略大小寫
     * conditions={matcherFlag:"0",excludeStrArr:[],length:"",ignoreCase:true}
     * @return {boolean}
     */
    isPatternMustExcludeSomeStr: function(input, conditions) {
        //參數
        var matcherFlag = conditions.matcherFlag;
        var excludeStrArr = conditions.excludeStrArr;
        var length = conditions.length;
        var ignoreCase = conditions.ignoreCase;
        //拼正則
        var size = excludeStrArr.length;
        var regex = (size == 0) ? "^" : "^(?!.*(?:{0}))";
        var subPattern = "";
        for(var i = 0; i < size; i++) {
            excludeStrArr[i] = StringUtils.escapeMetacharacterOfStr(excludeStrArr[i]);
            subPattern += excludeStrArr[i];
            if(i != size - 1) {
                subPattern += "|";
            }
        }
        regex = this.format(regex, [subPattern]);
        switch(matcherFlag) {
            case '0':
                regex += "\\d";
                break;
            case '1':
                regex += "[a-zA-Z]";
                break;
            case '2':
                regex += "[a-z]";
                break;
            case '3':
                regex += "[A-Z]";
                break;
            case '4':
                regex += "[!-/:-@\[-`{-~]";
                break;
            case '5':
                regex += "[\u4E00-\u9FA5]";
                break;
            case '6':
                regex += "[a-zA-Z0-9]";
                break;
            case '7':
                regex += "[a-z0-9]";
                break;
            case '8':
                regex += "[A-Z0-9]";
                break;
            case '9':
                regex += "[!-~]";
                break;
            case '10':
                regex += "[0-9\u4E00-\u9FA5]";
                break;
            case '11':
                regex += "[a-z!-/:-@\[-`{-~]";
                break;
            case '12':
                regex += "[A-Z!-/:-@\[-`{-~]";
                break;
            case '13':
                regex += "[a-zA-Z!-/:-@\[-`{-~]";
                break;
            case '14':
                regex += "[a-z\u4E00-\u9FA5]";
                break;
            case '15':
                regex += "[A-Z\u4E00-\u9FA5]";
                break;
            case '16':
                regex += "[a-zA-Z\u4E00-\u9FA5]";
                break;
            case '17':
                regex += "[\u4E00-\u9FA5!-/:-@\[-`{-~]";
                break;
            case '18':
                regex += "[\u4E00-\u9FA5!-~]";
                break;
            case '19':
                regex += "[a-z\u4E00-\u9FA5!-/:-@\[-`{-~]";
                break;
            case '20':
                regex += "[A-Z\u4E00-\u9FA5!-/:-@\[-`{-~]";
                break;
            case '100':
                regex += "[\s\S]";
                break;
            default:
                alert(matcherFlag + ":This type is not supported!");
        }
        regex += this.isNotBlank(length) ? "{" + length + "}" : "+";
        regex += "$";
        var pattern = new RegExp(regex, ignoreCase ? "i" : "");
        return pattern.test(input);
    },
    /**
     * @description 消息格式化
     * @param {String} message
     * @param {Array} arr
     */
    format: function(message, arr) {
        return message.replace(/{(\d+)}/g, function(matchStr, group1) {
            return arr[group1];
        });
    },
    /**
     * @description 把連續出現屢次的字母字符串進行壓縮。如輸入:aaabbbbcccccd 輸出:3a4b5cd
     * @param {String} input
     * @param {Boolean} ignoreCase : true or false
     */
    compressRepeatedStr: function(input, ignoreCase) {
        var pattern = new RegExp("([a-z])\\1+", ignoreCase ? "ig" : "g");
        return result = input.replace(pattern, function(matchStr, group1) {
            return matchStr.length + group1;
        });
    },
    /**
     * @description 校驗必須同時包含某些字符串
     * @param {String} input
     * @param {Object} conditions:裏面有多個屬性，以下：
     * @param {String} matcherFlag 匹配標識
     * 0:數字；1：字母；2：小寫字母；3:大寫字母；4：特殊字符,指英文狀態下的標點符號及括號等；5:中文;
     * 6:數字和字母；7：數字和小寫字母；8：數字和大寫字母；9：數字、字母和特殊字符；10：數字和中文；
     * 11：小寫字母和特殊字符；12：大寫字母和特殊字符；13：字母和特殊字符；14：小寫字母和中文；15：大寫字母和中文；
     * 16：字母和中文；17：特殊字符、和中文；18：特殊字符、字母和中文；19：特殊字符、小寫字母和中文；20：特殊字符、大寫字母和中文；
     * 100：全部字符;
     * @param {Array} excludeStrArr 排除的字符串，數組格式
     * @param {String} length 長度，可爲空。1,2表示長度1到2之間；10，表示10個以上字符；5表示長度爲5
     * @param {Boolean} ignoreCase 是否忽略大小寫
     * conditions={matcherFlag:"0",containStrArr:[],length:"",ignoreCase:true}
     * @return {boolean}
     */
    isPatternMustContainSomeStr: function(input, conditions) {
        //參數
        var matcherFlag = conditions.matcherFlag;
        var containStrArr = conditions.containStrArr;
        var length = conditions.length;
        var ignoreCase = conditions.ignoreCase;
        //建立正則
        var size = containStrArr.length;
        var regex = "^";
        var subPattern = "";
        for(var i = 0; i < size; i++) {
            containStrArr[i] = Bee.StringUtils.escapeMetacharacterOfStr(containStrArr[i]);
            subPattern += "(?=.*" + containStrArr[i] + ")";
        }
        regex += subPattern;
        switch(matcherFlag) {
            case '0':
                regex += "\\d";
                break;
            case '1':
                regex += "[a-zA-Z]";
                break;
            case '2':
                regex += "[a-z]";
                break;
            case '3':
                regex += "[A-Z]";
                break;
            case '4':
                regex += "[!-/:-@\[-`{-~]";
                break;
            case '5':
                regex += "[\u4E00-\u9FA5]";
                break;
            case '6':
                regex += "[a-zA-Z0-9]";
                break;
            case '7':
                regex += "[a-z0-9]";
                break;
            case '8':
                regex += "[A-Z0-9]";
                break;
            case '9':
                regex += "[!-~]";
                break;
            case '10':
                regex += "[0-9\u4E00-\u9FA5]";
                break;
            case '11':
                regex += "[a-z!-/:-@\[-`{-~]";
                break;
            case '12':
                regex += "[A-Z!-/:-@\[-`{-~]";
                break;
            case '13':
                regex += "[a-zA-Z!-/:-@\[-`{-~]";
                break;
            case '14':
                regex += "[a-z\u4E00-\u9FA5]";
                break;
            case '15':
                regex += "[A-Z\u4E00-\u9FA5]";
                break;
            case '16':
                regex += "[a-zA-Z\u4E00-\u9FA5]";
                break;
            case '17':
                regex += "[\u4E00-\u9FA5!-/:-@\[-`{-~]";
                break;
            case '18':
                regex += "[\u4E00-\u9FA5!-~]";
                break;
            case '19':
                regex += "[a-z\u4E00-\u9FA5!-/:-@\[-`{-~]";
                break;
            case '20':
                regex += "[A-Z\u4E00-\u9FA5!-/:-@\[-`{-~]";
                break;
            case '100':
                regex += "[\s\S]";
                break;
            default:
                alert(matcherFlag + ":This type is not supported!");
        }
        regex += this.isNotBlank(length) ? "{" + length + "}" : "+";
        regex += "$";
        var pattern = new RegExp(regex, ignoreCase ? "i" : "");
        return pattern.test(input);
    },
    /**
     * @description 中文校驗
     * @param input
     * @return {boolean}
     */
    isChinese: function(input) {
        return /^[\u4E00-\u9FA5]+$/.test(input);
    },
    /**
     * @description 去掉中文字符
     * @param input
     * @return {string|XML|void}
     */
    removeChinese: function(input) {
        return input.replace(/[\u4E00-\u9FA5]+/gm, "");
    },
    /**
     * @description 轉義元字符
     * @param input
     * @return {*}
     */
    escapeMetacharacter: function(input) {
        var metacharacter = "^$()*+.[]|\\-?{}|";
        if(metacharacter.indexOf(input) >= 0) {
            input = "\\" + input;
        }
        return input;
    },
    /**
     * @description 轉義字符串中的元字符
     * @param input
     * @return {*}
     */
    escapeMetacharacterOfStr: function(input) {
        return input.replace(/[\^\$\*\+\.\|\\\-\?\{\}\|]/gm, "\\$&");
    },
    /**
     * @description 加強字符串替換函數
     * @param input
     * @param oldStr
     * @param newStr
     * @return {string|XML|void}
     */
    replaceAll: function(input,oldStr,newStr)
    {
        return  input.replace(new RegExp(oldStr,"gm"),newStr);
    }
};