Ruby's Louvre

每天学习一点点算法

导航

javascript RegExp对象

JavaScript提供了一个RegExp对象来完成有关正则表达式的操作和功能，每一条正则表达式模式对应一个RegExp实例。有两种方式可以创建RegExp对象的实例。

使用RegExp的显式构造函数，语法为：new RegExp("pattern"[,"flags"])。

使用RegExp的隐式构造函数，采用纯文本格式：/pattern/[flags]。

pattern部分为要使用的正则表达式模式文本，是必须的。在第一种方式中，pattern部分以JavaScript字符串的形式存在，需要使用双引号或单引号括起来；在第二种方式中，pattern部分嵌套在两个“/”之间，不能使用引号。

flags部分设置正则表达式的标志信息，是可选项。如果设置flags部分，在第一种方式中，以字符串的形式存在；在第二种方式中，以文本的形式紧接在最后一个“/”字符之后。flags可以是以下标志字符的组合。

g是全局标志。如果设置了这个标志，对某个文本执行搜索和替换操作时，将对文本中所有匹配的部分起作用。如果不设置这个标志，则仅搜索和替换最早匹配的内容。

i是忽略大小写标志。如果设置了这个标志，进行匹配比较时，将忽略大小写。

m是多行标志。如果不设置这个标志，那么元字符“^”只与整个被搜索字符串的开始位置相匹配，而元字符“$”只与被搜索字符串的结束位置相匹配。如果设置了这个标志，“^”还可以与被搜索字符串中的“\n”或“\r”之后的位置（即下一行的行首）相匹配，而“$”还可以与被搜索字符串中的“\n”或“\r”之后的位置（即下一行的行尾）相匹配。

由于JavaScript字符串中的“\”是一个转义字符，因此，使用显式构造函数创建RegExp实例对象时，应将原始正则表达式中的“\”用“\\”替换。例如，在代码1.2中的两条语句是等价的。

由于正则表达式模式文本中的转义字符也是“\”，如果正则表达式中要匹配原义字符“\”，在正则表达式模式文本中要以“\\”来表示，当使用显式构造函数的方式创建RegExp实例对象的时候，就需要使用“\\\\”来表示原义字符“\”。

