javascript:内置对象 常用函数

一、常见的字符串处理函数

// 返回字符的长度,一个中文算2个
String.prototype.ChineseLength = function() {
    return this.replace(/[^\x00-\xff]/g, "**").length;
}

// 去掉字符串两端的空白字符
String.prototype.Trim = function() {
    return this.replace(/(^\s+)|(\s+$)/g, "");
}

// 去掉字符左端的的空白字符
String.prototype.LeftTrim = function() {
    return this.replace(/(^[\s]*)/g, "");
}

// 去掉字符右端的空白字符
String.prototype.RightTrim = function() {
    return this.replace(/([\s]*$)/g, "");
}

/* 忽略大小写比较字符串是否相等
注:不忽略大小写比较用 == 号*/
String.prototype.IgnoreCaseEquals = function(str) {
    return this.toLowerCase() == str.toLowerCase();
}

/* 不忽略大小写比较字符串是否相等*/
String.prototype.Equals = function(str) {
    return (this == str);
}

/* 比较字符串,根据结果返回 -1, 0
返回值  相同:0 不相同:-1
*/
String.prototype.CompareTo = function(str) {
    if (this == str) {
        return 0;
    } else
        return -1;
}

// 字符串替换
String.prototype.Replace = function(oldValue, newValue) {
    var reg = new RegExp(oldValue, "g");
    return this.replace(reg, newValue);
}

// 检查是否以特定的字符串结束
String.prototype.EndsWith = function(str) {
    return this.substr(this.length - str.length) == str;
}

// 判断字符串是否以指定的字符串开始
String.prototype.StartsWith = function(str) {
    return this.substr(0, str.length) == str;
}

//从左边截取n个字符
String.prototype.LeftSlice = function(n) {
    return this.substr(0, n);
}

//从右边截取n个字符
String.prototype.RightSlice = function(n) {
    return this.substring(this.length - n);
}

// 统计指定字符出现的次数
String.prototype.Occurs = function(ch) {
    //  var re = eval("/[^"+ch+"]/g");
    //  return this.replace(re, "").length;
    return this.split(ch).length - 1;
}


/* 构造特定样式的字符串,用 <span></span> 包含 */
String.prototype.Style = function(style) {
    return "<span style=\"".concat(style, "\">", this, "</span>");
}

// 构造类似StringBuilder的函数(连接多个字符串时用到,很方便)
function StringBuilder(str) {
    this.tempArr = new Array();
}
StringBuilder.prototype.Append = function(value) {
    this.tempArr.push(value);
    return this;
}
StringBuilder.prototype.Clear = function() {
    this.tempArr.length = 0;
}
StringBuilder.prototype.toString = function() {
    return this.tempArr.join('');
}

//字符串常见方法及扩展
function test() {
    var testStr = " This is a test string ";
    var testStr2 = "字符串";
    //    alert(testStr.Trim());
    //    alert(testStr.LeftTrim());
    //    alert(testStr.RightTrim());
    //    alert(testStr2.ChineseLength());
    //    alert(testStr2.CompareTo(testStr));
    //    alert(testStr2.StartsWith("字符串"));
    //    document.write(testStr2.Style("color:red;width:100px"));
    //    alert(testStr2.LeftSlice(2));
    //    alert(testStr.RightSlice(7));
    //    alert(testStr.Occurs("s"));
    /*StringBuilder测试*/
    //    var testStr3 = new StringBuilder("");
    //    testStr3.Append("test3\r\n");
    //    testStr3.Append("test3test3\r\n");
    //    testStr3.Append("test3");
    //    alert(testStr3.toString());
    //    testStr3.Clear();
    //    alert(testStr3.toString());
}

二、常用的正则

//检查字符串是否由数字组成
String.prototype.IsDigit = function() {
    var str = this.Trim();
    return (str.replace(/\d/g, "").length == 0);
}

