脑筋急转弯问题,俺不能理解,大家帮忙看一下.

Question

关键是*里面包含0("空匹配")第二次:输出:** : 
     .*进行贪婪匹配,第一次得到abcd,接下去继续寻找匹配,由于*包括0,因此找到第二个匹配("空匹配")第三次:输出:abcde
     [.] 表示.本身,结果很好理解
第四次:输出:*a*b*c*d*e*
     找到的匹配都是"空匹配"
<script type="text/javascript">
function Show(){
var txt = "匹配字符串 \t:\t " + arguments[0] + "\n";
txt += "LastIndex \t:\t " + arguments[1] + "\n";
txt += "原字符串  \t:\t " + arguments[2] + "\n";
alert(txt);
return "*";
}var sToMatch = "abcde";
document.write(sToMatch.replace(/.+/gi,Show) + "<br>");   //第一次:输出:*
document.write(sToMatch.replace(/.*/gi,Show) + "<br>");   //第二次:输出:**
document.write(sToMatch.replace(/[.]+/gi,Show) + "<br>"); //第三次:输出:abcde
document.write(sToMatch.replace(/[.]*/gi,Show) + "<br>"); //第四次:输出:*a*b*c*d*e*
</script>

Answer 1

第二次表示:匹配任何一个字符(\n除外)零次或多次,输出**,什么意思啊?不能理解一此取
abcde一次取“位置”第四个是NFA引擎为了避免死循环而让传动装置强制执行驱动。
所以才会向后换的
所以它们都可以根据*量词来取到0个匹配从而利用传动装置的驱动的特性来得到位置。

Answer 2

在replace的第二個參數中用function查看當前匹配可以比較好的理解，如同3樓风Na所示。好奇的解釋(4樓)比較官方！

Answer 3

是的可以根据如下代码来证实
<script type="text/javascript">
var string = 'abcde';
var a = /.*/g;
var b = /$/;
a.test(string);
b.lastIndex = a.lastIndex;
alert(b.test(string));
</script>$^边界字符 预查
等都是锚点标记。。
即我那里说的用来匹配位置用的如果匹配空内容的话，根据驱动的特性。
则会变成位置的匹配

Answer 4

另外replace参数一为正则，参数二为函数
则函数的arguments.length - 2是等同RegExp.index
不是lastMatch^^

Answer 5

An interesting thing:
<script type="text/javascript">
var sToMatch = "abcde";
document.write(sToMatch.replace(/.*$/gi,"*") + "<br>");   //输出:**
document.write(sToMatch.replace(/.*$\b$/gi,"*") + "<br>");   //输出:**
document.write(sToMatch.replace(/.*$$$$$$$$$$$$$/gi,"*") + "<br>");   //输出:**
</script>

Answer 6

呵呵,thanks,我记错了 ^_^

Answer 7

可不可发这么说呢:arguments[2]永远代表源字符串

Answer 8

再补充一下,我刚才又测试了一下:arguments[1]第一次匹配时它的值是0,第二次是:1,第三次是:2,依次类推,想问一下,这代表什么啊?

Answer 9

document.write(sToMatch.replace(/.+/gi,"*") + "<br>");
不去匹配0么
那为什么document.write(sToMatch.replace(/.*/gi,"*") + "<br>");
就要去匹配？
难道是因为0的特殊性：
/.+/gi匹配abcde后直接返回
而/.*/gi是先匹配0，再匹配的abcde?

Answer 10

你这样测试一下就知道了如下:
<script type="text/javascript">
function qq()
{
document.write(arguments[0] + "匹配<br>");
return "*";
}
document.write("abcde" .replace(/.*/gi,qq) + "<br>");  
</script>

Answer 11

我在我那个帖子是这样推断的
个人是这样理解的 
/.+/gi把"0a0b0c0d0e0"匹配了，然后返回 
/.*/gi是先什么都不匹配，然后再把"0a0b0c0d0e0"匹配了，所以替换了两个*出来 
不知道这样对吗？？不过我仔细想了想，你说得对，我上面的推断等于是搞复杂了，但是是正确的你这里人气较高啊，兄弟，生意都被你抢光了，呵呵

Answer 12

