求正则表达式

Question

字符串:ab=2009-01-01&abcd=2009-01-01用正则表达式怎么描述？1、除数字外其他字符均固定不变。
2、不对数字作合理性校验，如允许出现2999-15-65
3、&前后两部分顺序可以颠倒。

Answer 1

document.close();
document.open();
var datas = [
"ab=2009-01-01&abcd=2009-01-01",
"ab=2001-11-11&abcd=2009-11-12",
"ab=20aa-01-01&abcd=2009-01-01",
"abcd=2009-01-01&ab=2009-01-01",
"abcd=2009-1-1&ab=2009-1-1"
];var regex = /^ab=\d{4}-\d{2}-\d{2}&abcd=\d{4}-\d{2}-\d{2}$|^abcd=\d{4}-\d{2}-\d{2}&ab=\d{4}-\d{2}-\d{2}$/;
for (var i = 0; i < datas.length; i++) {
document.write(datas[i]);
document.write("=");
document.write(regex.test(datas[i]));
document.write("<br/>");
}

Answer 2

<script type="text/javascript">
<!--
var str = "ab=2009-01-01&abcd=2009-01-01";
reg = /ab(cd)*=\d{4}-\d{2}-\d{2}/;
alert(reg.test(str))
//-->
</script>

Answer 3

abcd=2009-01-01=true
ab=2009-01-01=true
abcdcdcd=2009-01-01=true

Answer 4

<script type="text/javascript">
<!--
var str = "ab=2009-01-01&abcd=2009-01-01";
reg = /^ab=\d{4}-\d{2}-\d{2}&abcd=\d{4}-\d{2}-\d{2}$|^abcd=\d{4}-\d{2}-\d{2}&ab=\d{4}-\d{2}-\d{2}/;
alert(reg.test(str))
//-->
</script>

Answer 5

没看到中间有个&
而且没有也应该用?不应该用*
见笑...

Answer 6

/&?ab(?:cd)?=\d{4}-\d{2}-\d{2}/2L的最严格

Answer 7

var reg = /^(ab|abcd)=(\d{4}-\d\d?-\d\d?)&((?!\1\))(?:ab|abcd))=(\d{4}-\d\d?-\d\d?)$/;

Answer 8

又被我看到了，凑个热闹<script type="text/javascript"> 
document.close();
document.open();
 
 
var datas = [
    "ab=2009-01-01&abcd=2009-01-01",
    "ab=2001-11-11&abcd=2009-11-12",
    "ab=20aa-01-01&abcd=2009-01-01",
    "abcd=2009-01-01&ab=2009-01-01",
    "abcd=2009-1-1&ab=2009-1-1"
];
 
var regex = /^(ab(?:cd)?)=\d{4}-\d{2}-\d{2}&(?!\1\b)ab(?:cd)?=\d{4}-\d{2}-\d{2}$/;
for (var i = 0; i < datas.length; i++) {
    document.write(datas[i]);
    document.write("=");
    document.write(regex.test(datas[i]));
    document.write("<br/>");
}
 
</script>采用“|”的分支结构，两侧分支表达式复杂度会影响匹配效率

Answer 9

今天是我因正则而存在，希望有一天是正则因我而存在javascript采用的提传令的NFA引擎，而传统NFA引擎对“|”分支结构的处理，是从左向右，逐个分支进行尝试匹配的，如果左侧分支匹配成功，将不再尝试右侧分支
各分支子表达式的复杂度，对整个正则匹配效率影响较大，在可以匹配成功的情况下，效率影响不会很明显，但是如果整个表达式最终匹配失败，由于需要在每个位置对所有分支进行尝试匹配，分支复杂度对正则效率的影响就比较大
所以为了提高正则匹配效率，一般尽量少使用分支结构，不得不使用的情况下，需要注意：
1、尽量抽象出分支的公共部分，减小分支复杂度，如(this|that)可写为th(is|at)
2、在不影响匹配结果的情况下，尽量把出现概率高的分支放左边在这个例子中，"(ab|abcd)"可优化为"ab(|cd)"，而这种写法也就相当于"ab(cd)??”，这是非贪婪模式，忽略优化的，所以在匹配"abcd"时，它先匹配到了"ab"，此时"(cd)??"会先忽略匹配，由"="取得控制权，来匹配"c"，匹配失败，回溯，由"(cd)??"来匹配"c”，成功，再匹配"d"，成功，再匹配"="，失败，将控制权交给"="，匹配"="，成功
这样做的匹配效率就不如贪婪模式"ab(?:cd)?"高，在匹配"abcd"时，它先匹配到了"ab"，此时"(cd)?"为匹配优先，由"(?:cd)?"取得控制权，来匹配"c"，匹配成功，再匹配"d"，成功，再匹配"="，失败，控制权交给"="，匹配"="，成功

Answer 10

lxcnn 敢问君子把精通正则书给背下来了?

Answer 11

谢谢各位，这么多人关心我，我会一一尝试大家的方案。不过也有点小小问题，1、正则表达是不应该那么长吧，搞得比原字符串还要长！我这个字符串是很有规律的，应该可以减下来吧。
2、要求说字符固定，那么&前后两部分同时出现，只不过顺序可以颠倒。
3、不一定要出现在口头或结尾。我自己是这么写的：reg = /(&?ab(cd)?=\d{4}-\d{2}-\d{2})(2)/本来预期可获得全匹配:
ab=2009-01-01&abcd=2009-01-01
子匹配：
ab=2009-01-01
&abcd=2009-01-01
cd但奇怪没有第二个子匹配。

Answer 12

不一定比原字符串长就不好，也不一定写得短就好，正则写得好坏，匹配效率的高低不看正则的长短，要看是否适用
比如时间的正则表达式，提取时可以简单的写为
 \d{4}-\d{2}-\d{2}
验证时如带闰年判断，则可以写为
^(?:(?:(?:(?:(?:1[6-9]|[2-9][0-9])?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))([-/.])(?:0?2\1(?:29)))|(?:(?:(?:1[6-9]|[2-9][0-9])?[0-9]{2})([-/.])(?:(?:(?:0?[13578]|1[02])\2(?:31))|(?:(?:0?[13-9]|1[0-2])\2(?:29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\2(?:0?[1-9]|1[0-9]|2[0-8]))))$
根据引擎的不同，对于量词的优化也不一样，有的引擎使用\d{2}这种写法匹配效率高，有的引擎使用\d\d这种写法匹配效率高
楼主的正则应该是下面这样写的吧
var reg = /(&?ab(cd)?=\d{4}-\d{2}-\d{2}){2}/; 
获取子匹配如何获取的？用的match
var str = "ab=2009-01-01&abcd=2009-01-01"; 
var regex = /(&?ab(cd)?=\d{4}-\d{2}-\d{2}){2}/;
var arr = str.match(regex);
for(var i=0;i<arr.length;i++)
{
    document.write(arr[i] + "<br />");
}那获取的结果应该是下面的才对
ab=2009-01-01&abcd=2009-01-01
&abcd=2009-01-01
cd
捕获组只保留最后一次匹配成功的内容，所以这里得到的当然是只有&abcd=2009-01-01了，javascript中MS没有办法获取全部的匹配，.NET中倒是有Capture可以做到这一点如果楼主只是用来提取，而且对于格式的严谨性没那么严格的要求，那么简单的写成这样，获取全部匹配内容就可以了
var regex = /(&?ab(?:cd)?=\d{4}-\d{2}-\d{2}){2}/;

Answer 13

多谢各位，尤其是lxcnn，你纠正我我很多错误。