// 校验字符串是否为浮点型
String.prototype.IsFloat = function() {
    var str = this.Trim();
    //如果为空,则不通过校验
    if (str == "")
        return false;
    //如果是整数,则校验整数的有效性
    if (str.indexOf(".") == -1) {
        return str.IsDigit();
    }
    else {
        if (/^(\-?)(\d+)(.{1})(\d+)$/g.test(str))
            return true;
        else
            return false;
    }
}

// 检验是否是负整数
function isNegativeInteger(str) {
    //如果为空,则不通过校验
    if (str == "")
        return false;
    if (str.IsDigit()) {
        if (parseInt(str, 10) < 0)
            return true;
        else
            return false;
    }
    else
        return false;
}

// 检验是否是负浮点数数
function isNegativeFloat(str) {
    //如果为空,则不通过校验
    if (str == "")
        return false;
    if (str.IsFloat()) {
        if (parseFloat(str, 10) < 0)
            return true;
        else
            return false;
    }
    else
        return false;
}

// 是否是由字母组成的字符串
function isCharacter(str) {
    return (/^[A-Za-z]+$/.test(str));
}

// 是否是字母、数字组成的字符串
function isNumberCharacter(str) {
    return (/^[A-Za-z0-9]+$/.test(str));
}

// 是否是email
function isEmail(str) {
    return (/(\S)+[@]{1}(\S)+[.]{1}(\w)+/.test(str))
}

// 是否是url(评注:网上流传的版本功能很有限,下面这个基本可以满足需求)
function isUrl(str) {
    return (/([a-zA-z]+:\/\/)?[^s]*/.test(str));
}

// 是否是ip地址
function isIpAddress(str) {
    return /(\d+)\.(\d+)\.(\d+)\.(\d+)/.test(str);
}

// 是否是汉字组成的字符串
function isChinese(str) {
    return (/^[\u4e00-\u9fa5]+$/.test(str));
}

// 是否是双字节字符(包括汉字在内)
function isUnicode(str) {
    return (/^[\x00-\xff]+$/.test(str));
}

//是否是电话号码
function isTelephone(str) {
    //兼容格式: 国家代码(2到3位)-区号(2到3位)(-)?电话号码(7到8位)-分机号(3位)
    return (/^(([0\+]\d{2,3}-)?(0\d{2,3}))?[-]?(\d{7,8})(-(\d{3,}))?$/.test(str));
}

//是否是手机号码
function isMobilePhone(str) {
    return (/^((\(\d{3}\))|(\d{3}\-))?1[3,5]\d{9}$/.test(str));
}

//是否是QQ号码(腾讯QQ号从10000开始)
function isQQNumber(str) {
    return (/^[1-9][0-9]{4,}$/.test(str));
}

//是否是国内的邮政编码(中国邮政编码为6位数字)
function isMailCode(str) {
    return (/\d{6}/.test(str));
}

//是否是国内的身份证号码
function isIdNumber(str) {
    return (/\d{15}|\d{18}/.test(str));
}