不能再搞了,再搞就真的晕了,下面的代码会输出如下:
我故意用汉字"匹配"换行了,其中下面五行都是空,请高手"潜水修行"说一下,下面五个"匹配"汉字的行匹配的是什么啊?
a匹配
匹配
匹配
匹配
匹配
匹配
**b*c*d*e* 
function qq()
{
document.write(arguments[0] + "匹配<br>");
return "*";
}
document.write("abcde".replace(/a*/gi,qq) + " <br>");  //输出:**b*c*d*e* 

Answer 13

[color=#800000]难道就没有一个规律吗?
哦,突然灵感来了,大家看对不对如下:如果按照我的推断应当是下面的匹配:
第1次 /a*/ 代表 a 匹配 "abcde"中的a
第1次 /a*/ 代表 a 匹配 "abcde"中的a
唉,灵感又消失了,还是听一下专家们的解释吧.[/color]

Answer 14

document.write(sToMatch.replace(/.+/gi,"*") + "<br>");   //第一次:输出:*
document.write(sToMatch.replace(/.*/gi,"*") + "<br>");   //第二次:输出:**
document.write(sToMatch.replace(/[.]+/gi,"*") + "<br>"); //第三次:输出:abcde
document.write(sToMatch.replace(/[.]*/gi,"*") + "<br>"); //第四次:输出:*a*b*c*d*e*你的提问很有代表性。第一个匹配一个以上的任意字符。所以是一个*
第二个匹配零个以上的任意字符。在字符串还未开始时，它认为是零匹配，所以先输出一个*，之后，字符串也是匹配的（同第一个），又输出一个*，所以是两个*
第三个和第四个，把.写入[]内，已经是一个正常的字符了，如\.一样了。所以第三个一个也没找到，原样输出，但是在第四个由于是零个以上匹配，所以认为每个字符前面都是零匹配，就会在每个字符之前输出一个*。[xyz] 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。  

Answer 15

我还是觉得第一次是零匹配吧？
不是你的提醒我还陷在里面呢，
我理解是
匹配---------->零次 
匹配---------->a
匹配---------->0
匹配---------->0
匹配---------->0
匹配---------->0
如果不对，静待佳人解答

Answer 16

3F貌似符合你的说法，晓得老
匹配---------->a 
匹配---------->0 
匹配---------->0 
匹配---------->0 
匹配---------->0
匹配---------->0

Answer 17

乱了,乱了全乱了,不分章程了.首先说:
其实,第一次是字符串匹配,第二次是:零匹配,如下可以证明:
function qq()
{
    document.write(arguments[0] + "匹配<br>");
    return "*";
}
document.write("abcde".replace(/.*/gi,qq) + " <br>");  //输出:**b*c*d*e* 再说:33楼的朋友.:
你所指的是哪一个正则是下面的吗?
function qq()
{
    document.write(arguments[0] + "匹配<br>");
    return "*";
}
document.write("abcde".replace(/a*/gi,qq) + " <br>");  //输出:**b*c*d*e* 
如果是的话,想问一下,你所指的:
匹配---------->0 
匹配---------->0 
匹配---------->0 
匹配---------->0 
0代表什么,是啥意思?
还有如果你指的是我说的正则的话("abcde".replace(/a*/gi,qq))你运行,我刚才贴出的代码第一行输出了:a匹配
证明第一次是匹配了a啊?你是怎么推测到第一次是零匹配啊?

Answer 18

好的.既然你了解了.现在多们什么也不讨论了,我们就只讨论这一个正则好吗?如下:function qq()
{
    document.write(arguments[0] + "匹配<br>");
    return "*";
}
document.write("abcde".replace(/.*/gi,qq) + " <br>");  
输出：
a匹配
匹配
匹配
匹配
匹配
匹配
**b*c*d*e* * 
想问一下各位高人,这也算是贪婪量词的匹配吧,哪里来的那么多的零匹配啊?

Answer 19

没注意看，3，4F正解，边对照书边去想反而搞乱了，orz
又学到了，多谢楼主的问题和大虾的解释

Answer 20

第一个匹配一个以上的任意字符。表达式匹配到abcde。所以是一个*
第二个匹配零个以上的任意字符。在字符串之前是空，表达式认为匹配到了，而后，又匹配到了字符串，表达式也认为匹配到了，所以输出两次匹配的替换**。我的表达能力比较差，好好看看，应该能明白的。

Answer 21

你这个咱那么固执,说你错了就是错了,我都证明给你看了,你还说,第一次不是零匹配了.如下:function qq()
{
    document.write(arguments[0] + "匹配<br>");
    return "*";
}
document.write("abced".replace(/.*/gi,qq) + "<br>"); 
//输出如下:
abced匹配    第一行输出这个代表什么啊?这不代表第一次是全字符匹配吗?
匹配          第二行输出空,你看到了吗?不是代表零匹配吗?你搞反了,又没有怪你,你还上来乱发.
**

Answer 22

就是3,4F和LZ自己的答案就是正解
刚开始完全误解“+, *“这2个东西，刚学正则1天，所以误解，望谅解

Answer 23

abcde
/a*/g;第一次
匹配a成功
第二次从a和b中间匹配成功取匹配0个
第三次从b和c中间成功取匹配0个

最后从e和后面匹配成功匹配0个

Answer 24

你好我现在看的是javascript高级程序设计(图灵出版社的)书上这么写的;
     (12)贪婪量词: 先看整个的字符串是否匹配.如果没有发现匹配,它去掉该字符串中的最后一个字符,并再尝试
                   如果还是没有匹配,那么再次去掉最后一个字符,这个过程会一直重复直到发现一个匹配或者
                   字符串不剩下任何字符.到目前为止讨论的所有量词都是贪婪的.
     (13)惰性量词: 先看字符串中的第一个字母是否匹配.如果单独这一个字符还不够,就读入下一个字符,组成两
                   个字符的字符串.如果还没有发现匹配,惰性量词继续从字符串中添加字符直到发现匹配或者
                   整个字符串都检查也没有匹配.惰性量词和贪婪量词的工作方式恰好相反.
     (14)支配量词: 只尝试匹配整个字符串.如果整个字符串不能产生匹配,不做进一步尝试.支配量词其实简单的
                   说,就是一发切.
      怎么表示贪婪,惰性,支配量词呢?
      例如:单独一个问号?表示是贪婪的,但一个问号后面再跟一个问号??就是惰性的.要使问号成为支配量词,在
           后面加上一个加号?+
那么下面的代码属于什么量词啊?如果是按书上说应当属于贪婪量词,如果是贪婪题词的话下面的代码第一次会是全字符匹配啊,但是结果第一次匹配了a所以第一次并没有全字符匹配.应当怎么解释啊如下::
function qq()
{
    document.write(arguments[0] + "匹配<br>");
    return "*";
}
document.write("abcde".replace(/a*/gi,qq) + " <br>");  //输出:**b*c*d*e* 
结果:
a匹配
匹配
匹配
匹配
匹配
匹配
**b*c*d*e* 

Answer 25

量词全都是优先的
惰性就是取最少的可能匹配和
普通量词是相反的
占有优先量词是不记录状态的abcde/a*/g因为是星量词，所以首先从开始部分保存一个备用状态（就是匹配0个，即开始的位置）
然后匹配了一个a成功了，然后保存备用状态就是就是a后面的那个位置
然后在去匹配b（因为限定字符a无法匹配b）所以发现匹配失败
然后引擎回溯一次到最进的备用状态。
就是a后面那个位置。
然后量词结束控制权交给后面，发现后面没有要求了
则报告匹配成功然后因为有全局匹配所以继续下一轮1.
这样它就从a后面的那个位置开始匹配0个保存状态
然后在去匹配b发现匹配失败
这样回溯到a后面匹配成功然后在次匹配
正则引擎会强制执行传动装置执行驱动过程这样就换到了b后面的位置
返回1.那样的操作
如此循环直到匹配结束为止
传动装置发现传不了了- -，很郁闷的报告失败。全局匹配的循环就结束了如果想阻止传动装置的驱动（在大多流派中）可以使用\G（匹配上一次匹配成功的位置）
当然阻止驱动也不会产生死循环.
好比改下式子变成/\Ga*/g
替换结果就会变成**bcde
当然，JS不支持\G你可以拿其他支持NFA的环境测试，好比.net