var re = new RegExp(\\\\)。
静态属性描述
index 是当前表达式模式首次匹配内容的开始位置，从0开始计数。其初始值为-1，每次成功匹配时，index属性都会随之改变。
input 返回当前所作用的字符串，可以简写为$_，初始值为空字符串""。
lastMatch 是当前表达式模式的最后一个匹配字符串，可以简写为$&。其初始值为空字符串""。在每次成功匹配时，lastMatch属性值都会随之改变。
lastParen 如果表达式模式中有括起来的子匹配，是当前表达式模式中最后的子匹配所匹配到的子字符串，可以简写为$+。其初始值为空字符串""。每次成功匹配时，lastParen属性值都会随之改变。
leftContext 是当前表达式模式最后一个匹配字符串左边的所有内容，可以简写为$`（其中“'”为键盘上“Esc”下边的反单引号）。初始值为空字符串""。每次成功匹配时，其属性值都会随之改变。
rightContext 是当前表达式模式最后一个匹配字符串右边的所有内容，可以简写为$’。初始值为空字符串""。每次成功匹配时，其属性值都会随之改变。
$1…$9属性 这些属性是只读的。如果表达式模式中有括起来的子匹配，$1…$9属性值分别是第1个到第9个子匹配所捕获到的内容。如果有超过9个以上的子匹配，$1…$9属性分别对应最后的9个子匹配。在一个表达式模式中，可以指定任意多个带括号的子匹配，但RegExp对象只能存储最后的9个子匹配的结果。在RegExp实例对象的一些方法所返回的结果数组中，可以获得所有圆括号内的子匹配结果。

实例属性描述
lastIndex 是当前表达式模式首次匹配内容中最后一个字符的下一个位置，从0开始计数，常被作为继续搜索时的起始位置，初始值为-1，表示从起始位置开始搜索，每次成功匹配时，lastIndex属性值都会随之改变。
global 是当前表达式模式首次匹配内容的开始位置，从0开始计数。其初始值为-1，每次成功匹配时，index属性都会随之改变。
ignoreCase 返回创建RegExp对象实例时指定的ignoreCase标志（i）的状态。如果创建RegExp对象实例时设置了i标志，该属性返回True，否则返回False，默认值为False。
multiLine 返回创建RegExp对象实例时指定的multiLine标志（m）的状态。如果创建RegExp对象实例时设置了m标志，该属性返回True，否则返回False，默认值为False。
source 返回创建RegExp对象实例时指定的表达式文本字符串。

实例方法描述
test 语法格式为test(str)。该方法检查一个字符串中是否存在创建RegExp对象实例时所指定的表达式模式，如果存在就返回True，否则返回False。如果找到匹配项，则会更新RegExp对象中的有关静态属性，以反映匹配情况。
exec 语法格式为exec(str)。该方法使用创建RegExp对象实例时所指定的表达式模式对一个字符串进行搜索，并返回一个包含搜索结果的数组。
如果为正则表达式设置了全局标志（g），可以通过多次调用exec和test方法在字符串中进行连续搜索，每次都是从RegExp对象的lastIndex属性值指定的位置开始搜索字符串。 如果没有设置全局标志（g），则exec和test方法忽略RegExp对象的lastIndex属性值，从字符串的起始位置开始搜索。
如果exec方法没有找到匹配，返回值为null；如果找到匹配，则返回一个数组，并更新RegExp对象中有关静态属性以反映匹配情况。返回数组中的元素0包含了完整的匹配结果，而元素1～n依次是表达式模式中定义的各个子匹配的结果。 exec方法返回的数组有3个属性，分别是input、index和lastIndex。
input属性是整个被搜索的字符串。
index属性是指匹配在整个被搜索字符串中的位置。
lastIndex属性是指匹配的子字符串的最后一个字符的下一个字符位置。
compile 语法格式为compile("pattern"[,"flags"])。该方法可以更换RegExp对象实例所使用的表达式模式， 并将新的表达式模式编译为内部格式，从而使以后的匹配过程执行更快。 如果要在循环中重复使用某个表达式，对其进行编译将使执行加速。 但是，如果在程序中使用了任何其他表达式模式后，再使用原来编译过的表达式模式，则这种编译毫无益处。 

 var reg = /^$/i  //匹配img标签

\/\*([\s\S])*?\*\/      匹配注释

/^[a-zA-Z0-9][\w\.\-]+@[\w\.\-]+$/


\/(?:[^\\[/]|\\.|\[(?:[^\\\]]|\\.)+])+\/[gim]*  正则 

rValidURL =  /^(([\w]+:)?\/\/)?(([\d\w]|%[a-fA-f\d]{2,2})+(:([\d\w]|%[a-fA-f\d]{2,2})+)?@)?([\d\w][-\d\w]{0,253}[\d\w]\.)+[\w]{2,4}(:[\d]+)?(\/([-+_~.\d\w]|%[a-fA-f\d]{2,2})*)*(\?(&?([-+_~.\d\w]|%[a-fA-f\d]{2,2})=?)*)?(#([-+_~.\d\w]|%[a-fA-f\d]{2,2})*)?$/;
    

//idcard
var isOk = (val == "");
if (!isOk) {
	if ((/^\d{15}$/).test(val)) {
		isOk = true; 
	} else if ((/^\d{17}[0-9xX]$/).test(val)) {
		var vs = "1,0,x,9,8,7,6,5,4,3,2".split(","),
			ps = "7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2".split(","),
			ss = val.toLowerCase().split(""),
			r = 0;
		for (var i = 0; i < 17; i++) {
			r += ps[i] * ss[i];
		}
		isOk = (vs[r % 11] == ss[17]);
	}
}

         
    //验证身份证
    function IDCardCheck(num) {
        num = num.toUpperCase();
        // 身份证号码为15位或者18位，15位时全为数字，18位前17位为数字，最后一位是校验位，可能为数字或字符X。
        if (!(/(^\d{15}$)|(^\d{17}([0-9]|X)$)/.test(num))) {
            // alert('输入的身份证号长度不对，或者号码不符合规定！\n15位号码应全为数字，18位号码末位可以为数字或X。');
            return false;
        }
        // 校验位按照ISO 7064:1983.MOD 11-2的规定生成，X可以认为是数字10。
        // 下面分别分析出生日期和校验位
        var len, re;
        len = num.length;
        if (len == 15) {
            re = new RegExp(/^(\d{6})(\d{2})(\d{2})(\d{2})(\d{3})$/);
            var arrSplit = num.match(re);

            // 检查生日日期是否正确
            var dtmBirth = new Date('19' + arrSplit[2] + '/' + arrSplit[3] + '/' + arrSplit[4]);
            var bGoodDay;
            bGoodDay = (dtmBirth.getYear() == Number(arrSplit[2])) && ((dtmBirth.getMonth() + 1) == Number(arrSplit[3])) && (dtmBirth.getDate() == Number(arrSplit[4]));
            if (!bGoodDay) {
                // alert('输入的身份证号里出生日期不对！');
                return false;
            }
            else {
                // 将15位身份证转成18位
                // 校验位按照ISO 7064:1983.MOD 11-2的规定生成，X可以认为是数字10。
                var arrInt = new Array(7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2);
                var arrCh = new Array('1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2');
                var nTemp = 0, i;
                num = num.substr(0, 6) + '19' + num.substr(6, num.length - 6);
                for (i = 0; i < 17; i++) {
                    nTemp += num.substr(i, 1) * arrInt[i];
                }
                num += arrCh[nTemp % 11];
                return true;
            }
        }
        if (len == 18) {
            re = new RegExp(/^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X)$/);
            var arrSplit = num.match(re);

            // 检查生日日期是否正确
            var dtmBirth = new Date(arrSplit[2] + "/" + arrSplit[3] + "/" + arrSplit[4]);
            var bGoodDay;
            bGoodDay = (dtmBirth.getFullYear() == Number(arrSplit[2])) && ((dtmBirth.getMonth() + 1) == Number(arrSplit[3])) && (dtmBirth.getDate() == Number(arrSplit[4]));
            if (!bGoodDay) {
                // alert(dtmBirth.getYear());
                // alert(arrSplit[2]);
                // alert('输入的身份证号里出生日期不对！');
                return false;
            }
            else {
                // 检验18位身份证的校验码是否正确。
                // 校验位按照ISO 7064:1983.MOD 11-2的规定生成，X可以认为是数字10。
                var valnum;
                var arrInt = new Array(7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2);
                var arrCh = new Array('1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2');
                var nTemp = 0, i;
                for (i = 0; i < 17; i++) {
                    nTemp += num.substr(i, 1) * arrInt[i];
                }
                valnum = arrCh[nTemp % 11];
                if (valnum != num.substr(17, 1)) {
                    // alert('18位身份证的校验码不正确！'); //应该为： + valnum
                    return false;
                }
                return true;
            }
        }
        return false;
    }
//http://jsperf.com/chinese-pin 更多身份证验证

//https://github.com/LeaVerou/prism/blob/gh-pages/prism.js
Prism.languages.clike = {
        'comment': {
                pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|(^|[^:])\/\/.*?(\r?\n|$))/g,
                lookbehind: true
        },
        'string': /("|')(\\?.)*?\1/g,
        'class-name': {
                pattern: /((?:class|interface|extends|implements|trait|instanceof|new)\s+)[a-z0-9_\.\\]+/ig,
                lookbehind: true,
                inside: {
                        punctuation: /(\.|\\)/
                }
        },
        'keyword': /\b(if|else|while|do|for|return|in|instanceof|function|new|try|catch|finally|null|break|continue)\b/g,
        'boolean': /\b(true|false)\b/g,
        'function': {
                pattern: /[a-z0-9_]+\(/ig,
                inside: {
                        punctuation: /\(/
                }
        },
        'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/g,
        'operator': /[-+]{1,2}|!|=?<|=?>|={1,2}|(&){1,2}|\|?\||\?|\*|\/|\~|\^|\%/g,
        'ignore': /&(lt|gt|amp);/gi,
        'punctuation': /[{}[\];(),.:]/g
};

/* **********************************************
     Begin prism-javascript.js
********************************************** */

Prism.languages.javascript = Prism.languages.extend('clike', {
        'keyword': /\b(var|let|if|else|while|do|for|return|in|instanceof|function|new|with|typeof|try|catch|finally|null|break|continue)\b/g,
        'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?|NaN|-?Infinity)\b/g
});

Prism.languages.insertBefore('javascript', 'keyword', {
        'regex': {
                pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/g,
                lookbehind: true
        }
});

if (Prism.languages.markup) {
        Prism.languages.insertBefore('markup', 'tag', {
                'script': {
                        pattern: /(<|<)script[\w\W]*?(>|>)[\w\W]*?(<|<)\/script(>|>)/ig,
                        inside: {
                                'tag': {
                                        pattern: /(<|<)script[\w\W]*?(>|>)|(<|<)\/script(>|>)/ig,
                                        inside: Prism.languages.markup.tag.inside
                                },
                                rest: Prism.languages.javascript
                        }
                }
        });
}

正则学习笔记

正则基础之——环视

posted on 2009-11-24 10:05  司徒正美  阅读(1551)  评论(0)    收藏  举报