//日期对象
function PowerDate() {
    this.date = null;
    //格式化时是否加零补位标志
    this.isFmtZero = false;
    this.weekArr = [["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"],
["SUN", "MON", "TUR", "WED", "THU", "FRI", "SAT"]];
    this.monthArr = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
    //初始化日期对象
    switch (arguments.length) {
        case 0:
            this.date = new Date();
            break;
        case 1:
            var reg = /^(\d{2,4})\D+(\d{1,2})\D+(\d{1,2})$/;
            var str = arguments[0].replace(/\s/, "");
            str = str.replace(reg, "$1/$2/$3");
            this.date = new Date(str);
            break;
        case 3:
            this.date = new Date(arguments[0], arguments[1] - 1, arguments[2]);
            break;
        case 6:
            this.date = new Date(arguments[0], arguments[1] - 1, arguments[2], arguments[3], arguments[4], arguments[5]);
            break;
        case 7:
            this.date = new Date(arguments[0], arguments[1] - 1, arguments[2], arguments[3], arguments[4], arguments[5], arguments[6]);
            break;
        default: this.date = new Date("1970/1/1"); break;
    }
    //初始化失败处理
    if (typeof (this.date) != "object" || !(/Date/.test(this.date.constructor)))
        throw (new Error(-1, '构造PowerDate方法失败,检查输入参数!'));

    this.getDate = function() {
        return this.date;
    }
    this.getFullYear = function() {
        return this.date.getFullYear();
    };
    this.getYear = function() {
        return this.date.getYear();
    };
    this.getMonth = function() {
        return this.frmWithZero(this.date.getMonth() + 1);
    };
    this.getDay = function() {
        return this.frmWithZero(this.date.getDate());
    };
    this.getHour = function() {
        return this.frmWithZero(this.date.getHours());
    };
    this.getMinute = function() {
        return this.frmWithZero(this.date.getMinutes());
    };
    this.getSecond = function() {
        return this.frmWithZero(this.date.getSeconds());
    };
    this.getMillisecond = function() {
        var ss = this.date.getMilliseconds();
        if (this.isFmtZero == true && ss < 10)
            return "00" + ss;
        else if (this.isFmtZero == true && ss < 100)
            return "0" + ss;
        else return ss;
    };
    this.getWeek = function() {
        return this.date.getDay();
    };
    this.setIsFmtZero = function(val) {
        this.isFmtZero = val;
    };
    this.frmWithZero = function(num) {
        if (this.isFmtZero == true && num < 10)
            return "0" + num;
        else return num;
    }
    /*
    功能:根据输入表达式返回日期字符串
    参数:dateFmt:字符串,由以下结构组成 yy:长写年,YY:短写年mm:数字月,MM:英文月,dd:日,hh:时,mi:分,ss秒,ms:毫秒,we:汉字星期,WE:英文星期.
    isFmtZero:布尔值,true:需要用0补位,false:不需要用0补位
    */
    this.getString = function(dateFmt) {
        if (typeof (dateFmt) != "string")
            throw (new Error(-1, 'getString()方法需要字符串类型参数!'));
        var str = dateFmt;
        str = str.replace(/yy/g, this.getFullYear());
        str = str.replace(/YY/g, this.getYear());
        str = str.replace(/mm/g, this.getMonth());
        str = str.replace(/MM/g, this.monthArr[this.getMonth() - 1]);
        str = str.replace(/dd/g, this.getDay());
        str = str.replace(/hh/g, this.getHour());
        str = str.replace(/mi/g, this.getMinute());
        str = str.replace(/ss/g, this.getSecond());
        str = str.replace(/ms/g, this.getMillisecond());
        str = str.replace(/we/g, this.weekArr[0][this.getWeek()]);
        str = str.replace(/WE/g, this.weekArr[1][this.getWeek()]);
        return str;
    };

    /* 功能 : 返回与某日期相距N天(N个24小时)的日期
    * 参数 : num number类型 可以为正负整数或者浮点数
    * 返回 : 新的PowerDate类型
    * 方法 : powerDate.dateAfterDays(num);
    */
    this.dateAfterDays = function(num) {
        if (typeof (num) != "number") throw new Error(-1, "dateAfterDays(num)参数为数值类型.");
        var dd = this.date.valueOf();
        dd += num * 24 * 3600 * 1000;
        this.date = new Date(dd);
        return this;
    };
    /* 功能 : 返回与某日期相距N秒的日期
    * 参数 : num number类型 可以为正负整数或者浮点数
    * 返回 : 新的日期
    * 方法 : powerDate.dateAfterDays(num);
    */
    this.dateAfterSeconds = function(num) {
        if (typeof (num) != "number") throw new Error(-1, "dateAfterDays(num)参数为数值类型.");
        var dd = this.date.valueOf();
        dd += num * 1000;
        this.date = new Date(dd);
        return this;
    };

    //判断是否是闰年
    this.isLeapYear = function() {
        var year = this.getFullYear();
        return (0 == year % 4 && ((year % 100 != 0) || (year % 400 == 0)));
    };

    //返回该月天数
    this.getDaysOfMonth = function() {
        return (new Date(this.getFullYear(), this.getMonth(), 0)).getDate();
    };

    //转换成大写日期(中文)
    this.getChinaDate = function() {
        var year = this.getFullYear();
        var month = this.getMonth();
        var day = this.getDay();
        var arrNum = ["", "", "", "", "", "", "", "", "", "", "", "十一", "十二"];
        var strTmp = "";
        for (var i = 0, j = year.toString().length; i < j; i++) {
            strTmp += arrNum[year.toString().charAt(i)];
        }
        strTmp += "";
        if (month.toString().substr(0, 1) == 0) {
            strTmp += arrNum[parseInt(month.toString().substr(1), 10)] + "";
        }
        else
            strTmp += arrNum[month] + "";
        if (day < 10)
            strTmp += arrNum[parseInt(day.toString().substr(1), 10)];
        else if (day < 20)
            strTmp += "" + arrNum[day - 10];
        else if (day < 30)
            strTmp += "二十" + arrNum[day - 20];
        else
            strTmp += "三十" + arrNum[day - 30];
        strTmp += "";
        return strTmp;
    };

    //日期比较函数,如大于参数:1,相等:0 不等: -1
    this.dateCompare = function(dat) {
        if (typeof (dat) == "string") {
            if (dat != "") dat = new Date(timeString);
            else dat = new Date();
        }
        if (typeof (dat) != "object" || !(/Date/.test(this.date.constructor))) {
            throw new Error(-2, "dateCompare的参数为日期类型或者可直接转化为日期类型的字符串!");
        }
        var d = this.date.getTime() - dat.getTime();
        return d > 0 ? 1 : (d == 0 ? 0 : -1);
    };

    /*功能:返回两日期之差
    *参数:pd   PowerDate对象
    *    type: 返回类别标识.yy:年,mm:月,dd:日,hh:小时,mi:分,ss:秒,ms:毫秒
    *    intOrFloat :返回整型还是浮点型值 0:整型,1:浮点型
    */
    this.calDateDistance = function(pd, type, intOrFloat) {
        var miSecMain = this.date.valueOf();
        var miSecSub = pd.getDate().valueOf();
        var num = 0;
        switch (type) {
            case "yy": num = this.getFullYear() - pd.getFullYear();
                break;
            case "mm": num = (this.getFullYear() - pd.getFullYear()) * 12 + this.getMonth() - pd.getMonth();
                break;
            case "dd": num = this.fmtRtnVal((miSecMain - miSecSub) / 86400000, intOrFloat);
                break;
            case "hh": num = this.fmtRtnVal((miSecMain - miSecSub) / 3600000, intOrFloat);
                break;
            case "mi": num = this.fmtRtnVal((miSecMain - miSecSub) / 60000, intOrFloat);
                break;
            case "ss": num = this.fmtRtnVal((miSecMain - miSecSub) / 1000, intOrFloat);
                break;
            case "ms": num = (miSecMain - miSecSub);
                break;
            default:
                throw new Error(-1, "没有您要求返回的类型,请检查输入参数!");
                break;
        }
        return num;
    };
    this.fmtRtnVal = function(val, intOrFloat) {
        //alert(val);
        return (intOrFloat == 0 ? Math.floor(val) : parseInt(val * 100) / 100);
    };
}

// 测试
function test() {
    var d = new PowerDate(" 1998/7/3 "); //实例化一个PowerDate对象
    d.setIsFmtZero(true); //设置为用0补位输出
    alert(d.getString("yy-mm-dd hh:mi:ss.ms we")); //输出日期字符串

    var d2 = new PowerDate(); //实例化一个PowerDate对象
    alert(d2.calDateDistance(new PowerDate("2005/7/31"), "yy", 1)); //输出日期字符串
    alert(d.getChinaDate());
    alert(d2.dateAfterDays(3).getFullYear());
}

 

posted @ 2015-06-11 11:15  8832A45C866CDB7D  阅读(136)  评论(0编辑  收藏  举报