javascript:内置对象学习笔记一

在实际的js开发过程中，我们常常会有相似或相同的需求。这时候如果没有很好的封装(通用功能)，代码的重复将不可避免。比如说页面的字符处理，js的正则表达式验证等等。下面我就将我自己浅薄的开发经验综合网上的庞杂资源稍稍综合整理一下，省得自己以后要用到时再搜索了。这个系列我会将平时常用的函数归纳整理起来，全当作是抛砖引玉吧。
Code is cheap.看代码：
一、常见的字符串处理函数

// 返回字符的长度，一个中文算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));
}

关于正则表达式，网上还有很多的有深度的文章，我这里就拷贝几段常用的代码了，其实学懂了基本的正则知识后普通的验证不过是小菜一碟，不再赘述。
三、日期处理函数
日期处理也是js的一个重要方面，而且比较容易出现意想不到的错误或者bug。下面就是收集整理的需要注意的一些常见函数（封装成一个时间类）：

//日期对象
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());
}

上面的这个类的来源请参考：http://www.duduwolf.com/wiki/2007/201.html 。认真看看原作者的编程才华，你是不是也会像我一样有“吾道不孤”的感慨和勤写代码的冲动呢？